You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by di...@apache.org on 2006/08/07 06:49:11 UTC
svn commit: r429238 [2/4] - in
/webservices/axis2/trunk/java/modules/adb-codegen:
src/org/apache/axis2/schema/ src/org/apache/axis2/schema/template/
src/org/apache/axis2/schema/writer/ test-resources/xsd/
test/org/apache/axis2/schema/compile/
Modified: webservices/axis2/trunk/java/modules/adb-codegen/src/org/apache/axis2/schema/SchemaCompiler.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/adb-codegen/src/org/apache/axis2/schema/SchemaCompiler.java?rev=429238&r1=429237&r2=429238&view=diff
==============================================================================
--- webservices/axis2/trunk/java/modules/adb-codegen/src/org/apache/axis2/schema/SchemaCompiler.java (original)
+++ webservices/axis2/trunk/java/modules/adb-codegen/src/org/apache/axis2/schema/SchemaCompiler.java Sun Aug 6 21:49:10 2006
@@ -1,1289 +1,1375 @@
-package org.apache.axis2.schema;
-
-import org.apache.axiom.om.OMAttribute;
-import org.apache.axiom.om.OMElement;
-import org.apache.axis2.namespace.Constants;
-import org.apache.axis2.schema.i18n.SchemaCompilerMessages;
-import org.apache.axis2.schema.util.SchemaPropertyLoader;
-import org.apache.axis2.schema.writer.BeanWriter;
-import org.apache.axis2.util.URLProcessor;
-import org.apache.ws.commons.schema.XmlSchema;
-import org.apache.ws.commons.schema.XmlSchemaAll;
-import org.apache.ws.commons.schema.XmlSchemaAny;
-import org.apache.ws.commons.schema.XmlSchemaAnyAttribute;
-import org.apache.ws.commons.schema.XmlSchemaAttribute;
-import org.apache.ws.commons.schema.XmlSchemaChoice;
-import org.apache.ws.commons.schema.XmlSchemaComplexContent;
-import org.apache.ws.commons.schema.XmlSchemaComplexContentExtension;
-import org.apache.ws.commons.schema.XmlSchemaComplexContentRestriction;
-import org.apache.ws.commons.schema.XmlSchemaComplexType;
-import org.apache.ws.commons.schema.XmlSchemaContent;
-import org.apache.ws.commons.schema.XmlSchemaContentModel;
-import org.apache.ws.commons.schema.XmlSchemaElement;
-import org.apache.ws.commons.schema.XmlSchemaImport;
-import org.apache.ws.commons.schema.XmlSchemaInclude;
-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.XmlSchemaSequence;
-import org.apache.ws.commons.schema.XmlSchemaSimpleContent;
-import org.apache.ws.commons.schema.XmlSchemaSimpleContentExtension;
-import org.apache.ws.commons.schema.XmlSchemaSimpleContentRestriction;
-import org.apache.ws.commons.schema.XmlSchemaSimpleType;
-import org.apache.ws.commons.schema.XmlSchemaSimpleTypeContent;
-import org.apache.ws.commons.schema.XmlSchemaSimpleTypeList;
-import org.apache.ws.commons.schema.XmlSchemaSimpleTypeRestriction;
-import org.apache.ws.commons.schema.XmlSchemaSimpleTypeUnion;
-import org.apache.ws.commons.schema.XmlSchemaType;
-
-import javax.xml.namespace.QName;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Properties;
-/*
- * Copyright 2004,2005 The Apache Software Foundation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Schema compiler for ADB. Based on WS-Commons schema object model.
- */
-public class SchemaCompiler {
-
-
- private CompilerOptions options;
- private HashMap processedTypemap;
-
- //the list of processedElements for the outer elements
- private HashMap processedElementMap;
-
- private HashMap processedAnonymousComplexTypesMap;
-
- //we need this map to keep the referenced elements. these elements need to be kept seperate
- //to avoid conflicts
- private HashMap processedElementRefMap;
- private HashMap simpleTypesMap;
- private HashMap changedTypeMap;
-
- // 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 processedTypeMetaInfoMap;
-
- //
- private ArrayList processedElementList;
-
- //a list of nillable elements - used to generate code
- //for nillable elements
- private List nillableElementList;
- // writee reference
- private BeanWriter writer = null;
- private Map baseSchemaTypeMap = null;
-
- //a map for keeping the already loaded schemas
- //the key is the targetnamespace and the value is the schema object
- private Map loadedSchemaMap = new HashMap();
-
- // 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 availableSchemaMap = new HashMap();
-
-
-
- // a list of externally identified QNames to be processed. This becomes
- // useful when only a list of external elements need to be processed
-
- public static final String ANY_ELEMENT_FIELD_NAME = "extraElement";
- public static final String EXTRA_ATTRIBUTE_FIELD_NAME = "extraAttributes";
-
- public static final String DEFAULT_CLASS_NAME = OMElement.class.getName();
- public static final String DEFAULT_CLASS_ARRAY_NAME = "org.apache.axiom.om.OMElement[]";
-
- public static final String DEFAULT_ATTRIB_CLASS_NAME = OMAttribute.class.getName();
- public static final String DEFAULT_ATTRIB_ARRAY_CLASS_NAME = "org.apache.axiom.om.OMAttribute[]";
-
-
- private static int typeCounter = 0;
-
-
-
-
- /**
- * @return the processes element map
- * includes the Qname of the element as the key and a
- * String representing the fully qualified class name
- */
- public HashMap getProcessedElementMap() {
- return processedElementMap;
- }
-
-
- /**
- * @return a map of Qname vs models. A model can be anything,
- * ranging from a DOM document to a stream. This is taken from the
- * writer and the schema compiler has no control over it
- */
- public Map getProcessedModelMap() {
- return writer.getModelMap();
- }
-
- /**
- * Constructor - Accepts a options bean
- *
- * @param options
- */
- public SchemaCompiler(CompilerOptions options) throws SchemaCompilationException {
-
- if (options == null) {
- //create an empty options object
- this.options = new CompilerOptions();
- } else {
- this.options = options;
- }
-
- //instantiate the maps
- processedTypemap = new HashMap();
- processedElementMap = new HashMap();
- simpleTypesMap = new HashMap();
- processedElementList = new ArrayList();
- processedAnonymousComplexTypesMap = new HashMap();
- changedTypeMap = new HashMap();
- processedTypeMetaInfoMap = new HashMap();
- processedElementRefMap = new HashMap();
- nillableElementList = new ArrayList();
-
- //load the writer and initiliaze the base types
- writer = SchemaPropertyLoader.getBeanWriterInstance();
- writer.init(this.options);
-
- //load the base types
- baseSchemaTypeMap = SchemaPropertyLoader.getTypeMapperInstance().getTypeMap();
-
-
- }
-
- /**
- * Compile a list of schemas
- * This actually calls the compile (XmlSchema s) method repeatedly
- *
- * @param schemalist
- * @throws SchemaCompilationException
- * @see #compile(org.apache.ws.commons.schema.XmlSchema)
- */
- public void compile(List schemalist) throws SchemaCompilationException {
- try {
-
- if (schemalist.isEmpty()){
- return;
- }
-
- //clear the loaded and available maps
- loadedSchemaMap.clear();
- availableSchemaMap.clear();
-
- XmlSchema schema;
- // first round - populate the avaialble map
- for (int i = 0; i < schemalist.size(); i++) {
- schema = (XmlSchema) schemalist.get(i);
- availableSchemaMap.put(
- schema.getTargetNamespace(),
- schema
- );
- }
-
- //set a mapper package if not avaialable
- if (writer.getExtensionMapperPackageName()==null){
- //get the first schema from the list and take that namespace as the
- //mapper namespace
- writer.registerExtensionMapperPackageName(
- URLProcessor.makePackageName(((XmlSchema) schemalist.get(0)).getTargetNamespace()));
- }
- // second round - call the schema compiler one by one
- for (int i = 0; i < schemalist.size(); i++) {
- compile((XmlSchema) schemalist.get(i),true);
- }
-
- //finish up
- finalizeSchemaCompilation();
-
- } catch (SchemaCompilationException e) {
- throw e;
- } catch (Exception e) {
- throw new SchemaCompilationException(e);
- }
- }
-
- /**
- * Compile (rather codegen) a single schema element
- * @param schema
- * @throws SchemaCompilationException
- */
- public void compile(XmlSchema schema) throws SchemaCompilationException {
- compile(schema,false);
- }
-
- /**
- * Compile (rather codegen) a single schema element
- * @param schema
- * @param 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.
- if (Constants.URI_2001_SCHEMA_XSD.equals(schema.getTargetNamespace())) {
- return;
- }
-
- //register the package from this namespace as the mapper classes package
- if (!isPartofGroup){
- //set a mapper package if not avaialable
- if (writer.getExtensionMapperPackageName()==null){
- writer.registerExtensionMapperPackageName(
- URLProcessor.makePackageName(schema.getTargetNamespace()));
- }
- }
-
- //First look for the schemas that are imported and process them
- //Note that these are processed recursively!
-
- //add the schema to the loaded schema list
- if (!loadedSchemaMap.containsKey(schema.getTargetNamespace())) {
- loadedSchemaMap.put(schema.getTargetNamespace(), schema);
- }
-
- XmlSchemaObjectCollection includes = schema.getIncludes();
- if (includes != null) {
- Iterator tempIterator = includes.getIterator();
- while (tempIterator.hasNext()) {
- Object o = tempIterator.next();
- if (o instanceof XmlSchemaImport) {
- XmlSchema schema1 = ((XmlSchemaImport) o).getSchema();
- if (schema1 != null) compile(schema1,isPartofGroup);
- }
- if (o instanceof XmlSchemaInclude) {
- XmlSchema schema1 = ((XmlSchemaInclude) o).getSchema();
- if (schema1 != null) 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()) {
- //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);
- }
-
- 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()) {
- //this is the set of outer elements so we need to generate classes
- writeElement((XmlSchemaElement) xmlSchemaElement2Iterator.next());
- }
-
- if (!isPartofGroup){
- //complete the compilation
- finalizeSchemaCompilation();
- }
- }
-
- /**
- * Completes the schema compilation process by writing the
- * mappers and the classes in a batch if needed
- * @throws SchemaCompilationException
- */
- private void finalizeSchemaCompilation() throws SchemaCompilationException {
- //write the extension mapping class
- writer.writeExtensionMapper(
- (BeanWriterMetaInfoHolder[])
- processedTypeMetaInfoMap.values().toArray(
- new BeanWriterMetaInfoHolder[processedTypeMetaInfoMap.size()]));
-
-
- if (options.isWrapClasses()) {
- writer.writeBatch();
- }
- }
-
- /**
- * @return the property map of the schemacompiler.
- * In this case it would be the property map loaded from
- * the configuration file
- */
- public Properties getCompilerProperties(){
- return SchemaPropertyLoader.getPropertyMap() ;
- }
-
-
- /**
- * Writes the element
- *
- * @param xsElt
- * @throws SchemaCompilationException
- */
- private void writeElement(XmlSchemaElement xsElt) throws SchemaCompilationException {
-
- if (this.processedElementMap.containsKey(xsElt.getQName())) {
- return;
- }
-
- XmlSchemaType schemaType = xsElt.getSchemaType();
-
-
- BeanWriterMetaInfoHolder metainf = new BeanWriterMetaInfoHolder();
- if (schemaType != null && schemaType.getName() != null) {
- //this is a named type
- QName qName = schemaType.getQName();
- //find the class name
- String className = findClassName(qName, isArray(xsElt));
-
- //this means the schema type actually returns a different QName
- if (changedTypeMap.containsKey(qName)) {
- metainf.registerMapping(xsElt.getQName(),
- (QName) changedTypeMap.get(qName),
- className);
- } else {
- metainf.registerMapping(xsElt.getQName(),
- qName,
- className);
- }
-
-
- }else if (xsElt.getRefName()!= 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
- }else if (xsElt.getSchemaTypeName()!= null) {
- QName qName = xsElt.getSchemaTypeName();
- String className = findClassName(qName, isArray(xsElt));
- metainf.registerMapping(xsElt.getQName(),
- qName,
- className);
-
-
- }else if (schemaType != null){ //the named type should have been handled already
-
- //we are going to special case the anonymous complex type. Our algorithm for dealing
- //with it is to generate a single object that has the complex content inside. Really the
- //intent of the user when he declares the complexType anonymously is to use it privately
- //First copy the schema types content into the metainf holder
- metainf = (BeanWriterMetaInfoHolder) this.processedAnonymousComplexTypesMap.get(xsElt);
- metainf.setAnonymous(true);
- }else{
- //this means we did not find any schema type associated with the particular element. we
- //should be throwing an exception here
- throw new SchemaCompilationException("no type!!");//todo i18n this
- }
-
- if (nillableElementList.contains(xsElt.getQName())){
- metainf.registerNillableQName(xsElt.getQName());
- }
-
-
- String writtenClassName = writer.write(xsElt, processedTypemap, metainf);
- //register the class name
- xsElt.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY,
- writtenClassName);
- processedElementMap.put(xsElt.getQName(), writtenClassName);
- }
-
- /**
- * For inner elements
- * @param xsElt
- * @param innerElementMap
- * @param parentSchema
- * @throws SchemaCompilationException
- */
- private void processElement(XmlSchemaElement xsElt,Map innerElementMap,List localNillableList,XmlSchema parentSchema) throws SchemaCompilationException {
- processElement(xsElt,false,innerElementMap,localNillableList,parentSchema);
- }
-
- /**
- * For outer elements
- * @param xsElt
- * @param parentSchema
- * @throws SchemaCompilationException
- */
- private void processElement(XmlSchemaElement xsElt,XmlSchema parentSchema) throws SchemaCompilationException {
- processElement(xsElt,true,null,null,parentSchema);
- }
- /**
- * Process and Element
- *
- * @param xsElt
- * @param isOuter- We need to know this since the treatment of outer elements is different that
- * inner elements
- * @param isArray- flag saying whether the elements represents an array
- * @throws SchemaCompilationException
- */
- private void processElement(XmlSchemaElement xsElt, boolean isOuter,Map innerElementMap,List localNillableList, XmlSchema parentSchema) throws SchemaCompilationException {
-
- //if the element is null, which usually happens when the qname is not
- //proper, throw an exceptions
- if (xsElt==null){
- throw new SchemaCompilationException(
- 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!
- if (isOuter && processedElementList.contains(xsElt.getQName())) {
- return;
- }
-
- XmlSchemaType schemaType = xsElt.getSchemaType();
- if (schemaType != null) {
- processSchema(xsElt, schemaType,parentSchema);
- //at this time it is not wise to directly write the class for the element
- //so we push the complete element to an arraylist and let the process
- //pass through. We'll be iterating through the elements writing them
- //later
-
- if (!isOuter) {
- if (schemaType.getName()!=null){
- // this element already has a name. Which means we can directly
- // register it
- String className = findClassName(schemaType.getQName(),
- isArray(xsElt));
-
- innerElementMap.put(xsElt.getQName(), className);
-
- //store in the schema map
- schemaType.addMetaInfo(
- SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY,
- className);
-
- if (baseSchemaTypeMap.containsValue(className)){
- schemaType.addMetaInfo(
- SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_PRIMITVE_KEY,
- Boolean.TRUE);
- }
- //since this is a inner element we should add it to the inner element map
- }else{
- //this is an anon type. This should have been already processed and registered at
- //the anon map. we've to write it just like we treat a referenced type(giving due
- //care that this is meant to be an attribute in some class)
-
- QName generatedTypeName = generateTypeQName(xsElt.getQName(), parentSchema);
-
- if (schemaType instanceof XmlSchemaComplexType){
- //set a name
- schemaType.setName(generatedTypeName.getLocalPart());
- writeComplexType((XmlSchemaComplexType)schemaType,
- (BeanWriterMetaInfoHolder)processedAnonymousComplexTypesMap.get(xsElt));
- //remove the reference from the anon list since we named the type
- processedAnonymousComplexTypesMap.remove(xsElt);
- String className = findClassName(schemaType.getQName(), isArray(xsElt));
- innerElementMap.put(
- xsElt.getQName(),
- className);
-
- //store in the schema map
- xsElt.addMetaInfo(
- SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY,
- className);
- }
- }
- }else{
- this.processedElementList.add(xsElt.getQName());
- }
- //referenced name
- }else if (xsElt.getRefName()!=null){
-
- //process the referenced type. It could be thought that the referenced element replaces this
- //element
- XmlSchema currentParentSchema = resolveParentSchema(xsElt.getRefName(),parentSchema);
- XmlSchemaElement referencedElement = currentParentSchema.getElementByName(xsElt.getRefName());
-
- //if the element is referenced, then it should be one of the outer (global) ones
- processElement(referencedElement, parentSchema);
-
- //no outer check required here. If the element is having a ref, then it is definitely
- //not an outer element since the top level elements are not supposed to have refs
- //Also we are sure that it should have a type reference
- QName referenceEltQName = referencedElement.getQName();
- if (referencedElement.getSchemaTypeName()!=null){
- String className = findClassName(referencedElement.getSchemaTypeName(), isArray(xsElt));
- //if this element is referenced, there's no QName for this element
- this.processedElementRefMap.put(referenceEltQName, className);
-
- referencedElement.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY,
- className);
- }else{
- //this referenced element has an anon type and that anon type has been already
- //processed. But in this case we need it to be a seperate class since this
- //complextype has to be added as an attribute in a class.
- //generate a name for this type
- QName generatedTypeName = generateTypeQName(referenceEltQName, parentSchema);
- XmlSchemaType referenceSchemaType = referencedElement.getSchemaType();
-
- if (referenceSchemaType instanceof XmlSchemaComplexType){
- //set a name
- referenceSchemaType.setName(generatedTypeName.getLocalPart());
-
- writeComplexType((XmlSchemaComplexType)referenceSchemaType,
- (BeanWriterMetaInfoHolder)processedAnonymousComplexTypesMap.get(referencedElement)
- );
- //remove the reference from the anon list since we named the type
- processedAnonymousComplexTypesMap.remove(referencedElement);
-
- //add this to the processed ref type map
- this.processedElementRefMap.put(referenceEltQName,findClassName(
- referenceSchemaType.getQName(), isArray(referencedElement)
- ));
- }
- }
- // schema type name is present but not the schema type object
- }else if (xsElt.getSchemaTypeName()!=null){
- //There can be instances where the SchemaType is null but the schemaTypeName is not!
- //this specifically happens with xsd:anyType.
- QName schemaTypeName = xsElt.getSchemaTypeName();
-
- XmlSchema currentParentSchema = resolveParentSchema(schemaTypeName,parentSchema);
- XmlSchemaType typeByName = currentParentSchema.getTypeByName(schemaTypeName);
-
- if (typeByName!=null){
- //this type is found in the schema so we can process it
- processSchema(xsElt, typeByName,currentParentSchema);
- if (!isOuter) {
- String className = findClassName(schemaTypeName, isArray(xsElt));
- //since this is a inner element we should add it to the inner element map
- innerElementMap.put(xsElt.getQName(), className);
- }else{
- this.processedElementList.add(xsElt.getQName());
- }
- }else{
- //this type is not found at all. we'll just register it with whatever the class name we can comeup with
- if (!isOuter) {
- String className = findClassName(schemaTypeName, isArray(xsElt));
- innerElementMap.put(xsElt.getQName(), className);
- }else{
- this.processedElementList.add(xsElt.getQName());
- }
- }
- }
-
- //add this elements QName to the nillable group if it has the nillable attribute
- if (xsElt.isNillable()){
- if (isOuter){
- this.nillableElementList.add(xsElt.getQName());
- }else{
- localNillableList.add(xsElt.getQName());
- }
- }
-
- }
-
- /**
- * resolve the parent schema for the given schema type name
- *
- * @param schemaTypeName
- * @param currentSchema
- * @return
- */
- private XmlSchema resolveParentSchema(QName schemaTypeName,XmlSchema currentSchema)
- throws SchemaCompilationException{
- String targetNamespace = schemaTypeName.getNamespaceURI();
- Object loadedSchema = loadedSchemaMap.get(targetNamespace);
- if (loadedSchema!=null){
- return (XmlSchema)loadedSchema;
- }else if (availableSchemaMap.containsKey(targetNamespace)) {
- //compile the referenced Schema first and then pass it
- XmlSchema schema = (XmlSchema) availableSchemaMap.get(targetNamespace);
- compile(schema);
- return schema;
- }else{
- return currentSchema;
- }
- }
-
- /**
- * Generate a unique type Qname using an element name
- * @param referenceEltQName
- * @param parentSchema
- * @return
- */
- private QName generateTypeQName(QName referenceEltQName, XmlSchema parentSchema) {
- QName generatedTypeName = new QName(referenceEltQName.getNamespaceURI(),
- referenceEltQName.getLocalPart() + getNextTypeSuffix());
- while (parentSchema.getTypeByName(generatedTypeName)!= null){
- generatedTypeName = new QName(referenceEltQName.getNamespaceURI(),
- referenceEltQName.getLocalPart() + getNextTypeSuffix());
- }
- return generatedTypeName;
- }
-
- /**
- * Finds whether a given class is already made
- * @param qName
- * @return
- */
- private boolean isAlreadyProcessed(QName qName){
- return processedTypemap.containsKey(qName)||
- simpleTypesMap.containsKey(qName) ||
- baseSchemaTypeMap.containsKey(qName);
- }
-
-
- /**
- * A method to pick the ref class name
- * @param name
- * @param isArray
- * @return
- */
- private String findRefClassName(QName name,boolean isArray){
- String className = null;
- if (processedElementRefMap.get(name)!=null){
- className =(String)processedElementRefMap.get(name);
-
- if (isArray) {
- //append the square braces that say this is an array
- //hope this works for all cases!!!!!!!
- //todo this however is a thing that needs to be
- //todo fixed to get complete language support
- className = className + "[]";
- }
- }
- return className;
-
- }
- /**
- * Finds a class name from the given Qname
- *
- * @param schemaType
- * @return
- */
- private String findClassName(QName qName, boolean isArray) {
-
- //find the class name
- String className;
- if (processedTypemap.containsKey(qName)) {
- className = (String) processedTypemap.get(qName);
- } else if (simpleTypesMap.containsKey(qName)) {
- className = (String) simpleTypesMap.get(qName);
- } else if (baseSchemaTypeMap.containsKey(qName)) {
- className = (String) baseSchemaTypeMap.get(qName);
- } else {
- // We seem to have failed in finding a class name for the
- //contained schema type. We better set the default then
- //however it's better if the default can be set through the
- //property file
- className = DEFAULT_CLASS_NAME;
- }
-
- if (isArray) {
- //append the square braces that say this is an array
- //hope this works for all cases!!!!!!!
- //todo this however is a thing that needs to be
- //todo fixed to get complete language support
- className = className + "[]";
- }
- return className;
- }
-
-
- /**
- * Process a schema element which has been refered to by an element
- * @param schemaType
- * @throws SchemaCompilationException
- */
- private void processSchema(XmlSchemaElement xsElt, XmlSchemaType schemaType,XmlSchema parentSchema) throws SchemaCompilationException {
- if (schemaType instanceof XmlSchemaComplexType) {
- //write classes for complex types
- XmlSchemaComplexType complexType = (XmlSchemaComplexType) schemaType;
- if (complexType.getName() != null) {
- processNamedComplexSchemaType(complexType,parentSchema);
- } else {
- processAnonymousComplexSchemaType(xsElt, complexType,parentSchema);
- }
- } else if (schemaType instanceof XmlSchemaSimpleType) {
- //process simple type
- processSimpleSchemaType((XmlSchemaSimpleType) schemaType,
- xsElt);
- }
- }
-
-
- /**
- * @param complexType
- * @throws SchemaCompilationException
- */
- private void processAnonymousComplexSchemaType(XmlSchemaElement elt, XmlSchemaComplexType complexType,XmlSchema parentSchema)
- throws SchemaCompilationException {
- BeanWriterMetaInfoHolder metaInfHolder = processComplexType(complexType,parentSchema);
-
- //since this is a special case (an unnamed complex type) we'll put the already processed
- //metainf holder in a special map to be used later
- this.processedAnonymousComplexTypesMap.put(elt, metaInfHolder);
- }
-
- /**
- * handle the complex types which are named
- * @param complexType
- */
- private void processNamedComplexSchemaType(XmlSchemaComplexType complexType,XmlSchema parentSchema) throws SchemaCompilationException {
-
- if (processedTypemap.containsKey(complexType.getQName())
- || baseSchemaTypeMap.containsKey(complexType.getQName())) {
- return;
- }
-
- // Must do this up front to support recursive types
- String fullyQualifiedClassName = writer.makeFullyQualifiedClassName(complexType.getQName());
- processedTypemap.put(complexType.getQName(), fullyQualifiedClassName);
-
- //register that in the schema metainfo bag
- complexType.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY,
- fullyQualifiedClassName);
-
- BeanWriterMetaInfoHolder metaInfHolder = processComplexType(complexType,parentSchema);
- //add this information to the metainfo holder
- metaInfHolder.setOwnQname(complexType.getQName());
- metaInfHolder.setOwnClassName(fullyQualifiedClassName);
- //write the class. This type mapping would have been populated right now
- //Note - We always write classes for named complex types
- writeComplexType(complexType, metaInfHolder);
-
-
- }
-
- /**
- * Writes a complex type
- * @param complexType
- * @param metaInfHolder
- * @param fullyQualifiedClassName the name returned by makeFullyQualifiedClassName() or null if it wasn't called
- * @throws SchemaCompilationException
- */
- private void writeComplexType(XmlSchemaComplexType complexType, BeanWriterMetaInfoHolder metaInfHolder)
- throws SchemaCompilationException {
- writer.write(complexType, processedTypemap, metaInfHolder);
- processedTypeMetaInfoMap.put(complexType.getQName(),metaInfHolder);
- }
-
- private BeanWriterMetaInfoHolder processComplexType(XmlSchemaComplexType complexType,XmlSchema parentSchema) throws SchemaCompilationException {
- XmlSchemaParticle particle = complexType.getParticle();
- BeanWriterMetaInfoHolder metaInfHolder = new BeanWriterMetaInfoHolder();
- if (particle != null) {
- //Process the particle
- processParticle(particle, metaInfHolder,parentSchema);
- }
-
- //process attributes - first look for the explicit attributes
- XmlSchemaObjectCollection attribs = complexType.getAttributes();
- Iterator attribIterator = attribs.getIterator();
- while (attribIterator.hasNext()) {
- Object o = attribIterator.next();
- if (o instanceof XmlSchemaAttribute) {
- processAttribute((XmlSchemaAttribute) o, metaInfHolder);
-
- }
- }
-
- //process any attribute
- //somehow the xml schema parser does not seem to pickup the any attribute!!
- XmlSchemaAnyAttribute anyAtt = complexType.getAnyAttribute();
- if (anyAtt != null) {
- processAnyAttribute(metaInfHolder,anyAtt);
- }
-
- //process content ,either complex or simple
- if (complexType.getContentModel()!=null){
- processContentModel(complexType.getContentModel(),
- metaInfHolder,
- parentSchema);
- }
- return metaInfHolder;
- }
-
- /**
- * Process the content models. A content model is either simple type or a complex type
- * and included inside a complex content
- */
- private void processContentModel(XmlSchemaContentModel content,
- BeanWriterMetaInfoHolder metaInfHolder,
- XmlSchema parentSchema)
- throws SchemaCompilationException{
- if (content instanceof XmlSchemaComplexContent){
- processComplexContent((XmlSchemaComplexContent)content,metaInfHolder,parentSchema);
- }else if (content instanceof XmlSchemaSimpleContent){
- processSimpleContent((XmlSchemaSimpleContent)content,metaInfHolder);
- }
- }
-
- /**
- * Prcess the complex content
- */
- private void processComplexContent(XmlSchemaComplexContent complexContent,
- BeanWriterMetaInfoHolder metaInfHolder,
- XmlSchema parentSchema)
- throws SchemaCompilationException{
- XmlSchemaContent content = complexContent.getContent();
-
- if (content instanceof XmlSchemaComplexContentExtension ){
-
- // to handle extension we need to attach the extended items to the base type
- // and create a new type
- 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
- XmlSchemaType type= parentSchema.getTypeByName(extension.getBaseTypeName());
- if (type instanceof XmlSchemaComplexType) {
- XmlSchemaComplexType complexType = (XmlSchemaComplexType) type;
- if (complexType.getName() != null) {
- processNamedComplexSchemaType(complexType,parentSchema);
- } else {
- //this is not possible. The extension should always
- //have a name
- throw new SchemaCompilationException("Unnamed complex type used in extension");//Internationlize this
- }
- } else if (type instanceof XmlSchemaSimpleType) {
- //process simple type
- processSimpleSchemaType((XmlSchemaSimpleType)type,null);
- }
- }
-
- // before actually processing this node, we need to recurse through the base types and add their
- // children (sometimes even preserving the order) to the metainfo holder of this type
- // the reason is that for extensions, the prefered way is to have the sequences of the base class
- //* before * the sequence of the child element.
- copyMetaInfoHierarchy(metaInfHolder,extension.getBaseTypeName(),parentSchema);
-
-
- //process the particle of this node
- processParticle(extension.getParticle(),metaInfHolder,parentSchema);
-
- //the particle has been processed, However since this is an extension we need to
- //add the basetype as an extension to the complex type class.
- // The basetype has been processed already
- metaInfHolder.setExtension(true);
- metaInfHolder.setExtensionClassName(findClassName(extension.getBaseTypeName(),false));
- //Note - this is no array! so the array boolean is false
-
- }else if (content instanceof XmlSchemaComplexContentRestriction){
- //todo handle complex restriction here
- throw new SchemaCompilationException(
- SchemaCompilerMessages.getMessage("schema.unsupportedcontenterror","Complex Content"));
- }
- }
-
- /**
- * Recursive method to populate the metainfo holders with info from the base types
- * @param metaInfHolder
- * @param baseTypeName
- * @param parentSchema
- */
- private void copyMetaInfoHierarchy(BeanWriterMetaInfoHolder metaInfHolder,
- QName baseTypeName,
- XmlSchema parentSchema)
- throws SchemaCompilationException {
-
- XmlSchemaType type = parentSchema.getTypeByName(baseTypeName);
-
- BeanWriterMetaInfoHolder baseMetaInfoHolder = (BeanWriterMetaInfoHolder)
- processedTypeMetaInfoMap.get(baseTypeName);
-
-
- if (baseMetaInfoHolder!= null){
-
- // see whether this type is also extended from some other type first
- // if so proceed to set their parents as well.
- if (type instanceof XmlSchemaComplexType){
- XmlSchemaComplexType complexType = (XmlSchemaComplexType)type;
- if (complexType.getContentModel()!= null){
- XmlSchemaContentModel content = complexType.getContentModel();
- if (content instanceof XmlSchemaComplexContent){
- XmlSchemaComplexContent complexContent =
- (XmlSchemaComplexContent)content;
- if (complexContent.getContent() instanceof XmlSchemaComplexContentExtension){
- XmlSchemaComplexContentExtension extension =
- (XmlSchemaComplexContentExtension)complexContent.getContent();
- //recursively call the copyMetaInfoHierarchy method
- copyMetaInfoHierarchy(baseMetaInfoHolder,
- extension.getBaseTypeName(),
- parentSchema);
-
- }else if (complexContent.getContent() instanceof XmlSchemaComplexContentRestriction){
-
- XmlSchemaComplexContentRestriction restriction =
- (XmlSchemaComplexContentRestriction)complexContent.getContent();
- //recursively call the copyMetaInfoHierarchy method
- copyMetaInfoHierarchy(baseMetaInfoHolder,
- restriction.getBaseTypeName(),
- parentSchema);
-
- }else{
- throw new SchemaCompilationException(
- SchemaCompilerMessages.getMessage("schema.unknowncontenterror"));
- }
-
- }else if (content instanceof XmlSchemaSimpleContent){
- throw new SchemaCompilationException(
- SchemaCompilerMessages.getMessage("schema.unsupportedcontenterror","Simple Content"));
- }else{
- throw new SchemaCompilationException(
- SchemaCompilerMessages.getMessage("schema.unknowncontenterror"));
- }
- }
-
- //Do the actual parent setting
- metaInfHolder.setAsParent(baseMetaInfoHolder);
- }
- }
- }
-
- /**
- *
- * @param simpleContent
- * @param metaInfHolder
- * @throws SchemaCompilationException
- */
- private void processSimpleContent(XmlSchemaSimpleContent simpleContent,BeanWriterMetaInfoHolder metaInfHolder)
- throws SchemaCompilationException{
- XmlSchemaContent content;
- content = simpleContent.getContent();
- if (content instanceof XmlSchemaSimpleContentExtension){
- //todo - handle simple type extension here
- throw new SchemaCompilationException(
- SchemaCompilerMessages.getMessage("schema.unsupportedcontenterror","Simple Content Extension"));
- }else if (content instanceof XmlSchemaSimpleContentRestriction){
- //todo - Handle simple type restriction here
- throw new SchemaCompilationException(
- SchemaCompilerMessages.getMessage("schema.unsupportedcontenterror","Simple Content Restriction"));
-
- }
- }
-
- /**
- * Handle any attribute
- * @param metainf
- */
- 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,
- DEFAULT_ATTRIB_ARRAY_CLASS_NAME,//always generate an array of
- //OMAttributes
- SchemaConstants.ANY_TYPE);
- metainf.addtStatus(qName, SchemaConstants.ATTRIBUTE_TYPE);
- metainf.addtStatus(qName, SchemaConstants.ARRAY_TYPE);
-
- }
-
-
-
- /**
- * Process the attribute
- *
- * @param att
- * @param metainf
- */
- public void processAttribute(XmlSchemaAttribute att, BeanWriterMetaInfoHolder metainf) {
- //for now we assume (!!!) that attributes refer to standard types only
- QName schemaTypeName = att.getSchemaTypeName();
- if (baseSchemaTypeMap.containsKey(schemaTypeName)) {
- metainf.registerMapping(att.getQName(),
- schemaTypeName,
- baseSchemaTypeMap.get(schemaTypeName).toString(), SchemaConstants.ATTRIBUTE_TYPE);
- } else {
- //todo his attribute refers to a custom type, probably one of the extended simple types.
- //todo handle it here
- }
- }
-
- /**
- * Process a particle- A particle may be a sequence,all or a choice
- *
- * @param particle
- * @param metainfHolder
- * @throws SchemaCompilationException
- */
- private void processParticle(XmlSchemaParticle particle, //particle being processed
- BeanWriterMetaInfoHolder metainfHolder // metainf holder
- ,XmlSchema parentSchema) throws SchemaCompilationException {
- if (particle instanceof XmlSchemaSequence) {
- XmlSchemaObjectCollection items = ((XmlSchemaSequence) particle).getItems();
- process(items, metainfHolder, true,parentSchema);
- } else if (particle instanceof XmlSchemaAll) {
- XmlSchemaObjectCollection items = ((XmlSchemaAll) particle).getItems();
- process(items, metainfHolder, false,parentSchema);
- } else if (particle instanceof XmlSchemaChoice) {
- XmlSchemaObjectCollection items = ((XmlSchemaChoice) particle).getItems();
- metainfHolder.setChoice(true);
- process(items, metainfHolder, false,parentSchema);
-
- }
- }
-
- /**
- * @param items
- * @param metainfHolder
- * @param order
- * @throws SchemaCompilationException
- */
- private void process(XmlSchemaObjectCollection items,
- BeanWriterMetaInfoHolder metainfHolder,
- boolean order,
- XmlSchema parentSchema) throws SchemaCompilationException {
- int count = items.getCount();
- Map processedElementArrayStatusMap = new LinkedHashMap();
- Map processedElementTypeMap = new LinkedHashMap();
- List localNillableList = new ArrayList();
-
- Map elementOrderMap = new HashMap();
-
- for (int i = 0; i < count; i++) {
- XmlSchemaObject item = items.getItem(i);
-
- if (item instanceof XmlSchemaElement) {
- //recursively process the element
- XmlSchemaElement xsElt = (XmlSchemaElement) item;
-
- boolean isArray = isArray(xsElt);
- processElement(xsElt, processedElementTypeMap,localNillableList,parentSchema); //we know for sure this is not an outer type
- processedElementArrayStatusMap.put(xsElt, (isArray) ? Boolean.TRUE : Boolean.FALSE);
- if (order) {
- //we need to keep the order of the elements. So push the elements to another
- //hashmap with the order number
- elementOrderMap.put(xsElt, new Integer(i));
- }
-
- //handle xsd:any ! We place an OMElement (or an array of OMElements) in the generated class
- } else if (item instanceof XmlSchemaAny) {
- XmlSchemaAny any = (XmlSchemaAny) item;
- processedElementTypeMap.put(new QName(ANY_ELEMENT_FIELD_NAME),any);
- //any can also be inside a sequence
- if (order) {
- elementOrderMap.put(any, new Integer(i));
- }
- //we do not register the array status for the any type
- processedElementArrayStatusMap.put(any,isArray(any) ? Boolean.TRUE : Boolean.FALSE);
- } else {
- //there may be other types to be handled here. Add them
- //when we are ready
- }
-
-
- }
-
- // loop through the processed items and add them to the matainf object
- Iterator processedElementsIterator = processedElementArrayStatusMap.keySet().iterator();
- int startingItemNumberOrder = metainfHolder.getOrderStartPoint();
- while (processedElementsIterator.hasNext()) {
- Object child = processedElementsIterator.next();
-
- // process the XmlSchemaElement
- if (child instanceof XmlSchemaElement){
- XmlSchemaElement elt = (XmlSchemaElement) child;
- String clazzName;
- QName referencedQName;
-
- if (elt.getQName()!=null){
- clazzName = (String) processedElementTypeMap.get(elt.getQName());
- referencedQName = elt.getQName();
- metainfHolder.registerMapping(referencedQName,
- elt.getSchemaType()!=null?elt.getSchemaType().getQName():elt.getSchemaTypeName(), //always get the schema type name from the schema it-self
- clazzName,
- ((Boolean) processedElementArrayStatusMap.get(elt)).booleanValue() ?
- SchemaConstants.ARRAY_TYPE :
- SchemaConstants.ELEMENT_TYPE);
-
- }else{ //probably this is referenced
- referencedQName = elt.getRefName();
- boolean arrayStatus = ((Boolean) processedElementArrayStatusMap.get(elt)).booleanValue();
- clazzName = findRefClassName(referencedQName,arrayStatus);
- metainfHolder.registerMapping(referencedQName,
- parentSchema.getElementByName(referencedQName).getSchemaTypeName()
- , clazzName,
- arrayStatus ?
- SchemaConstants.ARRAY_TYPE :
- SchemaConstants.ELEMENT_TYPE);
- }
-
-
-
- //register the occurence counts
- metainfHolder.addMaxOccurs(referencedQName, elt.getMaxOccurs());
- metainfHolder.addMinOccurs(referencedQName, elt.getMinOccurs());
- //we need the order to be preserved. So record the order also
- if (order) {
- //record the order in the metainf holder
- Integer integer = (Integer) elementOrderMap.get(elt);
- metainfHolder.registerQNameIndex(referencedQName,
- startingItemNumberOrder + integer.intValue());
- }
-
- //get the nillable state and register that on the metainf holder
- if (localNillableList.contains(elt.getQName())){
- metainfHolder.registerNillableQName(elt.getQName());
- }
-
- //get the binary state and add that to the status map
- if (isBinary(elt)){
- metainfHolder.addtStatus(elt.getQName(),
- SchemaConstants.BINARY_TYPE);
- }
- // process the XMLSchemaAny
- }else if (child instanceof XmlSchemaAny){
- XmlSchemaAny any = (XmlSchemaAny)child;
-
- //since there is only one element here it does not matter
- //for the constant. However the problem occurs if the users
- //uses the same name for an element decalration
- QName anyElementFieldName = new QName(ANY_ELEMENT_FIELD_NAME);
-
- //this can be an array or a single element
- boolean isArray = ((Boolean) processedElementArrayStatusMap.get(any)).booleanValue();
- metainfHolder.registerMapping(anyElementFieldName,
- null,
- isArray?DEFAULT_CLASS_ARRAY_NAME:DEFAULT_CLASS_NAME,
- SchemaConstants.ANY_TYPE);
- //if it's an array register an extra status flag with the system
- if (isArray){
- metainfHolder.addtStatus(anyElementFieldName,
- SchemaConstants.ARRAY_TYPE);
- }
- metainfHolder.addMaxOccurs(anyElementFieldName,any.getMaxOccurs());
- metainfHolder.addMinOccurs(anyElementFieldName,any.getMinOccurs());
-
- if (order) {
- //record the order in the metainf holder for the any
- Integer integer = (Integer) elementOrderMap.get(any);
- metainfHolder.registerQNameIndex(anyElementFieldName,
- startingItemNumberOrder + integer.intValue());
- }
- }
- }
-
- //set the ordered flag in the metainf holder
- metainfHolder.setOrdered(order);
- }
-
- /**
- * Checks whether a given element is a binary element
- * @param elt
- * @return
- */
- private boolean isBinary(XmlSchemaElement elt) {
- return elt.getSchemaType()!=null &&
- SchemaConstants.XSD_BASE64.equals(elt.getSchemaType().getQName());
- }
-
- /**
- * Handle the simple content
- *
- * @param simpleType
- */
- private void processSimpleSchemaType(XmlSchemaSimpleType simpleType,
- XmlSchemaElement xsElt) throws SchemaCompilationException{
- // handle the restriction
- XmlSchemaSimpleTypeContent content = simpleType.getContent();
- if (content != null) {
- if (content instanceof XmlSchemaSimpleTypeRestriction) {
- XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction) content;
- QName baseTypeName = restriction.getBaseTypeName();
- //check whether the base type is one of the base schema types
- if (baseSchemaTypeMap.containsKey(baseTypeName)) {
- //this is a basic xsd datatype. Populate the map and populate
- //the mappings map
- String className = (String) baseSchemaTypeMap.get(baseTypeName);
- this.simpleTypesMap.put(simpleType.getQName(), className);
- //set the old schema type QName and the new schema type QName
- this.changedTypeMap.put(simpleType.getQName(), baseTypeName);
- //add the class name to the meta info map
- simpleType.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY,
- className);
-
- //add an additional flag saying that this is a primitive type
- simpleType.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_PRIMITVE_KEY,
- Boolean.TRUE);
- } else {
- //recurse
- if (restriction.getBaseType() != null) {
- processSimpleSchemaType(restriction.getBaseType(),xsElt);
- }
- }
- }else if (content instanceof XmlSchemaSimpleTypeUnion) {
- //Todo - Handle unions here
- throw new SchemaCompilationException(
- SchemaCompilerMessages.getMessage("schema.unsupportedcontenterror","Simple Type Union"));
-
- }else if (content instanceof XmlSchemaSimpleTypeList){
- //todo - Handle lists here
- throw new SchemaCompilationException(
- SchemaCompilerMessages.getMessage("schema.unsupportedcontenterror","Simple Type List"));
- }
-
- }
-
-
- }
-
-
- /**
- * Find whether a given particle is an array. The logic for deciding
- * whether a given particle is an array is depending on their minOccurs
- * and maxOccurs counts. If Maxoccurs is greater than one (1) then the
- * content is an array.
- * Also no higher level element will have the maxOccurs greater than one
- *
- * @param particle
- * @return
- * @throws SchemaCompilationException
- */
- private boolean isArray(XmlSchemaParticle particle) throws SchemaCompilationException {
- long minOccurs = particle.getMinOccurs();
- long maxOccurs = particle.getMaxOccurs();
-
- if (maxOccurs < minOccurs) {
- throw new SchemaCompilationException();
- } else {
- return (maxOccurs > 1);
- }
-
- }
-
- private String getNextTypeSuffix(){
- if (typeCounter==Integer.MAX_VALUE){
- typeCounter = 0;
- }
- return ("_type" +typeCounter++);
- }
-
-}
+package org.apache.axis2.schema;
+
+import org.apache.axiom.om.OMAttribute;
+import org.apache.axiom.om.OMElement;
+import org.apache.axis2.namespace.Constants;
+import org.apache.axis2.schema.i18n.SchemaCompilerMessages;
+import org.apache.axis2.schema.util.SchemaPropertyLoader;
+import org.apache.axis2.schema.writer.BeanWriter;
+import org.apache.axis2.util.URLProcessor;
+import org.apache.ws.commons.schema.XmlSchema;
+import org.apache.ws.commons.schema.XmlSchemaAll;
+import org.apache.ws.commons.schema.XmlSchemaAny;
+import org.apache.ws.commons.schema.XmlSchemaAnyAttribute;
+import org.apache.ws.commons.schema.XmlSchemaAttribute;
+import org.apache.ws.commons.schema.XmlSchemaChoice;
+import org.apache.ws.commons.schema.XmlSchemaComplexContent;
+import org.apache.ws.commons.schema.XmlSchemaComplexContentExtension;
+import org.apache.ws.commons.schema.XmlSchemaComplexContentRestriction;
+import org.apache.ws.commons.schema.XmlSchemaComplexType;
+import org.apache.ws.commons.schema.XmlSchemaContent;
+import org.apache.ws.commons.schema.XmlSchemaContentModel;
+import org.apache.ws.commons.schema.XmlSchemaElement;
+import org.apache.ws.commons.schema.XmlSchemaImport;
+import org.apache.ws.commons.schema.XmlSchemaInclude;
+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.XmlSchemaSequence;
+import org.apache.ws.commons.schema.XmlSchemaSimpleContent;
+import org.apache.ws.commons.schema.XmlSchemaSimpleContentExtension;
+import org.apache.ws.commons.schema.XmlSchemaSimpleContentRestriction;
+import org.apache.ws.commons.schema.XmlSchemaSimpleType;
+import org.apache.ws.commons.schema.XmlSchemaSimpleTypeContent;
+import org.apache.ws.commons.schema.XmlSchemaSimpleTypeList;
+import org.apache.ws.commons.schema.XmlSchemaSimpleTypeRestriction;
+import org.apache.ws.commons.schema.XmlSchemaSimpleTypeUnion;
+import org.apache.ws.commons.schema.XmlSchemaType;
+
+import javax.xml.namespace.QName;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Schema compiler for ADB. Based on WS-Commons schema object model.
+ */
+public class SchemaCompiler {
+
+
+ private CompilerOptions options;
+ private HashMap processedTypemap;
+
+ //the list of processedElements for the outer elements
+ private HashMap processedElementMap;
+
+ private HashMap processedAnonymousComplexTypesMap;
+
+ //we need this map to keep the referenced elements. these elements need to be kept seperate
+ //to avoid conflicts
+ private HashMap processedElementRefMap;
+ private HashMap simpleTypesMap;
+ private HashMap changedTypeMap;
+
+ // 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 processedTypeMetaInfoMap;
+
+ //
+ private ArrayList processedElementList;
+
+ //a list of nillable elements - used to generate code
+ //for nillable elements
+ private List nillableElementList;
+ // writee reference
+ private BeanWriter writer = null;
+ private Map baseSchemaTypeMap = null;
+
+ //a map for keeping the already loaded schemas
+ //the key is the targetnamespace and the value is the schema object
+ private Map loadedSchemaMap = new HashMap();
+
+ // 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 availableSchemaMap = new HashMap();
+
+
+
+ // a list of externally identified QNames to be processed. This becomes
+ // useful when only a list of external elements need to be processed
+
+ public static final String ANY_ELEMENT_FIELD_NAME = "extraElement";
+ public static final String EXTRA_ATTRIBUTE_FIELD_NAME = "extraAttributes";
+
+ public static final String DEFAULT_CLASS_NAME = OMElement.class.getName();
+ public static final String DEFAULT_CLASS_ARRAY_NAME = "org.apache.axiom.om.OMElement[]";
+
+ public static final String DEFAULT_ATTRIB_CLASS_NAME = OMAttribute.class.getName();
+ public static final String DEFAULT_ATTRIB_ARRAY_CLASS_NAME = "org.apache.axiom.om.OMAttribute[]";
+
+
+ private static int typeCounter = 0;
+
+
+
+
+ /**
+ * @return the processes element map
+ * includes the Qname of the element as the key and a
+ * String representing the fully qualified class name
+ */
+ public HashMap getProcessedElementMap() {
+ return processedElementMap;
+ }
+
+
+ /**
+ * @return a map of Qname vs models. A model can be anything,
+ * ranging from a DOM document to a stream. This is taken from the
+ * writer and the schema compiler has no control over it
+ */
+ public Map getProcessedModelMap() {
+ return writer.getModelMap();
+ }
+
+ /**
+ * Constructor - Accepts a options bean
+ *
+ * @param options
+ */
+ public SchemaCompiler(CompilerOptions options) throws SchemaCompilationException {
+
+ if (options == null) {
+ //create an empty options object
+ this.options = new CompilerOptions();
+ } else {
+ this.options = options;
+ }
+
+ //instantiate the maps
+ processedTypemap = new HashMap();
+ processedElementMap = new HashMap();
+ simpleTypesMap = new HashMap();
+ processedElementList = new ArrayList();
+ processedAnonymousComplexTypesMap = new HashMap();
+ changedTypeMap = new HashMap();
+ processedTypeMetaInfoMap = new HashMap();
+ processedElementRefMap = new HashMap();
+ nillableElementList = new ArrayList();
+
+ //load the writer and initiliaze the base types
+ writer = SchemaPropertyLoader.getBeanWriterInstance();
+ writer.init(this.options);
+
+ //load the base types
+ baseSchemaTypeMap = SchemaPropertyLoader.getTypeMapperInstance().getTypeMap();
+
+
+ }
+
+ /**
+ * Compile a list of schemas
+ * This actually calls the compile (XmlSchema s) method repeatedly
+ *
+ * @param schemalist
+ * @throws SchemaCompilationException
+ * @see #compile(org.apache.ws.commons.schema.XmlSchema)
+ */
+ public void compile(List schemalist) throws SchemaCompilationException {
+ try {
+
+ if (schemalist.isEmpty()){
+ return;
+ }
+
+ //clear the loaded and available maps
+ loadedSchemaMap.clear();
+ availableSchemaMap.clear();
+
+ XmlSchema schema;
+ // first round - populate the avaialble map
+ for (int i = 0; i < schemalist.size(); i++) {
+ schema = (XmlSchema) schemalist.get(i);
+ availableSchemaMap.put(
+ schema.getTargetNamespace(),
+ schema
+ );
+ }
+
+ //set a mapper package if not avaialable
+ if (writer.getExtensionMapperPackageName()==null){
+ //get the first schema from the list and take that namespace as the
+ //mapper namespace
+ writer.registerExtensionMapperPackageName(
+ URLProcessor.makePackageName(((XmlSchema) schemalist.get(0)).getTargetNamespace()));
+ }
+ // second round - call the schema compiler one by one
+ for (int i = 0; i < schemalist.size(); i++) {
+ compile((XmlSchema) schemalist.get(i),true);
+ }
+
+ //finish up
+ finalizeSchemaCompilation();
+
+ } catch (SchemaCompilationException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new SchemaCompilationException(e);
+ }
+ }
+
+ /**
+ * Compile (rather codegen) a single schema element
+ * @param schema
+ * @throws SchemaCompilationException
+ */
+ public void compile(XmlSchema schema) throws SchemaCompilationException {
+ compile(schema,false);
+ }
+
+ /**
+ * Compile (rather codegen) a single schema element
+ * @param schema
+ * @param 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.
+ if (Constants.URI_2001_SCHEMA_XSD.equals(schema.getTargetNamespace())) {
+ return;
+ }
+
+ //register the package from this namespace as the mapper classes package
+ if (!isPartofGroup){
+ //set a mapper package if not avaialable
+ if (writer.getExtensionMapperPackageName()==null){
+ writer.registerExtensionMapperPackageName(
+ URLProcessor.makePackageName(schema.getTargetNamespace()));
+ }
+ }
+
+ //First look for the schemas that are imported and process them
+ //Note that these are processed recursively!
+
+ //add the schema to the loaded schema list
+ if (!loadedSchemaMap.containsKey(schema.getTargetNamespace())) {
+ loadedSchemaMap.put(schema.getTargetNamespace(), schema);
+ }
+
+ XmlSchemaObjectCollection includes = schema.getIncludes();
+ if (includes != null) {
+ Iterator tempIterator = includes.getIterator();
+ while (tempIterator.hasNext()) {
+ Object o = tempIterator.next();
+ if (o instanceof XmlSchemaImport) {
+ XmlSchema schema1 = ((XmlSchemaImport) o).getSchema();
+ if (schema1 != null) compile(schema1,isPartofGroup);
+ }
+ if (o instanceof XmlSchemaInclude) {
+ XmlSchema schema1 = ((XmlSchemaInclude) o).getSchema();
+ if (schema1 != null) 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()) {
+ //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);
+ }
+
+ 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()) {
+ //this is the set of outer elements so we need to generate classes
+ writeElement((XmlSchemaElement) xmlSchemaElement2Iterator.next());
+ }
+
+ if (!isPartofGroup){
+ //complete the compilation
+ finalizeSchemaCompilation();
+ }
+ }
+
+ /**
+ * Completes the schema compilation process by writing the
+ * mappers and the classes in a batch if needed
+ * @throws SchemaCompilationException
+ */
+ private void finalizeSchemaCompilation() throws SchemaCompilationException {
+ //write the extension mapping class
+ writer.writeExtensionMapper(
+ (BeanWriterMetaInfoHolder[])
+ processedTypeMetaInfoMap.values().toArray(
+ new BeanWriterMetaInfoHolder[processedTypeMetaInfoMap.size()]));
+
+
+ if (options.isWrapClasses()) {
+ writer.writeBatch();
+ }
+ }
+
+ /**
+ * @return the property map of the schemacompiler.
+ * In this case it would be the property map loaded from
+ * the configuration file
+ */
+ public Properties getCompilerProperties(){
+ return SchemaPropertyLoader.getPropertyMap() ;
+ }
+
+
+ /**
+ * Writes the element
+ *
+ * @param xsElt
+ * @throws SchemaCompilationException
+ */
+ private void writeElement(XmlSchemaElement xsElt) throws SchemaCompilationException {
+
+ if (this.processedElementMap.containsKey(xsElt.getQName())) {
+ return;
+ }
+
+ XmlSchemaType schemaType = xsElt.getSchemaType();
+
+
+ BeanWriterMetaInfoHolder metainf = new BeanWriterMetaInfoHolder();
+ if (schemaType != null && schemaType.getName() != null) {
+ //this is a named type
+ QName qName = schemaType.getQName();
+ //find the class name
+ String className = findClassName(qName, isArray(xsElt));
+
+ //this means the schema type actually returns a different QName
+ if (changedTypeMap.containsKey(qName)) {
+ metainf.registerMapping(xsElt.getQName(),
+ (QName) changedTypeMap.get(qName),
+ className);
+ } else {
+ metainf.registerMapping(xsElt.getQName(),
+ qName,
+ className);
+ }
+
+
+ }else if (xsElt.getRefName()!= 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
+ }else if (xsElt.getSchemaTypeName()!= null) {
+ QName qName = xsElt.getSchemaTypeName();
+ String className = findClassName(qName, isArray(xsElt));
+ metainf.registerMapping(xsElt.getQName(),
+ qName,
+ className);
+
+
+ }else if (schemaType != null){ //the named type should have been handled already
+
+ //we are going to special case the anonymous complex type. Our algorithm for dealing
+ //with it is to generate a single object that has the complex content inside. Really the
+ //intent of the user when he declares the complexType anonymously is to use it privately
+ //First copy the schema types content into the metainf holder
+ metainf = (BeanWriterMetaInfoHolder) this.processedAnonymousComplexTypesMap.get(xsElt);
+ metainf.setAnonymous(true);
+ }else{
+ //this means we did not find any schema type associated with the particular element. we
+ //should be throwing an exception here
+ throw new SchemaCompilationException("no type!!");//todo i18n this
+ }
+
+ if (nillableElementList.contains(xsElt.getQName())){
+ metainf.registerNillableQName(xsElt.getQName());
+ }
+
+
+ String writtenClassName = writer.write(xsElt, processedTypemap, metainf);
+ //register the class name
+ xsElt.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY,
+ writtenClassName);
+ processedElementMap.put(xsElt.getQName(), writtenClassName);
+ }
+
+ /**
+ * For inner elements
+ * @param xsElt
+ * @param innerElementMap
+ * @param parentSchema
+ * @throws SchemaCompilationException
+ */
+ private void processElement(XmlSchemaElement xsElt,Map innerElementMap,List localNillableList,XmlSchema parentSchema) throws SchemaCompilationException {
+ processElement(xsElt,false,innerElementMap,localNillableList,parentSchema);
+ }
+
+ /**
+ * For outer elements
+ * @param xsElt
+ * @param parentSchema
+ * @throws SchemaCompilationException
+ */
+ private void processElement(XmlSchemaElement xsElt,XmlSchema parentSchema) throws SchemaCompilationException {
+ processElement(xsElt,true,null,null,parentSchema);
+ }
+ /**
+ * Process and Element
+ *
+ * @param xsElt
+ * @param isOuter- We need to know this since the treatment of outer elements is different that
+ * inner elements
+ * @param isArray- flag saying whether the elements represents an array
+ * @throws SchemaCompilationException
+ */
+ private void processElement(XmlSchemaElement xsElt, boolean isOuter,Map innerElementMap,List localNillableList, XmlSchema parentSchema) throws SchemaCompilationException {
+
+ //if the element is null, which usually happens when the qname is not
+ //proper, throw an exceptions
+ if (xsElt==null){
+ throw new SchemaCompilationException(
+ 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!
+ if (isOuter && processedElementList.contains(xsElt.getQName())) {
+ return;
+ }
+
+ XmlSchemaType schemaType = xsElt.getSchemaType();
+ if (schemaType != null) {
+ processSchema(xsElt, schemaType,parentSchema);
+ //at this time it is not wise to directly write the class for the element
+ //so we push the complete element to an arraylist and let the process
+ //pass through. We'll be iterating through the elements writing them
+ //later
+
+ if (!isOuter) {
+ if (schemaType.getName()!=null){
+ // this element already has a name. Which means we can directly
+ // register it
+ String className = findClassName(schemaType.getQName(),
+ isArray(xsElt));
+
+ innerElementMap.put(xsElt.getQName(), className);
+
+ //store in the schema map
+ schemaType.addMetaInfo(
+ SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY,
+ className);
+
+ if (baseSchemaTypeMap.containsValue(className)){
+ schemaType.addMetaInfo(
+ SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_PRIMITVE_KEY,
+ Boolean.TRUE);
+ }
+ //since this is a inner element we should add it to the inner element map
+ }else{
+ //this is an anon type. This should have been already processed and registered at
+ //the anon map. we've to write it just like we treat a referenced type(giving due
+ //care that this is meant to be an attribute in some class)
+
+ QName generatedTypeName = generateTypeQName(xsElt.getQName(), parentSchema);
+
+ if (schemaType instanceof XmlSchemaComplexType){
+ //set a name
+ schemaType.setName(generatedTypeName.getLocalPart());
+ writeComplexType((XmlSchemaComplexType)schemaType,
+ (BeanWriterMetaInfoHolder)processedAnonymousComplexTypesMap.get(xsElt));
+ //remove the reference from the anon list since we named the type
+ processedAnonymousComplexTypesMap.remove(xsElt);
+ String className = findClassName(schemaType.getQName(), isArray(xsElt));
+ innerElementMap.put(
+ xsElt.getQName(),
+ className);
+
+ //store in the schema map
+ xsElt.addMetaInfo(
+ SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY,
+ className);
+ }
+ }
+ }else{
+ this.processedElementList.add(xsElt.getQName());
+ }
+ //referenced name
+ }else if (xsElt.getRefName()!=null){
+
+ //process the referenced type. It could be thought that the referenced element replaces this
+ //element
+ XmlSchema currentParentSchema = resolveParentSchema(xsElt.getRefName(),parentSchema);
+ XmlSchemaElement referencedElement = currentParentSchema.getElementByName(xsElt.getRefName());
+
+ //if the element is referenced, then it should be one of the outer (global) ones
+ processElement(referencedElement, parentSchema);
+
+ //no outer check required here. If the element is having a ref, then it is definitely
+ //not an outer element since the top level elements are not supposed to have refs
+ //Also we are sure that it should have a type reference
+ QName referenceEltQName = referencedElement.getQName();
+ if (referencedElement.getSchemaTypeName()!=null){
+ String className = findClassName(referencedElement.getSchemaTypeName(), isArray(xsElt));
+ //if this element is referenced, there's no QName for this element
+ this.processedElementRefMap.put(referenceEltQName, className);
+
+ referencedElement.addMetaInfo(SchemaConstants.SchemaCompilerInfoHolder.CLASSNAME_KEY,
+ className);
+ }else{
+ //this referenced element has an anon type and that anon type has been already
+ //processed. But in this case we need it to be a seperate class since this
+ //complextype has to be added as an attribute in a class.
+ //generate a name for this type
+ QName generatedTypeName = generateTypeQName(referenceEltQName, parentSchema);
+ XmlSchemaType referenceSchemaType = referencedElement.getSchemaType();
+
+ if (referenceSchemaType instanceof XmlSchemaComplexType){
+ //set a name
+ referenceSchemaType.setName(generatedTypeName.getLocalPart());
+
+ writeComplexType((XmlSchemaComplexType)referenceSchemaType,
+ (BeanWriterMetaInfoHolder)processedAnonymousComplexTypesMap.get(referencedElement)
+ );
+ //remove the reference from the anon list since we named the type
+ processedAnonymousComplexTypesMap.remove(referencedElement);
+
+ //add this to the processed ref type map
+ this.processedElementRefMap.put(referenceEltQName,findClassName(
+ referenceSchemaType.getQName(), isArray(referencedElement)
+ ));
+ }
+ }
+ // schema type name is present but not the schema type object
+ }else if (xsElt.getSchemaTypeName()!=null){
+ //There can be instances where the SchemaType is null but the schemaTypeName is not!
+ //this specifically happens with xsd:anyType.
+ QName schemaTypeName = xsElt.getSchemaTypeName();
+
+ XmlSchema currentParentSchema = resolveParentSchema(schemaTypeName,parentSchema);
+ XmlSchemaType typeByName = currentParentSchema.getTypeByName(schemaTypeName);
+
+ if (typeByName!=null){
+ //this type is found in the schema so we can process it
+ processSchema(xsElt, typeByName,currentParentSchema);
+ if (!isOuter) {
+ String className = findClassName(schemaTypeName, isArray(xsElt));
+ //since this is a inner element we should add it to the inner element map
+ innerElementMap.put(xsElt.getQName(), className);
+ }else{
+ this.processedElementList.add(xsElt.getQName());
+ }
+ }else{
+ //this type is not found at all. we'll just register it with whatever the class name we can comeup with
+ if (!isOuter) {
+ String className = findClassName(schemaTypeName, isArray(xsElt));
+ innerElementMap.put(xsElt.getQName(), className);
+ }else{
+ this.processedElementList.add(xsElt.getQName());
+ }
+ }
+ }
+
+ //add this elements QName to the nillable group if it has the nillable attribute
+ if (xsElt.isNillable()){
+ if (isOuter){
+ this.nillableElementList.add(xsElt.getQName());
+ }else{
+ localNillableList.add(xsElt.getQName());
+ }
+ }
+
+ }
+
+ /**
+ * resolve the parent schema for the given schema type name
+ *
+ * @param schemaTypeName
+ * @param currentSchema
+ * @return
+ */
+ private XmlSchema resolveParentSchema(QName schemaTypeName,XmlSchema currentSchema)
+ throws SchemaCompilationException{
+ String targetNamespace = schemaTypeName.getNamespaceURI();
+ Object loadedSchema = loadedSchemaMap.get(targetNamespace);
+ if (loadedSchema!=null){
+ return (XmlSchema)loadedSchema;
+ }else if (availableSchemaMap.containsKey(targetNamespace)) {
+ //compile the referenced Schema first and then pass it
+ XmlSchema schema = (XmlSchema) availableSchemaMap.get(targetNamespace);
+ compile(schema);
+ return schema;
+ }else{
+ return currentSchema;
+ }
+ }
+
+ /**
+ * Generate a unique type Qname using an element name
+ * @param referenceEltQName
+ * @param parentSchema
+ * @return
+ */
+ private QName generateTypeQName(QName referenceEltQName, XmlSchema parentSchema) {
+ QName generatedTypeName = new QName(referenceEltQName.getNamespaceURI(),
+ referenceEltQName.getLocalPart() + getNextTypeSuffix());
+ while (parentSchema.getTypeByName(generatedTypeName)!= null){
+ generatedTypeName = new QName(referenceEltQName.getNamespaceURI(),
+ referenceEltQName.getLocalPart() + getNextTypeSuffix());
+ }
+ return generatedTypeName;
+ }
+
+ /**
+ * Finds whether a given class is already made
+ * @param qName
+ * @return
+ */
+ private boolean isAlreadyProcessed(QName qName){
+ return processedTypemap.containsKey(qName)||
+ simpleTypesMap.containsKey(qName) ||
+ baseSchemaTypeMap.containsKey(qName);
+ }
+
+
+ /**
+ * A method to pick the ref class name
+ * @param name
+ * @param isArray
+ * @return
+ */
+ private String findRefClassName(QName name,boolean isArray){
+ String className = null;
+ if (processedElementRefMap.get(name)!=null){
+ className =(String)processedElementRefMap.get(name);
+
+ if (isArray) {
+ //append the square braces that say this is an array
+ //hope this works for all cases!!!!!!!
+ //todo this however is a thing that needs to be
+ //todo fixed to get complete language support
+ className = className + "[]";
+ }
+ }
+ return className;
+
+ }
+ /**
+ * Finds a class name from the given Qname
+ *
+ * @param schemaType
+ * @return
+ */
+ private String findClassName(QName qName, boolean isArray) {
+
+ //find the class name
+ String className;
+ if (processedTypemap.containsKey(qName)) {
+ className = (String) processedTypemap.get(qName);
+ } else if (simpleTypesMap.containsKey(qName)) {
+ className = (String) simpleTypesMap.get(qName);
+ } else if (baseSchemaTypeMap.containsKey(qName)) {
+ className = (String) baseSchemaTypeMap.get(qName);
+ } else {
+ // We seem to have failed in finding a class name for the
+ //contained schema type. We better set the default then
+ //however it's better if the default can be set through the
+ //property file
+ className = DEFAULT_CLASS_NAME;
+ }
+
+ if (isArray) {
+ //append the square braces that say this is an array
+ //hope this works for all cases!!!!!!!
+ //todo this however is a thing that needs to be
+ //todo fixed to get complete language support
+ className = className + "[]";
+ }
+ return className;
+ }
+
+
+ /**
+ * Process a schema element which has been refered to by an element
+ * @param schemaType
+ * @throws SchemaCompilationException
+ */
+ private void processSchema(XmlSchemaElement xsElt, XmlSchemaType schemaType,XmlSchema parentSchema) throws SchemaCompilationException {
+ if (schemaType instanceof XmlSchemaComplexType) {
+ //write classes for complex types
+ XmlSchemaComplexType complexType = (XmlSchemaComplexType) schemaType;
+ if (complexType.getName() != null) {
+ processNamedComplexSchemaType(complexType,parentSchema);
+ } else {
+ processAnonymousComplexSchemaType(xsElt, complexType,parentSchema);
+ }
+ } else if (schemaType instanceof XmlSchemaSimpleType) {
+ //process simple type
+ processSimpleSchemaType((XmlSchemaSimpleType) schemaType,
+ xsElt);
+ }
+ }
+
+
+ /**
+ * @param complexType
+ * @throws SchemaCompilationException
+ */
[... 636 lines stripped ...]
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org