/*

 * 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: ComplexTypeInfo.hpp 568078 2007-08-21 11:43:25Z amassari $

 */

#if !defined(COMPLEXTYPEINFO_HPP)

#define COMPLEXTYPEINFO_HPP

/**

  * The class act as a place holder to store complex type information.

  *

  * The class is intended for internal use.

  */

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

//  Includes

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

#include <xercesc/util/XMLString.hpp>

#include <xercesc/util/RefHash2KeysTableOf.hpp>

#include <xercesc/util/RefVectorOf.hpp>

#include <xercesc/framework/XMLElementDecl.hpp>

#include <xercesc/framework/XMLContentModel.hpp>

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

#include <xercesc/internal/XSerializable.hpp>

XERCES_CPP_NAMESPACE_BEGIN

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

//  Forward Declarations

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

class DatatypeValidator;

class ContentSpecNode;

class SchemaAttDefList;

class SchemaElementDecl;

class XSDLocator;

class VALIDATORS_EXPORT ComplexTypeInfo : public XSerializable, public XMemory

{

public:

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

    //  Public Constructors/Destructor

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

    ComplexTypeInfo(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);

    ~ComplexTypeInfo();

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

    //  Getter methods

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

    bool                     getAbstract() const;

    bool                     getAdoptContentSpec() const;

    bool                     containsAttWithTypeId() const;

    bool                     getPreprocessed() const;

    int                      getDerivedBy() const;

    int                      getBlockSet() const;

    int                      getFinalSet() const;

    int                      getScopeDefined() const;

    unsigned int             getElementId() const;

    int                      getContentType() const;

    unsigned int             elementCount() const;

    XMLCh*                   getTypeName() const;

    DatatypeValidator*       getBaseDatatypeValidator() const;

    DatatypeValidator*       getDatatypeValidator() const;

    ComplexTypeInfo*         getBaseComplexTypeInfo() const;

    ContentSpecNode*         getContentSpec() const;

    const SchemaAttDef*      getAttWildCard() const;

    SchemaAttDef*            getAttWildCard();

    const SchemaAttDef*      getAttDef(const XMLCh* const baseName,

                                       const int uriId) const;

    SchemaAttDef*            getAttDef(const XMLCh* const baseName,

                                       const int uriId);

    XMLAttDefList&           getAttDefList() const;

    const SchemaElementDecl* elementAt(const unsigned int index) const;

    SchemaElementDecl*       elementAt(const unsigned int index);

    XMLContentModel*         getContentModel(const bool checkUPA = false);

    const XMLCh*             getFormattedContentModel ()   const;

    XSDLocator*              getLocator() const;

    const XMLCh*             getTypeLocalName() const;

    const XMLCh*             getTypeUri() const;

    /**

     * returns true if this type is anonymous

     **/

    bool getAnonymous() const;

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

    //  Setter methods

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

    void setAbstract(const bool isAbstract);

    void setAdoptContentSpec(const bool toAdopt);

    void setAttWithTypeId(const bool value);

    void setPreprocessed(const bool aValue = true);

    void setDerivedBy(const int derivedBy);

    void setBlockSet(const int blockSet);

    void setFinalSet(const int finalSet);

    void setScopeDefined(const int scopeDefined);

    void setElementId(const unsigned int elemId);

    void setTypeName(const XMLCh* const typeName);

    void setContentType(const int contentType);

    void setBaseDatatypeValidator(DatatypeValidator* const baseValidator);

    void setDatatypeValidator(DatatypeValidator* const validator);

    void setBaseComplexTypeInfo(ComplexTypeInfo* const typeInfo);

    void setContentSpec(ContentSpecNode* const toAdopt);

    void setAttWildCard(SchemaAttDef* const toAdopt);

    void addAttDef(SchemaAttDef* const toAdd);

    void addElement(SchemaElementDecl* const toAdd);

    /**     

     * @deprecated; not thread-safe (will not work with shared grammars)

     */

    void setContentModel(XMLContentModel* const newModelToAdopt);

    void setLocator(XSDLocator* const aLocator);

    /**

     * sets this type to be anonymous

     **/

    void setAnonymous();

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

    //  Helper methods

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

    bool hasAttDefs() const;

    bool contains(const XMLCh* const attName);

    XMLAttDef* findAttr

    (

        const   XMLCh* const    qName

        , const unsigned int    uriId

        , const XMLCh* const    baseName

        , const XMLCh* const    prefix

        , const XMLElementDecl::LookupOpts      options

        ,       bool&           wasAdded

    )   const;

    bool resetDefs();

    void checkUniqueParticleAttribution

    (

        SchemaGrammar*    const pGrammar

      , GrammarResolver*  const pGrammarResolver

      , XMLStringPool*    const pStringPool

      , XMLValidator*     const pValidator

    ) ;

    /**

      * Return a singleton that represents 'anyType'

      *

      * @param emptyNSId the uri id of the empty namespace 

      */

    static ComplexTypeInfo* getAnyType(unsigned int emptyNSId);

