Modified: axis/axis2/java/core/branches/AXIS2-4091/modules/adb-codegen/src/org/apache/axis2/schema/SchemaCompiler.java URL: http://svn.apache.org/viewvc/axis/axis2/java/core/branches/AXIS2-4091/modules/adb-codegen/src/org/apache/axis2/schema/SchemaCompiler.java?rev=1818516&r1=1818515&r2=1818516&view=diff ============================================================================== --- axis/axis2/java/core/branches/AXIS2-4091/modules/adb-codegen/src/org/apache/axis2/schema/SchemaCompiler.java (original) +++ axis/axis2/java/core/branches/AXIS2-4091/modules/adb-codegen/src/org/apache/axis2/schema/SchemaCompiler.java Sun Dec 17 22:16:04 2017 @@ -35,7 +35,9 @@ import org.apache.ws.commons.schema.XmlS import org.apache.ws.commons.schema.XmlSchemaAnyAttribute; import org.apache.ws.commons.schema.XmlSchemaAttribute; import org.apache.ws.commons.schema.XmlSchemaAttributeGroup; +import org.apache.ws.commons.schema.XmlSchemaAttributeGroupMember; import org.apache.ws.commons.schema.XmlSchemaAttributeGroupRef; +import org.apache.ws.commons.schema.XmlSchemaAttributeOrGroupRef; import org.apache.ws.commons.schema.XmlSchemaChoice; import org.apache.ws.commons.schema.XmlSchemaCollection; import org.apache.ws.commons.schema.XmlSchemaComplexContent; @@ -47,8 +49,9 @@ import org.apache.ws.commons.schema.XmlS import org.apache.ws.commons.schema.XmlSchemaElement; import org.apache.ws.commons.schema.XmlSchemaEnumerationFacet; import org.apache.ws.commons.schema.XmlSchemaExternal; +import org.apache.ws.commons.schema.XmlSchemaFacet; import org.apache.ws.commons.schema.XmlSchemaGroup; -import org.apache.ws.commons.schema.XmlSchemaGroupBase; +import org.apache.ws.commons.schema.XmlSchemaGroupParticle; import org.apache.ws.commons.schema.XmlSchemaGroupRef; import org.apache.ws.commons.schema.XmlSchemaImport; import org.apache.ws.commons.schema.XmlSchemaInclude; @@ -60,11 +63,10 @@ import org.apache.ws.commons.schema.XmlS import org.apache.ws.commons.schema.XmlSchemaMinInclusiveFacet; import org.apache.ws.commons.schema.XmlSchemaMinLengthFacet; import org.apache.ws.commons.schema.XmlSchemaObject; -import org.apache.ws.commons.schema.XmlSchemaObjectCollection; -import org.apache.ws.commons.schema.XmlSchemaObjectTable; import org.apache.ws.commons.schema.XmlSchemaParticle; import org.apache.ws.commons.schema.XmlSchemaPatternFacet; import org.apache.ws.commons.schema.XmlSchemaSequence; +import org.apache.ws.commons.schema.XmlSchemaSequenceMember; import org.apache.ws.commons.schema.XmlSchemaSimpleContent; import org.apache.ws.commons.schema.XmlSchemaSimpleContentExtension; import org.apache.ws.commons.schema.XmlSchemaSimpleContentRestriction; @@ -81,7 +83,6 @@ import javax.xml.namespace.QName; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; -import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -102,21 +103,21 @@ public class SchemaCompiler { private static final Log log = LogFactory.getLog(SchemaCompiler.class); private CompilerOptions options; - private HashMap<QName,String> processedTypemap; + private HashMap<QName, String> processedTypemap; // have to keep a seperate group type map since same // name can be used to group and complextype - private HashMap<QName,String> processedGroupTypeMap; + private HashMap<QName, String> processedGroupTypeMap; //the list of processedElements for the outer elements - private HashMap<QName,String> processedElementMap; + private HashMap<QName, String> processedElementMap; - private HashMap<XmlSchemaElement,BeanWriterMetaInfoHolder> processedAnonymousComplexTypesMap; + private HashMap<XmlSchemaElement, BeanWriterMetaInfoHolder> processedAnonymousComplexTypesMap; //we need this map to keep the referenced elements. these elements need to be kept seperate //to avoid conflicts - private HashMap<QName,String> processedElementRefMap; - private HashMap<QName,String> simpleTypesMap; - private HashMap<QName,QName> changedTypeMap; + private HashMap<QName, String> processedElementRefMap; + private HashMap<QName, String> simpleTypesMap; + private HashMap<QName, QName> changedTypeMap; private HashSet<XmlSchemaSimpleType> changedSimpleTypeSet; private HashSet<XmlSchemaComplexType> changedComplexTypeSet; @@ -125,7 +126,7 @@ public class SchemaCompiler { // this map is necessary to retain the metainformation of types. The reason why these // meta info 'bags' would be useful later is to cater for the extensions and restrictions // of types - private HashMap<QName,BeanWriterMetaInfoHolder> processedTypeMetaInfoMap; + private HashMap<QName, BeanWriterMetaInfoHolder> processedTypeMetaInfoMap; // private ArrayList<QName> processedElementList; @@ -135,19 +136,19 @@ public class SchemaCompiler { private List<QName> nillableElementList; // writee reference private BeanWriter writer = null; - private Map<QName,String> baseSchemaTypeMap = null; + private Map<QName, String> baseSchemaTypeMap = null; //a map for keeping the already loaded schemas //the key is the targetnamespace and the value is the schema object - private Map<String,XmlSchema> loadedSchemaMap = new HashMap<String,XmlSchema>(); + private Map<String, XmlSchema> loadedSchemaMap = new HashMap<String, XmlSchema>(); // A map keeping the available schemas //the key is the targetnamespace and the value is the schema object //this map will be populated when multiple schemas //are fed to the schema compiler! - private Map<String,XmlSchema> availableSchemaMap = new HashMap<String,XmlSchema>(); + private Map<String, XmlSchema> availableSchemaMap = new HashMap<String, XmlSchema>(); - private Map<String,String> loadedSourceURI = new HashMap<String,String>(); + private Map<String, String> loadedSourceURI = new HashMap<String, String>(); // a list of externally identified QNames to be processed. This becomes // useful when only a list of external elements need to be processed @@ -164,7 +165,7 @@ public class SchemaCompiler { * includes the Qname of the element as the key and a * String representing the fully qualified class name */ - public HashMap<QName,String> getProcessedElementMap() { + public HashMap<QName, String> getProcessedElementMap() { return processedElementMap; } @@ -194,26 +195,26 @@ public class SchemaCompiler { Map<String, String> nsp2PackageMap = this.options.getNs2PackageMap(); - if (nsp2PackageMap == null){ + if (nsp2PackageMap == null) { nsp2PackageMap = new HashMap(); this.options.setNs2PackageMap(nsp2PackageMap); } - if (!nsp2PackageMap.containsKey("")){ - nsp2PackageMap.put("","axis2.apache.org"); + if (!nsp2PackageMap.containsKey("")) { + nsp2PackageMap.put("", "axis2.apache.org"); } //instantiate the maps - processedTypemap = new HashMap<QName,String>(); - processedGroupTypeMap = new HashMap<QName,String>(); + processedTypemap = new HashMap<QName, String>(); + processedGroupTypeMap = new HashMap<QName, String>(); - processedElementMap = new HashMap<QName,String>(); - simpleTypesMap = new HashMap<QName,String>(); + processedElementMap = new HashMap<QName, String>(); + simpleTypesMap = new HashMap<QName, String>(); processedElementList = new ArrayList<QName>(); - processedAnonymousComplexTypesMap = new HashMap<XmlSchemaElement,BeanWriterMetaInfoHolder>(); - changedTypeMap = new HashMap<QName,QName>(); - processedTypeMetaInfoMap = new HashMap<QName,BeanWriterMetaInfoHolder>(); - processedElementRefMap = new HashMap<QName,String>(); + processedAnonymousComplexTypesMap = new HashMap<XmlSchemaElement, BeanWriterMetaInfoHolder>(); + changedTypeMap = new HashMap<QName, QName>(); + processedTypeMetaInfoMap = new HashMap<QName, BeanWriterMetaInfoHolder>(); + processedElementRefMap = new HashMap<QName, String>(); nillableElementList = new ArrayList<QName>(); changedComplexTypeSet = new HashSet<XmlSchemaComplexType>(); @@ -265,14 +266,15 @@ public class SchemaCompiler { //mapper namespace for (XmlSchema schema : schemalist) { nsp = schema.getTargetNamespace(); - if ((nsp != null) && !nsp.equals("")){ + if ((nsp != null) && !nsp.equals("")) { break; } XmlSchema[] schemas = SchemaUtil.getAllSchemas(schema); for (int j = 0; schemas != null && j < schemas.length; j++) { nsp = schemas[j].getTargetNamespace(); - if (nsp != null) + if (nsp != null) { break; + } } } if (nsp == null) { @@ -281,10 +283,11 @@ public class SchemaCompiler { // if this name space exists in the ns2p list then we use it. if ((options.getNs2PackageMap() != null) - && (options.getNs2PackageMap().containsKey(nsp))) { + && (options.getNs2PackageMap().containsKey(nsp))) { writer.registerExtensionMapperPackageName(options.getNs2PackageMap().get(nsp)); } else { - writer.registerExtensionMapperPackageName(nsp == null ? null : URLProcessor.makePackageName(nsp)); + writer.registerExtensionMapperPackageName(nsp == null ? null : + URLProcessor.makePackageName(nsp)); } } // second round - call the schema compiler one by one @@ -319,7 +322,8 @@ public class SchemaCompiler { * @param isPartofGroup * @throws SchemaCompilationException */ - private void compile(XmlSchema schema, boolean isPartofGroup) throws SchemaCompilationException { + private void compile(XmlSchema schema, boolean isPartofGroup) + throws SchemaCompilationException { // some documents explicitly imports the schema of built in types. We don't actually need to compile // the built-in types. So check the target namespace here and ignore it. @@ -337,7 +341,7 @@ public class SchemaCompiler { } // if this name space exists in the ns2p list then we use it. if ((options.getNs2PackageMap() != null) - && (options.getNs2PackageMap().containsKey(ns))) { + && (options.getNs2PackageMap().containsKey(ns))) { writer.registerExtensionMapperPackageName(options.getNs2PackageMap().get(ns)); } else { writer.registerExtensionMapperPackageName(URLProcessor.makePackageName(ns)); @@ -355,7 +359,7 @@ public class SchemaCompiler { // but when importing import namesapce location is given as "". // this causese a problem in finding reference elements. see AXIS2-3029 // kept the null entry as well to safe gaurd any thing which acess using null - if (schema.getTargetNamespace() == null){ + if (schema.getTargetNamespace() == null) { loadedSchemaMap.put("", schema); } } @@ -370,74 +374,66 @@ public class SchemaCompiler { loadedSourceURI.put(key, key); } - XmlSchemaObjectCollection includes = schema.getIncludes(); - if (includes != null) { - Iterator tempIterator = includes.getIterator(); - while (tempIterator.hasNext()) { - Object o = tempIterator.next(); - if (o instanceof XmlSchemaImport) { - XmlSchemaImport schemaImport = (XmlSchemaImport)o; - XmlSchema schema1 = schemaImport.getSchema(); - if (schema1 != null) { - compile(schema1, isPartofGroup); - } else if (schemaImport.getNamespace().equals(Constants.NS_URI_XML)) { - // AXIS2-3229: some Web services (e.g. MS Exchange) assume that - // http://www.w3.org/XML/1998/namespace is a known namespace and that - // no schemaLocation is required when importing it. Load a local copy of - // the schema in that case. - schema1 = new XmlSchemaCollection().read(new InputSource( - SchemaCompiler.class.getResource("namespace.xsd").toExternalForm()), null); - schemaImport.setSchema(schema1); - compile(schema1, isPartofGroup); - } else if (!schemaImport.getNamespace().equals(Constants.URI_2001_SCHEMA_XSD)) { - // Give the user a hint why the schema compilation fails... - log.warn("No schemaLocation for import of " + schemaImport.getNamespace() + "; compilation may fail"); - } - } - if (o instanceof XmlSchemaInclude) { - XmlSchema schema1 = ((XmlSchemaInclude) o).getSchema(); - if (schema1 != null){ - if (schema1.getTargetNamespace() == null){ - // the target namespace of an included shchema should be same - // as the parent schema however if the schema uses the chemalon pattern - // target namespace can be null. so set it here. - // http://www.xfront.com/ZeroOneOrManyNamespaces.html#mixed - schema1.setTargetNamespace(schema.getTargetNamespace()); - } - compile(schema1, isPartofGroup); - } + for (XmlSchemaObject object : schema.getExternals()) { + if (object instanceof XmlSchemaImport) { + XmlSchemaImport schemaImport = (XmlSchemaImport) object; + XmlSchema schema1 = schemaImport.getSchema(); + if (schema1 != null) { + compile(schema1, isPartofGroup); + } else if (schemaImport.getNamespace().equals(Constants.NS_URI_XML)) { + // AXIS2-3229: some Web services (e.g. MS Exchange) assume that + // http://www.w3.org/XML/1998/namespace is a known namespace and that + // no schemaLocation is required when importing it. Load a local copy of + // the schema in that case. + schema1 = new XmlSchemaCollection().read(new InputSource( + SchemaCompiler.class.getResource("namespace.xsd").toExternalForm())); + schemaImport.setSchema(schema1); + compile(schema1, isPartofGroup); + } else if (!schemaImport.getNamespace().equals(Constants.URI_2001_SCHEMA_XSD)) { + // Give the user a hint why the schema compilation fails... + log.warn("No schemaLocation for import of " + schemaImport.getNamespace() + + "; compilation may fail"); + } + } + if (object instanceof XmlSchemaInclude) { + XmlSchema schema1 = ((XmlSchemaInclude) object).getSchema(); + if (schema1 != null) { + if (schema1.getTargetNamespace() == null) { + // the target namespace of an included shchema should be same + // as the parent schema however if the schema uses the chemalon pattern + // target namespace can be null. so set it here. + // http://www.xfront.com/ZeroOneOrManyNamespaces.html#mixed + schema1.setTargetNamespace(schema.getTargetNamespace()); + } + compile(schema1, isPartofGroup); } + } + } //select all the elements. We generate the code for types //only if the elements refer them!!! regardless of the fact that //we have a list of elementnames, we'll need to process all the elements - XmlSchemaObjectTable elements = schema.getElements(); - Iterator xmlSchemaElement1Iterator = elements.getValues(); - while (xmlSchemaElement1Iterator.hasNext()) { + for (XmlSchemaElement element : schema.getElements().values()) { //this is the set of outer elements so we need to generate classes //The outermost elements do not contain occurence counts (!) so we do not need //to check for arraytypes - processElement((XmlSchemaElement) xmlSchemaElement1Iterator.next(), schema); + processElement(element, schema); } - Iterator xmlSchemaElement2Iterator = elements.getValues(); - // re-iterate through the elements and write them one by one // if the mode is unpack this process will not really write the // classes but will accumilate the models for a final single shot // write - while (xmlSchemaElement2Iterator.hasNext()) { + for (XmlSchemaElement element : schema.getElements().values()) { //this is the set of outer elements so we need to generate classes - writeElement((XmlSchemaElement) xmlSchemaElement2Iterator.next()); + writeElement(element); } if (options.isGenerateAll()) { - Iterator xmlSchemaTypes2Iterator = schema.getSchemaTypes().getValues(); - while (xmlSchemaTypes2Iterator.hasNext()) { - XmlSchemaType schemaType = (XmlSchemaType) xmlSchemaTypes2Iterator.next(); + for (XmlSchemaType schemaType : schema.getSchemaTypes().values()) { if (this.isAlreadyProcessed(schemaType.getQName())) { continue; } @@ -450,8 +446,8 @@ public class SchemaCompiler { } else if (schemaType instanceof XmlSchemaSimpleType) { //process simple type processSimpleSchemaType((XmlSchemaSimpleType) schemaType, - null, - schema, null); + null, + schema, null); } } } @@ -471,8 +467,8 @@ public class SchemaCompiler { private void finalizeSchemaCompilation() throws SchemaCompilationException { //write the extension mapping class writer.writeExtensionMapper( - processedTypeMetaInfoMap.values().toArray( - new BeanWriterMetaInfoHolder[processedTypeMetaInfoMap.size()])); + processedTypeMetaInfoMap.values().toArray( + new BeanWriterMetaInfoHolder[processedTypeMetaInfoMap.size()])); if (options.isWrapClasses()) { @@ -534,31 +530,31 @@ public class SchemaCompiler { //this means the schema type actually returns a different QName if (changedTypeMap.containsKey(qName)) { metainf.registerMapping(xsElt.getQName(), - changedTypeMap.get(qName), - className); + changedTypeMap.get(qName), + className); } else { metainf.registerMapping(xsElt.getQName(), - qName, - className); + qName, + className); } // register the default value if present - if (xsElt.getDefaultValue() != null){ - metainf.registerDefaultValue(xsElt.getQName(),xsElt.getDefaultValue()); + if (xsElt.getDefaultValue() != null) { + metainf.registerDefaultValue(xsElt.getQName(), xsElt.getDefaultValue()); } // register the fixed value if present - if (xsElt.getFixedValue() != null){ - metainf.registerDefaultValue(xsElt.getQName(),xsElt.getFixedValue()); + if (xsElt.getFixedValue() != null) { + metainf.registerDefaultValue(xsElt.getQName(), xsElt.getFixedValue()); metainf.setFixed(true); } - + if (isBinary(xsElt)) { metainf.addtStatus(xsElt.getQName(), - SchemaConstants.BINARY_TYPE); + SchemaConstants.BINARY_TYPE); } - } else if (xsElt.getRefName() != null) { + } else if (xsElt.getRef().getTargetQName() != null) { // Since top level elements would not have references // and we only write toplevel elements, this should // not be a problem , atleast should not occur in a legal schema @@ -566,8 +562,8 @@ public class SchemaCompiler { QName qName = xsElt.getSchemaTypeName(); String className = findClassName(qName, isArray(xsElt)); metainf.registerMapping(xsElt.getQName(), - qName, - className); + qName, + className); } else if (schemaType != null) { //the named type should have been handled already @@ -582,9 +578,9 @@ public class SchemaCompiler { //this means we did not find any schema type associated with the particular element. log.warn(SchemaCompilerMessages.getMessage("schema.elementWithNoType", xsElt.getQName().toString())); metainf.registerMapping(xsElt.getQName(), - null, - writer.getDefaultClassName(), - SchemaConstants.ANY_TYPE); + null, + writer.getDefaultClassName(), + SchemaConstants.ANY_TYPE); } if (nillableElementList.contains(xsElt.getQName())) { @@ -606,7 +602,9 @@ public class SchemaCompiler { * @param parentSchema * @throws SchemaCompilationException */ - private void processElement(XmlSchemaElement xsElt, Map<QName,String> innerElementMap, List<QName> localNillableList, XmlSchema parentSchema) throws SchemaCompilationException { + private void processElement(XmlSchemaElement xsElt, Map<QName, String> innerElementMap, + List<QName> localNillableList, XmlSchema parentSchema) + throws SchemaCompilationException { processElement(xsElt, false, innerElementMap, localNillableList, parentSchema); } @@ -617,7 +615,8 @@ public class SchemaCompiler { * @param parentSchema * @throws SchemaCompilationException */ - private void processElement(XmlSchemaElement xsElt, XmlSchema parentSchema) throws SchemaCompilationException { + private void processElement(XmlSchemaElement xsElt, XmlSchema parentSchema) + throws SchemaCompilationException { processElement(xsElt, true, null, null, parentSchema); } @@ -629,7 +628,9 @@ public class SchemaCompiler { * inner elements * @throws SchemaCompilationException */ - private void processElement(XmlSchemaElement xsElt, boolean isOuter, Map<QName,String> innerElementMap, List<QName> localNillableList, XmlSchema parentSchema) throws SchemaCompilationException { + private void processElement(XmlSchemaElement xsElt, boolean isOuter, + Map<QName, String> innerElementMap, List<QName> localNillableList, + XmlSchema parentSchema) throws SchemaCompilationException { //if the element is null, which usually happens when the qname is not //proper, throw an exceptions @@ -638,7 +639,7 @@ public class SchemaCompiler { SchemaCompilerMessages.getMessage("schema.elementNull")); } - + //The processing element logic seems to be quite simple. Look at the relevant schema type //for each and every element and process that accordingly. //this means that any unused type definitions would not be generated! @@ -659,17 +660,19 @@ public class SchemaCompiler { // this element already has a name. Which means we can directly // register it String className = findClassName(schemaType.getQName(), - isArray(xsElt)); + isArray(xsElt)); innerElementMap.put(xsElt.getQName(), className); // always store the class name in the element meta Info itself // this details only needed by the unwrappig to set the complex type if (options.isUseWrapperClasses() && PrimitiveTypeFinder.isPrimitive(className)) { - className = PrimitiveTypeWrapper.getWrapper(className); + className = PrimitiveTypeWrapper.getWrapper(className); } - schemaType.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, className); - xsElt.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, className); + schemaType.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, + className); + xsElt.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, + className); if (baseSchemaTypeMap.containsValue(className)) { schemaType.addMetaInfo( @@ -687,17 +690,19 @@ public class SchemaCompiler { if (schemaType instanceof XmlSchemaComplexType) { //set a name schemaType.setName(generatedTypeName.getLocalPart()); - changedComplexTypeSet.add((XmlSchemaComplexType)schemaType); + changedComplexTypeSet.add((XmlSchemaComplexType) schemaType); // Must do this up front to support recursive types - String fullyQualifiedClassName = writer.makeFullyQualifiedClassName(schemaType.getQName()); + String fullyQualifiedClassName = writer. + makeFullyQualifiedClassName(schemaType.getQName()); processedTypemap.put(schemaType.getQName(), fullyQualifiedClassName); - BeanWriterMetaInfoHolder metaInfHolder = processedAnonymousComplexTypesMap.get(xsElt); + BeanWriterMetaInfoHolder metaInfHolder = + processedAnonymousComplexTypesMap.get(xsElt); metaInfHolder.setOwnQname(schemaType.getQName()); metaInfHolder.setOwnClassName(fullyQualifiedClassName); writeComplexType((XmlSchemaComplexType) schemaType, - metaInfHolder); + metaInfHolder); //remove the reference from the anon list since we named the type processedAnonymousComplexTypesMap.remove(xsElt); String className = findClassName(schemaType.getQName(), isArray(xsElt)); @@ -712,17 +717,19 @@ public class SchemaCompiler { } else if (schemaType instanceof XmlSchemaSimpleType) { //set a name schemaType.setName(generatedTypeName.getLocalPart()); - changedSimpleTypeSet.add((XmlSchemaSimpleType)schemaType); + changedSimpleTypeSet.add((XmlSchemaSimpleType) schemaType); // Must do this up front to support recursive types - String fullyQualifiedClassName = writer.makeFullyQualifiedClassName(schemaType.getQName()); + String fullyQualifiedClassName = writer. + makeFullyQualifiedClassName(schemaType.getQName()); processedTypemap.put(schemaType.getQName(), fullyQualifiedClassName); - BeanWriterMetaInfoHolder metaInfHolder = processedAnonymousComplexTypesMap.get(xsElt); + BeanWriterMetaInfoHolder metaInfHolder = + processedAnonymousComplexTypesMap.get(xsElt); metaInfHolder.setOwnQname(schemaType.getQName()); metaInfHolder.setOwnClassName(fullyQualifiedClassName); writeSimpleType((XmlSchemaSimpleType) schemaType, - metaInfHolder); + metaInfHolder); //remove the reference from the anon list since we named the type processedAnonymousComplexTypesMap.remove(xsElt); String className = findClassName(schemaType.getQName(), isArray(xsElt)); @@ -741,43 +748,55 @@ public class SchemaCompiler { this.processedElementList.add(xsElt.getQName()); } //referenced name - } else if (xsElt.getRefName() != null) { + } else if (xsElt.getRef().getTargetQName() != null) { - if (xsElt.getRefName().equals(SchemaConstants.XSD_SCHEMA)) { + if (xsElt.getRef().getTargetQName().equals(SchemaConstants.XSD_SCHEMA)) { innerElementMap.put(xsElt.getQName(), writer.getDefaultClassName()); return; } //process the referenced type. It could be thought that the referenced element replaces this //element - XmlSchema resolvedSchema = getParentSchema(parentSchema,xsElt.getRefName(),COMPONENT_ELEMENT); - if (resolvedSchema == null){ - throw new SchemaCompilationException("can not find the element " + xsElt.getRefName() - + " from the parent schema " + parentSchema.getTargetNamespace()); + XmlSchema resolvedSchema = getParentSchema(parentSchema, + xsElt.getRef().getTargetQName(), + COMPONENT_ELEMENT); + if (resolvedSchema == null) { + throw new SchemaCompilationException("can not find the element " + + xsElt.getRef().getTargetQName() + + " from the parent schema " + + parentSchema.getTargetNamespace()); } - XmlSchemaElement referencedElement = resolvedSchema.getElementByName(xsElt.getRefName()); + XmlSchemaElement referencedElement = resolvedSchema. + getElementByName(xsElt.getRef().getTargetQName()); if (referencedElement == null) { throw new SchemaCompilationException( - SchemaCompilerMessages.getMessage("schema.referencedElementNotFound", xsElt.getRefName().toString())); + SchemaCompilerMessages. + getMessage("schema.referencedElementNotFound", + xsElt.getRef().getTargetQName().toString())); } // here what we want is to set the schema type name for the element if ((referencedElement.getSchemaType() != null) - && (referencedElement.getSchemaType().getQName() != null)){ + && (referencedElement.getSchemaType().getQName() != null)) { // i.e this element refers to an complex type name if (!this.processedElementRefMap.containsKey(referencedElement.getQName())) { if (this.baseSchemaTypeMap.containsKey(referencedElement.getSchemaTypeName())) { this.processedElementRefMap.put(referencedElement.getQName(), - this.baseSchemaTypeMap.get(referencedElement.getSchemaTypeName())); + this.baseSchemaTypeMap. + get(referencedElement. + getSchemaTypeName())); } else { XmlSchema resolvedTypeSchema = getParentSchema(resolvedSchema, - referencedElement.getSchemaTypeName(), - COMPONENT_TYPE); + referencedElement. + getSchemaTypeName(), + COMPONENT_TYPE); XmlSchemaType xmlSchemaType = resolvedTypeSchema.getTypeByName( referencedElement.getSchemaTypeName().getLocalPart()); processSchema(referencedElement, xmlSchemaType, resolvedTypeSchema, true); this.processedElementRefMap.put(referencedElement.getQName(), - this.processedTypemap.get(referencedElement.getSchemaTypeName())); + this.processedTypemap. + get(referencedElement. + getSchemaTypeName())); } } String javaClassName; @@ -785,29 +804,34 @@ public class SchemaCompiler { // here we have to do nothing since we do not generate a name } else { javaClassName = this.processedTypemap.get(referencedElement.getSchemaTypeName()); - referencedElement.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, - javaClassName); + referencedElement.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder. + CLASSNAME_KEY, + javaClassName); xsElt.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, - javaClassName); + javaClassName); } } else if (referencedElement.getSchemaType() != null) { if (!this.processedElementRefMap.containsKey(referencedElement.getQName())) { - processSchema(referencedElement, referencedElement.getSchemaType(), resolvedSchema, true); + processSchema(referencedElement, referencedElement.getSchemaType(), + resolvedSchema, true); // if this is an anonomous complex type we have to set this this.processedElementRefMap.put(referencedElement.getQName(), - this.processedTypemap.get(referencedElement.getSchemaTypeName())); + this.processedTypemap.get(referencedElement. + getSchemaTypeName())); } - - String javaClassName = this.processedTypemap.get(referencedElement.getSchemaTypeName()); + + String javaClassName = this.processedTypemap. + get(referencedElement.getSchemaTypeName()); referencedElement.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, - javaClassName); + javaClassName); xsElt.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, - javaClassName); - } else if (referencedElement.getSchemaTypeName() != null){ + javaClassName); + } else if (referencedElement.getSchemaTypeName() != null) { QName schemaTypeName = referencedElement.getSchemaTypeName(); - XmlSchema newResolvedSchema = getParentSchema(resolvedSchema, schemaTypeName, COMPONENT_TYPE); + XmlSchema newResolvedSchema = getParentSchema(resolvedSchema, schemaTypeName, + COMPONENT_TYPE); XmlSchemaType xmlSchemaType = newResolvedSchema.getTypeByName(schemaTypeName); if (xmlSchemaType != null) { if (!this.processedElementRefMap.containsKey(referencedElement.getQName())) { @@ -815,17 +839,20 @@ public class SchemaCompiler { processSchema(referencedElement, xmlSchemaType, newResolvedSchema, false); // if this is an anonomous complex type we have to set this this.processedElementRefMap.put(referencedElement.getQName(), - this.processedTypemap.get(schemaTypeName)); + this.processedTypemap.get(schemaTypeName)); } - String javaClassName = this.processedTypemap.get(referencedElement.getSchemaTypeName()); - referencedElement.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, - javaClassName); + String javaClassName = this.processedTypemap.get(referencedElement. + getSchemaTypeName()); + referencedElement.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder. + CLASSNAME_KEY, + javaClassName); xsElt.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, - javaClassName); + javaClassName); } else { - throw new SchemaCompilationException(" Can not find the schema type with name " + schemaTypeName); + throw new SchemaCompilationException(" Can not find the schema type with name " + + schemaTypeName); } } @@ -836,10 +863,10 @@ public class SchemaCompiler { //this specifically happens with xsd:anyType. QName schemaTypeName = xsElt.getSchemaTypeName(); - XmlSchema resolvedSchema = getParentSchema(parentSchema,schemaTypeName,COMPONENT_TYPE); + XmlSchema resolvedSchema = getParentSchema(parentSchema, schemaTypeName, COMPONENT_TYPE); XmlSchemaType typeByName = null; - if (resolvedSchema != null){ - typeByName = resolvedSchema.getTypeByName(schemaTypeName); + if (resolvedSchema != null) { + typeByName = resolvedSchema.getTypeByName(schemaTypeName); } if (typeByName != null) { @@ -851,7 +878,7 @@ public class SchemaCompiler { innerElementMap.put(xsElt.getQName(), className); // set the class name to be used in unwrapping xsElt.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, - className); + className); } else { this.processedElementList.add(xsElt.getQName()); } @@ -862,7 +889,7 @@ public class SchemaCompiler { innerElementMap.put(xsElt.getQName(), className); // set the class name to be used in unwrapping xsElt.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, - className); + className); } else { this.processedElementList.add(xsElt.getQName()); } @@ -888,10 +915,12 @@ public class SchemaCompiler { */ private QName generateTypeQName(QName referenceEltQName, XmlSchema parentSchema) { QName generatedTypeName = new QName(referenceEltQName.getNamespaceURI(), - referenceEltQName.getLocalPart() + getNextTypeSuffix(referenceEltQName.getLocalPart())); + referenceEltQName.getLocalPart() + + getNextTypeSuffix(referenceEltQName.getLocalPart())); while (parentSchema.getTypeByName(generatedTypeName) != null) { generatedTypeName = new QName(referenceEltQName.getNamespaceURI(), - referenceEltQName.getLocalPart() + getNextTypeSuffix(referenceEltQName.getLocalPart())); + referenceEltQName.getLocalPart() + + getNextTypeSuffix(referenceEltQName.getLocalPart())); } return generatedTypeName; } @@ -903,9 +932,9 @@ public class SchemaCompiler { */ private boolean isAlreadyProcessed(QName qName) { return processedTypemap.containsKey(qName) || - simpleTypesMap.containsKey(qName) || - baseSchemaTypeMap.containsKey(qName) || - processedGroupTypeMap.containsKey(qName); + simpleTypesMap.containsKey(qName) || + baseSchemaTypeMap.containsKey(qName) || + processedGroupTypeMap.containsKey(qName); } @@ -951,7 +980,8 @@ public class SchemaCompiler { className = baseSchemaTypeMap.get(qName); } else { if (isSOAP_ENC(qName.getNamespaceURI())) { - throw new SchemaCompilationException(SchemaCompilerMessages.getMessage("schema.soapencoding.error", qName.toString())); + throw new SchemaCompilationException(SchemaCompilerMessages. + getMessage("schema.soapencoding.error", qName.toString())); } // We seem to have failed in finding a class name for the @@ -960,7 +990,7 @@ public class SchemaCompiler { //property file className = writer.getDefaultClassName(); log.warn(SchemaCompilerMessages - .getMessage("schema.typeMissing", qName.toString())); + .getMessage("schema.typeMissing", qName.toString())); } if (isArray) { @@ -981,8 +1011,9 @@ public class SchemaCompiler { * false otherwise */ public static boolean isSOAP_ENC(String s) { - if (s.equals(Constants.URI_SOAP11_ENC)) + if (s.equals(Constants.URI_SOAP11_ENC)) { return true; + } return s.equals(Constants.URI_SOAP12_ENC); } @@ -1003,22 +1034,25 @@ public class SchemaCompiler { if (complexType.getName() != null && !this.changedComplexTypeSet.contains(schemaType)) { // here complex type may be in another shcema so we have to find the // correct parent schema. - XmlSchema resolvedSchema = getParentSchema(parentSchema,complexType.getQName(),COMPONENT_TYPE); - if (resolvedSchema == null){ + XmlSchema resolvedSchema = getParentSchema(parentSchema, complexType.getQName(), + COMPONENT_TYPE); + if (resolvedSchema == null) { throw new SchemaCompilationException("can not find the parent schema for the " + - "complex type " + complexType.getQName() + " from the parent schema " + - parentSchema.getTargetNamespace()); + "complex type " + complexType.getQName() + + " from the parent schema " + + parentSchema.getTargetNamespace()); } else { - processNamedComplexSchemaType(complexType, resolvedSchema); + processNamedComplexSchemaType(complexType, resolvedSchema); } } else { - processAnonymousComplexSchemaType(xsElt, complexType, parentSchema, isWriteAnonComplexType); + processAnonymousComplexSchemaType(xsElt, complexType, parentSchema, + isWriteAnonComplexType); } } else if (schemaType instanceof XmlSchemaSimpleType) { //process simple type processSimpleSchemaType((XmlSchemaSimpleType) schemaType, - xsElt, - parentSchema, null); + xsElt, + parentSchema, null); } } @@ -1054,11 +1088,13 @@ public class SchemaCompiler { javaClassName = writer.makeFullyQualifiedClassName(generatedTypeName); processedTypemap.put(generatedTypeName, javaClassName); this.processedElementRefMap.put(elt.getQName(), javaClassName); - complexType.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, javaClassName); + complexType.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, + javaClassName); } - BeanWriterMetaInfoHolder metaInfHolder = processComplexType(elt.getQName(),complexType, parentSchema); + BeanWriterMetaInfoHolder metaInfHolder = processComplexType(elt.getQName(), complexType, + parentSchema); // here the only difference is that we generate the class // irrespective of where we need it or not @@ -1080,10 +1116,11 @@ public class SchemaCompiler { * @param complexType */ private void processNamedComplexSchemaType(XmlSchemaComplexType complexType, - XmlSchema parentSchema) throws SchemaCompilationException { + XmlSchema parentSchema) + throws SchemaCompilationException { if (processedTypemap.containsKey(complexType.getQName()) - || baseSchemaTypeMap.containsKey(complexType.getQName())) { + || baseSchemaTypeMap.containsKey(complexType.getQName())) { return; } @@ -1093,9 +1130,10 @@ public class SchemaCompiler { //register that in the schema metainfo bag complexType.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, - fullyQualifiedClassName); + fullyQualifiedClassName); - BeanWriterMetaInfoHolder metaInfHolder = processComplexType(complexType.getQName(),complexType, parentSchema); + BeanWriterMetaInfoHolder metaInfHolder = processComplexType(complexType.getQName(), + complexType, parentSchema); //add this information to the metainfo holder metaInfHolder.setOwnQname(complexType.getQName()); metaInfHolder.setOwnClassName(fullyQualifiedClassName); @@ -1113,10 +1151,12 @@ public class SchemaCompiler { * @param metaInfHolder * @throws SchemaCompilationException */ - private String writeComplexType(XmlSchemaComplexType complexType, BeanWriterMetaInfoHolder metaInfHolder) + private String writeComplexType(XmlSchemaComplexType complexType, + BeanWriterMetaInfoHolder metaInfHolder) throws SchemaCompilationException { String javaClassName = writer.write(complexType.getQName(), - processedTypemap, processedGroupTypeMap, metaInfHolder, complexType.isAbstract()); + processedTypemap, processedGroupTypeMap, metaInfHolder, + complexType.isAbstract()); processedTypeMetaInfoMap.put(complexType.getQName(), metaInfHolder); return javaClassName; } @@ -1124,16 +1164,18 @@ public class SchemaCompiler { /** * Writes complex Sequence,Choice, all elements - * @param qname complex type qname + * + * @param qname complex type qname * @param metaInfHolder - * @return written java class name + * @return written java class name * @throws SchemaCompilationException */ - private String writeComplexParticle(QName qname,BeanWriterMetaInfoHolder metaInfHolder) + private String writeComplexParticle(QName qname, BeanWriterMetaInfoHolder metaInfHolder) throws SchemaCompilationException { - String javaClassName = writer.write(qname, processedTypemap, processedGroupTypeMap, metaInfHolder,false); + String javaClassName = writer.write(qname, processedTypemap, processedGroupTypeMap, + metaInfHolder, false); processedTypeMetaInfoMap.put(qname, metaInfHolder); return javaClassName; } @@ -1145,7 +1187,8 @@ public class SchemaCompiler { * @param metaInfHolder * @throws SchemaCompilationException */ - private void writeSimpleType(XmlSchemaSimpleType simpleType, BeanWriterMetaInfoHolder metaInfHolder) + private void writeSimpleType(XmlSchemaSimpleType simpleType, + BeanWriterMetaInfoHolder metaInfHolder) throws SchemaCompilationException { writer.write(simpleType, processedTypemap, processedGroupTypeMap, metaInfHolder); processedTypeMetaInfoMap.put(simpleType.getQName(), metaInfHolder); @@ -1161,13 +1204,14 @@ public class SchemaCompiler { //Process the particle processParticle(parentElementQName, particle, metaInfHolder, parentSchema); } - - if(complexType.isMixed()){ - throw new SchemaCompilationException("XSD complexType with mix content not supported in ADB"); + + if (complexType.isMixed()) { + throw new SchemaCompilationException("XSD complexType with mix content not " + + "supported in ADB"); } //process attributes - first look for the explicit attributes - processAttributes(complexType.getAttributes(),metaInfHolder,parentSchema); + processAttributes(complexType.getAttributes(), metaInfHolder, parentSchema); //process any attribute //somehow the xml schema parser does not seem to pickup the any attribute!! @@ -1180,44 +1224,63 @@ public class SchemaCompiler { //process content ,either complex or simple if (complexType.getContentModel() != null) { processContentModel(complexType.getContentModel(), - metaInfHolder, - parentSchema); + metaInfHolder, + parentSchema); } return metaInfHolder; } - private void processAttributes(XmlSchemaObjectCollection attributes, + private void processAttributes(List<XmlSchemaAttributeOrGroupRef> attributes, BeanWriterMetaInfoHolder metaInfHolder, XmlSchema parentSchema) throws SchemaCompilationException { - Iterator attribIterator = attributes.getIterator(); - while (attribIterator.hasNext()) { - Object o = attribIterator.next(); - if (o instanceof XmlSchemaAttribute) { - processAttribute((XmlSchemaAttribute) o, metaInfHolder, parentSchema); - } else if (o instanceof XmlSchemaAttributeGroupRef){ - processAttributeGroupReference((XmlSchemaAttributeGroupRef)o,metaInfHolder,parentSchema); + + for (XmlSchemaObject object : attributes) { + if (object instanceof XmlSchemaAttribute) { + processAttribute((XmlSchemaAttribute) object, metaInfHolder, parentSchema); + } else if (object instanceof XmlSchemaAttributeGroupRef) { + processAttributeGroupReference((XmlSchemaAttributeGroupRef) object, metaInfHolder, + parentSchema); } } } + private void processGroupAttributes(List<XmlSchemaAttributeGroupMember> attributes, + BeanWriterMetaInfoHolder metaInfHolder, + XmlSchema resolvedSchema) + throws SchemaCompilationException { + for (XmlSchemaAttributeGroupMember member : attributes) { + if (member instanceof XmlSchemaAttribute) { + processAttribute((XmlSchemaAttribute) member, metaInfHolder, resolvedSchema); + } else if (member instanceof XmlSchemaAttributeGroupRef) { + processAttributeGroupReference((XmlSchemaAttributeGroupRef) member, metaInfHolder, + resolvedSchema); + } + } + } + + private void processAttributeGroupReference(XmlSchemaAttributeGroupRef attributeGroupRef, BeanWriterMetaInfoHolder metaInfHolder, - XmlSchema parentSchema) throws SchemaCompilationException { + XmlSchema parentSchema) + throws SchemaCompilationException { - QName attributeGroupRefName = attributeGroupRef.getRefName(); - if (attributeGroupRefName != null){ - XmlSchema resolvedSchema = getParentSchema(parentSchema,attributeGroupRefName,COMPONENT_ATTRIBUTE_GROUP); + QName attributeGroupRefName = attributeGroupRef.getRef().getTargetQName(); + if (attributeGroupRefName != null) { + XmlSchema resolvedSchema = getParentSchema(parentSchema, attributeGroupRefName, + COMPONENT_ATTRIBUTE_GROUP); if (resolvedSchema == null) { throw new SchemaCompilationException("can not find the attribute group reference name " + - attributeGroupRefName + " from the parent schema " + parentSchema.getTargetNamespace()); + attributeGroupRefName + " from the parent schema " + + parentSchema.getTargetNamespace()); } else { XmlSchemaAttributeGroup xmlSchemaAttributeGroup = - (XmlSchemaAttributeGroup) resolvedSchema.getAttributeGroups().getItem(attributeGroupRefName); + resolvedSchema.getAttributeGroups().get(attributeGroupRefName); if (xmlSchemaAttributeGroup != null) { - processAttributes(xmlSchemaAttributeGroup.getAttributes(), metaInfHolder, resolvedSchema); + processGroupAttributes(xmlSchemaAttributeGroup.getAttributes(), metaInfHolder, + resolvedSchema); } else { throw new SchemaCompilationException("Can not find an attribute group for group reference " - + attributeGroupRefName.getLocalPart()); + + attributeGroupRefName.getLocalPart()); } } @@ -1254,15 +1317,18 @@ public class SchemaCompiler { // to handle extension we need to attach the extended items to the base type // and create a new type - XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension)content; + XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension) content; //process the base type if it has not been processed yet if (!isAlreadyProcessed(extension.getBaseTypeName())) { //pick the relevant basetype from the schema and process it - XmlSchema resolvedSchema = getParentSchema(parentSchema, extension.getBaseTypeName(), COMPONENT_TYPE); + XmlSchema resolvedSchema = getParentSchema(parentSchema, extension.getBaseTypeName(), + COMPONENT_TYPE); if (resolvedSchema == null) { - throw new SchemaCompilationException("can not find the compley type " + extension.getBaseTypeName() - + " from the parent type " + parentSchema.getTargetNamespace()); + throw new SchemaCompilationException("can not find the compley type " + + extension.getBaseTypeName() + + " from the parent type " + + parentSchema.getTargetNamespace()); } else { XmlSchemaType type = resolvedSchema.getTypeByName(extension.getBaseTypeName()); if (type instanceof XmlSchemaComplexType) { @@ -1290,12 +1356,13 @@ public class SchemaCompiler { //process the particle of this node if (extension.getParticle() != null) { - processParticle(extension.getBaseTypeName(),extension.getParticle(), metaInfHolder, parentSchema); + processParticle(extension.getBaseTypeName(), extension.getParticle(), metaInfHolder, + parentSchema); } // process attributes //process attributes - first look for the explicit attributes - processAttributes(extension.getAttributes(),metaInfHolder,parentSchema); + processAttributes(extension.getAttributes(), metaInfHolder, parentSchema); //process any attribute //somehow the xml schema parser does not seem to pickup the any attribute!! @@ -1314,15 +1381,20 @@ public class SchemaCompiler { //Note - this is no array! so the array boolean is false } } else if (content instanceof XmlSchemaComplexContentRestriction) { - XmlSchemaComplexContentRestriction restriction = (XmlSchemaComplexContentRestriction) content; + XmlSchemaComplexContentRestriction restriction = + (XmlSchemaComplexContentRestriction) content; //process the base type if it has not been processed yet if (!isAlreadyProcessed(restriction.getBaseTypeName())) { //pick the relevant basetype from the schema and process it - XmlSchema resolvedSchema = getParentSchema(parentSchema, restriction.getBaseTypeName(), COMPONENT_TYPE); + XmlSchema resolvedSchema = getParentSchema(parentSchema, + restriction.getBaseTypeName(), + COMPONENT_TYPE); if (resolvedSchema == null) { - throw new SchemaCompilationException("can not find the complex type " + restriction.getBaseTypeName() - + " from the parent type " + parentSchema.getTargetNamespace()); + throw new SchemaCompilationException("can not find the complex type " + + restriction.getBaseTypeName() + + " from the parent type " + + parentSchema.getTargetNamespace()); } else { XmlSchemaType type = resolvedSchema.getTypeByName(restriction.getBaseTypeName()); if (type instanceof XmlSchemaComplexType) { @@ -1335,7 +1407,8 @@ public class SchemaCompiler { throw new SchemaCompilationException("Unnamed complex type used in restriction");//Internationlize this } } else if (type instanceof XmlSchemaSimpleType) { - throw new SchemaCompilationException("Not a valid restriction, complex content restriction base type cannot be a simple type."); + throw new SchemaCompilationException("Not a valid restriction, " + + "complex content restriction base type cannot be a simple type."); } } } @@ -1343,10 +1416,11 @@ public class SchemaCompiler { copyMetaInfoHierarchy(metaInfHolder, restriction.getBaseTypeName(), parentSchema); //process the particle of this node - processParticle(restriction.getBaseTypeName(),restriction.getParticle(), metaInfHolder, parentSchema); + processParticle(restriction.getBaseTypeName(), restriction.getParticle(), metaInfHolder, + parentSchema); //process attributes - first look for the explicit attributes - processAttributes(restriction.getAttributes(),metaInfHolder,parentSchema); + processAttributes(restriction.getAttributes(), metaInfHolder, parentSchema); //process any attribute //somehow the xml schema parser does not seem to pickup the any attribute!! @@ -1358,7 +1432,8 @@ public class SchemaCompiler { if (!writer.getDefaultClassName().equals(className)) { metaInfHolder.setRestriction(true); - metaInfHolder.setRestrictionClassName(findClassName(restriction.getBaseTypeName(), false)); + metaInfHolder.setRestrictionClassName(findClassName(restriction.getBaseTypeName(), + false)); //Note - this is no array! so the array boolean is false } } @@ -1376,10 +1451,11 @@ public class SchemaCompiler { XmlSchema parentSchema) throws SchemaCompilationException { - XmlSchema resolvedSchema = getParentSchema(parentSchema,baseTypeName,COMPONENT_TYPE); + XmlSchema resolvedSchema = getParentSchema(parentSchema, baseTypeName, COMPONENT_TYPE); if (resolvedSchema == null) { throw new SchemaCompilationException("can not find type " + baseTypeName - + " from the parent schema " + parentSchema.getTargetNamespace()); + + " from the parent schema " + + parentSchema.getTargetNamespace()); } else { XmlSchemaType type = resolvedSchema.getTypeByName(baseTypeName); BeanWriterMetaInfoHolder baseMetaInfoHolder = @@ -1397,50 +1473,57 @@ public class SchemaCompiler { if (content instanceof XmlSchemaComplexContent) { XmlSchemaComplexContent complexContent = (XmlSchemaComplexContent) content; - if (complexContent.getContent() instanceof XmlSchemaComplexContentExtension) { + if (complexContent.getContent() instanceof + XmlSchemaComplexContentExtension) { XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension) complexContent.getContent(); //recursively call the copyMetaInfoHierarchy method copyMetaInfoHierarchy(baseMetaInfoHolder, - extension.getBaseTypeName(), - resolvedSchema); + extension.getBaseTypeName(), + resolvedSchema); - } else if (complexContent.getContent() instanceof XmlSchemaComplexContentRestriction) { + } else if (complexContent.getContent() instanceof + XmlSchemaComplexContentRestriction) { XmlSchemaComplexContentRestriction restriction = (XmlSchemaComplexContentRestriction) complexContent.getContent(); //recursively call the copyMetaInfoHierarchy method copyMetaInfoHierarchy(baseMetaInfoHolder, - restriction.getBaseTypeName(), - resolvedSchema); + restriction.getBaseTypeName(), + resolvedSchema); } else { throw new SchemaCompilationException( - SchemaCompilerMessages.getMessage("schema.unknowncontenterror")); + SchemaCompilerMessages. + getMessage("schema.unknowncontenterror")); } } else if (content instanceof XmlSchemaSimpleContent) { XmlSchemaSimpleContent simpleContent = (XmlSchemaSimpleContent) content; - if (simpleContent.getContent() instanceof XmlSchemaSimpleContentExtension) { - XmlSchemaSimpleContentExtension extension = (XmlSchemaSimpleContentExtension) simpleContent + if (simpleContent.getContent() instanceof + XmlSchemaSimpleContentExtension) { + XmlSchemaSimpleContentExtension extension = + (XmlSchemaSimpleContentExtension) simpleContent .getContent(); // recursively call the copyMetaInfoHierarchy // method copyMetaInfoHierarchy(baseMetaInfoHolder, - extension.getBaseTypeName(), resolvedSchema); + extension.getBaseTypeName(), resolvedSchema); - } else if (simpleContent.getContent() instanceof XmlSchemaSimpleContentRestriction) { + } else if (simpleContent.getContent() instanceof + XmlSchemaSimpleContentRestriction) { - XmlSchemaSimpleContentRestriction restriction = (XmlSchemaSimpleContentRestriction) simpleContent + XmlSchemaSimpleContentRestriction restriction = + (XmlSchemaSimpleContentRestriction) simpleContent .getContent(); // recursively call the copyMetaInfoHierarchy // method copyMetaInfoHierarchy(baseMetaInfoHolder, - restriction.getBaseTypeName(), resolvedSchema); + restriction.getBaseTypeName(), resolvedSchema); } - + } else { throw new SchemaCompilationException( SchemaCompilerMessages.getMessage("schema.unknowncontenterror")); @@ -1457,7 +1540,7 @@ public class SchemaCompiler { // code as union if (baseMetaInfoHolder.isUnion()) { metaInfHolder.setUnion(true); - for (Map.Entry<QName,String> entry : baseMetaInfoHolder.getMemberTypes().entrySet()) { + for (Map.Entry<QName, String> entry : baseMetaInfoHolder.getMemberTypes().entrySet()) { metaInfHolder.addMemberType(entry.getKey(), entry.getValue()); } } @@ -1480,7 +1563,9 @@ public class SchemaCompiler { * @param metaInfHolder * @throws SchemaCompilationException */ - private void processSimpleContent(XmlSchemaSimpleContent simpleContent, BeanWriterMetaInfoHolder metaInfHolder, XmlSchema parentSchema) + private void processSimpleContent(XmlSchemaSimpleContent simpleContent, + BeanWriterMetaInfoHolder metaInfHolder, + XmlSchema parentSchema) throws SchemaCompilationException { XmlSchemaContent content; content = simpleContent.getContent(); @@ -1490,10 +1575,13 @@ public class SchemaCompiler { //process the base type if it has not been processed yet if (!isAlreadyProcessed(extension.getBaseTypeName())) { //pick the relevant basetype from the schema and process it - XmlSchema resolvedSchema = getParentSchema(parentSchema, extension.getBaseTypeName(), COMPONENT_TYPE); + XmlSchema resolvedSchema = getParentSchema(parentSchema, extension.getBaseTypeName(), + COMPONENT_TYPE); if (resolvedSchema == null) { - throw new SchemaCompilationException("can not find type " + extension.getBaseTypeName() - + " from the parent schema " + parentSchema.getTargetNamespace()); + throw new SchemaCompilationException("can not find type " + + extension.getBaseTypeName() + + " from the parent schema " + + parentSchema.getTargetNamespace()); } else { XmlSchemaType type = resolvedSchema.getTypeByName(extension.getBaseTypeName()); if (type instanceof XmlSchemaComplexType) { @@ -1517,10 +1605,7 @@ public class SchemaCompiler { processSimpleExtensionBaseType(extension.getBaseTypeName(), metaInfHolder, parentSchema); //process attributes - XmlSchemaObjectCollection attribs = extension.getAttributes(); - Iterator attribIterator = attribs.getIterator(); - while (attribIterator.hasNext()) { - Object attr = attribIterator.next(); + for (XmlSchemaAttributeOrGroupRef attr : extension.getAttributes()) { if (attr instanceof XmlSchemaAttribute) { processAttribute((XmlSchemaAttribute) attr, metaInfHolder, parentSchema); @@ -1539,10 +1624,14 @@ public class SchemaCompiler { //process the base type if it has not been processed yet if (!isAlreadyProcessed(restriction.getBaseTypeName())) { //pick the relevant basetype from the schema and process it - XmlSchema resolvedSchema = getParentSchema(parentSchema, restriction.getBaseTypeName(), COMPONENT_TYPE); + XmlSchema resolvedSchema = getParentSchema(parentSchema, + restriction.getBaseTypeName(), + COMPONENT_TYPE); if (resolvedSchema == null) { - throw new SchemaCompilationException("can not find type " + restriction.getBaseTypeName() - + " from the parent schema " + parentSchema.getTargetNamespace()); + throw new SchemaCompilationException("can not find type " + + restriction.getBaseTypeName() + + " from the parent schema " + + parentSchema.getTargetNamespace()); } else { XmlSchemaType type = resolvedSchema.getTypeByName(restriction.getBaseTypeName()); @@ -1564,13 +1653,14 @@ public class SchemaCompiler { } //process restriction base type processSimpleRestrictionBaseType(restriction.getBaseTypeName(), - restriction.getBaseTypeName(), - metaInfHolder, - parentSchema); + restriction.getBaseTypeName(), + metaInfHolder, + parentSchema); metaInfHolder.setSimple(true); - - if (!SchemaConstants.XSD_BOOLEAN.equals(restriction.getBaseTypeName())){ - processFacets(restriction.getFacets(), restriction.getBaseTypeName(), metaInfHolder, parentSchema); + + if (!SchemaConstants.XSD_BOOLEAN.equals(restriction.getBaseTypeName())) { + processFacets(restriction.getFacets(), restriction.getBaseTypeName(), metaInfHolder, + parentSchema); } } } @@ -1583,7 +1673,8 @@ public class SchemaCompiler { */ public void processSimpleExtensionBaseType(QName extBaseType, BeanWriterMetaInfoHolder metaInfHolder, - XmlSchema parentSchema) throws SchemaCompilationException { + XmlSchema parentSchema) + throws SchemaCompilationException { //find the class name String className = findClassName(extBaseType, false); @@ -1597,21 +1688,22 @@ public class SchemaCompiler { //this means the schema type actually returns a different QName if (changedTypeMap.containsKey(extBaseType)) { metaInfHolder.registerMapping(extBaseType, - changedTypeMap.get(extBaseType), - className, SchemaConstants.ELEMENT_TYPE); + changedTypeMap.get(extBaseType), + className, SchemaConstants.ELEMENT_TYPE); } else { metaInfHolder.registerMapping(extBaseType, - extBaseType, - className, SchemaConstants.ELEMENT_TYPE); + extBaseType, + className, SchemaConstants.ELEMENT_TYPE); } metaInfHolder.setSimple(true); // we have already process when it comes to this place } else if (processedTypemap.containsKey(extBaseType)) { //set the extension base class name - XmlSchema resolvedSchema = getParentSchema(parentSchema,extBaseType,COMPONENT_TYPE); + XmlSchema resolvedSchema = getParentSchema(parentSchema, extBaseType, COMPONENT_TYPE); if (resolvedSchema == null) { throw new SchemaCompilationException("can not find the type " + extBaseType - + " from the parent schema " + parentSchema.getTargetNamespace()); + + " from the parent schema " + + parentSchema.getTargetNamespace()); } else { XmlSchemaType type = resolvedSchema.getTypeByName(extBaseType); if (type instanceof XmlSchemaSimpleType) { @@ -1622,16 +1714,15 @@ public class SchemaCompiler { copyMetaInfoHierarchy(metaInfHolder, extBaseType, resolvedSchema); } else if (type instanceof XmlSchemaComplexType) { XmlSchemaComplexType complexType = (XmlSchemaComplexType) type; - // do not set as a simple type since we want to - // print the element names - metaInfHolder.setExtension(true); - metaInfHolder.setExtensionClassName(className); - copyMetaInfoHierarchy(metaInfHolder, extBaseType, resolvedSchema); - XmlSchemaContentModel typeContent =complexType.getContentModel(); - if(typeContent != null && typeContent instanceof XmlSchemaSimpleContent){ - metaInfHolder.setSimple(true); - } - + // do not set as a simple type since we want to + // print the element names + metaInfHolder.setExtension(true); + metaInfHolder.setExtensionClassName(className); + copyMetaInfoHierarchy(metaInfHolder, extBaseType, resolvedSchema); + XmlSchemaContentModel typeContent = complexType.getContentModel(); + if (typeContent != null && typeContent instanceof XmlSchemaSimpleContent) { + metaInfHolder.setSimple(true); + } } } @@ -1642,7 +1733,7 @@ public class SchemaCompiler { //get the binary state and add that to the status map if (isBinary(extBaseType)) { metaInfHolder.addtStatus(extBaseType, - SchemaConstants.BINARY_TYPE); + SchemaConstants.BINARY_TYPE); } } @@ -1655,7 +1746,8 @@ public class SchemaCompiler { public void processSimpleRestrictionBaseType(QName qName, QName resBaseType, BeanWriterMetaInfoHolder metaInfHolder, - XmlSchema parentSchema) throws SchemaCompilationException { + XmlSchema parentSchema) + throws SchemaCompilationException { //find the class name String className = findClassName(resBaseType, false); @@ -1664,12 +1756,12 @@ public class SchemaCompiler { if (baseSchemaTypeMap.containsKey(resBaseType)) { if (changedTypeMap.containsKey(resBaseType)) { metaInfHolder.registerMapping(qName, - changedTypeMap.get(resBaseType), - className, SchemaConstants.ELEMENT_TYPE); + changedTypeMap.get(resBaseType), + className, SchemaConstants.ELEMENT_TYPE); } else { metaInfHolder.registerMapping(qName, - resBaseType, - className, SchemaConstants.ELEMENT_TYPE); + resBaseType, + className, SchemaConstants.ELEMENT_TYPE); } } else if (processedTypemap.containsKey(resBaseType)) { //this is not a standared type @@ -1689,34 +1781,28 @@ public class SchemaCompiler { * Process Facets. * * @param metaInfHolder - * @param facets + * @param facets */ - private void processFacets( XmlSchemaObjectCollection facets,QName restrictionName, + private void processFacets(List<XmlSchemaFacet> facets, QName restrictionName, BeanWriterMetaInfoHolder metaInfHolder, XmlSchema parentSchema) { - - Iterator facetIterator = facets.getIterator(); - - while (facetIterator.hasNext()) { - Object obj = facetIterator.next(); - if (obj instanceof XmlSchemaPatternFacet) { - XmlSchemaPatternFacet pattern = (XmlSchemaPatternFacet) obj; + for (XmlSchemaFacet facet : facets) { + if (facet instanceof XmlSchemaPatternFacet) { + XmlSchemaPatternFacet pattern = (XmlSchemaPatternFacet) facet; // some patterns contain \ so we have to replace them String patternString = pattern.getValue().toString(); // replace backword slashes patternString = patternString.replaceAll("\\\\", "\\\\\\\\"); - patternString = patternString.replaceAll("\"","\\\\\""); + patternString = patternString.replaceAll("\"", "\\\\\""); if ((metaInfHolder.getPatternFacet() != null) && - (metaInfHolder.getPatternFacet().trim().length() > 0)){ + (metaInfHolder.getPatternFacet().trim().length() > 0)) { // i.e there is a pattern faceset patternString = metaInfHolder.getPatternFacet().trim() + "|" + patternString; } metaInfHolder.setPatternFacet(patternString); - } - - else if (obj instanceof XmlSchemaEnumerationFacet) { - XmlSchemaEnumerationFacet enumeration = (XmlSchemaEnumerationFacet) obj; + } else if (facet instanceof XmlSchemaEnumerationFacet) { + XmlSchemaEnumerationFacet enumeration = (XmlSchemaEnumerationFacet) facet; if (restrictionName.equals(SchemaConstants.XSD_QNAME)) { // we have to process the qname here and shoud find the local part and namespace uri String value = enumeration.getValue().toString(); @@ -1731,45 +1817,29 @@ public class SchemaCompiler { metaInfHolder.addEnumFacet(enumeration.getValue().toString()); } - } - - else if (obj instanceof XmlSchemaLengthFacet) { - XmlSchemaLengthFacet length = (XmlSchemaLengthFacet) obj; + } else if (facet instanceof XmlSchemaLengthFacet) { + XmlSchemaLengthFacet length = (XmlSchemaLengthFacet) facet; metaInfHolder.setLengthFacet(Integer.parseInt(length.getValue().toString())); - } - - else if (obj instanceof XmlSchemaTotalDigitsFacet) { - XmlSchemaTotalDigitsFacet totalDigits = (XmlSchemaTotalDigitsFacet) obj; + } else if (facet instanceof XmlSchemaTotalDigitsFacet) { + XmlSchemaTotalDigitsFacet totalDigits = (XmlSchemaTotalDigitsFacet) facet; metaInfHolder.setTotalDigitsFacet(totalDigits.getValue().toString()); - } - - else if (obj instanceof XmlSchemaMaxExclusiveFacet) { - XmlSchemaMaxExclusiveFacet maxEx = (XmlSchemaMaxExclusiveFacet) obj; + } else if (facet instanceof XmlSchemaMaxExclusiveFacet) { + XmlSchemaMaxExclusiveFacet maxEx = (XmlSchemaMaxExclusiveFacet) facet; metaInfHolder.setMaxExclusiveFacet(maxEx.getValue().toString()); - } - - else if (obj instanceof XmlSchemaMinExclusiveFacet) { - XmlSchemaMinExclusiveFacet minEx = (XmlSchemaMinExclusiveFacet) obj; + } else if (facet instanceof XmlSchemaMinExclusiveFacet) { + XmlSchemaMinExclusiveFacet minEx = (XmlSchemaMinExclusiveFacet) facet; metaInfHolder.setMinExclusiveFacet(minEx.getValue().toString()); - } - - else if (obj instanceof XmlSchemaMaxInclusiveFacet) { - XmlSchemaMaxInclusiveFacet maxIn = (XmlSchemaMaxInclusiveFacet) obj; + } else if (facet instanceof XmlSchemaMaxInclusiveFacet) { + XmlSchemaMaxInclusiveFacet maxIn = (XmlSchemaMaxInclusiveFacet) facet; metaInfHolder.setMaxInclusiveFacet(maxIn.getValue().toString()); - } - - else if (obj instanceof XmlSchemaMinInclusiveFacet) { - XmlSchemaMinInclusiveFacet minIn = (XmlSchemaMinInclusiveFacet) obj; + } else if (facet instanceof XmlSchemaMinInclusiveFacet) { + XmlSchemaMinInclusiveFacet minIn = (XmlSchemaMinInclusiveFacet) facet; metaInfHolder.setMinInclusiveFacet(minIn.getValue().toString()); - } - - else if (obj instanceof XmlSchemaMaxLengthFacet) { - XmlSchemaMaxLengthFacet maxLen = (XmlSchemaMaxLengthFacet) obj; + } else if (facet instanceof XmlSchemaMaxLengthFacet) { + XmlSchemaMaxLengthFacet maxLen = (XmlSchemaMaxLengthFacet) facet; metaInfHolder.setMaxLengthFacet(Integer.parseInt(maxLen.getValue().toString())); - } - - else if (obj instanceof XmlSchemaMinLengthFacet) { - XmlSchemaMinLengthFacet minLen = (XmlSchemaMinLengthFacet) obj; + } else if (facet instanceof XmlSchemaMinLengthFacet) { + XmlSchemaMinLengthFacet minLen = (XmlSchemaMinLengthFacet) facet; metaInfHolder.setMinLengthFacet(Integer.parseInt(minLen.getValue().toString())); } } @@ -1780,17 +1850,18 @@ public class SchemaCompiler { * * @param metainf */ - private void processAnyAttribute(BeanWriterMetaInfoHolder metainf, XmlSchemaAnyAttribute anyAtt) { + private void processAnyAttribute(BeanWriterMetaInfoHolder metainf, + XmlSchemaAnyAttribute anyAtt) { //The best thing we can do here is to add a set of OMAttributes //since attributes do not have the notion of minoccurs/maxoccurs the //safest option here is to have an OMAttribute array QName qName = new QName(EXTRA_ATTRIBUTE_FIELD_NAME); metainf.registerMapping(qName, - null, - writer.getDefaultAttribArrayClassName(),//always generate an array of - //OMAttributes - SchemaConstants.ANY_TYPE); + null, + writer.getDefaultAttribArrayClassName(),//always generate an array of + //OMAttributes + SchemaConstants.ANY_TYPE); metainf.addtStatus(qName, SchemaConstants.ATTRIBUTE_TYPE); metainf.addtStatus(qName, SchemaConstants.ARRAY_TYPE); @@ -1803,7 +1874,8 @@ public class SchemaCompiler { * @param att * @param metainf */ - public void processAttribute(XmlSchemaAttribute att, BeanWriterMetaInfoHolder metainf, XmlSchema parentSchema) + public void processAttribute(XmlSchemaAttribute att, BeanWriterMetaInfoHolder metainf, + XmlSchema parentSchema) throws SchemaCompilationException { QName schemaTypeName = att.getSchemaTypeName(); @@ -1812,10 +1884,11 @@ public class SchemaCompiler { if (baseSchemaTypeMap.containsKey(schemaTypeName)) { metainf.registerMapping(att.getQName(), schemaTypeName, - baseSchemaTypeMap.get(schemaTypeName).toString(), SchemaConstants.ATTRIBUTE_TYPE); + baseSchemaTypeMap.get(schemaTypeName).toString(), + SchemaConstants.ATTRIBUTE_TYPE); // add optional attribute status if set - String use = att.getUse().getValue(); + String use = att.getUse().toString(); if (USE_NONE.equals(use) || USE_OPTIONAL.equals(use)) { metainf.addtStatus(att.getQName(), SchemaConstants.OPTIONAL_TYPE); } @@ -1826,19 +1899,22 @@ public class SchemaCompiler { SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY, className); // set the default value - if (att.getDefaultValue() != null){ - metainf.registerDefaultValue(att.getQName(),att.getDefaultValue()); - } - if(att.getFixedValue() != null){ + if (att.getDefaultValue() != null) { + metainf.registerDefaultValue(att.getQName(), att.getDefaultValue()); + } + if (att.getFixedValue() != null) { metainf.registerDefaultValue(att.getQName(), att.getFixedValue()); metainf.setFixed(true);
[... 1345 lines stripped ...]
