/*

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

 */

/*

 * $Id: XSModel.hpp 568078 2007-08-21 11:43:25Z amassari $

 */

#if !defined(XSMODEL_HPP)

#define XSMODEL_HPP

#include <xercesc/util/PlatformUtils.hpp>

#include <xercesc/framework/psvi/XSObject.hpp>

#include <xercesc/framework/psvi/XSNamedMap.hpp>

#include <xercesc/util/ValueVectorOf.hpp>

#include <xercesc/validators/schema/SchemaElementDecl.hpp>

XERCES_CPP_NAMESPACE_BEGIN

/**

 * This class contains all properties of the Schema infoitem as determined

 * after an entire validation episode.  That is, it contains all the properties

 * of all the Schema Namespace Information objects that went into

 * the validation episode.

 * Since it is not like other components, it  does not 

 * inherit from the XSObject interface.

 * This is *always* owned by the validator /parser object from which

 * it is obtained.  It is designed to be subclassed; subclasses will

 * specify under what conditions it may be relied upon to have meaningful contents.

 */

// forward declarations

class Grammar;

class XMLGrammarPool;

class XSAnnotation;

class XSAttributeDeclaration;

class XSAttributeGroupDefinition;

class XSElementDeclaration;

class XSModelGroupDefinition;

class XSNamespaceItem;

class XSNotationDeclaration;

class XSTypeDefinition;

class XSObjectFactory;

class XMLPARSER_EXPORT XSModel : public XMemory

{

public:

    //  Constructors and Destructor

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

    /** @name Constructors */

    //@{

    /**

      * The constructor to be used when a grammar pool contains all needed info

      * @param grammarPool  the grammar pool containing the underlying data structures

      * @param manager      The configurable memory manager

      */

    XSModel( XMLGrammarPool *grammarPool

                , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);

    /**

      * The constructor to be used when the XSModel must represent all

      * components in the union of an existing XSModel and a newly-created

      * Grammar(s) from the GrammarResolver

      *

      * @param baseModel  the XSModel upon which this one is based

      * @param grammarResolver  the grammar(s) whose components are to be merged

      * @param manager     The configurable memory manager

      */

    XSModel( XSModel *baseModel

                , GrammarResolver *grammarResolver

                , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);

    //@};

    /** @name Destructor */

    //@{

    ~XSModel();

    //@}

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

    /** @name XSModel methods */

    //@{

    /**

     * Convenience method. Returns a list of all namespaces that belong to 

     * this schema. The value <code>null</code> is not a valid namespace 

     * name, but if there are components that don't have a target namespace, 

     * <code>null</code> is included in this list. 

     */

    StringList *getNamespaces();

    /**

     * A set of namespace schema information information items ( of type 

     * <code>XSNamespaceItem</code>), one for each namespace name which 

     * appears as the target namespace of any schema component in the schema 

     * used for that assessment, and one for absent if any schema component 

     * in the schema had no target namespace. For more information see 

     * schema information. 

     */

    XSNamespaceItemList *getNamespaceItems();

    /**

     * [schema components]: a list of top-level components, i.e. element 

     * declarations, attribute declarations, etc. 

     * @param objectType The type of the declaration, i.e. 

     *   <code>ELEMENT_DECLARATION</code>, 

     *   <code>TYPE_DEFINITION</code> and any other component type that

     * may be a property of a schema component.

     * @return A list of top-level definition of the specified type in 

     *   <code>objectType</code> or <code>null</code>. 

     */

    XSNamedMap<XSObject> *getComponents(XSConstants::COMPONENT_TYPE objectType);

    /**

     * Convenience method. Returns a list of top-level component declarations 

     * that are defined within the specified namespace, i.e. element 

     * declarations, attribute declarations, etc. 

     * @param objectType The type of the declaration, i.e. 

     *   <code>ELEMENT_DECLARATION</code>.

     * @param compNamespace The namespace to which declaration belongs or 

     *   <code>null</code> (for components with no target namespace).

     * @return A list of top-level definitions of the specified type in 

     *   <code>objectType</code> and defined in the specified 

     *   <code>namespace</code> or <code>null</code>. 

     */

    XSNamedMap<XSObject> *getComponentsByNamespace(XSConstants::COMPONENT_TYPE objectType, 

                                               const XMLCh *compNamespace);

    /**

     *  [annotations]: a set of annotations.

     */

    XSAnnotationList *getAnnotations();

    /**

     * Convenience method. Returns a top-level element declaration. 

     * @param name The name of the declaration.

     * @param compNamespace The namespace of the declaration, null if absent.

     * @return A top-level element declaration or <code>null</code> if such 

     *   declaration does not exist. 

     */

    XSElementDeclaration *getElementDeclaration(const XMLCh *name

            , const XMLCh *compNamespace);

    /**

     * Convenience method. Returns a top-level attribute declaration. 

     * @param name The name of the declaration.

     * @param compNamespace The namespace of the declaration, null if absent.

     * @return A top-level attribute declaration or <code>null</code> if such 

     *   declaration does not exist. 

     */

    XSAttributeDeclaration *getAttributeDeclaration(const XMLCh *name

            , const XMLCh *compNamespace);

