KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > geronimo > axis > builder > HeavyweightTypeInfoBuilder


1 /**
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */

17 package org.apache.geronimo.axis.builder;
18
19 import java.beans.IntrospectionException JavaDoc;
20 import java.beans.Introspector JavaDoc;
21 import java.beans.PropertyDescriptor JavaDoc;
22 import java.lang.reflect.Field JavaDoc;
23 import java.util.ArrayList JavaDoc;
24 import java.util.Collection JavaDoc;
25 import java.util.HashMap JavaDoc;
26 import java.util.HashSet JavaDoc;
27 import java.util.Iterator JavaDoc;
28 import java.util.List JavaDoc;
29 import java.util.Map JavaDoc;
30 import java.util.Set JavaDoc;
31 import javax.xml.namespace.QName JavaDoc;
32 import javax.xml.rpc.encoding.DeserializerFactory JavaDoc;
33 import javax.xml.rpc.encoding.SerializerFactory JavaDoc;
34
35 import org.apache.axis.description.AttributeDesc;
36 import org.apache.axis.description.ElementDesc;
37 import org.apache.axis.description.FieldDesc;
38 import org.apache.axis.description.OperationDesc;
39 import org.apache.axis.description.ParameterDesc;
40 import org.apache.axis.encoding.DefaultJAXRPC11TypeMappingImpl;
41 import org.apache.axis.encoding.DefaultSOAPEncodingTypeMappingImpl;
42 import org.apache.axis.encoding.TypeMappingImpl;
43 import org.apache.axis.encoding.XMLType;
44 import org.apache.axis.encoding.ser.ArrayDeserializerFactory;
45 import org.apache.axis.encoding.ser.ArraySerializerFactory;
46 import org.apache.axis.encoding.ser.BeanDeserializerFactory;
47 import org.apache.axis.encoding.ser.BeanSerializerFactory;
48 import org.apache.axis.encoding.ser.EnumDeserializerFactory;
49 import org.apache.axis.encoding.ser.EnumSerializerFactory;
50 import org.apache.axis.encoding.ser.SimpleListDeserializerFactory;
51 import org.apache.axis.encoding.ser.SimpleListSerializerFactory;
52 import org.apache.commons.logging.Log;
53 import org.apache.commons.logging.LogFactory;
54 import org.apache.geronimo.axis.client.ArrayTypeInfo;
55 import org.apache.geronimo.axis.client.TypeInfo;
56 import org.apache.geronimo.common.DeploymentException;
57 import org.apache.geronimo.kernel.ClassLoading;
58 import org.apache.geronimo.xbeans.j2ee.JavaWsdlMappingType;
59 import org.apache.geronimo.xbeans.j2ee.JavaXmlTypeMappingType;
60 import org.apache.geronimo.xbeans.j2ee.VariableMappingType;
61 import org.apache.geronimo.webservices.builder.SchemaTypeKey;
62 import org.apache.xmlbeans.SchemaLocalAttribute;
63 import org.apache.xmlbeans.SchemaParticle;
64 import org.apache.xmlbeans.SchemaProperty;
65 import org.apache.xmlbeans.SchemaType;
66 import org.apache.xmlbeans.soap.SOAPArrayType;
67 import org.apache.xmlbeans.soap.SchemaWSDLArrayType;
68
69 /**
70  * @version $Rev: 476049 $ $Date: 2006-11-16 23:35:17 -0500 (Thu, 16 Nov 2006) $
71  */

