XMLAttDef.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_XMLATTDEF_HPP)
#define XERCESC_INCLUDE_GUARD_XMLATTDEF_HPP
 
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/XMemory.hpp>
#include <xercesc/internal/XSerializable.hpp>
 
XERCES_CPP_NAMESPACE_BEGIN
 
class XMLAttr;
 
class XMLPARSER_EXPORT XMLAttDef : public XSerializable, public XMemory
{
public:
    // -----------------------------------------------------------------------
    //  Class specific types
    //
    //  AttTypes
    //      The list of possible types that an attribute can have, according
    //      to the XML 1.0 spec and schema.
    //
    //  DefAttTypes
    //      The modifiers that an attribute decl can have, which indicates
    //      whether instances of that attributes are required, implied, etc..
    //
    //  CreateReasons
    //      This type is used to store how an attribute declaration got into
    //      the elementdecl's attribute pool.
    //
    // -----------------------------------------------------------------------
    enum AttTypes
    {
        CData               = 0
        , ID                = 1
        , IDRef             = 2
        , IDRefs            = 3
        , Entity            = 4
        , Entities          = 5
        , NmToken           = 6
        , NmTokens          = 7
        , Notation          = 8
        , Enumeration       = 9
        , Simple            = 10
        , Any_Any           = 11
        , Any_Other         = 12
        , Any_List          = 13
 
        , AttTypes_Count
        , AttTypes_Min      = 0
        , AttTypes_Max      = 13
        , AttTypes_Unknown  = -1
    };
 
    enum DefAttTypes
    {
        Default                  = 0
        , Fixed                  = 1
        , Required               = 2
        , Required_And_Fixed     = 3
        , Implied                = 4
        , ProcessContents_Skip   = 5
        , ProcessContents_Lax    = 6
        , ProcessContents_Strict = 7
        , Prohibited             = 8
 
        , DefAttTypes_Count
        , DefAttTypes_Min   = 0
        , DefAttTypes_Max   = 8
        , DefAttTypes_Unknown = -1
    };
 
    enum CreateReasons
    {
        NoReason
        , JustFaultIn
    };
 
