http://xml.apache.org/http://www.apache.org/http://www.w3.org/

Home

Readme
Charter
Release Info

Installation
Download
Build Instructions

FAQs
Samples
API Docs

DOM C++ Binding
Programming
Migration Guide

Feedback
Bug-Reporting
PDF Document

Source Repository
User Mail Archive
Devel Mail Archive

API Docs for SAX and DOM
 

XMLEntityDecl.hpp

Go to the documentation of this file.
00001 /*
00002  * Copyright 1999-2004 The Apache Software Foundation.
00003  * 
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  * 
00008  *      http://www.apache.org/licenses/LICENSE-2.0
00009  * 
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00017 /*
00018  * $Id: XMLEntityDecl.hpp 191054 2005-06-17 02:56:35Z jberry $
00019  */
00020 
00021 #if !defined(XMLENTITYDECL_HPP)
00022 #define XMLENTITYDECL_HPP
00023 
00024 #include <xercesc/util/XMemory.hpp>
00025 #include <xercesc/util/PlatformUtils.hpp>
00026 #include <xercesc/util/XMLString.hpp>
00027 #include <xercesc/internal/XSerializable.hpp>
00028 
00029 XERCES_CPP_NAMESPACE_BEGIN
00030 
00049 class  XMLEntityDecl : public XSerializable, public XMemory
00050 {
00051 public:
00052     // -----------------------------------------------------------------------
00053     //  Constructors and Destructor
00054     // -----------------------------------------------------------------------
00055 
00058 
00062     XMLEntityDecl(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
00063 
00070     XMLEntityDecl
00071     (
00072         const   XMLCh* const    entName
00073         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
00074     );
00075 
00084     XMLEntityDecl
00085     (
00086         const   XMLCh* const    entName
00087         , const XMLCh* const    value
00088         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
00089     );
00090 
00099     XMLEntityDecl
00100     (
00101         const   XMLCh* const    entName
00102         , const XMLCh           value
00103         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
00104     );
00106 
00109 
00113     virtual ~XMLEntityDecl();
00114 
00116 
00117 
00118     // -----------------------------------------------------------------------
00119     //  Virtual entity decl interface
00120     // -----------------------------------------------------------------------
00121 
00124 
00132     virtual bool getDeclaredInIntSubset() const = 0;
00133 
00139     virtual bool getIsParameter() const = 0;
00140 
00146     virtual bool getIsSpecialChar() const = 0;
00147 
00149 
00150 
00151     // -----------------------------------------------------------------------
00152     //  Getter methods
00153     // -----------------------------------------------------------------------
00154 
00157 
00162     unsigned int getId() const;
00163 
00169     const XMLCh* getName() const;
00170 
00175     const XMLCh* getNotationName() const;
00176 
00181     const XMLCh* getPublicId() const;
00182 
00187     const XMLCh* getSystemId() const;
00188 
00192     const XMLCh* getBaseURI() const;
00193 
00199     const XMLCh* getValue() const;
00200 
00206     unsigned int getValueLen() const;
00207 
00212     bool isExternal() const;
00213 
00219     bool isUnparsed() const;
00220 
00228     MemoryManager* getMemoryManager() const;
00229 
00231 
00232 
00233     // -----------------------------------------------------------------------
00234     //  Setter methods
00235     // -----------------------------------------------------------------------
00236 
00239 
00248     void setName
00249     (
00250         const   XMLCh* const    entName
00251     );
00252 
00259     void setNotationName(const XMLCh* const newName);
00260 
00267     void setPublicId(const XMLCh* const newId);
00268 
00278     void setSystemId(const XMLCh* const newId);
00279 
00286     void setBaseURI(const XMLCh* const newId);
00287 
00295     void setValue(const XMLCh* const newValue);
00296 
00298 
00299     /* For internal use only */
00300     void setId(const unsigned int newId);
00301 
00302 
00303     // -----------------------------------------------------------------------
00304     //  Support named pool syntax
00305     // -----------------------------------------------------------------------
00306 
00309 
00316     const XMLCh* getKey() const;
00317 
00319 
00320     /***
00321      * Support for Serialization/De-serialization
00322      ***/
00323     DECL_XSERIALIZABLE(XMLEntityDecl)
00324 
00325 private :
00326     // -----------------------------------------------------------------------
00327     //  Unimplemented constructors and operators
00328     // -----------------------------------------------------------------------
00329     XMLEntityDecl(const XMLEntityDecl&);
00330     XMLEntityDecl& operator=(XMLEntityDecl&);
00331 
00332 
00333     // -----------------------------------------------------------------------
00334     //  XMLEntityDecl: Private helper methods
00335     // -----------------------------------------------------------------------
00336     void cleanUp();
00337 
00338 
00339     // -----------------------------------------------------------------------
00340     //  Private data members
00341     //
00342     //  fId
00343     //      This is the unique id given to this entity decl.
00344     //
00345     //  fName
00346     //      The name of the enitity. Entity names are never namespace based.
00347     //
00348     //  fNotationName
00349     //      The optional notation of the entity. If there was none, then its
00350     //      empty.
00351     //
00352     //  fPublicId
00353     //      The public id of the entity, which can be empty.
00354     //
00355     //  fSystemId
00356     //      The system id of the entity.
00357     //
00358     //  fValue
00359     //  fValueLen
00360     //      The entity's value and length, which is only valid if its an
00361     //      internal style entity.
00362     //
00363     //  fBaseURI
00364     //      The base URI of the entity.   According to XML InfoSet, such value
00365     //      is the URI where it is declared (NOT referenced).
00366     // -----------------------------------------------------------------------
00367     unsigned int    fId;
00368     unsigned int    fValueLen;
00369     XMLCh*          fValue;
00370     XMLCh*          fName;
00371     XMLCh*          fNotationName;
00372     XMLCh*          fPublicId;
00373     XMLCh*          fSystemId;
00374     XMLCh*          fBaseURI;
00375     MemoryManager*  fMemoryManager;
00376 };
00377 
00378 
00379 // ---------------------------------------------------------------------------
00380 //  XMLEntityDecl: Getter methods
00381 // ---------------------------------------------------------------------------
00382 inline unsigned int XMLEntityDecl::getId() const
00383 {
00384     return fId;
00385 }
00386 
00387 inline const XMLCh* XMLEntityDecl::getName() const
00388 {
00389     return fName;
00390 }
00391 
00392 inline const XMLCh* XMLEntityDecl::getNotationName() const
00393 {
00394     return fNotationName;
00395 }
00396 
00397 inline const XMLCh* XMLEntityDecl::getPublicId() const
00398 {
00399     return fPublicId;
00400 }
00401 
00402 inline const XMLCh* XMLEntityDecl::getSystemId() const
00403 {
00404     return fSystemId;
00405 }
00406 
00407 inline const XMLCh* XMLEntityDecl::getBaseURI() const
00408 {
00409     return fBaseURI;
00410 }
00411 
00412 inline const XMLCh* XMLEntityDecl::getValue() const
00413 {
00414     return fValue;
00415 }
00416 
00417 inline unsigned int XMLEntityDecl::getValueLen() const
00418 {
00419     return fValueLen;
00420 }
00421 
00422 inline bool XMLEntityDecl::isExternal() const
00423 {
00424     // If it has a system or public id, its external
00425     return ((fPublicId != 0) || (fSystemId != 0));
00426 }
00427 
00428 inline bool XMLEntityDecl::isUnparsed() const
00429 {
00430     // If it has a notation, its unparsed
00431     return (fNotationName != 0);
00432 }
00433 
00434 inline MemoryManager* XMLEntityDecl::getMemoryManager() const
00435 {
00436     return fMemoryManager;
00437 }
00438 
00439 // ---------------------------------------------------------------------------
00440 //  XMLEntityDecl: Setter methods
00441 // ---------------------------------------------------------------------------
00442 inline void XMLEntityDecl::setId(const unsigned int newId)
00443 {
00444     fId = newId;
00445 }
00446 
00447 inline void XMLEntityDecl::setNotationName(const XMLCh* const newName)
00448 {
00449     if (fNotationName)
00450         fMemoryManager->deallocate(fNotationName);
00451 
00452     fNotationName = XMLString::replicate(newName, fMemoryManager);
00453 }
00454 
00455 inline void XMLEntityDecl::setPublicId(const XMLCh* const newId)
00456 {
00457     if (fPublicId)
00458         fMemoryManager->deallocate(fPublicId);
00459 
00460     fPublicId = XMLString::replicate(newId, fMemoryManager);
00461 }
00462 
00463 inline void XMLEntityDecl::setSystemId(const XMLCh* const newId)
00464 {
00465     if (fSystemId)
00466         fMemoryManager->deallocate(fSystemId);
00467 
00468     fSystemId = XMLString::replicate(newId, fMemoryManager);
00469 }
00470 
00471 inline void XMLEntityDecl::setBaseURI(const XMLCh* const newId)
00472 {
00473     if (fBaseURI)
00474         fMemoryManager->deallocate(fBaseURI);
00475 
00476     fBaseURI = XMLString::replicate(newId, fMemoryManager);
00477 }
00478 
00479 inline void XMLEntityDecl::setValue(const XMLCh* const newValue)
00480 {
00481     if (fValue)
00482         fMemoryManager->deallocate(fValue);
00483 
00484     fValue = XMLString::replicate(newValue, fMemoryManager);
00485     fValueLen = XMLString::stringLen(newValue);
00486 }
00487 
00488 
00489 // ---------------------------------------------------------------------------
00490 //  XMLEntityDecl: Support named pool syntax
00491 // ---------------------------------------------------------------------------
00492 inline const XMLCh* XMLEntityDecl::getKey() const
00493 {
00494     return fName;
00495 }
00496 
00497 XERCES_CPP_NAMESPACE_END
00498 
00499 #endif


Copyright © 1994-2004 The Apache Software Foundation. All Rights Reserved.