XMLElementDecl.hpp
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:26k
源码类别:

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2001 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  56. /*
  57.  * $Log: XMLElementDecl.hpp,v $
  58.  * Revision 1.7  2003/05/16 21:36:55  knoaman
  59.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  60.  *
  61.  * Revision 1.6  2003/05/15 18:26:07  knoaman
  62.  * Partial implementation of the configurable memory manager.
  63.  *
  64.  * Revision 1.5  2003/03/07 18:08:10  tng
  65.  * Return a reference instead of void for operator=
  66.  *
  67.  * Revision 1.4  2003/01/29 19:45:35  gareth
  68.  * added api for DOMTypeInfo
  69.  *
  70.  * Revision 1.3  2002/11/04 15:00:21  tng
  71.  * C++ Namespace Support.
  72.  *
  73.  * Revision 1.2  2002/08/20 16:55:33  tng
  74.  * [Bug 6251] Info during compilation.
  75.  *
  76.  * Revision 1.1.1.1  2002/02/01 22:21:51  peiyongz
  77.  * sane_include
  78.  *
  79.  * Revision 1.18  2001/08/21 16:06:10  tng
  80.  * Schema: Unique Particle Attribution Constraint Checking.
  81.  *
  82.  * Revision 1.17  2001/07/24 18:30:47  knoaman
  83.  * Added support for <group> + extra constraint checking for complexType
  84.  *
  85.  * Revision 1.16  2001/06/21 14:25:28  knoaman
  86.  * Fix for bug 1946
  87.  *
  88.  * Revision 1.15  2001/05/11 13:25:32  tng
  89.  * Copyright update.
  90.  *
  91.  * Revision 1.14  2001/05/03 20:34:22  tng
  92.  * Schema: SchemaValidator update
  93.  *
  94.  * Revision 1.13  2001/04/19 18:16:52  tng
  95.  * Schema: SchemaValidator update, and use QName in Content Model
  96.  *
  97.  * Revision 1.12  2001/03/21 21:56:02  tng
  98.  * Schema: Add Schema Grammar, Schema Validator, and split the DTDValidator into DTDValidator, DTDScanner, and DTDGrammar.
  99.  *
  100.  * Revision 1.11  2001/03/21 19:29:29  tng
  101.  * Schema: Content Model Updates, by Pei Yong Zhang.
  102.  *
  103.  * Revision 1.10  2001/02/26 19:29:13  tng
  104.  * Schema: add virtual method getURI(), getContentSpec and setContenSpec in XMLElementDecl, and DTDElementDecl.
  105.  *
  106.  * Revision 1.9  2001/02/26 19:21:30  tng
  107.  * Schema: add parameter prefix in findElem and findAttr.
  108.  *
  109.  * Revision 1.8  2000/12/14 18:49:57  tng
  110.  * Fix API document generation warning: "Warning: end of member group without matching begin"
  111.  *
  112.  * Revision 1.7  2000/11/30 18:22:38  andyh
  113.  * reuseValidator - fix bugs (spurious errors) that occured on reuse due to
  114.  * pools already containing some items.  Fixed by Tinny Ng.
  115.  *
  116.  * Revision 1.6  2000/05/11 23:11:32  andyh
  117.  * Add missing validity checks for stand-alone documents, character range
  118.  * and Well-formed parsed entities.  Changes contributed by Sean MacRoibeaird
  119.  * <sean.Macroibeaird@ireland.sun.com>
  120.  *
  121.  * Revision 1.5  2000/02/24 20:00:23  abagchi
  122.  * Swat for removing Log from API docs
  123.  *
  124.  * Revision 1.4  2000/02/16 19:48:56  roddey
  125.  * More documentation updates
  126.  *
  127.  * Revision 1.3  2000/02/15 01:21:30  roddey
  128.  * Some initial documentation improvements. More to come...
  129.  *
  130.  * Revision 1.2  2000/02/06 07:47:48  rahulj
  131.  * Year 2K copyright swat.
  132.  *
  133.  * Revision 1.1.1.1  1999/11/09 01:08:32  twl
  134.  * Initial checkin
  135.  *
  136.  * Revision 1.2  1999/11/08 20:44:38  rahul
  137.  * Swat for adding in Product name and CVS comment log variable.
  138.  *
  139.  */
  140. #if !defined(XMLELEMENTDECL_HPP)
  141. #define XMLELEMENTDECL_HPP
  142. #include <xercesc/framework/XMLAttr.hpp>
  143. #include <xercesc/framework/XMLAttDefList.hpp>
  144. #include <xercesc/util/XMLString.hpp>
  145. #include <xercesc/util/PlatformUtils.hpp>
  146. XERCES_CPP_NAMESPACE_BEGIN
  147. class ContentSpecNode;
  148. class XMLContentModel;
  149. /**
  150.  *  This class defines the core information of an element declaration. Each
  151.  *  validator (DTD, Schema, etc...) will have its own information that it
  152.  *  associations with the declaration of an element, but they must all share
  153.  *  at least this core information, i.e. they must all derive from this
  154.  *  class. The set of info enforced at this level is driven by the needs of
  155.  *  XML 1.0 spec validation and well formedness checks.
  156.  *
  157.  *  This class defines some special element id values for invalid elements
  158.  *  and PCDATA elements, as well as a string for the special PCDATA element
  159.  *  name. All validators must honor these special values in order to allow
  160.  *  content models to work generically (i.e. to let code know when its dealing
  161.  *  with invalid or PCDATA element ids without having to know what type of
  162.  *  validator its messing with.)
  163.  */
  164. class XMLPARSER_EXPORT XMLElementDecl : public XMemory
  165. {
  166.  public:
  167.     // -----------------------------------------------------------------------
  168.     //  Class specific types
  169.     //
  170.     //  CreateReasons
  171.     //      This type is used to store how an element declaration got into
  172.     //      the grammar's element pool. They are faulted in for various
  173.     //      reasons.
  174.     //
  175.     //  LookupOpts
  176.     //      These are the values used by the attribute lookup methods.
  177.     //
  178.     //  CharDataOpts
  179.     //      This is used to indicate how this type of element reacts to
  180.     //      character data as content.
  181.     // -----------------------------------------------------------------------
  182.     enum CreateReasons
  183.     {
  184.         NoReason
  185.         , Declared
  186.         , AttList
  187.         , InContentModel
  188.         , AsRootElem
  189.         , JustFaultIn
  190.     };
  191.     enum LookupOpts
  192.     {
  193.         AddIfNotFound
  194.         , FailIfNotFound
  195.     };
  196.     enum CharDataOpts
  197.     {
  198.         NoCharData
  199.         , SpacesOk
  200.         , AllCharData
  201.     };
  202.     // -----------------------------------------------------------------------
  203.     //  Public static data
  204.     //
  205.     //  fgInvalidElemId
  206.     //      A value to represent an invalid element node id.
  207.     //
  208.     //  fgPCDataElemId
  209.     //      This is the value to use to represent a PCDATA node when an
  210.     //      element id is required.
  211.     //
  212.     //  fgPCDataElemName
  213.     //      This is the value to use to represent a PCDATA node when an
  214.     //      element name is required.
  215.     // -----------------------------------------------------------------------
  216.     static const unsigned int   fgInvalidElemId;
  217.     static const unsigned int   fgPCDataElemId;
  218.     static const XMLCh          fgPCDataElemName[];
  219.     // -----------------------------------------------------------------------
  220.     //  Destructor
  221.     // -----------------------------------------------------------------------
  222.     /** @name Destructor */
  223.     //@{
  224.     virtual ~XMLElementDecl();
  225.     //@}
  226.     // -----------------------------------------------------------------------
  227.     //  The virtual element decl interface
  228.     // -----------------------------------------------------------------------
  229.     /** @name Virual ElementDecl interface */
  230.     //@{
  231.     /** Find an attribute by name or optionally fault it in.
  232.       *
  233.       * The derived class should look up the passed attribute in the list of
  234.       * of attributes for this element. If namespaces are enabled, then it
  235.       * should use the uriId/baseName pair, else it should use the qName. The
  236.       * options allow the caller to indicate whether the attribute should be
  237.       * defaulted in if not found. If it is defaulted in, then wasAdded should
  238.       * be set, else it should be cleared. If its not found and the caller does
  239.       * not want defaulting, then return a null pointer.
  240.       *
  241.       * @param  qName       This is the qName of the attribute, i.e. the actual
  242.       *                     lexical name found.
  243.       *
  244.       * @param  uriId       This is the id of the URI of the namespace to which
  245.       *                     this attribute mapped. Only valid if namespaces are
  246.       *                     enabled.
  247.       *
  248.       * @param  baseName    This is the base part of the name, i.e. after any
  249.       *                     prefix.
  250.       *
  251.       * @param  prefix      The prefix, if any, of this attribute's name. If
  252.       *                     this is empty, then uriID is meaningless as well.
  253.       *
  254.       * @param  options     Indicates the lookup options.
  255.       *
  256.       * @param  wasAdded    Should be set if the attribute is faulted in, else
  257.       *                     cleared.
  258.       */
  259.     virtual XMLAttDef* findAttr
  260.     (
  261.         const   XMLCh* const    qName
  262.         , const unsigned int    uriId
  263.         , const XMLCh* const    baseName
  264.         , const XMLCh* const    prefix
  265.         , const LookupOpts      options
  266.         ,       bool&           wasAdded
  267.     )   const = 0;
  268.     /** Get a list of attributes defined for this element.
  269.       *
  270.       * The derived class should return a reference to some member object which
  271.       * implements the XMLAttDefList interface. This object gives the scanner the
  272.       * ability to look through the attributes defined for this element.
  273.       *
  274.       * It is done this way for efficiency, though of course this is not thread
  275.       * safe. The scanner guarantees that it won't ever call this method in any
  276.       * nested way, but the outside world must be careful about when it calls
  277.       * this method, and optimally never would.
  278.       */
  279.     virtual XMLAttDefList& getAttDefList() const = 0;
  280.     /** The character data options for this element type
  281.       *
  282.       * The derived class should return an appropriate character data opts value
  283.       * which correctly represents its tolerance towards whitespace or character
  284.       * data inside of its instances. This allows the scanner to do all of the
  285.       * validation of character data.
  286.       */
  287.     virtual CharDataOpts getCharDataOpts() const = 0;
  288.     /** Indicate whether this element type defined any attributes
  289.       *
  290.       * The derived class should return a boolean that indicates whether this
  291.       * element has any attributes defined for it or not. This is an optimization
  292.       * that allows the scanner to skip some work if no attributes exist.
  293.       */
  294.     virtual bool hasAttDefs() const = 0;
  295.     /** Reset the flags on the attribute definitions.
  296.       *
  297.       * This method is called by the scanner at the beginning of each scan
  298.       * of a start tag, asking this element decl to reset the 'declared' flag
  299.       * of each of its attribute defs. This allows the scanner to mark each
  300.       * one as declared yet or not.
  301.       */
  302.     virtual bool resetDefs() = 0;
  303.     /** Get a pointer to the content spec node
  304.       *
  305.       * This method will return a const pointer to the content spec node object
  306.       * of this element.
  307.       *
  308.       * @return A const pointer to the element's content spec node
  309.       */
  310.     virtual const ContentSpecNode* getContentSpec() const = 0;
  311.     /** Get a pointer to the content spec node
  312.       *
  313.       * This method is identical to the previous one, except that it is non
  314.       * const.
  315.       */
  316.     virtual ContentSpecNode* getContentSpec() = 0;
  317.     /** Set the content spec node object for this element type
  318.       *
  319.       * This method will adopt the based content spec node object. This is called
  320.       * by the actual validator which is parsing its DTD or Schema or whatever
  321.       * and store it on the element decl object via this method.
  322.       *
  323.       * @param  toAdopt This method will adopt the passed content node spec
  324.       *         object. Any previous object is destroyed.
  325.       */
  326.     virtual void setContentSpec(ContentSpecNode* toAdopt) = 0;
  327.     /** Get a pointer to the abstract content model
  328.       *
  329.       * This method will return a const pointer to the content model object
  330.       * of this element. This class is a simple abstraction that allows an
  331.       * element to define and use multiple, specialized content model types
  332.       * internally but still allow the outside world to do simple stuff with
  333.       * them.
  334.       *
  335.       * @return A pointer to the element's content model, via the basic
  336.       * abstract content model type.
  337.       */
  338.     virtual XMLContentModel* getContentModel() = 0;
  339.     /** Set the content model object for this element type
  340.       *
  341.       * This method will adopt the based content model object. This is called
  342.       * by the actual validator which is parsing its DTD or Schema or whatever
  343.       * a creating an element decl. It will build what it feels is the correct
  344.       * content model type object and store it on the element decl object via
  345.       * this method.
  346.       *
  347.       * @param  newModelToAdopt This method will adopt the passed content model
  348.       *         object. Any previous object is destroyed.
  349.       */
  350.     virtual void setContentModel(XMLContentModel* const newModelToAdopt) = 0;
  351.     /** Geta formatted string of the content model
  352.       *
  353.       * This method is a convenience method which will create a formatted
  354.       * representation of the content model of the element. It will not always
  355.       * exactly recreate the original model, since some normalization or
  356.       * or reformatting may occur. But, it will be a technically accurate
  357.       * representation of the original content model.
  358.       *
  359.       * @return A pointer to an internal buffer which contains the formatted
  360.       *         content model. The caller does not own this buffer and should
  361.       *         copy it if it needs to be kept around.
  362.       */
  363.     virtual const XMLCh* getFormattedContentModel ()   const = 0;
  364.     //@}
  365.     // -----------------------------------------------------------------------
  366.     //  Getter methods
  367.     // -----------------------------------------------------------------------
  368.     /** @name Getter methods */
  369.     //@{
  370.     /** Get the base name of this element type.
  371.       *
  372.       * Return the base name part of the element's name. This is the
  373.       * same regardless of whether namespaces are enabled or not.
  374.       *
  375.       * @return A const pointer to the base name of the element decl.
  376.       */
  377.     const XMLCh* getBaseName() const;
  378.     XMLCh* getBaseName();
  379.     /** Get the URI id of this element type.
  380.       *
  381.       * Return the URI Id of this element.
  382.       *
  383.       * @return The URI Id of the element decl, or the emptyNamespaceId if not applicable.
  384.       */
  385.     unsigned int getURI() const;
  386.     /** Get the QName of this element type.
  387.       *
  388.       * Return the QName part of the element's name.  This is the
  389.       * same regardless of whether namespaces are enabled or not.
  390.       *
  391.       * @return A const pointer to the QName of the element decl.
  392.       */
  393.     const QName* getElementName() const;
  394.     QName* getElementName();
  395.     /** Get the full name of this element type.
  396.       *
  397.       * Return the full name of the element. If namespaces
  398.       * are not enabled, then this is the qName. Else it is the {uri}baseName
  399.       * form. For those validators that always require namespace processing, it
  400.       * will always be in the latter form because namespace processing will always
  401.       * be on.
  402.       */
  403.     const XMLCh* getFullName() const;
  404.     /** Get the create reason for this element type
  405.       *
  406.       * This method returns an enumeration which indicates why this element
  407.       * declaration exists. Elements can be used before they are actually
  408.       * declared, so they will often be faulted into the pool and marked as
  409.       * to why they are there.
  410.       *
  411.       * @return An enumerated value that indicates the reason why this element
  412.       * was added to the element decl pool.
  413.       */
  414.     CreateReasons getCreateReason() const;
  415.     /** Get the element decl pool id for this element type
  416.       *
  417.       * This method will return the element decl pool id of this element
  418.       * declaration. This uniquely identifies this element type within the
  419.       * parse event that it is declared within. This value is assigned by the
  420.       * grammar whose decl pool this object belongs to.
  421.       *
  422.       * @return The element decl id of this element declaration.
  423.       */
  424.     unsigned int getId() const;
  425.     /**
  426.      * @return the uri part of DOM Level 3 TypeInfo
  427.      */
  428.     virtual const XMLCh* getDOMTypeInfoUri() const = 0;
  429.     /**
  430.      * @return the name part of DOM Level 3 TypeInfo
  431.      */
  432.     virtual const XMLCh* getDOMTypeInfoName() const = 0;
  433.     /** Indicate whether this element type has been declared yet
  434.       *
  435.       * This method returns a boolean that indicates whether this element
  436.       * has been declared yet. There are a number of reasons why an element
  437.       * declaration can be faulted in, but eventually it must be declared or
  438.       * its an error. See the CreateReasons enumeration.
  439.       *
  440.       * @return true if this element has been declared, else false.
  441.       */
  442.     bool isDeclared() const;
  443.     /** Indicate whether this element type has been declared externally
  444.       *
  445.       * This method returns a boolean that indicates whether this element
  446.       * has been declared externally.
  447.       *
  448.       * @return true if this element has been declared externally, else false.
  449.       */
  450.     bool isExternal() const;
  451.     /** Get the memory manager
  452.       *
  453.       * This method returns the configurable memory manager used by the
  454.       * element declaration for dynamic allocation/deacllocation.
  455.       *
  456.       * @return the memory manager
  457.       */
  458.     MemoryManager* getMemoryManager() const;
  459.     //@}
  460.     // -----------------------------------------------------------------------
  461.     //  Setter methods
  462.     // -----------------------------------------------------------------------
  463.     /** @name Setter methods */
  464.     //@{
  465.     /** Set the element name object for this element type
  466.       *
  467.       * This method will adopt the based content spec node object. This is called
  468.       * by the actual validator which is parsing its DTD or Schema or whatever
  469.       * and store it on the element decl object via this method.
  470.       *
  471.       * @param  prefix       Prefix of the element
  472.       * @param  localPart    Base Name of the element
  473.       * @param  uriId        The uriId of the element
  474.       */
  475.       void setElementName(const XMLCh* const       prefix
  476.                         , const XMLCh* const       localPart
  477.                         , const int                uriId );
  478.     /** Set the element name object for this element type
  479.       *
  480.       * This method will adopt the based content spec node object. This is called
  481.       * by the actual validator which is parsing its DTD or Schema or whatever
  482.       * and store it on the element decl object via this method.
  483.       *
  484.       * @param  rawName      Full Name of the element
  485.       * @param  uriId        The uriId of the element
  486.       */
  487.       void setElementName(const XMLCh* const    rawName
  488.                         , const int             uriId );
  489.     /** Set the element name object for this element type
  490.       *
  491.       * This method will adopt the based content spec node object. This is called
  492.       * by the actual validator which is parsing its DTD or Schema or whatever
  493.       * and store it on the element decl object via this method.
  494.       *
  495.       * @param  elementName  QName of the element
  496.       */
  497.       void setElementName(const QName* const    elementName);
  498.     /** Update the create reason for this element type.
  499.       *
  500.       * This method will update the 'create reason' field for this element
  501.       * decl object. As the validator parses its DTD, Schema, etc... it will
  502.       * encounter various references to an element declaration, which will
  503.       * cause the element declaration to either be declared or to be faulted
  504.       * into the pool in preperation for some future declaration. As it does
  505.       * so,it will update this field to indicate the current satus of the
  506.       * decl object.
  507.       */
  508.     void setCreateReason(const CreateReasons newReason);
  509.     /** Set the element decl pool id for this element type
  510.       *
  511.       * This method will set the pool id of this element decl. This is called
  512.       * by the grammar which created this object, and will provide this
  513.       * decl object with a unique id within the parse event that created it.
  514.       */
  515.     void setId(const unsigned int newId);
  516.     /** Set the element decl to indicate external declaration
  517.       *
  518.       */
  519.     void setExternalElemDeclaration(const bool aValue);
  520.     //@}
  521.     // -----------------------------------------------------------------------
  522.     //  Miscellaneous methods
  523.     // -----------------------------------------------------------------------
  524.     /** @name Miscellenous methods */
  525.     //@{
  526.     //@}
  527. protected :
  528.     // -----------------------------------------------------------------------
  529.     //  Hidden constructors
  530.     // -----------------------------------------------------------------------
  531.     XMLElementDecl(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
  532. private :
  533.     // -----------------------------------------------------------------------
  534.     //  Unimplemented constructors and operators
  535.     // -----------------------------------------------------------------------
  536.     XMLElementDecl(const XMLElementDecl&);
  537.     XMLElementDecl& operator=(const XMLElementDecl&);
  538.     // -----------------------------------------------------------------------
  539.     //  Data members
  540.     //
  541.     //  fElementName
  542.     //      This is the name of the element decl.
  543.     //
  544.     //  fCreateReason
  545.     //      We sometimes have to put an element decl object into the elem
  546.     //      decl pool before the element's declaration is seen, such as when
  547.     //      its used in another element's content model or an att list is
  548.     //      seen for it. This flag tells us whether its been declared, and
  549.     //      if not why it had to be created.
  550.     //
  551.     //  fId
  552.     //      The unique id of this element. This is created by the derived
  553.     //      class, or more accurately the grammar that owns the objects
  554.     //      of the derived types. But, since they all have to have them, we
  555.     //      let them all store the id here. It is defaulted to have the
  556.     //      value fgInvalidElem until explicitly set.
  557.     //
  558.     //  fExternalElement
  559.     //      This flag indicates whether or the element was declared externally.
  560.     // -----------------------------------------------------------------------
  561.     MemoryManager*      fMemoryManager;
  562.     QName*              fElementName;
  563.     CreateReasons       fCreateReason;
  564.     unsigned int        fId;
  565.     bool                fExternalElement;
  566. };
  567. // ---------------------------------------------------------------------------
  568. //  XMLElementDecl: Getter methods
  569. // ---------------------------------------------------------------------------
  570. inline const XMLCh* XMLElementDecl::getBaseName() const
  571. {
  572.     return fElementName->getLocalPart();
  573. }
  574. inline XMLCh* XMLElementDecl::getBaseName()
  575. {
  576.     return fElementName->getLocalPart();
  577. }
  578. inline unsigned int XMLElementDecl::getURI() const
  579. {
  580.     return fElementName->getURI();
  581. }
  582. inline const QName* XMLElementDecl::getElementName() const
  583. {
  584.     return fElementName;
  585. }
  586. inline QName* XMLElementDecl::getElementName()
  587. {
  588.     return fElementName;
  589. }
  590. inline const XMLCh* XMLElementDecl::getFullName() const
  591. {
  592.     return fElementName->getRawName();
  593. }
  594. inline XMLElementDecl::CreateReasons XMLElementDecl::getCreateReason() const
  595. {
  596.     return fCreateReason;
  597. }
  598. inline unsigned int XMLElementDecl::getId() const
  599. {
  600.     return fId;
  601. }
  602. inline bool XMLElementDecl::isDeclared() const
  603. {
  604.     return (fCreateReason == Declared);
  605. }
  606. inline bool XMLElementDecl::isExternal() const
  607. {
  608.     return fExternalElement;
  609. }
  610. inline MemoryManager* XMLElementDecl::getMemoryManager() const
  611. {
  612.     return fMemoryManager;
  613. }
  614. // ---------------------------------------------------------------------------
  615. //  XMLElementDecl: Setter methods
  616. // ---------------------------------------------------------------------------
  617. inline void
  618. XMLElementDecl::setCreateReason(const XMLElementDecl::CreateReasons newReason)
  619. {
  620.     fCreateReason = newReason;
  621. }
  622. inline void XMLElementDecl::setId(const unsigned int newId)
  623. {
  624.     fId = newId;
  625. }
  626. inline void XMLElementDecl::setExternalElemDeclaration(const bool aValue)
  627. {
  628.     fExternalElement = aValue;
  629. }
  630. XERCES_CPP_NAMESPACE_END
  631. #endif