XMLElementDecl.hpp

Go to the documentation of this file.

/*
 * 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$
 */
 
#if !defined(XERCESC_INCLUDE_GUARD_XMLELEMENTDECL_HPP)
#define XERCESC_INCLUDE_GUARD_XMLELEMENTDECL_HPP
 
#include <xercesc/framework/XMLAttr.hpp>
#include <xercesc/framework/XMLAttDefList.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/internal/XSerializable.hpp>
 
XERCES_CPP_NAMESPACE_BEGIN
 
class ContentSpecNode;
class XMLContentModel;
 
class XMLPARSER_EXPORT XMLElementDecl : public XSerializable, public XMemory
{
 public:
    // -----------------------------------------------------------------------
    //  Class specific types
    //
    //  CreateReasons
    //      This type is used to store how an element declaration got into
    //      the grammar's element pool. They are faulted in for various
    //      reasons.
    //
    //  LookupOpts
    //      These are the values used by the attribute lookup methods.
    //
    //  CharDataOpts
    //      This is used to indicate how this type of element reacts to
    //      character data as content.
    // -----------------------------------------------------------------------
    enum CreateReasons
    {
        NoReason
        , Declared
        , AttList
        , InContentModel
        , AsRootElem
        , JustFaultIn
    };
 
    enum CharDataOpts
    {
        NoCharData
        , SpacesOk
        , AllCharData
    };
 
 
    // -----------------------------------------------------------------------
    //  Public static data
    //
    //  fgInvalidElemId
    //      A value to represent an invalid element node id.
    //
    //  fgPCDataElemId
    //      This is the value to use to represent a PCDATA node when an
    //      element id is required.
    //
    //  fgPCDataElemName
    //      This is the value to use to represent a PCDATA node when an
    //      element name is required.
    // -----------------------------------------------------------------------
    static const unsigned int   fgInvalidElemId;
    static const unsigned int   fgPCDataElemId;
    static const XMLCh          fgPCDataElemName[];
 
 
 
    // -----------------------------------------------------------------------
    //  Destructor
    // -----------------------------------------------------------------------
    virtual ~XMLElementDecl();
 
 
    // -----------------------------------------------------------------------
    //  The virtual element decl interface
    // -----------------------------------------------------------------------
 
 
    virtual XMLAttDefList& getAttDefList() const = 0;
 
    virtual CharDataOpts getCharDataOpts() const = 0;
 
    virtual bool hasAttDefs() const = 0;
 
    virtual const ContentSpecNode* getContentSpec() const = 0;
 
    virtual ContentSpecNode* getContentSpec() = 0;
 
    virtual void setContentSpec(ContentSpecNode* toAdopt) = 0;
 
    virtual XMLContentModel* getContentModel() = 0;
 
    virtual void setContentModel(XMLContentModel* const newModelToAdopt) = 0;
 
    virtual const XMLCh* getFormattedContentModel ()   const = 0;
 
 
 
    // -----------------------------------------------------------------------
    //  Getter methods
    // -----------------------------------------------------------------------
 
 
    const XMLCh* getBaseName() const;
    XMLCh* getBaseName();
 
    unsigned int getURI() const;
 
    const QName* getElementName() const;
    QName* getElementName();
 
    const XMLCh* getFullName() const;
 
    CreateReasons getCreateReason() const;
 
    XMLSize_t getId() const;
 
    bool isDeclared() const;
 
    bool isExternal() const;
 
    MemoryManager* getMemoryManager() const;
 
 
 
    // -----------------------------------------------------------------------
    //  Setter methods
    // -----------------------------------------------------------------------
 
 
      void setElementName(const XMLCh* const       prefix
                        , const XMLCh* const       localPart
                        , const int                uriId );
 
      void setElementName(const XMLCh* const    rawName
                        , const int             uriId );
 
      void setElementName(const QName* const    elementName);
 
    void setCreateReason(const CreateReasons newReason);
 