    /**

      *  Notification that lazy data has been deleted

      */

    static void reinitAnyType();

    /***

     * Support for Serialization/De-serialization

     ***/

    DECL_XSERIALIZABLE(ComplexTypeInfo)

private:

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

    //  Unimplemented contstructors and operators

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

    ComplexTypeInfo(const ComplexTypeInfo& elemInfo);

    ComplexTypeInfo& operator= (const ComplexTypeInfo& other);

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

    //  Private helper methods

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

    void faultInAttDefList() const;

    XMLContentModel* createChildModel(ContentSpecNode* specNode, const bool isMixed);

    XMLContentModel* makeContentModel(const bool checkUPA = false);

    XMLContentModel* buildContentModel(ContentSpecNode* const specNode);

    XMLCh* formatContentModel () const ;

    ContentSpecNode* expandContentModel(ContentSpecNode* const curNode, const int minOccurs, const int maxOccurs);

    ContentSpecNode* convertContentSpecTree(ContentSpecNode* const curNode, const bool checkUPA = false);

    void resizeContentSpecOrgURI();

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

    //  Private data members

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

    bool                               fAnonymous;

    bool                               fAbstract;

    bool                               fAdoptContentSpec;

    bool                               fAttWithTypeId;

    bool                               fPreprocessed;

    int                                fDerivedBy;

    int                                fBlockSet;

    int                                fFinalSet;

    int                                fScopeDefined;

    int                                fContentType;

    unsigned int                       fElementId;

    unsigned int                       fUniqueURI;

    unsigned int                       fContentSpecOrgURISize;

    XMLCh*                             fTypeName;

    XMLCh*                             fTypeLocalName;

    XMLCh*                             fTypeUri;

    DatatypeValidator*                 fBaseDatatypeValidator;

    DatatypeValidator*                 fDatatypeValidator;

    ComplexTypeInfo*                   fBaseComplexTypeInfo;

    ContentSpecNode*                   fContentSpec;

    SchemaAttDef*                      fAttWildCard;

    SchemaAttDefList*                  fAttList;

    RefVectorOf<SchemaElementDecl>*    fElements;    

    RefHash2KeysTableOf<SchemaAttDef>* fAttDefs;

    XMLContentModel*                   fContentModel;

    XMLCh*                             fFormattedModel;

    unsigned int*                      fContentSpecOrgURI;

    XSDLocator*                        fLocator;

    MemoryManager*                     fMemoryManager;

    static ComplexTypeInfo*            fAnyType;

};

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

//  ComplexTypeInfo: Getter methods

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

inline bool ComplexTypeInfo::getAbstract() const {

    return fAbstract;

}

inline bool ComplexTypeInfo::getAdoptContentSpec() const {

    return fAdoptContentSpec;

}

inline bool ComplexTypeInfo::containsAttWithTypeId() const {

    return fAttWithTypeId;

}

inline bool ComplexTypeInfo::getPreprocessed() const {

    return fPreprocessed;

}

inline int ComplexTypeInfo::getDerivedBy() const {

    return fDerivedBy;

}

inline int ComplexTypeInfo::getBlockSet() const {

    return fBlockSet;

}

inline int ComplexTypeInfo::getFinalSet() const {

    return fFinalSet;

}

inline int ComplexTypeInfo::getScopeDefined() const {

    return fScopeDefined;

}

inline unsigned int ComplexTypeInfo::getElementId() const {

    return fElementId;

}

inline int ComplexTypeInfo::getContentType() const {

    return fContentType;

}

inline unsigned int ComplexTypeInfo::elementCount() const {

    if (fElements) {

        return fElements->size();

    }

    return 0;

}

inline XMLCh* ComplexTypeInfo::getTypeName() const {

    return fTypeName;

}

inline DatatypeValidator* ComplexTypeInfo::getBaseDatatypeValidator() const {

    return fBaseDatatypeValidator;

}

inline DatatypeValidator* ComplexTypeInfo::getDatatypeValidator() const {

    return fDatatypeValidator;

}

inline ComplexTypeInfo* ComplexTypeInfo::getBaseComplexTypeInfo() const {

    return fBaseComplexTypeInfo;

}

inline ContentSpecNode* ComplexTypeInfo::getContentSpec() const {

    return fContentSpec;

}

inline const SchemaAttDef* ComplexTypeInfo::getAttWildCard() const {

    return fAttWildCard;

}

inline SchemaAttDef* ComplexTypeInfo::getAttWildCard() {

    return fAttWildCard;

}

inline const SchemaAttDef* ComplexTypeInfo::getAttDef(const XMLCh* const baseName,

                                                      const int uriId) const {

    return fAttDefs->get(baseName, uriId);

}

inline SchemaAttDef* ComplexTypeInfo::getAttDef(const XMLCh* const baseName,

                                                const int uriId)

{

    return fAttDefs->get(baseName, uriId);

}

inline SchemaElementDecl*