    // -----------------------------------------------------------------------
    //  Public static data members
    // -----------------------------------------------------------------------
    static const unsigned int fgInvalidAttrId;
 
 
    // -----------------------------------------------------------------------
    //  Public, static methods
    // -----------------------------------------------------------------------
 
 
    static const XMLCh* getAttTypeString(const AttTypes attrType
        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
 
    static const XMLCh* getDefAttTypeString(const DefAttTypes attrType
        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
 
 
 
    // -----------------------------------------------------------------------
    //  Destructor
    // -----------------------------------------------------------------------
 
 
    virtual ~XMLAttDef();
 
 
    // -----------------------------------------------------------------------
    //  The virtual attribute def interface
    // -----------------------------------------------------------------------
 
 
    virtual const XMLCh* getFullName() const = 0;
 
    virtual void reset() = 0;
 
 
 
    // -----------------------------------------------------------------------
    //  Getter methods
    // -----------------------------------------------------------------------
 
 
    DefAttTypes getDefaultType() const;
 
    const XMLCh* getEnumeration() const;
 
    XMLSize_t getId() const;
 
    AttTypes getType() const;
 
    const XMLCh* getValue() const;
 
    CreateReasons getCreateReason() const;
 
    bool isExternal() const;
 
    MemoryManager* getMemoryManager() const;
 
 
 
    // -----------------------------------------------------------------------
    //  Setter methods
    // -----------------------------------------------------------------------
 
 
    void setDefaultType(const XMLAttDef::DefAttTypes newValue);
 
    void setId(const XMLSize_t newId);
 
    void setType(const XMLAttDef::AttTypes newValue);
 
    void setValue(const XMLCh* const newValue);
 
    void setEnumeration(const XMLCh* const newValue);
 
    void setCreateReason(const CreateReasons newReason);
 
    void setExternalAttDeclaration(const bool aValue);
 
 
    /***
     * Support for Serialization/De-serialization
     ***/
    DECL_XSERIALIZABLE(XMLAttDef)
 
protected :
    // -----------------------------------------------------------------------
    //  Hidden constructors
    // -----------------------------------------------------------------------
    XMLAttDef
    (
        const   AttTypes       type = CData
        , const DefAttTypes    defType= Implied
        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
    );
    XMLAttDef
    (
        const   XMLCh* const        attValue
        , const AttTypes            type
        , const DefAttTypes         defType
        , const XMLCh* const        enumValues = 0
        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
    );
 
 
private :
    // -----------------------------------------------------------------------
    //  Unimplemented constructors and operators
    // -----------------------------------------------------------------------
    XMLAttDef(const XMLAttDef&);
    XMLAttDef& operator=(const XMLAttDef&);
 
 
    // -----------------------------------------------------------------------
    //  Private helper methods
    // -----------------------------------------------------------------------
    void cleanUp();
 
 
    // -----------------------------------------------------------------------
    //  Private data members
    //
    //  fDefaultType
    //      Indicates what, if any, default stuff this attribute has.
    //
    //  fEnumeration
    //      If its an enumeration, this is the list of values as space
    //      separated values.
    //
    //  fId
    //      This is the unique id of this attribute, given to it when its put
    //      into the validator's attribute decl pool. It defaults to the
    //      special value XMLAttrDef::fgInvalidAttrId.
    //
    //  fType
    //      The type of attribute, which is one of the AttTypes values.
    //
    //  fValue
    //      This is the value of the attribute, which is the default value
    //      given in the attribute declaration.
    //
    //  fCreateReason
    //      This flag tells us how this attribute got created.  Sometimes even
    //      the attribute was not declared for the element, we want to fault
    //      fault it into the pool to avoid lots of redundant errors.
    //
    //  fExternalAttribute
    //      This flag indicates whether or not the attribute was declared externally.
    // -----------------------------------------------------------------------
    DefAttTypes     fDefaultType;
    AttTypes        fType;
    CreateReasons   fCreateReason;   
    bool            fExternalAttribute;
    XMLSize_t       fId;
    XMLCh*          fValue;
    XMLCh*          fEnumeration;
    MemoryManager*  fMemoryManager;
};
 
 
// ---------------------------------------------------------------------------
//  Getter methods
// ---------------------------------------------------------------------------
inline XMLAttDef::DefAttTypes XMLAttDef::getDefaultType() const
{
    return fDefaultType;
}
 
inline const XMLCh* XMLAttDef::getEnumeration() const
{
    return fEnumeration;
}
 
inline XMLSize_t XMLAttDef::getId() const
{
    return fId;
}
 
inline XMLAttDef::AttTypes XMLAttDef::getType() const
{
    return fType;
}
 
inline const XMLCh* XMLAttDef::getValue() const
{
    return fValue;
}
 
inline XMLAttDef::CreateReasons XMLAttDef::getCreateReason() const
{
    return fCreateReason;
}
 
inline bool XMLAttDef::isExternal() const
{
    return fExternalAttribute;
}
 
inline MemoryManager* XMLAttDef::getMemoryManager() const
{
    return fMemoryManager;
}
 
// ---------------------------------------------------------------------------
//  XMLAttDef: Setter methods
// ---------------------------------------------------------------------------
inline void XMLAttDef::setDefaultType(const XMLAttDef::DefAttTypes newValue)
{
    fDefaultType = newValue;
}
 
inline void XMLAttDef::setEnumeration(const XMLCh* const newValue)
{
    if (fEnumeration)
        fMemoryManager->deallocate(fEnumeration);
 
    fEnumeration = XMLString::replicate(newValue, fMemoryManager);
}
 
inline void XMLAttDef::setId(const XMLSize_t newId)
{
    fId = newId;
}
 
inline void XMLAttDef::setType(const XMLAttDef::AttTypes newValue)
{
    fType = newValue;
}
 
inline void XMLAttDef::setValue(const XMLCh* const newValue)
{
    if (fValue)
       fMemoryManager->deallocate(fValue);
 
    fValue = XMLString::replicate(newValue, fMemoryManager);
}
 
inline void
XMLAttDef::setCreateReason(const XMLAttDef::CreateReasons newReason)
{
    fCreateReason = newReason;
}
 
inline void XMLAttDef::setExternalAttDeclaration(const bool aValue)
{
    fExternalAttribute = aValue;
}
 
XERCES_CPP_NAMESPACE_END
 
#endif