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
 

XMLAttDef.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: XMLAttDef.hpp 191054 2005-06-17 02:56:35Z jberry $
00019  */
00020 
00021 #if !defined(ATTDEF_HPP)
00022 #define ATTDEF_HPP
00023 
00024 #include <xercesc/util/PlatformUtils.hpp>
00025 #include <xercesc/util/XMLString.hpp>
00026 #include <xercesc/util/XMemory.hpp>
00027 #include <xercesc/internal/XSerializable.hpp>
00028 
00029 XERCES_CPP_NAMESPACE_BEGIN
00030 
00031 class XMLAttr;
00032 
00051 class  XMLAttDef : public XSerializable, public XMemory
00052 {
00053 public:
00054     // -----------------------------------------------------------------------
00055     //  Class specific types
00056     //
00057     //  AttTypes
00058     //      The list of possible types that an attribute can have, according
00059     //      to the XML 1.0 spec and schema.
00060     //
00061     //  DefAttTypes
00062     //      The modifiers that an attribute decl can have, which indicates
00063     //      whether instances of that attributes are required, implied, etc..
00064     //
00065     //  CreateReasons
00066     //      This type is used to store how an attribute declaration got into
00067     //      the elementdecl's attribute pool.
00068     //
00069     // -----------------------------------------------------------------------
00070     enum AttTypes
00071     {
00072         CData               = 0
00073         , ID                = 1
00074         , IDRef             = 2
00075         , IDRefs            = 3
00076         , Entity            = 4
00077         , Entities          = 5
00078         , NmToken           = 6
00079         , NmTokens          = 7
00080         , Notation          = 8
00081         , Enumeration       = 9
00082         , Simple            = 10
00083         , Any_Any           = 11
00084         , Any_Other         = 12
00085         , Any_List          = 13
00086 
00087         , AttTypes_Count
00088         , AttTypes_Min      = 0
00089         , AttTypes_Max      = 13
00090         , AttTypes_Unknown  = -1
00091     };
00092 
00093     enum DefAttTypes
00094     {
00095         Default                  = 0
00096         , Fixed                  = 1
00097         , Required               = 2
00098         , Required_And_Fixed     = 3
00099         , Implied                = 4
00100         , ProcessContents_Skip   = 5
00101         , ProcessContents_Lax    = 6
00102         , ProcessContents_Strict = 7
00103         , Prohibited             = 8
00104 
00105         , DefAttTypes_Count
00106         , DefAttTypes_Min   = 0
00107         , DefAttTypes_Max   = 8
00108         , DefAttTypes_Unknown = -1
00109     };
00110 
00111     enum CreateReasons
00112     {
00113         NoReason
00114         , JustFaultIn
00115     };
00116 
00117     // -----------------------------------------------------------------------
00118     //  Public static data members
00119     // -----------------------------------------------------------------------
00120     static const unsigned int fgInvalidAttrId;
00121 
00122 
00123     // -----------------------------------------------------------------------
00124     //  Public, static methods
00125     // -----------------------------------------------------------------------
00126 
00129 
00140     static const XMLCh* getAttTypeString(const AttTypes attrType
00141         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
00142 
00153     static const XMLCh* getDefAttTypeString(const DefAttTypes attrType
00154         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
00155 
00157 
00158 
00159     // -----------------------------------------------------------------------
00160     //  Destructor
00161     // -----------------------------------------------------------------------
00162 
00165 
00169     virtual ~XMLAttDef();
00171 
00172 
00173     // -----------------------------------------------------------------------
00174     //  The virtual attribute def interface
00175     // -----------------------------------------------------------------------
00176 
00179 
00188     virtual const XMLCh* getFullName() const = 0;
00189 
00194     virtual void reset() = 0;
00195 
00197 
00198 
00199     // -----------------------------------------------------------------------
00200     //  Getter methods
00201     // -----------------------------------------------------------------------
00202 
00205 
00214     DefAttTypes getDefaultType() const;
00215 
00225     const XMLCh* getEnumeration() const;
00226 
00235     unsigned int getId() const;
00236 
00251     bool getProvided() const;
00252 
00262     AttTypes getType() const;
00263 
00273     const XMLCh* getValue() const;
00274 
00283     CreateReasons getCreateReason() const;
00284 
00292     bool isExternal() const;
00293 
00301     MemoryManager* getMemoryManager() const;
00302 
00303 
00308     virtual const XMLCh* getDOMTypeInfoUri() const = 0;
00309 
00314     virtual const XMLCh* getDOMTypeInfoName() const = 0;
00315 
00317 
00318 
00319     // -----------------------------------------------------------------------
00320     //  Setter methods
00321     // -----------------------------------------------------------------------
00322 
00325 
00334     void setDefaultType(const XMLAttDef::DefAttTypes newValue);
00335 
00344     void setId(const unsigned int newId);
00345 
00355     void setProvided(const bool newValue);
00356 
00364     void setType(const XMLAttDef::AttTypes newValue);
00365 
00376     void setValue(const XMLCh* const newValue);
00377 
00388     void setEnumeration(const XMLCh* const newValue);
00389 
00397     void setCreateReason(const CreateReasons newReason);
00398 
00404     void setExternalAttDeclaration(const bool aValue);
00405 
00407 
00408     /***
00409      * Support for Serialization/De-serialization
00410      ***/
00411     DECL_XSERIALIZABLE(XMLAttDef)
00412 
00413 protected :
00414     // -----------------------------------------------------------------------
00415     //  Hidden constructors
00416     // -----------------------------------------------------------------------
00417     XMLAttDef
00418     (
00419         const   AttTypes       type = CData
00420         , const DefAttTypes    defType= Implied
00421         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
00422     );
00423     XMLAttDef
00424     (
00425         const   XMLCh* const        attValue
00426         , const AttTypes            type
00427         , const DefAttTypes         defType
00428         , const XMLCh* const        enumValues = 0
00429         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
00430     );
00431 
00432 
00433 private :
00434     // -----------------------------------------------------------------------
00435     //  Unimplemented constructors and operators
00436     // -----------------------------------------------------------------------
00437     XMLAttDef(const XMLAttDef&);
00438     XMLAttDef& operator=(const XMLAttDef&);
00439 
00440 
00441     // -----------------------------------------------------------------------
00442     //  Private helper methods
00443     // -----------------------------------------------------------------------
00444     void cleanUp();
00445 
00446 
00447     // -----------------------------------------------------------------------
00448     //  Private data members
00449     //
00450     //  fDefaultType
00451     //      Indicates what, if any, default stuff this attribute has.
00452     //
00453     //  fEnumeration
00454     //      If its an enumeration, this is the list of values as space
00455     //      separated values.
00456     //
00457     //  fId
00458     //      This is the unique id of this attribute, given to it when its put
00459     //      into the validator's attribute decl pool. It defaults to the
00460     //      special value XMLAttrDef::fgInvalidAttrId.
00461     //
00462     //  fProvided
00463     //      This field is really for use by the scanner. It is used to track
00464     //      which of the attributes of an element were provided. Any marked
00465     //      as not provided (after scanning the start tag) and having a
00466     //      default type of Required, is in error.
00467     //
00468     //  fType
00469     //      The type of attribute, which is one of the AttTypes values.
00470     //
00471     //  fValue
00472     //      This is the value of the attribute, which is the default value
00473     //      given in the attribute declaration.
00474     //
00475     //  fCreateReason
00476     //      This flag tells us how this attribute got created.  Sometimes even
00477     //      the attribute was not declared for the element, we want to fault
00478     //      fault it into the pool to avoid lots of redundant errors.
00479     //
00480     //  fExternalAttribute
00481     //      This flag indicates whether or not the attribute was declared externally.
00482     // -----------------------------------------------------------------------
00483     DefAttTypes     fDefaultType;
00484     AttTypes        fType;
00485     CreateReasons   fCreateReason;
00486     bool            fProvided;
00487     bool            fExternalAttribute;
00488     unsigned int    fId;
00489     XMLCh*          fValue;
00490     XMLCh*          fEnumeration;
00491     MemoryManager*  fMemoryManager;
00492 };
00493 
00494 
00495 // ---------------------------------------------------------------------------
00496 //  Getter methods
00497 // ---------------------------------------------------------------------------
00498 inline XMLAttDef::DefAttTypes XMLAttDef::getDefaultType() const
00499 {
00500     return fDefaultType;
00501 }
00502 
00503 inline const XMLCh* XMLAttDef::getEnumeration() const
00504 {
00505     return fEnumeration;
00506 }
00507 
00508 inline unsigned int XMLAttDef::getId() const
00509 {
00510     return fId;
00511 }
00512 
00513 inline bool XMLAttDef::getProvided() const
00514 {
00515     return fProvided;
00516 }
00517 
00518 inline XMLAttDef::AttTypes XMLAttDef::getType() const
00519 {
00520     return fType;
00521 }
00522 
00523 inline const XMLCh* XMLAttDef::getValue() const
00524 {
00525     return fValue;
00526 }
00527 
00528 inline XMLAttDef::CreateReasons XMLAttDef::getCreateReason() const
00529 {
00530     return fCreateReason;
00531 }
00532 
00533 inline bool XMLAttDef::isExternal() const
00534 {
00535     return fExternalAttribute;
00536 }
00537 
00538 inline MemoryManager* XMLAttDef::getMemoryManager() const
00539 {
00540     return fMemoryManager;
00541 }
00542 
00543 // ---------------------------------------------------------------------------
00544 //  XMLAttDef: Setter methods
00545 // ---------------------------------------------------------------------------
00546 inline void XMLAttDef::setDefaultType(const XMLAttDef::DefAttTypes newValue)
00547 {
00548     fDefaultType = newValue;
00549 }
00550 
00551 inline void XMLAttDef::setEnumeration(const XMLCh* const newValue)
00552 {
00553     if (fEnumeration)
00554         fMemoryManager->deallocate(fEnumeration);
00555 
00556     fEnumeration = XMLString::replicate(newValue, fMemoryManager);
00557 }
00558 
00559 inline void XMLAttDef::setId(const unsigned int newId)
00560 {
00561     fId = newId;
00562 }
00563 
00564 inline void XMLAttDef::setProvided(const bool newValue)
00565 {
00566     fProvided = newValue;
00567 }
00568 
00569 inline void XMLAttDef::setType(const XMLAttDef::AttTypes newValue)
00570 {
00571     fType = newValue;
00572 }
00573 
00574 inline void XMLAttDef::setValue(const XMLCh* const newValue)
00575 {
00576     if (fValue)
00577        fMemoryManager->deallocate(fValue);
00578 
00579     fValue = XMLString::replicate(newValue, fMemoryManager);
00580 }
00581 
00582 inline void
00583 XMLAttDef::setCreateReason(const XMLAttDef::CreateReasons newReason)
00584 {
00585     fCreateReason = newReason;
00586 }
00587 
00588 inline void XMLAttDef::setExternalAttDeclaration(const bool aValue)
00589 {
00590     fExternalAttribute = aValue;
00591 }
00592 
00593 XERCES_CPP_NAMESPACE_END
00594 
00595 #endif


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