* 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.

*/

    private static final Log log = LogFactory.getLog(SchemaCompiler .class);

    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();

    private Map loadedSourceURI = 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){

                String nsp = null;

                //get the first schema from the list and take that namespace as the

                //mapper namespace

                for (int i = 0; nsp == null && i < schemalist.size(); i++) {

                    nsp = ((XmlSchema) schemalist.get(i)).getTargetNamespace();

                    if (nsp != null)

                        break;

                    XmlSchema[] schemas = SchemaUtil.getAllSchemas((XmlSchema) schemalist.get(i));

                    for (int j = 0; schemas != null && j < schemas.length; j++) {

                        nsp = schemas[j].getTargetNamespace();

                        if (nsp != null)

                            break;

                    }

                }

                if(nsp == null) {

                    nsp = URLProcessor.DEFAULT_PACKAGE;

                }

                 // if this name space exists in the ns2p list then we use it.

                if ((options.getNs2PackageMap() != null)

                        && (options.getNs2PackageMap().containsKey(nsp))){

                    writer.registerExtensionMapperPackageName((String) options.getNs2PackageMap().get(nsp));

                } else {

                   writer.registerExtensionMapperPackageName(URLProcessor.makePackageName(nsp));

                }

            }

            // 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);

        }

       

        // If we have/are loading a schema with a specific targetnamespace from a certain URI,

        // then just return back to the caller to avoid recursion.

        if (schema.getSourceURI() != null){

            String key = schema.getTargetNamespace() + ":" + schema.getSourceURI();

            if(loadedSourceURI.containsKey(key)){

                return;

            }

            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) {

                    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(options.isGenerateAll()) {

            Iterator xmlSchemaTypes2Iterator = schema.getSchemaTypes().getValues();

            while (xmlSchemaTypes2Iterator.hasNext()) {

                XmlSchemaType schemaType = (XmlSchemaType) xmlSchemaTypes2Iterator.next();

                if(this.isAlreadyProcessed(schemaType.getQName())) {

                    continue;

                }

                if (schemaType instanceof XmlSchemaComplexType) {

                    //write classes for complex types

                    XmlSchemaComplexType complexType = (XmlSchemaComplexType) schemaType;

                    if (complexType.getName() != null) {

                        processNamedComplexSchemaType(complexType, schema);

                    }

                } else if (schemaType instanceof XmlSchemaSimpleType) {

                    //process simple type

                    processSimpleSchemaType((XmlSchemaSimpleType) schemaType,

                            null,

                            schema);

                }

            }

        }

        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.

            log.warn(SchemaCompilerMessages.getMessage("schema.elementWithNoType", xsElt.getQName().toString()));

            metainf.registerMapping(xsElt.getQName(),

                    null,

                    DEFAULT_CLASS_NAME,

                    SchemaConstants.ANY_TYPE);

        }

        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

     * @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());

                        // Must do this up front to support recursive types

                        String fullyQualifiedClassName = writer.makeFullyQualifiedClassName(schemaType.getQName());

                        processedTypemap.put(schemaType.getQName(), fullyQualifiedClassName);

                        BeanWriterMetaInfoHolder metaInfHolder = (BeanWriterMetaInfoHolder) processedAnonymousComplexTypesMap.get(xsElt);

                        metaInfHolder.setOwnQname(schemaType.getQName());

                        metaInfHolder.setOwnClassName(fullyQualifiedClassName);

                        writeComplexType((XmlSchemaComplexType)schemaType,

                                metaInfHolder);

                        //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 if (schemaType instanceof XmlSchemaSimpleType){

                        //set a name

                        schemaType.setName(generatedTypeName.getLocalPart());

                        // Must do this up front to support recursive types

                        String fullyQualifiedClassName = writer.makeFullyQualifiedClassName(schemaType.getQName());

                        processedTypemap.put(schemaType.getQName(), fullyQualifiedClassName);

                        BeanWriterMetaInfoHolder metaInfHolder = (BeanWriterMetaInfoHolder) processedAnonymousComplexTypesMap.get(xsElt);

                        metaInfHolder.setOwnQname(schemaType.getQName());

                        metaInfHolder.setOwnClassName(fullyQualifiedClassName);

                        writeSimpleType((XmlSchemaSimpleType)schemaType,

                                metaInfHolder);

                        //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){

            if(xsElt.getRefName().equals(SchemaConstants.XSD_SCHEMA)){

                innerElementMap.put(xsElt.getQName(), SchemaCompiler.DEFAULT_CLASS_NAME);

                return;

            }

            //process the referenced type. It could be thought that the referenced element replaces this

            //element

            XmlSchemaElement referencedElement = getReferencedElement(parentSchema, xsElt.getRefName());

            if (referencedElement==null){

                throw new SchemaCompilationException(

                        SchemaCompilerMessages.getMessage("schema.referencedElementNotFound", xsElt.getRefName().toString()));

            }

            //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){

                    if (referencedElement.getSchemaTypeName() == null){

                        referencedElement.setSchemaTypeName(generatedTypeName);

                    }

                    //set a name

                    referenceSchemaType.setName(generatedTypeName.getLocalPart());

                    String javaclassName =  writeComplexType((XmlSchemaComplexType) referenceSchemaType,

                            (BeanWriterMetaInfoHolder)processedAnonymousComplexTypesMap.get(referencedElement)

                    );

                    //remove the reference from the anon list since we named the type

                    // DEEPAL :- We can not remove the entry from the hashtable ,

                    // this will fail if there are two reference for the same type

                    //processedAnonymousComplexTypesMap.remove(referencedElement);

                    processedTypemap.put(generatedTypeName, javaclassName);

                    this.processedElementRefMap.put(referenceEltQName, javaclassName);

                }

            }

            // 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 = getType(currentParentSchema, 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

     */

    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

     */

    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;

    }

    /**

     * Generate a unique attribute Qname using the ref name

     * @param attrRefName

     * @param parentSchema

     * @return Returns the generated attribute name

     */

    private QName generateAttributeQName(QName attrRefName, XmlSchema parentSchema) {

      if (typeCounter==Integer.MAX_VALUE){

            typeCounter = 0;

        }

        QName generatedAttrName = new QName(attrRefName.getNamespaceURI(),

            attrRefName.getLocalPart() + typeCounter++);

        while (parentSchema.getTypeByName(generatedAttrName)!= null){

            generatedAttrName = new QName(attrRefName.getNamespaceURI(),

                attrRefName.getLocalPart() + typeCounter++);

        }

        return generatedAttrName;

    }

    /**

     * Finds whether a given class is already made

     * @param qName

     */

    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

     */

    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 qName

     * @param isArray

     * @return FQCN

     */

    private String findClassName(QName qName, boolean isArray) throws SchemaCompilationException {

        //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 {

            if(isSOAP_ENC(qName.getNamespaceURI())) {

                throw new SchemaCompilationException(SchemaCompilerMessages.getMessage("schema.soapencoding.error", qName.toString()));

            }

            // 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;

            log.warn(SchemaCompilerMessages

                    .getMessage("schema.typeMissing", qName.toString()));

        }

        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;

    }

    /**

     * Returns true if SOAP_ENC Namespace.

     *

     * @param s a string representing the URI to check

     * @return true if <code>s</code> matches a SOAP ENCODING namespace URI,

     *         false otherwise

     */

    public static boolean isSOAP_ENC(String s) {

        if (s.equals(Constants.URI_SOAP11_ENC))

            return true;

        return s.equals(Constants.URI_SOAP12_ENC);

    }

    /**

     * 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,

                    parentSchema);

        }

    }

    /**

     * @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 String writeComplexType(XmlSchemaComplexType complexType, BeanWriterMetaInfoHolder metaInfHolder)

            throws SchemaCompilationException {

        String javaClassName = writer.write(complexType, processedTypemap, metaInfHolder);

        processedTypeMetaInfoMap.put(complexType.getQName(),metaInfHolder);

        return javaClassName;

    }

    /**

     * Writes a complex type

     * @param simpleType

     * @param metaInfHolder

     * @throws SchemaCompilationException

     */

    private void writeSimpleType(XmlSchemaSimpleType simpleType, BeanWriterMetaInfoHolder metaInfHolder)

            throws SchemaCompilationException {

        writer.write(simpleType, processedTypemap, metaInfHolder);

        processedTypeMetaInfoMap.put(simpleType.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,parentSchema);

            }

        }

        //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,parentSchema);

            metaInfHolder.setSimple(true);

        }

    }

    /**

     * 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 = getType(parentSchema, 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,parentSchema);

                }

            }

            // 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

            if (extension.getParticle() != null){

                processParticle(extension.getParticle(),metaInfHolder,parentSchema);

            }

            // process attributes

            //process attributes - first look for the explicit attributes

            XmlSchemaObjectCollection attribs = extension.getAttributes();

            Iterator attribIterator = attribs.getIterator();

            while (attribIterator.hasNext()) {

                Object o = attribIterator.next();

                if (o instanceof XmlSchemaAttribute) {

                    processAttribute((XmlSchemaAttribute) o, metaInfHolder,parentSchema);

                }

            }

            //process any attribute

            //somehow the xml schema parser does not seem to pickup the any attribute!!

            XmlSchemaAnyAttribute anyAtt = extension.getAnyAttribute();

            if (anyAtt != null) {

                processAnyAttribute(metaInfHolder,anyAtt);

            }

            String className = findClassName(extension.getBaseTypeName(), false);

            if (!SchemaCompiler.DEFAULT_CLASS_NAME.equals(className)) {

                //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(className);

                //Note  - this is no array! so the array boolean is false

            }

        }else if (content instanceof XmlSchemaComplexContentRestriction){

          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

                XmlSchemaType type = getType(parentSchema, restriction.getBaseTypeName());

                if (type instanceof XmlSchemaComplexType) {

                    XmlSchemaComplexType complexType = (XmlSchemaComplexType) type;

                    if (complexType.getName() != null) {

                        processNamedComplexSchemaType(complexType,parentSchema);

                    } else {

                        //this is not possible. The restriction should always

                        //have a name

                        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.");

                }

            }

            copyMetaInfoHierarchy(metaInfHolder,restriction.getBaseTypeName(),parentSchema);

            //process the particle of this node

            processParticle(restriction.getParticle(),metaInfHolder,parentSchema);

             //process attributes - first look for the explicit attributes

            XmlSchemaObjectCollection attribs = restriction.getAttributes();

            Iterator attribIterator = attribs.getIterator();

            while (attribIterator.hasNext()) {

                Object o = attribIterator.next();

                if (o instanceof XmlSchemaAttribute) {

                    processAttribute((XmlSchemaAttribute) o, metaInfHolder,parentSchema);

                }

            }

            //process any attribute

            //somehow the xml schema parser does not seem to pickup the any attribute!!

            XmlSchemaAnyAttribute anyAtt = restriction.getAnyAttribute();

            if (anyAtt != null) {

                processAnyAttribute(metaInfHolder,anyAtt);

            }

            String className = findClassName(restriction.getBaseTypeName(), false);

            if (!SchemaCompiler.DEFAULT_CLASS_NAME.equals(className)) {

                metaInfHolder.setRestriction(true);

                metaInfHolder.setRestrictionClassName(findClassName(restriction.getBaseTypeName(), false));

                //Note  - this is no array! so the array boolean is false

            }

        }

    }

    /**

     * 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;

        type = parentSchema.getTypeByName(baseTypeName);

        if (type == null){

            type = getType(parentSchema,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);