    /**

     * Convenience method. Returns a top-level simple or complex type 

     * definition. 

     * @param name The name of the definition.

     * @param compNamespace The namespace of the declaration, null if absent.

     * @return An <code>XSTypeDefinition</code> or <code>null</code> if such 

     *   definition does not exist. 

     */

    XSTypeDefinition *getTypeDefinition(const XMLCh *name

            , const XMLCh *compNamespace);

    /**

     * Convenience method. Returns a top-level attribute group definition. 

     * @param name The name of the definition.

     * @param compNamespace The namespace of the declaration, null if absent.

     * @return A top-level attribute group definition or <code>null</code> if 

     *   such definition does not exist. 

     */

    XSAttributeGroupDefinition *getAttributeGroup(const XMLCh *name

            , const XMLCh *compNamespace);

    /**

     * Convenience method. Returns a top-level model group definition. 

     * @param name The name of the definition.

     * @param compNamespace The namespace of the declaration, null if absent.

     * @return A top-level model group definition definition or 

     *   <code>null</code> if such definition does not exist. 

     */

    XSModelGroupDefinition *getModelGroupDefinition(const XMLCh *name

            , const XMLCh *compNamespace);

    /**

     * Convenience method. Returns a top-level notation declaration. 

     * @param name The name of the declaration.

     * @param compNamespace The namespace of the declaration, null if absent.

     * @return A top-level notation declaration or <code>null</code> if such 

     *   declaration does not exist. 

     */

    XSNotationDeclaration *getNotationDeclaration(const XMLCh *name

            , const XMLCh *compNamespace);

    /**

      * Optional.  Return a component given a component type and a unique Id.  

      * May not be supported for all component types.

      * @param compId unique Id of the component within its type

      * @param compType type of the component

      * @return the component of the given type with the given Id, or 0

      * if no such component exists or this is unsupported for

      * this type of component.

      */

    XSObject *getXSObjectById(unsigned int  compId

                , XSConstants::COMPONENT_TYPE compType);

    //@}

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

    /** methods needed by implementation */

    //@{

    XMLStringPool*  getURIStringPool();

    XSNamespaceItem* getNamespaceItem(const XMLCh* const key);

    /**

      * Get the XSObject (i.e. XSElementDeclaration) that corresponds to

      * to a schema grammar component (i.e. SchemaElementDecl)

      * @param key schema component object

      *

      * @return the corresponding XSObject

      */

    XSObject* getXSObject(void* key);

    //@}

private:

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

    //  Helper methods

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

    void addGrammarToXSModel

    (

        XSNamespaceItem* namespaceItem

    );

    void addS4SToXSModel

    (

        XSNamespaceItem* const namespaceItem

        , RefHashTableOf<DatatypeValidator>* const builtInDV

    );

    void addComponentToNamespace

    (

         XSNamespaceItem* const namespaceItem

         , XSObject* const component

         , int componentIndex

         , bool addToXSModel = true

    );

    void addComponentToIdVector

    (

        XSObject* const component

        , int componentIndex

    );

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

    //  Unimplemented constructors and operators

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

    XSModel(const XSModel&);

    XSModel & operator=(const XSModel &);

protected:

    friend class XSObjectFactory;

    friend class XSObject;

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

    //  data members

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

    // fMemoryManager:

    //  used for any memory allocations

    MemoryManager* const                    fMemoryManager;

    StringList*                             fNamespaceStringList;

    XSNamespaceItemList*                    fXSNamespaceItemList;

    RefVectorOf<XSObject>*                  fIdVector[XSConstants::MULTIVALUE_FACET];    

    /* Need a XSNamedMap for each component    top-level?

	      ATTRIBUTE_DECLARATION     = 1,	   

	      ELEMENT_DECLARATION       = 2,	    

	      TYPE_DEFINITION           = 3,	    

	      ATTRIBUTE_USE             = 4,	   no 

	      ATTRIBUTE_GROUP_DEFINITION= 5,	    

	      MODEL_GROUP_DEFINITION    = 6,	   

	      MODEL_GROUP               = 7,	   no 

	      PARTICLE                  = 8,	   no

	      WILDCARD                  = 9,	   no

	      IDENTITY_CONSTRAINT       = 10,	   no

	      NOTATION_DECLARATION      = 11,	    

	      ANNOTATION                = 12,	   no 

	      FACET                     = 13,      no

	      MULTIVALUE_FACET          = 14       no

    */

    XSNamedMap<XSObject>*                   fComponentMap[XSConstants::MULTIVALUE_FACET];

    XMLStringPool*                          fURIStringPool;

    XSAnnotationList*                       fXSAnnotationList;

    RefHashTableOf<XSNamespaceItem>*        fHashNamespace;

    XSObjectFactory*                        fObjFactory;

    RefVectorOf<XSNamespaceItem>*           fDeleteNamespace;

    XSModel*                                fParent;

    bool                                    fDeleteParent;

    bool                                    fAddedS4SGrammar;

};

inline XMLStringPool*  XSModel::getURIStringPool()

{

    return fURIStringPool;

}

inline StringList *XSModel::getNamespaces()

{

    return fNamespaceStringList;

}

inline XSNamespaceItemList *XSModel::getNamespaceItems()

{

    return fXSNamespaceItemList;

}

XERCES_CPP_NAMESPACE_END

#endif