72 public class HeavyweightTypeInfoBuilder implements TypeInfoBuilder {
73     private static final String JavaDoc SOAP_ENCODING_NS = "http://schemas.xmlsoap.org/soap/encoding/";
74     private static final String JavaDoc XML_SCHEMA_NS = "http://www.w3.org/2001/XMLSchema";
75     
76     private static final Log log = LogFactory.getLog(HeavyweightTypeInfoBuilder.class);
77
78     private final ClassLoader JavaDoc cl;
79     private final Map JavaDoc schemaTypeKeyToSchemaTypeMap;
80     private final Set JavaDoc wrapperElementQNames;
81     private final Collection JavaDoc operations;
82     private final boolean hasEncoded;
83
84     public HeavyweightTypeInfoBuilder(ClassLoader JavaDoc cl, Map JavaDoc schemaTypeKeyToSchemaTypeMap, Set JavaDoc wrapperElementQNames, Collection JavaDoc operations, boolean hasEncoded) {
85         this.cl = cl;
86         this.schemaTypeKeyToSchemaTypeMap = schemaTypeKeyToSchemaTypeMap;
87         this.wrapperElementQNames = wrapperElementQNames;
88         this.operations = operations;
89         this.hasEncoded = hasEncoded;
90     }
91
92     public List JavaDoc buildTypeInfo(JavaWsdlMappingType mapping) throws DeploymentException {
93         List JavaDoc typeInfoList = new ArrayList JavaDoc();
94
95         Set JavaDoc mappedTypeQNames = new HashSet JavaDoc();
96
97         JavaXmlTypeMappingType[] javaXmlTypeMappings = mapping.getJavaXmlTypeMappingArray();
98         for (int j = 0; j < javaXmlTypeMappings.length; j++) {
99             JavaXmlTypeMappingType javaXmlTypeMapping = javaXmlTypeMappings[j];
100
101             SchemaTypeKey key;
102             boolean isElement = javaXmlTypeMapping.getQnameScope().getStringValue().equals("element");
103             boolean isSimpleType = javaXmlTypeMapping.getQnameScope().getStringValue().equals("simpleType");
104             if (javaXmlTypeMapping.isSetRootTypeQname()) {
105                 QName JavaDoc typeQName = javaXmlTypeMapping.getRootTypeQname().getQNameValue();
106                 key = new SchemaTypeKey(typeQName, isElement, isSimpleType, false, null);
107
108                 // Skip the wrapper elements.
109
if (wrapperElementQNames.contains(typeQName)) {
110                     continue;
111                 }
112             } else if (javaXmlTypeMapping.isSetAnonymousTypeQname()) {
113                 String JavaDoc anonTypeQNameString = javaXmlTypeMapping.getAnonymousTypeQname().getStringValue();
114                 int pos = anonTypeQNameString.lastIndexOf(":");
115                 if (pos == -1) {
116                     throw new DeploymentException("anon QName is invalid, no final ':' " + anonTypeQNameString);
117                 }
118
119                 //this appears to be ignored...
120
QName JavaDoc typeQName = new QName JavaDoc(anonTypeQNameString.substring(0, pos), anonTypeQNameString.substring(pos + 1));
121                 key = new SchemaTypeKey(typeQName, isElement, isSimpleType, true, null);
122
123                 // Skip the wrapper elements.
124
if (wrapperElementQNames.contains(new QName JavaDoc(anonTypeQNameString.substring(0, pos), anonTypeQNameString.substring(pos + 2)))) {
125                     continue;
126                 }
127             } else {
128                 throw new DeploymentException("either root type qname or anonymous type qname must be set");
129             }
130
131             SchemaType schemaType = (SchemaType) schemaTypeKeyToSchemaTypeMap.get(key);
132             if (schemaType == null) {
133                 // if it is a built-in type, then one assumes a redundant mapping.
134
if (null != TypeMappingLookup.getFactoryPair(key.getqName())) {
135                     continue;
136                 }
137 // throw new DeploymentException("Schema type key " + key + " not found in analyzed schema: " + schemaTypeKeyToSchemaTypeMap);
138
log.warn("Schema type key " + key + " not found in analyzed schema: " + schemaTypeKeyToSchemaTypeMap);
139                 continue;
140             }
141             mappedTypeQNames.add(key.getqName());
142
143             String JavaDoc className = javaXmlTypeMapping.getJavaType().getStringValue().trim();
144             Class JavaDoc clazz = null;
145             try {
146                 clazz = ClassLoading.loadClass(className, cl);
147             } catch (ClassNotFoundException JavaDoc e2) {
148                 throw new DeploymentException("Could not load java type", e2);
149             }
150
151             TypeInfo.UpdatableTypeInfo internalTypeInfo = defineSerializerPair(schemaType, clazz);
152
153             populateInternalTypeInfo(clazz, key, schemaType, javaXmlTypeMapping, internalTypeInfo);
154
155             typeInfoList.add(internalTypeInfo.buildTypeInfo());
156         }
157
158         Map JavaDoc qNameToKey = new HashMap JavaDoc();
159         for (Iterator JavaDoc iter = schemaTypeKeyToSchemaTypeMap.keySet().iterator(); iter.hasNext();) {
160             SchemaTypeKey key = (SchemaTypeKey) iter.next();
161             qNameToKey.put(key.getqName(), key);
162         }
163
164         for (Iterator JavaDoc iter = operations.iterator(); iter.hasNext();) {
165             OperationDesc operationDesc = (OperationDesc) iter.next();
166             ArrayList JavaDoc parameters = new ArrayList JavaDoc(operationDesc.getParameters());
167             ParameterDesc returnParameterDesc = operationDesc.getReturnParamDesc();
168             if (null != returnParameterDesc.getTypeQName() &&
169                     false == returnParameterDesc.getTypeQName().equals(XMLType.AXIS_VOID)) {
170                 parameters.add(returnParameterDesc);
171             }
172             for (Iterator JavaDoc iterator = parameters.iterator(); iterator.hasNext();) {
173                 ParameterDesc parameterDesc = (ParameterDesc) iterator.next();
174                 QName JavaDoc typeQName = parameterDesc.getTypeQName();
175                 if (null == typeQName) {
176                     continue;
177                 } else if (mappedTypeQNames.contains(typeQName)) {
178                     continue;
179                 } else if (typeQName.getNamespaceURI().equals(XML_SCHEMA_NS) ||
180                         typeQName.getNamespaceURI().equals(SOAP_ENCODING_NS)) {
181                     continue;
182                 }
183
184                 SchemaTypeKey key = (SchemaTypeKey) qNameToKey.get(typeQName);
185                 if (null == key) {
186                     log.warn("Type QName [" + typeQName + "] defined by operation [" +
187                             operationDesc + "] has not been found in schema: " + schemaTypeKeyToSchemaTypeMap);
188                     continue;
189                 }
190                 SchemaType schemaType = (SchemaType) schemaTypeKeyToSchemaTypeMap.get(key);
191                 mappedTypeQNames.add(key.getqName());
192
193                 if (false == schemaType.isSimpleType()) {
194                     if (false == parameterDesc.getJavaType().isArray()) {
195                         if (false == mappedTypeQNames.contains(schemaType.getName())) {
196                             // TODO: this lookup is not enough: the jaxrpc mapping file may define an anonymous
197
// mapping.
198
log.warn("Operation [" + operationDesc + "] uses XML type [" + schemaType +
199                                     "], whose mapping is not declared by the jaxrpc mapping file.\n Continuing deployment; " +
200                                     "yet, the deployment is not-portable.");
201                         }
202                         continue;
203                     }
204                 }
205
206                 Class JavaDoc clazz = parameterDesc.getJavaType();
207                 TypeInfo.UpdatableTypeInfo internalTypeInfo = defineSerializerPair(schemaType, clazz);
208                 setTypeQName(internalTypeInfo, key);
209                 internalTypeInfo.setFields(new FieldDesc[0]);
210
211                 typeInfoList.add(internalTypeInfo.buildTypeInfo());
212             }
213         }
214
215         return typeInfoList;
216     }
217
218     private TypeInfo.UpdatableTypeInfo defineSerializerPair(SchemaType schemaType, Class JavaDoc clazz)
219             throws DeploymentException {
220         TypeInfo.UpdatableTypeInfo internalTypeInfo = new TypeInfo.UpdatableTypeInfo();
221         Class JavaDoc serializerFactoryClass = null;
222         Class JavaDoc deserializerFactoryClass = null;
223         if (schemaType.isSimpleType()) {
224             if (SchemaType.ATOMIC == schemaType.getSimpleVariety()) {
225                 if (clazz.isArray()) {
226                     internalTypeInfo = new ArrayTypeInfo.UpdatableArrayTypeInfo();
227                     serializerFactoryClass = ArraySerializerFactory.class;
228                     deserializerFactoryClass = ArrayDeserializerFactory.class;
229                     //TODO set componentType, componentQName
230
} else if (null != schemaType.getEnumerationValues()) {
231                     serializerFactoryClass = EnumSerializerFactory.class;
232                     deserializerFactoryClass = EnumDeserializerFactory.class;
233                 } else {
234                     QName JavaDoc typeQName = schemaType.getPrimitiveType().getName();
235                     FactoryPair pair = (FactoryPair) TypeMappingLookup.getFactoryPair(typeQName);
236                     if (null == pair) {
237                         throw new DeploymentException("Primitive type [" + typeQName + "] is not registered.");
238                     }
239                     serializerFactoryClass = pair.serializerFactoryClass;
240                     deserializerFactoryClass = pair.deserializerFactoryClass;
241                 }
242             } else if (SchemaType.LIST == schemaType.getSimpleVariety()) {
243                 serializerFactoryClass = SimpleListSerializerFactory.class;
244                 deserializerFactoryClass = SimpleListDeserializerFactory.class;
245             } else {
246                 throw new DeploymentException("Schema type [" + schemaType + "] is invalid.");
247             }
248         } else {
249             if (clazz.isArray()) {
250                 internalTypeInfo = new ArrayTypeInfo.UpdatableArrayTypeInfo();
251                 serializerFactoryClass = ArraySerializerFactory.class;
252                 deserializerFactoryClass = ArrayDeserializerFactory.class;
253                 QName JavaDoc componentType = null;
254                 //First, handle case that looks like this:
255
// <complexType name="ArrayOfstring">
256
// <complexContent>
257
// <restriction base="soapenc:Array">
258
// <attribute ref="soapenc:arrayType" wsdl:arrayType="xsd:string[]"/>
259
// </restriction>
260
// </complexContent>
261
// </complexType>
262
SchemaLocalAttribute arrayTypeAttribute = schemaType.getAttributeModel().getAttribute(new QName JavaDoc(SOAP_ENCODING_NS, "arrayType"));
263                 if (arrayTypeAttribute != null) {
264                     SchemaWSDLArrayType wsdlArrayType = (SchemaWSDLArrayType) arrayTypeAttribute;
265                     SOAPArrayType soapArrayType = wsdlArrayType.getWSDLArrayType();
266                     if (soapArrayType != null) {
267                         componentType = soapArrayType.getQName();
268                         log.debug("extracted componentType " + componentType + " from schemaType " + schemaType);
269                     } else {
270                         log.info("no SOAPArrayType for component from schemaType " + schemaType);
271                     }
272                 } else {
273                     log.warn("No soap array info for schematype: " + schemaType);
274                 }
275                 if (componentType == null) {
276                     //If that didn't work, try to handle case like this:
277
// <complexType name="ArrayOfstring1">
278
// <complexContent>
279
// <restriction base="soapenc:Array">
280
// <sequence>
281
// <element name="string1" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>
282
// </sequence>
283
// </restriction>
284
// </complexContent>
285
// </complexType>
286
//todo consider if we should check for maxOccurs > 1
287
if (schemaType.getBaseType().getName().equals(new QName JavaDoc(SOAP_ENCODING_NS, "Array"))) {
288                         SchemaProperty[] properties = schemaType.getDerivedProperties();
289                         if (properties.length != 1) {
290                             throw new DeploymentException("more than one element inside array definition: " + schemaType);
291                         }
292                         componentType = properties[0].getType().getName();
293                         log.debug("determined component type from element type");
294                     }
295
296                 }
297
298                 ((ArrayTypeInfo.UpdatableArrayTypeInfo)internalTypeInfo).setComponentType(componentType);
299                 //If we understand the axis comments correctly, componentQName is never set for j2ee ws.
300
} else {
301                 QName JavaDoc typeQName;
302                 if (SchemaType.SIMPLE_CONTENT == schemaType.getContentType()) {
303                     typeQName = schemaType.getBaseType().getName();
304                 } else if (SchemaType.EMPTY_CONTENT == schemaType.getContentType() ||
305                         SchemaType.ELEMENT_CONTENT == schemaType.getContentType() ||
306                         SchemaType.MIXED_CONTENT == schemaType.getContentType()) {
307                     typeQName = schemaType.getName();
308                 } else {
309                     throw new DeploymentException("Schema type [" + schemaType + "] is invalid.");
310                 }
311                 FactoryPair pair = (FactoryPair) TypeMappingLookup.getFactoryPair(typeQName);
312                 if (null != pair) {
313                     serializerFactoryClass = pair.serializerFactoryClass;
314                     deserializerFactoryClass = pair.deserializerFactoryClass;
315                 } else {
316                     serializerFactoryClass = BeanSerializerFactory.class;
317                     deserializerFactoryClass = BeanDeserializerFactory.class;
318                 }
319             }
320         }
321
322         internalTypeInfo.setClazz(clazz);
323         internalTypeInfo.setSerializerClass(serializerFactoryClass);
324         internalTypeInfo.setDeserializerClass(deserializerFactoryClass);
325         return internalTypeInfo;
326     }
327
328     private void setTypeQName(TypeInfo.UpdatableTypeInfo typeInfo, SchemaTypeKey key) {
329         //figure out the name axis expects to look up under.
330
QName JavaDoc axisKey = key.getElementQName();
331         if (axisKey == null) {
332             axisKey = key.getqName();
333         }
334         typeInfo.setQName(axisKey);
335     }
336
337     private void populateInternalTypeInfo(Class JavaDoc javaClass, SchemaTypeKey key, SchemaType schemaType, JavaXmlTypeMappingType javaXmlTypeMapping, TypeInfo.UpdatableTypeInfo typeInfo) throws DeploymentException {
338         String JavaDoc ns = key.getqName().getNamespaceURI();
339         typeInfo.setCanSearchParents(schemaType.getDerivationType() == SchemaType.DT_RESTRICTION);
340
341         setTypeQName(typeInfo, key);
342
343         Map JavaDoc paramNameToType = new HashMap JavaDoc();
344         if (null == schemaType.getContentModel()) {
345             ;
346         } else if (SchemaParticle.SEQUENCE == schemaType.getContentModel().getParticleType()
347                 || SchemaParticle.ALL == schemaType.getContentModel().getParticleType()) {
348             SchemaParticle[] properties = schemaType.getContentModel().getParticleChildren();
349             for (int i = 0; i < properties.length; i++) {
350                 SchemaParticle parameter = properties[i];
351                 paramNameToType.put(parameter.getName(), parameter);
352             }
353         } else if (SchemaParticle.ELEMENT == schemaType.getContentModel().getParticleType()) {
354             SchemaParticle parameter = schemaType.getContentModel();
355             paramNameToType.put(parameter.getName(), parameter);
356         } else {
357             throw new DeploymentException("Only element, sequence, and all particle types are supported." +
358                     " SchemaType name =" + schemaType.getName());
359         }
360
361         Map JavaDoc attNameToType = new HashMap JavaDoc();
362         if (null != schemaType.getAttributeModel()) {
363             SchemaLocalAttribute[] attributes = schemaType.getAttributeModel().getAttributes();
364             for (int i = 0; i < attributes.length; i++) {
365                 SchemaLocalAttribute attribute = attributes[i];
366                 Object JavaDoc old = attNameToType.put(attribute.getName().getLocalPart(), attribute);
367                 if (old != null) {
368                     throw new DeploymentException("Complain to your expert group member, spec does not support attributes with the same local name and differing namespaces: original: " + old + ", duplicate local name: " + attribute);
369                 }
370             }
371         }
372         
373         VariableMappingType[] variableMappings = javaXmlTypeMapping.getVariableMappingArray();
374
375         // short-circuit the processing of arrays as they should not define variable-mapping elements.
376
if (javaClass.isArray()) {
377             if (0 != variableMappings.length) {
378                 // for portability reason we simply warn and not fail.
379
log.warn("Ignoring variable-mapping defined for class " + javaClass + " which is an array.");
380             }
381             typeInfo.setFields(new FieldDesc[0]);
382             return;
383         }
384
385         FieldDesc[] fields = new FieldDesc[variableMappings.length];
386         typeInfo.setFields(fields);
387
388         PropertyDescriptor JavaDoc[] propertyDescriptors = new PropertyDescriptor JavaDoc[0];
389         try {
390             propertyDescriptors = Introspector.getBeanInfo(javaClass).getPropertyDescriptors();
391         } catch (IntrospectionException JavaDoc e) {
392             throw new DeploymentException("Class " + javaClass + " is not a valid javabean", e);
393         }
394         Map JavaDoc properties = new HashMap JavaDoc();
395         for (int i = 0; i < propertyDescriptors.length; i++) {
396             PropertyDescriptor JavaDoc propertyDescriptor = propertyDescriptors[i];
397             properties.put(propertyDescriptor.getName(), propertyDescriptor.getPropertyType());
398         }
399         for (int i = 0; i < variableMappings.length; i++) {
400             VariableMappingType variableMapping = variableMappings[i];
401             String JavaDoc fieldName = variableMapping.getJavaVariableName().getStringValue().trim();
402
403             if (variableMapping.isSetXmlAttributeName()) {
404                 AttributeDesc attributeDesc = new AttributeDesc();
405                 attributeDesc.setFieldName(fieldName);
406                 Class JavaDoc javaType = (Class JavaDoc) properties.get(fieldName);
407                 if (javaType == null) {
408                     throw new DeploymentException("field name " + fieldName + " not found in " + properties);
409                 }
410                 String JavaDoc attributeLocalName = variableMapping.getXmlAttributeName().getStringValue().trim();
411                 QName JavaDoc xmlName = new QName JavaDoc("", attributeLocalName);
412                 attributeDesc.setXmlName(xmlName);
413
414                 SchemaLocalAttribute attribute = (SchemaLocalAttribute) attNameToType.get(attributeLocalName);
415                 if (null == attribute) {
416                     throw new DeploymentException("attribute " + xmlName + " not found in schema " + schemaType.getName());
417                 }
418                 attributeDesc.setXmlType(attribute.getType().getName());
419
420                 fields[i] = attributeDesc;
421             } else {
422                 ElementDesc elementDesc = new ElementDesc();
423                 elementDesc.setFieldName(fieldName);
424                 Class JavaDoc javaType = (Class JavaDoc) properties.get(fieldName);
425                 if (javaType == null) {
426                     //see if it is a public field
427
try {
428                         Field JavaDoc field = javaClass.getField(fieldName);
429                         javaType = field.getType();
430                     } catch (NoSuchFieldException JavaDoc e) {
431                         throw new DeploymentException("field name " + fieldName + " not found in " + properties);
432                     }
433                 }
434                 QName JavaDoc xmlName = new QName JavaDoc("", variableMapping.getXmlElementName().getStringValue().trim());
435                 SchemaParticle particle = (SchemaParticle) paramNameToType.get(xmlName);
436                 if (null == particle) {
437                     xmlName = new QName JavaDoc(ns, variableMapping.getXmlElementName().getStringValue().trim());
438                     particle = (SchemaParticle) paramNameToType.get(xmlName);
439                     if (null == particle) {
440                         throw new DeploymentException("element " + xmlName + " not found in schema " + schemaType.getName());
441                     }
442                 } else if (SchemaParticle.ELEMENT != particle.getParticleType()) {
443                     throw new DeploymentException(xmlName + " is not an element in schema " + schemaType.getName());
444                 }
445                 elementDesc.setNillable(particle.isNillable() || hasEncoded);
446                 elementDesc.setXmlName(xmlName);
447                 if (null != particle.getType().getName()) {
448                     elementDesc.setXmlType(particle.getType().getName());
449                 } else {
450                     QName JavaDoc anonymousName;
451                     if (key.isAnonymous()) {
452                         anonymousName = new QName JavaDoc(key.getqName().getNamespaceURI(), key.getqName().getLocalPart() +
453                                 ">" + particle.getName().getLocalPart());
454                     } else {
455                         anonymousName = new QName JavaDoc(key.getqName().getNamespaceURI(),
456                                 ">" + key.getqName().getLocalPart() + ">" + particle.getName().getLocalPart());
457                     }
458                     elementDesc.setXmlType(anonymousName);
459                 }
460
461                 if (javaType.isArray()) {
462                     elementDesc.setMinOccurs(particle.getIntMinOccurs());
463                     elementDesc.setMaxOccurs(particle.getIntMaxOccurs());
464                     //TODO axis seems to have the wrong name for this property based on how it is used
465
elementDesc.setMaxOccursUnbounded(particle.getIntMaxOccurs() > 1);
466                 }
467
468                 fields[i] = elementDesc;
469             }
470         }
471     }
472
473     private static class TypeMappingLookup {
474         private static final TypeMappingImpl SOAP_TM = DefaultSOAPEncodingTypeMappingImpl.getSingleton();
475         private static final TypeMappingImpl JAXRPC_TM = DefaultJAXRPC11TypeMappingImpl.getSingleton();
476
477         public static FactoryPair getFactoryPair(QName JavaDoc xmlType) {
478             Class JavaDoc clazz = SOAP_TM.getClassForQName(xmlType, null, null);
479             SerializerFactory JavaDoc sf;
480             DeserializerFactory JavaDoc df;
481             if (null != clazz) {
482                 sf = SOAP_TM.getSerializer(clazz, xmlType);
483                 df = SOAP_TM.getDeserializer(clazz, xmlType, null);
484             } else {
485                 clazz = JAXRPC_TM.getClassForQName(xmlType, null, null);
486                 if (null == clazz) {
487                     return null;
488                 }
489                 sf = JAXRPC_TM.getSerializer(clazz, xmlType);
490                 df = JAXRPC_TM.getDeserializer(clazz, xmlType, null);
491             }
492             return new FactoryPair(sf.getClass(), df.getClass());
493         }
494     }
495
496     private static class FactoryPair {
497         private final Class JavaDoc serializerFactoryClass;
498         private final Class JavaDoc deserializerFactoryClass;
499
500         private FactoryPair(Class JavaDoc serializerFactoryClass, Class JavaDoc deserializerFactoryClass) {
501             this.serializerFactoryClass = serializerFactoryClass;
502             this.deserializerFactoryClass = deserializerFactoryClass;
503         }
504     }
505 }
506
Popular Tags