* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements. See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership. The ASF licenses this file

* to you 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 static final int COMPONENT_TYPE = 1;

    public static final int COMPONENT_ELEMENT = 2;

    public static final int COMPONENT_ATTRIBUTE = 3;

    public static final int COMPONENT_ATTRIBUTE_GROUP = 4;

    public static final int COMPONENT_GROUP = 5;

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

    private CompilerOptions options;

    private HashMap<QName, String> processedTypemap;

    // have to keep a seperate group type map since same

    // name can be used to group and complextype

    private HashMap<QName, String> processedGroupTypeMap;

    //the list of processedElements for the outer elements

    private HashMap<QName, String> processedElementMap;

    //need to use IdentityHashMap to store processedAnonymousComplexTypes

    //because the key used with the map, XmlSchemaElement, is not immutable

    private IdentityHashMap<XmlSchemaElement, BeanWriterMetaInfoHolder> processedAnonymousComplexTypesMap;

    //we need this map to keep the referenced elements. these elements need to be kept seperate

    //to avoid conflicts

    private HashMap<QName, String> processedElementRefMap;

    private HashMap<QName, String> simpleTypesMap;

    private HashMap<QName, QName> changedTypeMap;

    private HashSet<XmlSchemaSimpleType> changedSimpleTypeSet;

    private HashSet<XmlSchemaComplexType> changedComplexTypeSet;

    private HashSet<XmlSchemaElement> changedElementSet;

    // this map is necessary to retain the metainformation of types. The reason why these

    // meta info 'bags' would be useful later is to cater for the extensions and restrictions

    // of types

    private HashMap<QName, BeanWriterMetaInfoHolder> processedTypeMetaInfoMap;

    //

    private ArrayList<QName> processedElementList;

    //a list of nillable elements - used to generate code

    //for nillable elements

    private List<QName> nillableElementList;

    // writee reference

    private BeanWriter writer = null;

    private Map<QName, String> baseSchemaTypeMap = null;

    //a map for keeping the already loaded schemas

    //the key is the targetnamespace and the value is the schema object

    private Map<String, XmlSchema> loadedSchemaMap = new HashMap<String, XmlSchema>();

    // A map keeping the available schemas

    //the key is the targetnamespace and the value is the schema object

    //this map will be populated when multiple schemas

    //are fed to the schema compiler!

    private Map<String, XmlSchema> availableSchemaMap = new HashMap<String, XmlSchema>();

    private Map<String, String> loadedSourceURI = new HashMap<String, String>();

    // a list of externally identified QNames to be processed. This becomes

    // useful when  only a list of external elements need to be processed

    public static final String ANY_ELEMENT_FIELD_NAME = "extraElement";

    public static final String EXTRA_ATTRIBUTE_FIELD_NAME = "extraAttributes";

    public static final String USE_OPTIONAL = "optional";

    public static final String USE_REQUIRED = "required";

    public static final String USE_NONE = "none";

    /**

     * @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<QName, String> 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;

        }

        Map<String, String> nsp2PackageMap = this.options.getNs2PackageMap();

        if (nsp2PackageMap == null) {

            nsp2PackageMap = new HashMap();

            this.options.setNs2PackageMap(nsp2PackageMap);

        }

        if (!nsp2PackageMap.containsKey("")) {

            nsp2PackageMap.put("", "axis2.apache.org");

        }

        //instantiate the maps

        processedTypemap = new HashMap<QName, String>();

        processedGroupTypeMap = new HashMap<QName, String>();

        processedElementMap = new HashMap<QName, String>();

        simpleTypesMap = new HashMap<QName, String>();

        processedElementList = new ArrayList<QName>();

        processedAnonymousComplexTypesMap = new IdentityHashMap<XmlSchemaElement, BeanWriterMetaInfoHolder>();

        changedTypeMap = new HashMap<QName, QName>();

        processedTypeMetaInfoMap = new HashMap<QName, BeanWriterMetaInfoHolder>();

        processedElementRefMap = new HashMap<QName, String>();

        nillableElementList = new ArrayList<QName>();

        changedComplexTypeSet = new HashSet<XmlSchemaComplexType>();

        changedSimpleTypeSet = new HashSet<XmlSchemaSimpleType>();

        changedElementSet = new HashSet<XmlSchemaElement>();

        //load the writer and initiliaze the base types

        writer = SchemaPropertyLoader.getBeanWriterInstance();

        writer.init(this.options);

        //load the base types

        baseSchemaTypeMap = SchemaPropertyLoader.getTypeMapperInstance().getTypeMap();

        // adding all the soap encoding schema classes

        processedTypemap.putAll(SchemaPropertyLoader.getTypeMapperInstance().getSoapEncodingTypesMap());

    }

    /**

     * 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<XmlSchema> schemalist) throws SchemaCompilationException {

        try {

            if (schemalist.isEmpty()) {

                return;

            }

            //clear the loaded and available maps

            loadedSchemaMap.clear();

            availableSchemaMap.clear();

            // first round - populate the avaialble map

            for (XmlSchema schema : schemalist) {

                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 (XmlSchema schema : schemalist) {

                    nsp = schema.getTargetNamespace();

                    if ((nsp != null) && !nsp.equals("")) {

                        break;

                    }

                    XmlSchema[] schemas = SchemaUtil.getAllSchemas(schema);

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

                        nsp = schemas[j].getTargetNamespace();

                        if (nsp != null) {

                            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(options.getNs2PackageMap().get(nsp));

                } else {

                    writer.registerExtensionMapperPackageName(nsp == null ? null :

                                                              URLProcessor.makePackageName(nsp));

                }

            }

            // second round - call the schema compiler one by one

            for (XmlSchema schema : schemalist) {

                compile(schema, 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) {

                String ns = schema.getTargetNamespace();

                if (ns == null) {

                    ns = URLProcessor.DEFAULT_PACKAGE;

                }

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

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

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

                    writer.registerExtensionMapperPackageName(options.getNs2PackageMap().get(ns));

                } else {

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

                }

            }

        }

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

            // when the target name space is not given schema.getTargetNamesapce returns null.

            // but when importing import namesapce location is given as "".

            // this causese a problem in finding reference elements. see AXIS2-3029

            // kept the null entry as well to safe gaurd any thing which acess using null

            if (schema.getTargetNamespace() == null) {

                loadedSchemaMap.put("", 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);

        }

        for (XmlSchemaObject object : schema.getExternals()) {

            if (object instanceof XmlSchemaImport) {

                XmlSchemaImport schemaImport = (XmlSchemaImport) object;

                XmlSchema schema1 = schemaImport.getSchema();

                if (schema1 != null) {

                    compile(schema1, isPartofGroup);

                } else if (schemaImport.getNamespace().equals(Constants.NS_URI_XML)) {

                    // AXIS2-3229: some Web services (e.g. MS Exchange) assume that

                    // http://www.w3.org/XML/1998/namespace is a known namespace and that

                    // no schemaLocation is required when importing it. Load a local copy of

                    // the schema in that case.

                    schema1 = new XmlSchemaCollection().read(new InputSource(

                            SchemaCompiler.class.getResource("namespace.xsd").toExternalForm()));

                    schemaImport.setSchema(schema1);

                    compile(schema1, isPartofGroup);

                } else if (!schemaImport.getNamespace().equals(Constants.URI_2001_SCHEMA_XSD)) {

                    // Give the user a hint why the schema compilation fails...

                    log.warn("No schemaLocation for import of " + schemaImport.getNamespace() +

                             "; compilation may fail");

                }

            }

            if (object instanceof XmlSchemaInclude) {

                XmlSchema schema1 = ((XmlSchemaInclude) object).getSchema();

                if (schema1 != null) {

                    if (schema1.getTargetNamespace() == null) {

                        // the target namespace of an included shchema should be same

                        // as the parent schema however if the schema uses the chemalon pattern

                        // target namespace can be null. so set it here.

                        // http://www.xfront.com/ZeroOneOrManyNamespaces.html#mixed

                        schema1.setTargetNamespace(schema.getTargetNamespace());

                    }

                    compile(schema1, isPartofGroup);

                }

            }

        }

        //select all the elements. We generate the code for types

        //only if the elements refer them!!! regardless of the fact that

        //we have a list of elementnames, we'll need to process all the elements

        for (XmlSchemaElement element : schema.getElements().values()) {

            //this is the set of outer elements so we need to generate classes

            //The outermost elements do not contain occurence counts (!) so we do not need

            //to check for arraytypes

            processElement(element, schema);

        }

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

        for (XmlSchemaElement element : schema.getElements().values()) {

            //this is the set of outer elements so we need to generate classes

            writeElement(element);

        }

        if (options.isGenerateAll()) {

            for (XmlSchemaType schemaType : schema.getSchemaTypes().values()) {

                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, null);

                }

            }

        }

        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(

                processedTypeMetaInfoMap.values().toArray(

                        new BeanWriterMetaInfoHolder[processedTypeMetaInfoMap.size()]));

        if (options.isWrapClasses()) {

            writer.writeBatch();

        }

        // resets the changed types

        for (XmlSchemaComplexType xmlSchemaComplexType : changedComplexTypeSet) {

            xmlSchemaComplexType.setName(null);

        }

        for (XmlSchemaSimpleType xmlSchemaSimpleType : changedSimpleTypeSet) {

            xmlSchemaSimpleType.setName(null);

        }

        for (XmlSchemaElement xmlSchemaElement : changedElementSet) {

            xmlSchemaElement.setSchemaTypeName(null);

        }

    }

    /**

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

            // element declared at the top level and have simple types may

            // use primitive type if we do not add this check

            if (options.isUseWrapperClasses() && PrimitiveTypeFinder.isPrimitive(className)) {

                className = PrimitiveTypeWrapper.getWrapper(className);

            }

            //this means the schema type actually returns a different QName

            if (changedTypeMap.containsKey(qName)) {

                metainf.registerMapping(xsElt.getQName(),