* Redistribution and use of this software and associated documentation

* ("Software"), with or without modification, are permitted provided

* that the following conditions are met:

*

* 1. Redistributions of source code must retain copyright

*    statements and notices.  Redistributions must also contain a

*    copy of this document.

*

* 2. Redistributions in binary form must reproduce the

*    above copyright notice, this list of conditions and the

*    following disclaimer in the documentation and/or other

*    materials provided with the distribution.

*

* 3. The name "Exolab" must not be used to endorse or promote

*    products derived from this Software without prior written

*    permission of Intalio, Inc.  For written permission,

*    please contact info@exolab.org.

*

* 4. Products derived from this Software may not be called "Exolab"

*    nor may "Exolab" appear in their names without prior written

*    permission of Intalio, Inc. Exolab is a registered

*    trademark of Intalio, Inc.

*

* 5. Due credit should be given to the Exolab Project

*    (http://www.exolab.org/).

*

* THIS SOFTWARE IS PROVIDED BY INTALIO, INC. AND CONTRIBUTORS

* ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT

* NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL

* INTALIO, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED

* OF THE POSSIBILITY OF SUCH DAMAGE.

*

* Copyright 1999-2004 (C) Intalio Inc. All Rights Reserved.

*

* This file was originally developed by Keith Visco during the course

* of employment at Intalio Inc.

* Portions of this file developed by Keith Visco after Jan 19 2005 are

* Copyright (C) 2005 Keith Visco. All Rights Reserverd.

*

* $Id: SourceFactory.java 7996 2008-12-16 08:25:44Z wguttmn $

*/

* Creates the Java Source classes for Schema components.

*

* @author <a href="mailto:keith AT kvisco DOT com">Keith Visco</a>

* @author <a href="mailto:blandin@intalio.com">Arnaud Blandin</a>

* @version $Revision: 7996 $ $Date: 2006-04-25 15:08:23 -0600 (Tue, 25 Apr 2006) $

*/

    private static final String ENUM_ACCESS_INTERFACE =

        "org.exolab.castor.types.EnumeratedTypeAccess";

    private static final short  BASE_TYPE_ENUMERATION   = 0;

    private static final short  OBJECT_TYPE_ENUMERATION = 1;

    private static final String CLASS_METHOD_SUFFIX     = "Class";

    private static final String CLASS_KEYWORD           = "class";

    private static final String ITEM_NAME               = "Item";

    /**  The current Binding for which we are creating classes. */

    private ExtendedBinding _binding = null;

    /** The member factory. */

    private MemberFactory _memberFactory = null;

    private short _enumerationType = OBJECT_TYPE_ENUMERATION;

    /**

     * A flag indicating whether or not to generate XML marshaling framework

     * specific methods.

     */

    private boolean _createMarshalMethods = true;

    /**

     * A flag indicating whether or not to implement CastorTestable (used by the

     * Castor Testing Framework).

     */

    private boolean _testable = false;

    /** A flag indicating that SAX1 should be used when generating the source. */

    private boolean _sax1 = false;

    /** The TypeConversion instance to use for mapping SimpleTypes into XSTypes. */

    private TypeConversion _typeConversion = null;

    /** Enumeration factory used to create code for enumerations. */

    private final EnumerationFactory _enumerationFactory;

    /**

     * Creates a new SourceFactory with the given FieldInfoFactory.

     *

     * @param config the BuilderConfiguration instance (must not be null).

     * @param infoFactory the FieldInfoFactory to use

     * @param groupNaming Group naming scheme to be used.

     * @param sourceGenerator the calling source generator.

     */

    public SourceFactory(final BuilderConfiguration config,

            final FieldInfoFactory infoFactory,

            final GroupNaming groupNaming,

            final SourceGenerator sourceGenerator) {

        super(config, infoFactory, groupNaming, sourceGenerator);

        // set the config into the info factory (CASTOR-1346)

        infoFactory.setBoundProperties(config.boundPropertiesEnabled());

        this._memberFactory =

            new MemberFactory(config, infoFactory, getGroupNaming(), sourceGenerator);

        this._typeConversion = new TypeConversion(getConfig());

        this._enumerationFactory =

            new EnumerationFactory(getConfig(), getGroupNaming(), sourceGenerator);

    } //-- SourceFactory

   /**

     * Sets whether or not to create the XML marshaling framework specific

     * methods (marshal, unmarshal, validate) in the generated classes. By

     * default, these methods are generated.

     *

     * @param createMarshalMethods

     *            a boolean, when true indicates to generated the marshaling

     *            framework methods

     *

     */

    public void setCreateMarshalMethods(final boolean createMarshalMethods) {

        _createMarshalMethods = createMarshalMethods;

    } //-- setCreateMarshalMethpds

    /**

     * Sets whether or not to create extra collection methods for accessing the

     * actual collection.

     *

     * @param extraMethods

     *            a boolean that when true indicates that extra collection

     *            accessor methods should be created. False by default.

     * @see org.exolab.castor.builder.SourceFactory#setReferenceMethodSuffix

     */

    public void setCreateExtraMethods(final boolean extraMethods) {

        getInfoFactory().setCreateExtraMethods(extraMethods);

    } //-- setCreateExtraMethods

    /**

     * Sets the method suffix (ending) to use when creating the extra collection

     * methods.

     *

     * @param suffix

     *            the method suffix to use when creating the extra collection

     *            methods. If null or emtpty the default value, as specified in

     *            CollectionInfo will be used.

     * @see org.exolab.castor.builder.SourceFactory#setCreateExtraMethods

     */

    public void setReferenceMethodSuffix(final String suffix) {

        getInfoFactory().setReferenceMethodSuffix(suffix);

    } //-- setReferenceMethodSuffix

    /**

     * Sets whether or not to implement CastorTestable.

     *

     * @param testable

     *            if true, indicates to implement CastorTestable

     */

    public void setTestable(final boolean testable) {

        _testable = testable;

    }

   /**

     * Sets to true if SAX1 should be used in the marshall method.

     *

     * @param sax1

     *            true if SAX1 should be used.

     */

    public void setSAX1(final boolean sax1) {

        _sax1 = sax1;

    }

    /**

     * Set to true if enumerated type lookups should be performed in a case

     * insensitive manner.

     *

     * @param caseInsensitive

     *            when true

     */

    public void setCaseInsensitive(final boolean caseInsensitive) {

        _enumerationFactory.setCaseInsensitive(caseInsensitive);

    }

    //------------------/

    //- Public Methods -/

    //------------------/

    /**

     * Creates a new ClassInfo for the given XMLBindingComponent.

     *

     * @param component the XMLBindingComponent that abstracts all XML Schema

     *        definition for a XML Schema component.

     * @param sgState The given state of the SourceGenerator.

     * @return an array of JClasses reflecting the given XMLBindingComponent.

     */

    public JClass[] createSourceCode(final XMLBindingComponent component,

                                     final SGStateInfo sgState) {

        if (component == null) {

            throw new IllegalStateException("XMLBindingComponent may not be null.");

        }

        if (sgState == null) {

            throw new IllegalStateException("SGStateInfo may not be null.");

        }

        //-- check for previous JClass bindings

        JClass[] classes = sgState.getSourceCode(component.getAnnotated());

        if (classes != null) {

            return classes;

        }

        _binding = component.getBinding();

        if (sgState.verbose()) {

             String name = component.getXMLName();

             if (name == null) {

                 name = component.getJavaClassName();

             }

             String msg = "Creating classes for: " + name;

             sgState.getDialog().notify(msg);

        }

        //0-- set the packageName

        String packageName = component.getJavaPackage();

        if (packageName == null || packageName.length() == 0) {

            packageName = sgState.getPackageName();

        }

        //1-- get the name

        //--if no package used then try to append the default package

        //--used in the SourceGenerator

        String className = component.getQualifiedName();

        if (className.indexOf('.') == -1) {

            //--be sure it is a valid className

            className = getJavaNaming().toJavaClassName(className);

            className = resolveClassName(className, packageName);

        }

        //2-- check if we have to create an Item class

        boolean createGroupItem = component.createGroupItem();

        if (createGroupItem) {

            className += ITEM_NAME;

            classes = new JClass[2];

        } else {

            classes = new JClass[1];

        }

        //3-- Create factoryState and chain it to sgState to prevent endless loop

        FactoryState state =

            new FactoryState(className, sgState, packageName, component);

        state.setCreateGroupItem(createGroupItem);

        if (sgState.getCurrentFactoryState() != null) {

            state.setParent(sgState.getCurrentFactoryState());

        }

        sgState.setCurrentFactoryState(state);

        //--Prevent endless loop

        if (state.processed(component.getAnnotated())) {

            return new JClass[0];

        }

        //-- Mark the enclosed annotated structure as processed in the

        //-- current FactoryState for preventing endless loop.

        state.markAsProcessed(component.getAnnotated());

        //////////////////////////////////////////////////////

        //NOTE: check that the component is not referring to

        //an imported schema to prevent class creation

        //////////////////////////////////////////////////////

        //4-- intialization of the JClass

        ClassInfo classInfo = state.getClassInfo();

        JClass    jClass    = state.getJClass();

        initialize(jClass);

        if (classInfo.hasNature(XMLInfoNature.class.getName())) {

            final XMLInfoNature xmlNature = new XMLInfoNature(classInfo);

           

            //-- name information

            xmlNature.setNodeName(component.getXMLName());

           

            //-- namespace information

            xmlNature.setNamespaceURI(component.getTargetNamespace());

           

            //5--processing the type

            XMLType type = component.getXMLType();

            boolean createForSingleGroup = false;

            boolean creatingForAnElement =

                (component.getAnnotated().getStructureType() == Structure.ELEMENT);

           

            //-- created from element definition information

            xmlNature.setElementDefinition(creatingForAnElement);

           

            // deal with substitution groups

            if (creatingForAnElement) {

                ElementDecl elementDeclaration = (ElementDecl) component.getAnnotated();

                Enumeration<ElementDecl> possibleSubstitutes = elementDeclaration.getSubstitutionGroupMembers();

                if (possibleSubstitutes.hasMoreElements()) {

                    List<String> substitutionGroupMembers = new ArrayList<String>();

                    while (possibleSubstitutes.hasMoreElements()) {

                        ElementDecl substitute = possibleSubstitutes.nextElement();

                        substitutionGroupMembers.add(substitute.getName());

                    }

                    xmlNature.setSubstitutionGroups(substitutionGroupMembers);

                }

            }

            if (type != null) {

                if (type.isComplexType()) {

                    processComplexType(component, sgState, state);

                } else if (type.isSimpleType()) {

                    SimpleType simpleType = (SimpleType) type;

                    //-- handle our special case for enumerated types

                    if (simpleType.hasFacet(Facet.ENUMERATION)) {

                        processSimpleTypeEnumeration(component, sgState, classInfo, simpleType);

                    } else {

                        //////////////////////////////////////////////////////////

                        //NOTE: generate sources if the flag for generating sources

                        //from imported schemas is on

                        //////////////////////////////////////////////////////////

                        return new JClass[0];

                    }

                } else if (type.isAnyType()) {

                    //-- Do not create classes for AnyType

                    xmlNature.setSchemaType(new XSClass(SGTypes.OBJECT));

                    return new JClass[0];

                }

            } else {

                //--no type we must be facing an XML schema group

                //--MODEL GROUP OR GROUP

                createForSingleGroup = processSchemaGroup(component, state, classInfo);

            }

            //6--createGroupItem

            if (createGroupItem) {

                //-- create Bound Properties code

                if (component.hasBoundProperties()) {

                    createPropertyChangeMethods(jClass);

                }

                sgState.bindReference(jClass, classInfo);

                classes[1] = jClass;

                //-- create main group class

                String fname = component.getJavaClassName() + ITEM_NAME;

                fname = getJavaNaming().toJavaMemberName(fname, false);

                FieldInfo fInfo = null;

                if (createForSingleGroup) {

                    //By default a nested group Item can occur only once

                    fInfo = getInfoFactory().createFieldInfo(new XSClass(jClass), fname);

                } else {

                    fInfo = getInfoFactory().createCollection(

                            new XSClass(jClass), "_items", fname, getJavaNaming(), getConfig().useJava50());

                }

                fInfo.setContainer(true);

                String newClassName = className.substring(0, className.length() - 4);

                state = new FactoryState(newClassName, sgState, packageName, component);

                classInfo = state.getClassInfo();

                jClass    = state.getJClass();

                initialize(jClass);

                if (type != null && type.isComplexType()) {

                    ComplexType complexType = (ComplexType) type;

                    if (complexType.isTopLevel() ^ creatingForAnElement) {

                        //process attributes and content type since it has not be performed before

                        Annotated saved = component.getAnnotated();

                        processAttributes(component.getBinding(), complexType, state);

                        component.setView(saved);

                        if (complexType.getContentType() == ContentType.mixed) {

                            FieldInfo fieldInfo = _memberFactory.createFieldInfoForContent(

                                    component, new XSString(), getConfig().useJava50());

                            handleField(fieldInfo, state, component);

                        } else if (complexType.getContentType().getType() == ContentType.SIMPLE) {

                            SimpleContent simpleContent = (SimpleContent) complexType.getContentType();

                            SimpleType temp = simpleContent.getSimpleType();

                            XSType xsType = _typeConversion.convertType(

                                    temp, packageName, getConfig().useJava50());

                            FieldInfo fieldInfo = _memberFactory.createFieldInfoForContent(

                                    component, xsType, getConfig().useJava50());

                            handleField(fieldInfo, state, component);

                            temp = null;

                        } else {

                            // handle multi-valued choice group

                            xmlNature.setSchemaType(new XSClass(jClass));

                        }

                    }

                }

                classInfo.addFieldInfo(fInfo);

                fInfo.getMemberAndAccessorFactory().createJavaField(fInfo, jClass);

                fInfo.getMemberAndAccessorFactory().createAccessMethods(

                        fInfo, jClass, getConfig().useJava50(), getConfig().getAnnotationBuilders());

                fInfo.getMemberAndAccessorFactory().generateInitializerCode(

                        fInfo, jClass.getConstructor(0).getSourceCode());

                //-- name information

                XMLInfoNature xmlInfoNature = new XMLInfoNature(classInfo);

                xmlInfoNature.setNodeName(component.getXMLName());

                //-- mark as a container

                xmlInfoNature.setContainer(true);

               

                // -- if we have a superclass, make sure that the actual type extends it, not the

                // xxxItem holder class.

                String actSuperClass = classes[1].getSuperClassQualifiedName();

                jClass.setSuperClass(actSuperClass);

                classes[1].setSuperClass(null);

            }

        }

       

        classes[0] = jClass;

        //7--set the class information given the component information

        //--base class

        String baseClass = component.getExtends();

        if (baseClass != null && baseClass.length() > 0) {

            //-- at this point if a base class has been set

            //-- it means that it is a class generated for an element

            //-- that extends a class generated for a complexType. Thus

            //-- no change is possible

            if (jClass.getSuperClassQualifiedName() == null) {

                jClass.setSuperClass(baseClass);

            }

        }

        //--interface implemented

        String[] implemented = component.getImplements();

        if (implemented != null) {

            for (int i = 0; i < implemented.length; i++) {

                String interfaceName = implemented[i];

                if ((interfaceName != null) && (interfaceName.length() > 0)) {

                    jClass.addInterface(interfaceName);

                }

            }

        }

        //--final

        jClass.getModifiers().setFinal(component.isFinal());

        //--abstract

        if (component.isAbstract()) {

            jClass.getModifiers().setAbstract(true);

            classInfo.setAbstract(true);

        }

       

        processAppInfo(component.getAnnotated(), classInfo);

        extractAnnotations(component.getAnnotated(), jClass);

        createContructorForDefaultValueForSimpleContent(component.getAnnotated(), classInfo, sgState);

        makeMethods(component, sgState, state, jClass, baseClass);

       

        if (classInfo.hasNature(JDOClassInfoNature.class.getName())) {

            JDOClassInfoNature jdoNature = new JDOClassInfoNature(classInfo);

            if (jdoNature.getDetachable()) {

                createJdoTimestampImplementations(jClass);

            }

        }

        sgState.bindReference(jClass, classInfo);

        sgState.bindReference(component.getAnnotated(), classInfo);

        //-- Save source code bindings to prevent duplicate code generation

        sgState.bindSourceCode(component.getAnnotated(), classes);

        // custom annotations

        AnnotationBuilder[] annotationBuilders = getConfig().getAnnotationBuilders();

        for (int i = 0; i < annotationBuilders.length; i++) {

            AnnotationBuilder annotationBuilder = annotationBuilders[i];

            annotationBuilder.addClassAnnotations(classInfo, jClass);

        }

        return classes;

    }

    /**

     * This method adds a contructor with a string parameter to set the default

     * value of a simple content. If the provided class is not a Simple Content

     * class, nothing is done.

     *

     * @param annotated type information for the class to potentially create a

     *        constructor for

     * @param classInfo the ClassInfo for the class to potentially create a

     *        constructor for

     */

    private void createContructorForDefaultValueForSimpleContent(final Annotated annotated,

                                                                 final ClassInfo classInfo,

                                                                 final SGStateInfo sgStateInfo) {

        FieldInfo textFieldInfo =  classInfo.getTextField();

        boolean generate = false;

        boolean inherited = false;

       

        // check if there is some field inherited from a type

        if (annotated instanceof ElementDecl) {

            XMLType type = ((ElementDecl) annotated).getType();

            ClassInfo typeInfo = sgStateInfo.resolve(type);

            if (typeInfo != null && typeInfo.getTextField() != null) {

                textFieldInfo = typeInfo.getTextField();

                inherited = true;

            }

            generate = (type.isComplexType() && ((ComplexType) type).isSimpleContent());

        }

       

        // check if we are a complexType ourself

        else if (annotated instanceof ComplexType && ((ComplexType) annotated).isSimpleContent()) {

            generate = true;

        }

       

        // discard primitiv types and collections

        if (textFieldInfo != null) {

            XSType textFieldType = new XMLInfoNature(textFieldInfo).getSchemaType();

            if (textFieldType != null && textFieldType.getJType().isArray()) {

                generate = false;

            }

        }

        if (!generate) {

            return;

        }

        XMLInfoNature xmlNature = new XMLInfoNature(textFieldInfo);

       

        // create constructor

        JClass jClass = classInfo.getJClass();

        JParameter parameter = new JParameter(new JClass("java.lang.String"), "defaultValue");

        JConstructor constructor = jClass.createConstructor(new JParameter[] {parameter});

        JSourceCode sourceCode = new JSourceCode();

        if (inherited) {

            sourceCode.add("super(defaultValue);");

        } else {

            sourceCode.add("try {");

            String defaultValue =

                xmlNature.getSchemaType().createDefaultValueWithString("defaultValue");

            sourceCode.addIndented("setContent(" + defaultValue + ");");

            sourceCode.add(" } catch(Exception e) {");

            sourceCode.addIndented("throw new RuntimeException(\"Unable to cast default value for simple content!\");");

            sourceCode.add(" } ");

        }

        constructor.setSourceCode(sourceCode);

        jClass.addConstructor(constructor);

    }

    /**

     * Extract 'documentation' annotations from the {@link Annotated} instance given.

     * @param annotated {@link Annotated} instance to extract annotations from.

     * @param jClass {@link JClass} instance to inject annotations into.

     */

    private void extractAnnotations(final Annotated annotated, final JClass jClass) {

        //-- process annotation

        String comment  = extractCommentsFromAnnotations(annotated);

        if (comment != null) {

            jClass.getJDocComment().setComment(comment);

           

            if (getConfig().generateExtraDocumentationMethods()) {

                generateExtraDocumentationMethods(annotated, jClass);

            }

        }

    }

    /**

     * Creates the #getXmlSchemaDocumentation methods for the given JClass.

     *

     * @param annotated

     *            The {@link Annotation} instance to extract the XML schema

     *            documentation instances from.

     * @param parent

     *            the JClass to create the #getXmlSchemaDocumentation() methods

     *            for

     */

    private void generateExtraDocumentationMethods(final Annotated annotated,

            final JClass jClass) {

        JField documentationsField =

            new JField(new JClass("java.util.Map"), "_xmlSchemaDocumentations");

        documentationsField.setComment("The content of the <xsd:documentation> elements");

        documentationsField.setInitString("new java.util.HashMap()");

        jClass.addMember(documentationsField);

        Enumeration<Annotation> annotations = annotated.getAnnotations();

        while (annotations.hasMoreElements()) {

            Annotation annotation = annotations.nextElement();

            Enumeration<Documentation> documentations = annotation.getDocumentation();

            while (documentations.hasMoreElements()) {

                Documentation documentation = documentations.nextElement();

                JConstructor defaultConstructor = jClass.getConstructor(0);

                String documentationContent = normalize(documentation.getContent());

                documentationContent =

                    StringUtil.replaceAll(documentationContent, "\n", "\"\n+ \" ");

                defaultConstructor.getSourceCode().add("_xmlSchemaDocumentations.put(\""

                        +  documentation.getSource() + "\", \""

                        + documentationContent + "\");");

            }

        }

        JMethod aMethod = new JMethod("getXmlSchemaDocumentations",

                new JClass("java.util.Map"),

        " A collection of documentation elements.");

        JSourceCode sourceCode = aMethod.getSourceCode();

        sourceCode.add("return _xmlSchemaDocumentations;");

        jClass.addMethod(aMethod);

        JMethod anotherMethod = new JMethod("getXmlSchemaDocumentation",

                new JClass("java.lang.String"),

                    " A specific XML schema documentation element.");

        JParameter parameter = new JParameter(new JClass("java.lang.String"), "source");

        anotherMethod.addParameter(parameter);

        sourceCode = anotherMethod.getSourceCode();

        sourceCode.add("return (java.lang.String) _xmlSchemaDocumentations.get(source);");

        jClass.addMethod(anotherMethod);

    }

    /**

     * Generate methods for our class.

     *

     * @param component

     * @param sgState

     * @param state

     * @param jClass

     * @param baseClass

     */

    private void makeMethods(

            final XMLBindingComponent component,

            final SGStateInfo sgState,

            final FactoryState state,

            final JClass jClass,

            final String baseClass) {

        //NOTE: be careful with the derivation stuff when generating bounds properties

        if (_createMarshalMethods) {

            //-- #validate()

            createValidateMethods(jClass);

            //--don't generate marshal/unmarshal methods

            //--for abstract classes

            if (!component.isAbstract()) {

                //-- #marshal()

                createMarshalMethods(jClass);

                //-- #unmarshal()

                createUnmarshalMethods(jClass, sgState);

            }

        }

        //create equals() method?

        if (component.hasEquals()) {

            createEqualsMethod(jClass);

            createHashCodeMethod(jClass);

        }

        //implements CastorTestable?

        if (_testable) {

            createTestableMethods(jClass, state);

        }

        //-- This boolean is set to create bound properties

        //-- even if the user has set the SUPER CLASS property

        String superclassQualifiedName = jClass.getSuperClassQualifiedName();

        if (superclassQualifiedName == null || superclassQualifiedName.equals(baseClass)) {

            //-- create Bound Properties code

            if (component.hasBoundProperties()) {

                createPropertyChangeMethods(jClass);

            }

        }

    }

    private boolean processSchemaGroup(final XMLBindingComponent component,

                                       final FactoryState state, final ClassInfo classInfo) {

        try {

            Group group = (Group) component.getAnnotated();

            processContentModel(group, state);

            component.setView(group);

            //-- Check Group Type

            Order order = group.getOrder();

            GroupInfo groupInfo = new XMLInfoNature(classInfo).getGroupInfo();

            if (order == Order.choice) {

                groupInfo.setAsChoice();

            } else if (order == Order.sequence) {

                groupInfo.setAsSequence();

            } else {

                groupInfo.setAsAll();

            }

            return group.getMaxOccurs() == 1;

        } catch (ClassCastException ce) {

            //--Should not happen

            throw new IllegalArgumentException("Illegal binding component: " + ce.getMessage());

        }

    }

    private void processSimpleTypeEnumeration(final XMLBindingComponent component,

                                              final SGStateInfo sgState, final ClassInfo classInfo,

                                              final SimpleType simpleType) {

        //-- Don't create source code for simple types that

        //-- don't belong in the elements target namespace

        String tns = simpleType.getSchema().getTargetNamespace();

        boolean create = false;

        if (tns == null) {

            create = (component.getTargetNamespace() == null);

        } else {

            create = tns.equals(component.getTargetNamespace());

        }

        if (create) {

            ClassInfo tmpInfo = sgState.resolve(simpleType);

            JClass tmpClass = null;

            if (tmpInfo != null) {

                tmpClass = tmpInfo.getJClass();

            } else {

                tmpClass = createSourceCode(component.getBinding(), simpleType, sgState);

            }

            XMLInfoNature xmlNature = new XMLInfoNature(classInfo);

            xmlNature.setSchemaType(new XSClass(tmpClass));

        }

    }

    private void processComplexType(final XMLBindingComponent component, final SGStateInfo sgState,

                                    final FactoryState state) {

        XMLType   type      = component.getXMLType();

        ClassInfo classInfo = state.getClassInfo();

        JClass    jClass    = state.getJClass();

        boolean creatingForAnElement =

            (component.getAnnotated().getStructureType() == Structure.ELEMENT);

        ComplexType complexType = (ComplexType) type;

        if (complexType.isTopLevel() && creatingForAnElement) {

             //--move the view and keep the structure

             Annotated saved = component.getAnnotated();

             String previousPackage = component.getJavaPackage();

             XMLBindingComponent baseComponent = new XMLBindingComponent(

                     getConfig(), getGroupNaming());

             baseComponent.setBinding(component.getBinding());

             baseComponent.setView(complexType);

             //-- call createSourceCode to pre-process the complexType

             createSourceCode(baseComponent, sgState);

             String baseClassName = null;

             String basePackage = baseComponent.getJavaPackage();

             //--if the base class is not in the same package

             //--of the current class then we have to qualify the base

             //--class

             if (basePackage != null && !basePackage.equals(previousPackage)) {

                 baseClassName = baseComponent.getQualifiedName();

                 if (baseClassName.indexOf('.') == -1) {

                     //--be sure it is a valid className

                     baseClassName = getJavaNaming().toJavaClassName(baseClassName);

                 }

             } else {

                 baseClassName = baseComponent.getJavaClassName();

             }

             jClass.setSuperClass(baseClassName);

             basePackage = null;

             baseClassName = null;

             component.setView(saved);

             saved = null;

        } else if (complexType.isTopLevel() || creatingForAnElement) {

            //generate class if the complexType is anonymous and we create classes

            //for an element OR if the complexType is top-level and we create

            //classes for it.

            //-- check Group type

            if (complexType.getParticleCount() == 1) {

                Particle particle = complexType.getParticle(0);

                if (particle.getStructureType() == Structure.GROUP) {

                    Group group = (Group) particle;

                    if (group.getOrder() == Order.choice) {

                        new XMLInfoNature(classInfo).getGroupInfo().setAsChoice();

                    }

                }

            }

            Annotated saved = component.getAnnotated();

            processComplexType(complexType, state);

            component.setView(saved);

            saved = null;

        }

    }

    /**

     * Creates the Java source code to support the given Simpletype.

     *

     * @param binding Current XML binding

     * @param simpleType the Simpletype to create the Java source for

     * @param sgState the current SGStateInfo (cannot be null).

     * @return the JClass representation of the given Simpletype

     */

    public JClass createSourceCode(final ExtendedBinding binding,

            final SimpleType simpleType, final SGStateInfo sgState) {

        if (SimpleTypesFactory.isBuiltInType(simpleType.getTypeCode())) {

            String err = "You cannot construct a ClassInfo for a built-in SimpleType.";

            throw new IllegalArgumentException(err);

        }

        if (sgState == null) {

            throw new IllegalArgumentException("SGStateInfo cannot be null.");

        }

        //-- Unions are currently processed as the built-in

        //-- basetype for the member types of the Union, so

        //-- do nothing for now...however we can warn

        //-- user that no validation will be peformed on the

        //-- union

        if (simpleType.getStructureType() == Structure.UNION) {

            if (!sgState.getSuppressNonFatalWarnings()) {

                String message = "warning: support for unions is incomplete.";

                sgState.getDialog().notify(message);

            }

            return null;

        }

        ClassInfo cInfo = sgState.resolve(simpleType);