/* * 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: XMLAttr.hpp 568078 2007-08-21 11:43:25Z amassari $ */ #if !defined(XMLATTR_HPP) #define XMLATTR_HPP #include #include #include #include XERCES_CPP_NAMESPACE_BEGIN /** * This class defines the information about an attribute that will come out * of the scanner during parsing. This information does not depend upon the * type of validator because it is not tied to any scheme/DTD type info. Its * just the raw XML 1.0 information that will be reported about an attribute * in the startElement() callback method of the XMLDocumentHandler class. * Hence it is not intended to be extended or derived from. Its designed to * be used as is. * * The 'specified' field of this class indicates whether the attribute was * actually present or whether it was faulted in because it had a fixed or * default value. * * The code receiving this information can ask its validator for more info * about the attribute, i.e. get its declaration from the DTD/Schema info. * * Because of the heavy use (and reuse) of instances of this class, and the * number of string members it has, this class takes pains to not reallocate * string members unless it has to. It keeps up with how long each buffer * is and only reallocates if the new value won't fit. */ class XMLPARSER_EXPORT XMLAttr : public XMemory { public: // ----------------------------------------------------------------------- // Constructors and Destructor // ----------------------------------------------------------------------- /** @name Constructors */ //@{ /** * The default constructor just setsup an empty attribute to be filled * in the later. Though the initial state is a reasonable one, it is * not documented because it should not be depended on. * * @param manager The configurable memory manager */ XMLAttr(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager); /** * This is the primary constructor which takes all of the information * required to construct a complete attribute object. * * @param uriId The id into the validator's URI pool of the URI * that the prefix mapped to. Only used if namespaces * are enabled/supported. * * @param attrName The base name of the attribute, i.e. the part * after any prefix. * * @param attrPrefix The prefix, if any, of this attribute's name. If * this is empty, then uriID is meaningless as well. * * @param attrValue The value string of the attribute, which should * be fully normalized by XML rules! * * @param type The type of the attribute. This will indicate * the type of normalization done and constrains * the value content. Make sure that the value * set meets the constraints! * * @param specified Indicates whether the attribute was explicitly * specified or not. If not, then it was faulted * in from a FIXED or DEFAULT value. * * @param manager The configurable memory manager * @param datatypeValidator type used to validate the attribute, * if it was validated by an XML Schema * @param isSchema true if and only if this attribute was validated * by an XML Schema */ XMLAttr ( const unsigned int uriId , const XMLCh* const attrName , const XMLCh* const attrPrefix , const XMLCh* const attrValue , const XMLAttDef::AttTypes type = XMLAttDef::CData , const bool specified = true , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager , DatatypeValidator * datatypeValidator = 0 , const bool isSchema = false ); /** * This is the primary constructor which takes all of the information * required to construct a complete attribute object. * * @param uriId The id into the validator's URI pool of the URI * that the prefix mapped to. Only used if namespaces * are enabled/supported. * * @param rawName The raw name of the attribute. * * @param attrValue The value string of the attribute, which should * be fully normalized by XML rules! * * @param type The type of the attribute. This will indicate * the type of normalization done and constrains * the value content. Make sure that the value * set meets the constraints! * * @param specified Indicates whether the attribute was explicitly * specified or not. If not, then it was faulted * in from a FIXED or DEFAULT value. * * @param manager The configurable memory manager * @param datatypeValidator type used to validate the attribute, * if it was validated by an XML Schema * @param isSchema true if and only if this attribute was validated * by an XML Schema */ XMLAttr ( const unsigned int uriId , const XMLCh* const rawName , const XMLCh* const attrValue , const XMLAttDef::AttTypes type = XMLAttDef::CData , const bool specified = true , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager , DatatypeValidator * datatypeValidator = 0 , const bool isSchema = false ); //@} /** @name Destructor */ //@{ ~XMLAttr(); //@} // ----------------------------------------------------------------------- // Getter methods // ----------------------------------------------------------------------- /** @name Getter methods */ //@{ /** * This methode returns the attribute name in a QName format. */ QName* getAttName() const; /** * This method gets a const pointer tot he name of the attribute. The * form of this name is defined by the validator in use. */ const XMLCh* getName() const; /** * This method will get a const pointer to the prefix string of this * attribute. Since prefixes are optional, it may be zero. */ const XMLCh* getPrefix() const; /** * This method will get the QName of this attribute, which will be the * prefix if any, then a colon, then the base name. If there was no * prefix, its the same as the getName() method. */ const XMLCh* getQName() const; /** * This method will get the specified flag, which indicates whether * the attribute was explicitly specified or just faulted in. */ bool getSpecified() const; /** * This method will get the type of the attribute. The available types * are defined by the XML specification. */ XMLAttDef::AttTypes getType() const; /** * This method will get the value of the attribute. The value can be * be an empty string, but never null if the object is correctly * set up. */ const XMLCh* getValue() const; /** * This method will get the id of the URI that this attribute's prefix * mapped to. If namespaces are not on, then its value is meaningless. */ unsigned int getURIId() const; /** * @return the uri part of DOM Level 3 TypeInfo * @deprecated */ const XMLCh* getValidatingTypeURI() const; /** * @return the name part of DOM Level 3 TypeInfo * @deprecated */ const XMLCh* getValidatingTypeName() const; //@} // ----------------------------------------------------------------------- // Setter methods // ----------------------------------------------------------------------- /** @name Setter methods */ //@{ /** * This method is called to set up a default constructed object after * the fact, or to reuse a previously used object. * * @param uriId The id into the validator's URI pool of the URI * that the prefix mapped to. Only used if namespaces * are enabled/supported. * * @param attrName The base name of the attribute, i.e. the part * after any prefix. * * @param attrPrefix The prefix, if any, of this attribute's name. If * this is empty, then uriID is meaningless as well. * * @param attrValue The value string of the attribute, which should * be fully normalized by XML rules according to the * attribute type. * * @param type The type of the attribute. This will indicate * the type of normalization done and constrains * the value content. Make sure that the value * set meets the constraints! * @param datatypeValidator type used to validate the attribute, * if it was validated by an XML Schema * @param isSchema true if and only if this attribute was validated * by an XML Schema * */ void set ( const unsigned int uriId , const XMLCh* const attrName , const XMLCh* const attrPrefix , const XMLCh* const attrValue , const XMLAttDef::AttTypes type = XMLAttDef::CData , DatatypeValidator * datatypeValidator = 0 , const bool isSchema = false ); /** * This method is called to set up a default constructed object after * the fact, or to reuse a previously used object. * * @param uriId The id into the validator's URI pool of the URI * that the prefix mapped to. Only used if namespaces * are enabled/supported. * * @param attrRawName The raw name of the attribute. * * @param attrValue The value string of the attribute, which should * be fully normalized by XML rules according to the * attribute type. * * @param type The type of the attribute. This will indicate * the type of normalization done and constrains * the value content. Make sure that the value * set meets the constraints! * @param datatypeValidator type used to validate the attribute, * if it was validated by an XML Schema * @param isSchema true if and only if this attribute was validated * by an XML Schema */ void set ( const unsigned int uriId , const XMLCh* const attrRawName , const XMLCh* const attrValue , const XMLAttDef::AttTypes type = XMLAttDef::CData , DatatypeValidator * datatypeValidator = 0 , const bool isSchema = false ); /** * This method will update just the name related fields of the * attribute object. The other fields are left as is. * * @param uriId The id into the validator's URI pool of the URI * that the prefix mapped to. Only used if namespaces * are enabled/supported. * * @param attrName The base name of the attribute, i.e. the part * after any prefix. * * @param attrPrefix The prefix, if any, of this attribute's name. If * this is empty, then uriID is meaningless as well. */ void setName ( const unsigned int uriId , const XMLCh* const attrName , const XMLCh* const attrPrefix ); /** * This method will update the specified state of the object. * * @param newValue Indicates whether the attribute was explicitly * specified or not. If not, then it was faulted * in from a FIXED or DEFAULT value. */ void setSpecified(const bool newValue); /** * This method will update the attribute type of the object. * * @param newType The type of the attribute. This will indicate * the type of normalization done and constrains * the value content. Make sure that the value * set meets the constraints! */ void setType(const XMLAttDef::AttTypes newType); /** * This method will update the value field of the attribute. * * @param newValue The value string of the attribute, which should * be fully normalized by XML rules according to the * attribute type. */ void setValue(const XMLCh* const newValue); /** * This method will set the URI id field of this attribute. This is * generally only ever called internally by the parser itself during * the parsing process. * * @param uriId The uriId of the attribute. */ void setURIId(const unsigned int uriId); /** * This method will update the datatype validator that was used * to assess the validity of the value of this attribute. * @param datatypeValidator DatatypeValidator used to assess the validity * of this attribute's value * @deprecated */ void setDatatypeValidator(DatatypeValidator * datatypeValidator); /** * This method will define whether the attribute was * validated by an XML Schema * @param isSchema true indicates that this attribute was validated * by an XML Schema; false indicates otherwise * @deprecated */ void setSchemaValidated(const bool isSchema); //@} private : // ----------------------------------------------------------------------- // Unimplemented constructors and operators // ----------------------------------------------------------------------- XMLAttr(const XMLAttr&); XMLAttr& operator=(const XMLAttr&); // ----------------------------------------------------------------------- // Private, helper methods // ----------------------------------------------------------------------- void cleanUp(); // ----------------------------------------------------------------------- // Private instance variables // // fAttName // The Attribute Name; // // fSpecified // True if this attribute appeared in the element; else, false if // it was defaulted from an AttDef. // // fType // The attribute type enum value for this attribute. Indicates what // type of attribute it was. // // fValue // fValueBufSz // The attribute value that was given in the attribute instance, and // its current buffer size (minus one, where the null is.) // // fMemoryManager // The memory manager used for dynamic memory allocation/deallocation // fDatatypeValidator // The validator used to validate the value of this attribute. // The attribute does not own this object, and it is only // used in the calculation of DOMTypeInfo information. // fIsSchemaValidated // whether this attribute was validated by an XML Schema // // ----------------------------------------------------------------------- bool fSpecified; XMLAttDef::AttTypes fType; unsigned int fValueBufSz; XMLCh* fValue; QName* fAttName; MemoryManager* fMemoryManager; DatatypeValidator * fDatatypeValidator; bool fIsSchemaValidated; }; // --------------------------------------------------------------------------- // XMLAttr: Constructors and Destructor // --------------------------------------------------------------------------- inline XMLAttr::~XMLAttr() { cleanUp(); } // --------------------------------------------------------------------------- // XMLAttr: Getter methods // --------------------------------------------------------------------------- inline QName* XMLAttr::getAttName() const { return fAttName; } inline const XMLCh* XMLAttr::getName() const { return fAttName->getLocalPart(); } inline const XMLCh* XMLAttr::getPrefix() const { return fAttName->getPrefix(); } inline bool XMLAttr::getSpecified() const { return fSpecified; } inline XMLAttDef::AttTypes XMLAttr::getType() const { return fType; } inline const XMLCh* XMLAttr::getValue() const { return fValue; } inline unsigned int XMLAttr::getURIId() const { return fAttName->getURI(); } inline const XMLCh* XMLAttr::getValidatingTypeName() const { if(fIsSchemaValidated) { if(!fDatatypeValidator || fDatatypeValidator->getAnonymous()) return 0; return fDatatypeValidator->getTypeLocalName(); } else { return XMLAttDef::getAttTypeString(fType, fMemoryManager); } } inline const XMLCh* XMLAttr::getValidatingTypeURI() const { if(fIsSchemaValidated) { if(!fDatatypeValidator || fDatatypeValidator->getAnonymous()) return 0; return fDatatypeValidator->getTypeUri(); } else { return 0; } } // --------------------------------------------------------------------------- // XMLAttr: Setter methods // --------------------------------------------------------------------------- inline void XMLAttr::set(const unsigned int uriId , const XMLCh* const attrName , const XMLCh* const attrPrefix , const XMLCh* const attrValue , const XMLAttDef::AttTypes type , DatatypeValidator * datatypeValidator , const bool isSchema ) { // Set the name info and the value via their respective calls fAttName->setName(attrPrefix, attrName, uriId); setValue(attrValue); // And store the type fType = type; // and set up info for DOM type info fIsSchemaValidated = isSchema; fDatatypeValidator = datatypeValidator; } inline void XMLAttr::set(const unsigned int uriId , const XMLCh* const attrRawName , const XMLCh* const attrValue , const XMLAttDef::AttTypes type , DatatypeValidator * datatypeValidator , const bool isSchema ) { // Set the name info and the value via their respective calls fAttName->setName(attrRawName, uriId); setValue(attrValue); // And store the type fType = type; // and set up info for DOM type info fIsSchemaValidated = isSchema; fDatatypeValidator = datatypeValidator; } inline void XMLAttr::setType(const XMLAttDef::AttTypes newValue) { fType = newValue; } inline void XMLAttr::setSpecified(const bool newValue) { fSpecified = newValue; } inline void XMLAttr::setDatatypeValidator(DatatypeValidator *datatypeValidator) { fDatatypeValidator = datatypeValidator; } inline void XMLAttr::setSchemaValidated(const bool isSchema) { fIsSchemaValidated = isSchema; } XERCES_CPP_NAMESPACE_END #endif