/* * 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: DatatypeValidator.hpp 568078 2007-08-21 11:43:25Z amassari $ */ #if !defined(DATATYPEVALIDATOR_HPP) #define DATATYPEVALIDATOR_HPP #include #include #include #include #include #include #include #include #include XERCES_CPP_NAMESPACE_BEGIN class MemoryManager; /** * DataTypeValidator defines the interface that data type validators must * obey. These validators can be supplied by the application writer and may * be useful as standalone code as well as plugins to the validator * architecture. * * Notice: * The datatype validator will own the facets hashtable passed to it during * construction, which means that the datatype validator will be responsible * for the deletion. The facets hashtable will be created during parsing and * passed to the appropriate datatype validator which in turn will delete it * upon its destruction. * */ class VALIDATORS_EXPORT DatatypeValidator : public XSerializable, public XMemory { public: // ----------------------------------------------------------------------- // Constant data // ----------------------------------------------------------------------- //facets enum { FACET_LENGTH = 1, FACET_MINLENGTH = 1<<1, FACET_MAXLENGTH = 1<<2, FACET_PATTERN = 1<<3, FACET_ENUMERATION = 1<<4, FACET_MAXINCLUSIVE = 1<<5, FACET_MAXEXCLUSIVE = 1<<6, FACET_MININCLUSIVE = 1<<7, FACET_MINEXCLUSIVE = 1<<8, FACET_TOTALDIGITS = 1<<9, FACET_FRACTIONDIGITS = 1<<10, FACET_ENCODING = 1<<11, FACET_DURATION = 1<<12, FACET_PERIOD = 1<<13, FACET_WHITESPACE = 1<<14 }; //2.4.2.6 whiteSpace - Datatypes enum { PRESERVE = 0, REPLACE = 1, COLLAPSE = 2 }; enum ValidatorType { String, AnyURI, QName, Name, NCName, Boolean, Float, Double, Decimal, HexBinary, Base64Binary, Duration, DateTime, Date, Time, MonthDay, YearMonth, Year, Month, Day, ID, IDREF, ENTITY, NOTATION, List, Union, AnySimpleType, UnKnown }; // ----------------------------------------------------------------------- // Public Destructor // ----------------------------------------------------------------------- /** @name Destructor. */ //@{ virtual ~DatatypeValidator(); //@} // ----------------------------------------------------------------------- // Getter methods // ----------------------------------------------------------------------- /** @name Getter Functions */ //@{ /** * Returns the final values of the simpleType */ int getFinalSet() const; /** * Returns the datatype facet if any is set. */ RefHashTableOf* getFacets() const; /** * Returns default value (collapse) for whiteSpace facet. * This function is overwritten in StringDatatypeValidator. */ short getWSFacet () const; /** * Returns the base datatype validator if set. */ DatatypeValidator* getBaseValidator() const; /** * Returns the 'class' type of datatype validator */ ValidatorType getType() const; /** * Returns whether the type is atomic or not * * To be redefined in List/Union validators */ virtual bool isAtomic() const; /** * Returns the datatype enumeration if any is set. * Derived class shall provide their own copy. */ virtual const RefArrayVectorOf* getEnumString() const = 0; /** * returns true if this type is anonymous **/ bool getAnonymous() const; /** * sets this type to be anonymous **/ void setAnonymous(); /** * Fundamental Facet: ordered */ XSSimpleTypeDefinition::ORDERING getOrdered() const; /** * Fundamental Facet: cardinality. */ bool getFinite() const; /** * Fundamental Facet: bounded. */ bool getBounded() const; /** * Fundamental Facet: numeric. */ bool getNumeric() const; /** * Canonical Representation * * Derivative datatype may overwrite this method once * it has its own canonical representation other than * the default one. * * @param rawData: data in raw string * @param memMgr: memory manager * @param toValiate: to validate the raw string or not * * @return: canonical representation of the data * * Note: * * 1. the return value is kept in memory allocated * by the memory manager passed in or by dv's * if no memory manager is provided. * * 2. client application is responsible for the * proper deallcation of the memory allocated * for the returned value. * * 3. In the case where the rawData is not valid * with regards to the fundamental datatype, * a null string is returned. * */ virtual const XMLCh* getCanonicalRepresentation ( const XMLCh* const rawData , MemoryManager* const memMgr = 0 , bool toValidate = false ) const; //@} // ----------------------------------------------------------------------- // Validation methods // ----------------------------------------------------------------------- /** @name Validation Function */ //@{ /** * Checks that the "content" string is valid datatype. * If invalid, a Datatype validation exception is thrown. * * @param content A string containing the content to be validated * */ virtual void validate ( const XMLCh* const content , ValidationContext* const context = 0 , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ) = 0; /** * Checks whether a given type can be used as a substitute * * @param toCheck A datatype validator of the type to be used as a * substitute * * To be redefined in UnionDatatypeValidator */ virtual bool isSubstitutableBy(const DatatypeValidator* const toCheck); //@} // ----------------------------------------------------------------------- // Compare methods // ----------------------------------------------------------------------- /** @name Compare Function */ //@{ /** * Compares content in the Domain value vs. lexical value. * * e.g. If type is a float then 1.0 may be equivalent to 1 even though * both are lexically different. * * @param value1 string to compare * * @param value2 string to compare * * We will provide a default behavior that should be redefined at the * children level, if necessary (i.e. boolean case). */ virtual int compare(const XMLCh* const value1, const XMLCh* const value2 , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); //@} /** * Returns an instance of the base datatype validator class * Used by the DatatypeValidatorFactory. */ virtual DatatypeValidator* newInstance ( RefHashTableOf* const facets , RefArrayVectorOf* const enums , const int finalSet , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ) = 0; /** * Returns the uri,name of the type this validator is for */ const XMLCh* getTypeName() const; /** * sets the uri,name that this validator is for - typeName is uri,name string. * due to the internals of xerces this will set the uri to be the schema uri if * there is no comma in typeName */ void setTypeName(const XMLCh* const typeName); /** * sets the uri,name that this validator is for */ void setTypeName(const XMLCh* const name, const XMLCh* const uri); /** * Returns the uri of the type this validator is for */ const XMLCh* getTypeUri() const; /** * Returns the name of the type this validator is for */ const XMLCh* getTypeLocalName() const; /** * Returns the plugged-in memory manager */ MemoryManager* getMemoryManager() const; /*** * Support for Serialization/De-serialization ***/ DECL_XSERIALIZABLE(DatatypeValidator) /*** * * Serialzie DatatypeValidator derivative * * Param * serEng: serialize engine * dv: DatatypeValidator derivative * * Return: * ***/ static void storeDV(XSerializeEngine& serEng , DatatypeValidator* const dv); /*** * * Create a DatatypeValidator derivative from the binary * stream. * * Param * serEng: serialize engine * * Return: * DatatypeValidator derivative * ***/ static DatatypeValidator* loadDV(XSerializeEngine& serEng); protected: // ----------------------------------------------------------------------- // Protected Constructors // ----------------------------------------------------------------------- /** @name Constructors */ //@{ /** * * @param baseValidator The base datatype validator for derived * validators. Null if native validator. * * @param facets A hashtable of datatype facets (except enum). * * @param finalSet 'final' value of the simpleType */ DatatypeValidator(DatatypeValidator* const baseValidator, RefHashTableOf* const facets, const int finalSet, const ValidatorType type, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager); //@} friend class DatatypeValidatorFactory; friend class XSObjectFactory; /** * facetDefined */ int getFacetsDefined() const; void setFacetsDefined(int); /** * fixed */ int getFixed() const; void setFixed(int); /** * fPattern */ const XMLCh* getPattern() const; void setPattern(const XMLCh* ); /** * fRegex */ RegularExpression* getRegex() const; void setRegex(RegularExpression* const); /** * set fType */ void setType(ValidatorType); /** * set fWhiteSpace */ void setWhiteSpace(short); /** * get WSString */ const XMLCh* getWSstring(const short WSType) const; /** * Fundamental Facet: ordered */ void setOrdered(XSSimpleTypeDefinition::ORDERING ordered); /** * Fundamental Facet: cardinality. */ void setFinite(bool finite); /** * Fundamental Facet: bounded. */ void setBounded(bool bounded); /** * Fundamental Facet: numeric. */ void setNumeric(bool numeric); private: // ----------------------------------------------------------------------- // CleanUp methods // ----------------------------------------------------------------------- void cleanUp(); // ----------------------------------------------------------------------- // Unimplemented constructors and operators // ----------------------------------------------------------------------- DatatypeValidator(const DatatypeValidator&); DatatypeValidator& operator=(const DatatypeValidator&); // ----------------------------------------------------------------------- // Private data members // // fFinalSet // stores "final" values of simpleTypes // // fBaseValidator // This is a pointer to a base datatype validator. If value is null, // it means we have a native datatype validator not a derived one. // // fFacets // This is a hashtable of dataype facets. // // fType // Stores the class type of datatype validator // // fFacetsDefined // Stores the constaiting facets flag // // fPattern // the pointer to the String of the pattern. The actual data is // in the Facets. // // fRegex // pointer to the RegularExpress object // // // fFixed // if {fixed} is true, then types for which this type is the // {base type definition} cannot specify a value for a specific // facet. // // fTypeName // the uri,name of the type this validator will validate // // fTypeLocalName // the name of the type this validator will validate // // fTypeUri // the uri of the type this validator will validate // fAnonymous // true if this type is anonynous // // ----------------------------------------------------------------------- bool fAnonymous; bool fFinite; bool fBounded; bool fNumeric; short fWhiteSpace; int fFinalSet; int fFacetsDefined; int fFixed; ValidatorType fType; XSSimpleTypeDefinition::ORDERING fOrdered; DatatypeValidator* fBaseValidator; RefHashTableOf* fFacets; XMLCh* fPattern; RegularExpression* fRegex; XMLCh* fTypeName; const XMLCh* fTypeLocalName; const XMLCh* fTypeUri; protected: // ----------------------------------------------------------------------- // Protected data members // // fMemoryManager // Pluggable memory manager for dynamic allocation/deallocation. // ----------------------------------------------------------------------- MemoryManager* fMemoryManager; }; // --------------------------------------------------------------------------- // DatatypeValidator: Getters // --------------------------------------------------------------------------- inline int DatatypeValidator::getFinalSet() const { return fFinalSet; } inline RefHashTableOf* DatatypeValidator::getFacets() const { return fFacets; } inline DatatypeValidator* DatatypeValidator::getBaseValidator() const { return fBaseValidator; } inline short DatatypeValidator::getWSFacet() const { return fWhiteSpace; } inline DatatypeValidator::ValidatorType DatatypeValidator::getType() const { return fType; } inline int DatatypeValidator::getFacetsDefined() const { return fFacetsDefined; } inline int DatatypeValidator::getFixed() const { return fFixed; } inline const XMLCh* DatatypeValidator::getPattern() const { return fPattern; } inline RegularExpression* DatatypeValidator::getRegex() const { return fRegex; } inline const XMLCh* DatatypeValidator::getTypeName() const { return fTypeName; } inline bool DatatypeValidator::getAnonymous() const { return fAnonymous; } inline const XMLCh* DatatypeValidator::getTypeLocalName() const { return fTypeLocalName; } inline const XMLCh* DatatypeValidator::getTypeUri() const { return fTypeUri; } inline MemoryManager* DatatypeValidator::getMemoryManager() const { return fMemoryManager; } inline XSSimpleTypeDefinition::ORDERING DatatypeValidator::getOrdered() const { return fOrdered; } inline bool DatatypeValidator::getFinite() const { return fFinite; } inline bool DatatypeValidator::getBounded() const { return fBounded; } inline bool DatatypeValidator::getNumeric() const { return fNumeric; } // --------------------------------------------------------------------------- // DatatypeValidator: Setters // --------------------------------------------------------------------------- inline void DatatypeValidator::setType(ValidatorType theType) { fType = theType; } inline void DatatypeValidator::setWhiteSpace(short newValue) { fWhiteSpace = newValue; } inline void DatatypeValidator::setFacetsDefined(int facets) { fFacetsDefined |= facets; } inline void DatatypeValidator::setFixed(int fixed) { fFixed |= fixed; } inline void DatatypeValidator::setPattern(const XMLCh* pattern) { if (fPattern) { fMemoryManager->deallocate(fPattern);//delete [] fPattern; delete fRegex; } fPattern = XMLString::replicate(pattern, fMemoryManager); fRegex = new (fMemoryManager) RegularExpression(fPattern, SchemaSymbols::fgRegEx_XOption, fMemoryManager); } inline void DatatypeValidator::setRegex(RegularExpression* const regex) { fRegex = regex; } inline bool DatatypeValidator::isAtomic() const { return true; } inline void DatatypeValidator::setAnonymous() { fAnonymous = true; } inline void DatatypeValidator::setOrdered(XSSimpleTypeDefinition::ORDERING ordered) { fOrdered = ordered; } inline void DatatypeValidator::setFinite(bool finite) { fFinite = finite; } inline void DatatypeValidator::setBounded(bool bounded) { fBounded = bounded; } inline void DatatypeValidator::setNumeric(bool numeric) { fNumeric = numeric; } // --------------------------------------------------------------------------- // DatatypeValidators: Compare methods // --------------------------------------------------------------------------- inline int DatatypeValidator::compare(const XMLCh* const lValue, const XMLCh* const rValue , MemoryManager* const) { return XMLString::compareString(lValue, rValue); } // --------------------------------------------------------------------------- // DatatypeValidators: Validation methods // --------------------------------------------------------------------------- inline bool DatatypeValidator::isSubstitutableBy(const DatatypeValidator* const toCheck) { const DatatypeValidator* dv = toCheck; while (dv != 0) { if (dv == this) { return true; } dv = dv->getBaseValidator(); } return false; } XERCES_CPP_NAMESPACE_END #endif /** * End of file DatatypeValidator.hpp */