    void setId(const XMLSize_t newId);
 
 
    void setExternalElemDeclaration(const bool aValue);
 
 
 
    // -----------------------------------------------------------------------
    //  Miscellaneous methods
    // -----------------------------------------------------------------------
 
 
 
    /***
     * Support for Serialization/De-serialization
     ***/
    DECL_XSERIALIZABLE(XMLElementDecl)
 
    enum objectType
    {
        Schema
      , DTD
      , UnKnown
    };
 
    virtual XMLElementDecl::objectType  getObjectType() const = 0;
 
    static void            storeElementDecl(XSerializeEngine&        serEng
                                          , XMLElementDecl*    const element);
 
    static XMLElementDecl* loadElementDecl(XSerializeEngine& serEng);
 
protected :
    // -----------------------------------------------------------------------
    //  Hidden constructors
    // -----------------------------------------------------------------------
    XMLElementDecl(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
 
private :
    // -----------------------------------------------------------------------
    //  Unimplemented constructors and operators
    // -----------------------------------------------------------------------
    XMLElementDecl(const XMLElementDecl&);
    XMLElementDecl& operator=(const XMLElementDecl&);
 
 
    // -----------------------------------------------------------------------
    //  Data members
    //
    //  fElementName
    //      This is the name of the element decl.
    //
    //  fCreateReason
    //      We sometimes have to put an element decl object into the elem
    //      decl pool before the element's declaration is seen, such as when
    //      its used in another element's content model or an att list is
    //      seen for it. This flag tells us whether its been declared, and
    //      if not why it had to be created.
    //
    //  fId
    //      The unique id of this element. This is created by the derived
    //      class, or more accurately the grammar that owns the objects
    //      of the derived types. But, since they all have to have them, we
    //      let them all store the id here. It is defaulted to have the
    //      value fgInvalidElem until explicitly set.
    //
    //  fExternalElement
    //      This flag indicates whether or the element was declared externally.
    // -----------------------------------------------------------------------
    MemoryManager*      fMemoryManager;
    QName*              fElementName;
    CreateReasons       fCreateReason;
    XMLSize_t           fId;
    bool                fExternalElement;
};
 
 
// ---------------------------------------------------------------------------
//  XMLElementDecl: Getter methods
// ---------------------------------------------------------------------------
inline const XMLCh* XMLElementDecl::getBaseName() const
{
    return fElementName->getLocalPart();
}
 
inline XMLCh* XMLElementDecl::getBaseName()
{
    return fElementName->getLocalPart();
}
 
inline unsigned int XMLElementDecl::getURI() const
{
    return fElementName->getURI();
}
 
inline const QName* XMLElementDecl::getElementName() const
{
    return fElementName;
}
 
inline QName* XMLElementDecl::getElementName()
{
    return fElementName;
}
 
inline const XMLCh* XMLElementDecl::getFullName() const
{
    return fElementName->getRawName();
}
 
inline XMLElementDecl::CreateReasons XMLElementDecl::getCreateReason() const
{
    return fCreateReason;
}
 
inline XMLSize_t XMLElementDecl::getId() const
{
    return fId;
}
 
inline bool XMLElementDecl::isDeclared() const
{
    return (fCreateReason == Declared);
}
 
 
inline bool XMLElementDecl::isExternal() const
{
    return fExternalElement;
}
 
inline MemoryManager* XMLElementDecl::getMemoryManager() const
{
    return fMemoryManager;
}
 
 
// ---------------------------------------------------------------------------
//  XMLElementDecl: Setter methods
// ---------------------------------------------------------------------------
inline void
XMLElementDecl::setCreateReason(const XMLElementDecl::CreateReasons newReason)
{
    fCreateReason = newReason;
}
 
inline void XMLElementDecl::setId(const XMLSize_t newId)
{
    fId = newId;
}
 
 
inline void XMLElementDecl::setExternalElemDeclaration(const bool aValue)
{
    fExternalElement = aValue;
}
 
XERCES_CPP_NAMESPACE_END
 
#endif