/* * 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: SchemaValidator.hpp 568078 2007-08-21 11:43:25Z amassari $ */ #if !defined(SCHEMAVALIDATOR_HPP) #define SCHEMAVALIDATOR_HPP #include #include #include #include #include #include XERCES_CPP_NAMESPACE_BEGIN class GrammarResolver; class DatatypeValidator; class SchemaElementDecl; // // This is a derivative of the abstract validator interface. This class // implements a validator that supports standard XML Schema semantics. // This class handles scanning the of the schema, and provides // the standard validation services against the Schema info it found. // class VALIDATORS_EXPORT SchemaValidator : public XMLValidator { public: // ----------------------------------------------------------------------- // Constructors and Destructor // ----------------------------------------------------------------------- SchemaValidator ( XMLErrorReporter* const errReporter = 0 , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); virtual ~SchemaValidator(); // ----------------------------------------------------------------------- // Implementation of the XMLValidator interface // ----------------------------------------------------------------------- virtual int checkContent ( XMLElementDecl* const elemDecl , QName** const children , const unsigned int childCount ); virtual void faultInAttr ( XMLAttr& toFill , const XMLAttDef& attDef ) const; virtual void preContentValidation(bool reuseGrammar, bool validateDefAttr = false); virtual void postParseValidation(); virtual void reset(); virtual bool requiresNamespaces() const; virtual void validateAttrValue ( const XMLAttDef* attDef , const XMLCh* const attrValue , bool preValidation = false , const XMLElementDecl* elemDecl = 0 ); virtual void validateElement ( const XMLElementDecl* elemDef ); virtual Grammar* getGrammar() const; virtual void setGrammar(Grammar* aGrammar); // ----------------------------------------------------------------------- // Virtual DTD handler interface. // ----------------------------------------------------------------------- virtual bool handlesDTD() const; // ----------------------------------------------------------------------- // Virtual Schema handler interface. handlesSchema() always return false. // ----------------------------------------------------------------------- virtual bool handlesSchema() const; // ----------------------------------------------------------------------- // Schema Validator methods // ----------------------------------------------------------------------- void normalizeWhiteSpace(DatatypeValidator* dV, const XMLCh* const value, XMLBuffer& toFill); // ----------------------------------------------------------------------- // Setter methods // ----------------------------------------------------------------------- void setGrammarResolver(GrammarResolver* grammarResolver); void setXsiType(const XMLCh* const prefix , const XMLCh* const localPart , const unsigned int uriId); void setNillable(bool isNil); void setErrorReporter(XMLErrorReporter* const errorReporter); void setExitOnFirstFatal(const bool newValue); void setDatatypeBuffer(const XMLCh* const value); void clearDatatypeBuffer(); // ----------------------------------------------------------------------- // Getter methods // ----------------------------------------------------------------------- ComplexTypeInfo* getCurrentTypeInfo() const; DatatypeValidator *getCurrentDatatypeValidator() const; DatatypeValidator *getMostRecentAttrValidator() const; bool getErrorOccurred() const; bool getIsElemSpecified() const; const XMLCh* getNormalizedValue() const; private: // ----------------------------------------------------------------------- // Unimplemented constructors and operators // ----------------------------------------------------------------------- SchemaValidator(const SchemaValidator&); SchemaValidator& operator=(const SchemaValidator&); // ----------------------------------------------------------------------- // Element Consitency Checking methods // ----------------------------------------------------------------------- void checkRefElementConsistency(SchemaGrammar* const currentGrammar, const ComplexTypeInfo* const curTypeInfo, const XercesGroupInfo* const curGroup = 0); // ----------------------------------------------------------------------- // Particle Derivation Checking methods // ----------------------------------------------------------------------- void checkParticleDerivation(SchemaGrammar* const currentGrammar, const ComplexTypeInfo* const typeInfo); void checkParticleDerivationOk(SchemaGrammar* const currentGrammar, ContentSpecNode* const curNode, const int derivedScope, ContentSpecNode* const baseNode, const int baseScope, const ComplexTypeInfo* const baseInfo = 0, const bool toCheckOccurrence = true); ContentSpecNode* checkForPointlessOccurrences(ContentSpecNode* const specNode, const ContentSpecNode::NodeTypes nodeType, ValueVectorOf* const nodes); void gatherChildren(const ContentSpecNode::NodeTypes parentNodeType, ContentSpecNode* const specNode, ValueVectorOf* const nodes); bool isOccurrenceRangeOK(const int min1, const int max1, const int min2, const int max2); void checkNSCompat(const ContentSpecNode* const derivedSpecNode, const ContentSpecNode* const baseSpecNode, const bool toCheckOccurence); bool wildcardEltAllowsNamespace(const ContentSpecNode* const baseSpecNode, const unsigned int derivedURI); void checkNameAndTypeOK(SchemaGrammar* const currentGrammar, const ContentSpecNode* const derivedSpecNode, const int derivedScope, const ContentSpecNode* const baseSpecNode, const int baseScope, const ComplexTypeInfo* const baseInfo = 0); SchemaElementDecl* findElement(const int scope, const unsigned int uriIndex, const XMLCh* const name, SchemaGrammar* const grammar, const ComplexTypeInfo* const typeInfo = 0); void checkICRestriction(const SchemaElementDecl* const derivedElemDecl, const SchemaElementDecl* const baseElemDecl, const XMLCh* const derivedElemName, const XMLCh* const baseElemName); void checkTypesOK(const SchemaElementDecl* const derivedElemDecl, const SchemaElementDecl* const baseElemDecl, const XMLCh* const derivedElemName); void checkRecurseAsIfGroup(SchemaGrammar* const currentGrammar, ContentSpecNode* const derivedSpecNode, const int derivedScope, const ContentSpecNode* const baseSpecNode, const int baseScope, ValueVectorOf* const nodes, const ComplexTypeInfo* const baseInfo); void checkRecurse(SchemaGrammar* const currentGrammar, const ContentSpecNode* const derivedSpecNode, const int derivedScope, ValueVectorOf* const derivedNodes, const ContentSpecNode* const baseSpecNode, const int baseScope, ValueVectorOf* const baseNodes, const ComplexTypeInfo* const baseInfo, const bool toLax = false); void checkNSSubset(const ContentSpecNode* const derivedSpecNode, const ContentSpecNode* const baseSpecNode); bool isWildCardEltSubset(const ContentSpecNode* const derivedSpecNode, const ContentSpecNode* const baseSpecNode); void checkNSRecurseCheckCardinality(SchemaGrammar* const currentGrammar, const ContentSpecNode* const derivedSpecNode, ValueVectorOf* const derivedNodes, const int derivedScope, ContentSpecNode* const baseSpecNode, const bool toCheckOccurence); void checkRecurseUnordered(SchemaGrammar* const currentGrammar, const ContentSpecNode* const derivedSpecNode, ValueVectorOf* const derivedNodes, const int derivedScope, ContentSpecNode* const baseSpecNode, ValueVectorOf* const baseNodes, const int baseScope, const ComplexTypeInfo* const baseInfo); void checkMapAndSum(SchemaGrammar* const currentGrammar, const ContentSpecNode* const derivedSpecNode, ValueVectorOf* const derivedNodes, const int derivedScope, ContentSpecNode* const baseSpecNode, ValueVectorOf* const baseNodes, const int baseScope, const ComplexTypeInfo* const baseInfo); ContentSpecNode* getNonUnaryGroup(ContentSpecNode* const pNode); // ----------------------------------------------------------------------- // Private data members // // ----------------------------------------------------------------------- // The following comes from or set by the Scanner // fSchemaGrammar // The current schema grammar used by the validator // // fGrammarResolver // All the schema grammar stored // // fXsiType // Store the Schema Type Attribute Value if schema type is specified // // fNil // Indicates if Nillable has been set // ----------------------------------------------------------------------- // The following used internally in the validator // // fCurrentDatatypeValidator // The validator used for validating the content of elements // with simple types // // fDatatypeBuffer // Buffer for simple type element string content // // fTrailing // Previous chunk had a trailing space // // fSeenId // Indicate if an attribute of ID type has been seen already, reset per element. // // fSchemaErrorReporter // Report schema process errors // // fTypeStack // Stack of complex type declarations. // // fMostRecentAttrValidator // DatatypeValidator that validated attribute most recently processed // // fErrorOccurred // whether an error occurred in the most recent operation // ----------------------------------------------------------------------- MemoryManager* fMemoryManager; SchemaGrammar* fSchemaGrammar; GrammarResolver* fGrammarResolver; QName* fXsiType; bool fNil; DatatypeValidator* fCurrentDatatypeValidator; XMLBuffer* fNotationBuf; XMLBuffer fDatatypeBuffer; bool fTrailing; bool fSeenId; XSDErrorReporter fSchemaErrorReporter; ValueStackOf* fTypeStack; DatatypeValidator * fMostRecentAttrValidator; bool fErrorOccurred; bool fElemIsSpecified; }; // --------------------------------------------------------------------------- // SchemaValidator: Setter methods // --------------------------------------------------------------------------- inline void SchemaValidator::setGrammarResolver(GrammarResolver* grammarResolver) { fGrammarResolver = grammarResolver; } inline void SchemaValidator::setXsiType(const XMLCh* const prefix , const XMLCh* const localPart , const unsigned int uriId) { delete fXsiType; fXsiType = new (fMemoryManager) QName(prefix, localPart, uriId, fMemoryManager); } inline void SchemaValidator::setNillable(bool isNil) { fNil = isNil; } inline void SchemaValidator::setExitOnFirstFatal(const bool newValue) { fSchemaErrorReporter.setExitOnFirstFatal(newValue); } inline void SchemaValidator::setDatatypeBuffer(const XMLCh* const value) { fDatatypeBuffer.append(value); } inline void SchemaValidator::clearDatatypeBuffer() { fDatatypeBuffer.reset(); } // --------------------------------------------------------------------------- // SchemaValidator: Getter methods // --------------------------------------------------------------------------- inline ComplexTypeInfo* SchemaValidator::getCurrentTypeInfo() const { if (fTypeStack->empty()) return 0; return fTypeStack->peek(); } inline DatatypeValidator * SchemaValidator::getCurrentDatatypeValidator() const { return fCurrentDatatypeValidator; } inline DatatypeValidator *SchemaValidator::getMostRecentAttrValidator() const { return fMostRecentAttrValidator; } // --------------------------------------------------------------------------- // Virtual interface // --------------------------------------------------------------------------- inline Grammar* SchemaValidator::getGrammar() const { return fSchemaGrammar; } inline void SchemaValidator::setGrammar(Grammar* aGrammar) { fSchemaGrammar = (SchemaGrammar*) aGrammar; } inline void SchemaValidator::setErrorReporter(XMLErrorReporter* const errorReporter) { XMLValidator::setErrorReporter(errorReporter); fSchemaErrorReporter.setErrorReporter(errorReporter); } // --------------------------------------------------------------------------- // SchemaValidator: DTD handler interface // --------------------------------------------------------------------------- inline bool SchemaValidator::handlesDTD() const { // No DTD scanning return false; } // --------------------------------------------------------------------------- // SchemaValidator: Schema handler interface // --------------------------------------------------------------------------- inline bool SchemaValidator::handlesSchema() const { return true; } // --------------------------------------------------------------------------- // SchemaValidator: Particle derivation checking // --------------------------------------------------------------------------- inline bool SchemaValidator::isOccurrenceRangeOK(const int min1, const int max1, const int min2, const int max2) { if (min1 >= min2 && (max2 == SchemaSymbols::XSD_UNBOUNDED || (max1 != SchemaSymbols::XSD_UNBOUNDED && max1 <= max2))) { return true; } return false; } inline bool SchemaValidator::getErrorOccurred() const { return fErrorOccurred; } inline bool SchemaValidator::getIsElemSpecified() const { return fElemIsSpecified; } inline const XMLCh* SchemaValidator::getNormalizedValue() const { return fDatatypeBuffer.getRawBuffer(); } XERCES_CPP_NAMESPACE_END #endif