/* * Copyright 1999-2004 The Apache Software Foundation. *  * Licensed 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. *//* * $Log: XMLEntityDecl.hpp,v $ * Revision 1.10  2004/09/08 13:55:59  peiyongz * Apache License Version 2.0 * * Revision 1.9  2003/12/01 23:23:25  neilg * fix for bug 25118; thanks to Jeroen Witmond * * Revision 1.8  2003/10/10 16:23:29  peiyongz * Implementation of Serialization/Deserialization * * Revision 1.7  2003/05/16 21:36:55  knoaman * Memory manager implementation: Modify constructors to pass in the memory manager. * * Revision 1.6  2003/05/15 18:26:07  knoaman * Partial implementation of the configurable memory manager. * * Revision 1.5  2003/04/21 20:46:01  knoaman * Use XMLString::release to prepare for configurable memory manager. * * Revision 1.4  2003/03/07 18:08:10  tng * Return a reference instead of void for operator= * * Revision 1.3  2002/11/04 15:00:21  tng * C++ Namespace Support. * * Revision 1.2  2002/08/22 19:27:41  tng * [Bug 11448] DomCount has problems with XHTML1.1 DTD. * * Revision 1.1.1.1  2002/02/01 22:21:51  peiyongz * sane_include * * Revision 1.6  2000/02/24 20:00:23  abagchi * Swat for removing Log from API docs * * Revision 1.5  2000/02/16 23:03:48  roddey * More documentation updates * * Revision 1.4  2000/02/16 21:42:58  aruna1 * API Doc++ summary changes in * * Revision 1.3  2000/02/15 01:21:30  roddey * Some initial documentation improvements. More to come... * * Revision 1.2  2000/02/06 07:47:48  rahulj * Year 2K copyright swat. * * Revision 1.1.1.1  1999/11/09 01:08:32  twl * Initial checkin * * Revision 1.2  1999/11/08 20:44:38  rahul * Swat for adding in Product name and CVS comment log variable. * */#if !defined(XMLENTITYDECL_HPP)#define XMLENTITYDECL_HPP#include <xercesc/util/XMemory.hpp>#include <xercesc/util/PlatformUtils.hpp>#include <xercesc/util/XMLString.hpp>#include <xercesc/internal/XSerializable.hpp>XERCES_CPP_NAMESPACE_BEGIN/** *  This class defines that core information that defines an XML entity, no *  matter what validator is used. Each validator will create a derivative *  of this class which adds any extra information it requires. * *  This class supports keyed collection semantics via the getKey() method *  which extracts the key field, the entity name in this case. The name will *  have whatever form is deemed appropriate for the type of validator in *  use. * *  When setting the fields of this class, you must make sure that you do *  not set conflicting values. For instance, an internal entity cannot have *  a notation name. And an external entity cannot have a value string. *  These rules are defined by the XML specification. In most cases, these *  objects are created by validator objects as they parse a DTD or Schema *  or whatever, at which time they confirm the correctness of the data before *  creating the entity decl object. */class XMLPARSER_EXPORT XMLEntityDecl : public XSerializable, public XMemory{public:    // -----------------------------------------------------------------------    //  Constructors and Destructor    // -----------------------------------------------------------------------    /** @name Constructors */    //@{    /**      *  Deafult Constructor      */    XMLEntityDecl(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);    /** Constructor with a const entity name      *      * @param  entName The new name to give to this entity.      * @param  manager Pointer to the memory manager to be used to      *                 allocate objects.      */    XMLEntityDecl    (        const   XMLCh* const    entName        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager    );    /**      * Constructor with a const entity name and value      *      * @param  entName The new name to give to this entity.      * @param  value   The new value to give to this entity name.      * @param  manager Pointer to the memory manager to be used to      *                 allocate objects.      */    XMLEntityDecl    (        const   XMLCh* const    entName        , const XMLCh* const    value        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager    );    /**      * Constructor with a const entity name and single XMLCh value      *      * @param  entName The new name to give to this entity.      * @param  value   The new value to give to this entity name.      * @param manager  Pointer to the memory manager to be used to      *                 allocate objects.      */    XMLEntityDecl    (        const   XMLCh* const    entName        , const XMLCh           value        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager    );    //@}    /** @name Destructor */    //@{    /**      *  Default destructor      */    virtual ~XMLEntityDecl();    //@}    // -----------------------------------------------------------------------    //  Virtual entity decl interface    // -----------------------------------------------------------------------    /** @name The pure virtual methods in this interface. */    //@{    /** Get the 'declared in internal subset' flag      *      * Gets the state of the flag which indicates whether the entity was      * declared in the internal or external subset. Some structural      * description languages might not have an internal subset concept, in      * which case this will always return false.      */    virtual bool getDeclaredInIntSubset() const = 0;    /** Get the 'is parameter entity' flag      *      * Gets the state of the flag which indicates whether this entity is      * a parameter entity. If not, then its a general entity.      */    virtual bool getIsParameter() const = 0;    /** Get the 'is special char entity' flag      *      * Gets the state of the flag that indicates whether this entity is      * one of the special, intrinsically supported character entities.      */    virtual bool getIsSpecialChar() const = 0;    //@}    // -----------------------------------------------------------------------    //  Getter methods    // -----------------------------------------------------------------------    /** @name Getter methods */    //@{    /**      * Gets the pool id of this entity. Validators maintain all decls in      * pools, from which they can be quickly extracted via id.      */    unsigned int getId() const;    /**      * Returns a const pointer to the name of this entity decl. This name      * will be in whatever format is appropriate for the type of validator      * in use.      */    const XMLCh* getName() const;    /**      * Gets the notation name, if any, declared for this entity. If this      * entity is not a notation type entity, it will be a null pointer.      */    const XMLCh* getNotationName() const;    /**      * Gets the public id declared for this entity. Public ids are optional      * so it can be a null pointer.      */    const XMLCh* getPublicId() const;    /**      * Gets the system id declared for this entity. The system id is required      * so this method should never return a null pointers.      */    const XMLCh* getSystemId() const;    /**      * Gets the base URI for this entity.      */    const XMLCh* getBaseURI() const;    /**      * This method returns the value of an internal entity. If this is not      * an internal entity (i.e. its external), then this will be a null      * pointer.      */    const XMLCh* getValue() const;    /**     *  This method returns the number of characters in the value returned     *  by getValue(). If this entity is external, this will be zero since     *  an external entity has no internal value.     */    unsigned int getValueLen() const;    /**      * Indicates that this entity is an external entity. If not, then it is      * assumed to be an internal entity, suprise.      */    bool isExternal() const;    /**      * Indicates whether this entity is unparsed. This is meaningless for      * internal entities. Some external entities are unparsed in that they      * refer to something other than XML source.      */    bool isUnparsed() const;    /** Get the plugged-in memory manager      *      * This method returns the plugged-in memory manager user for dynamic      * memory allocation/deallocation.      *