ComplexTypeInfo::elementAt(const unsigned int index) {

    if (!fElements) {

        return 0; // REVISIT - need to throw an exception

    }

    return fElements->elementAt(index);

}

inline const SchemaElementDecl*

ComplexTypeInfo::elementAt(const unsigned int index) const {

    if (!fElements) {

        return 0; // REVISIT - need to throw an exception

    }

    return fElements->elementAt(index);

}

inline XMLContentModel* ComplexTypeInfo::getContentModel(const bool checkUPA)

{

    if (!fContentModel && fContentSpec)

        fContentModel = makeContentModel(checkUPA);

    return fContentModel;

}

inline XSDLocator* ComplexTypeInfo::getLocator() const

{

    return fLocator;

}

inline bool ComplexTypeInfo::getAnonymous() const {

    return fAnonymous;

}

inline const XMLCh* ComplexTypeInfo::getTypeLocalName() const

{

    return fTypeLocalName;

}

inline const XMLCh* ComplexTypeInfo::getTypeUri() const

{

   return fTypeUri;

}

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

//  ComplexTypeInfo: Setter methods

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

inline void ComplexTypeInfo::setAbstract(const bool isAbstract) {

    fAbstract = isAbstract;

}

inline void ComplexTypeInfo::setAdoptContentSpec(const bool toAdopt) {

    fAdoptContentSpec = toAdopt;

}

inline void ComplexTypeInfo::setAttWithTypeId(const bool value) {

    fAttWithTypeId = value;

}

inline void ComplexTypeInfo::setPreprocessed(const bool aValue) {

    fPreprocessed = aValue;

}

inline void ComplexTypeInfo::setDerivedBy(const int derivedBy) {

    fDerivedBy = derivedBy;

}

inline void ComplexTypeInfo::setBlockSet(const int blockSet) {

    fBlockSet = blockSet;

}

inline void ComplexTypeInfo::setFinalSet(const int finalSet) {

    fFinalSet = finalSet;

}

inline void ComplexTypeInfo::setScopeDefined(const int scopeDefined) {

    fScopeDefined = scopeDefined;

}

inline void ComplexTypeInfo::setElementId(const unsigned int elemId) {

    fElementId = elemId;

}

inline void

ComplexTypeInfo::setContentType(const int contentType) {

    fContentType = contentType;

}

inline void ComplexTypeInfo::setTypeName(const XMLCh* const typeName) {

    fMemoryManager->deallocate(fTypeName);//delete [] fTypeName;

    fMemoryManager->deallocate(fTypeLocalName);//delete [] fTypeLocalName;

    fMemoryManager->deallocate(fTypeUri);//delete [] fTypeUri;    

    if (typeName)

    {

        fTypeName = XMLString::replicate(typeName, fMemoryManager);

        int index = XMLString::indexOf(fTypeName, chComma);

        int length = XMLString::stringLen(fTypeName);

        fTypeLocalName = (XMLCh*) fMemoryManager->allocate

        (

            (length - index + 1) * sizeof(XMLCh)

        ); //new XMLCh[length - index + 1];

        XMLString::subString(fTypeLocalName, fTypeName, index + 1, length, fMemoryManager);

        fTypeUri = (XMLCh*) fMemoryManager->allocate

        (

            (index + 1) * sizeof(XMLCh)

        ); //new XMLCh[index + 1];

        XMLString::subString(fTypeUri, fTypeName, 0, index, fMemoryManager);        

    }

    else

    {

        fTypeName = fTypeLocalName = fTypeUri = 0;

    }

}

inline void

ComplexTypeInfo::setBaseDatatypeValidator(DatatypeValidator* const validator) {

    fBaseDatatypeValidator = validator;

}

inline void

ComplexTypeInfo::setDatatypeValidator(DatatypeValidator* const validator) {

    fDatatypeValidator = validator;

}

inline void

ComplexTypeInfo::setBaseComplexTypeInfo(ComplexTypeInfo* const typeInfo) {

    fBaseComplexTypeInfo = typeInfo;

}

inline void ComplexTypeInfo::addElement(SchemaElementDecl* const elem) {

    if (!fElements) {

        fElements = new (fMemoryManager) RefVectorOf<SchemaElementDecl>(8, false, fMemoryManager);

    }

    else if (fElements->containsElement(elem)) {

        return;

    }

    fElements->addElement(elem);

}

inline void ComplexTypeInfo::setAttWildCard(SchemaAttDef* const toAdopt) {

    if (fAttWildCard) {

       delete fAttWildCard;

    }

    fAttWildCard = toAdopt;

}

inline void

ComplexTypeInfo::setContentModel(XMLContentModel* const newModelToAdopt)

{

    delete fContentModel;

    fContentModel = newModelToAdopt;

    // reset formattedModel

    if (fFormattedModel)

    {

        fMemoryManager->deallocate(fFormattedModel);

        fFormattedModel = 0;

    }

}

inline void ComplexTypeInfo::setAnonymous() {

    fAnonymous = true;