| /* |
| * 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 <xercesc/framework/XMLValidator.hpp> |
| #include <xercesc/framework/XMLBuffer.hpp> |
| #include <xercesc/util/ValueStackOf.hpp> |
| #include <xercesc/validators/common/ContentSpecNode.hpp> |
| #include <xercesc/validators/schema/SchemaGrammar.hpp> |
| #include <xercesc/validators/schema/XSDErrorReporter.hpp> |
| |
| 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<ContentSpecNode*>* const nodes); |
| void gatherChildren(const ContentSpecNode::NodeTypes parentNodeType, |
| ContentSpecNode* const specNode, |
| ValueVectorOf<ContentSpecNode*>* 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<ContentSpecNode*>* const nodes, |
| const ComplexTypeInfo* const baseInfo); |
| void checkRecurse(SchemaGrammar* const currentGrammar, |
| const ContentSpecNode* const derivedSpecNode, |
| const int derivedScope, |
| ValueVectorOf<ContentSpecNode*>* const derivedNodes, |
| const ContentSpecNode* const baseSpecNode, |
| const int baseScope, |
| ValueVectorOf<ContentSpecNode*>* 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<ContentSpecNode*>* const derivedNodes, |
| const int derivedScope, |
| ContentSpecNode* const baseSpecNode, |
| const bool toCheckOccurence); |
| void checkRecurseUnordered(SchemaGrammar* const currentGrammar, |
| const ContentSpecNode* const derivedSpecNode, |
| ValueVectorOf<ContentSpecNode*>* const derivedNodes, |
| const int derivedScope, |
| ContentSpecNode* const baseSpecNode, |
| ValueVectorOf<ContentSpecNode*>* const baseNodes, |
| const int baseScope, |
| const ComplexTypeInfo* const baseInfo); |
| void checkMapAndSum(SchemaGrammar* const currentGrammar, |
| const ContentSpecNode* const derivedSpecNode, |
| ValueVectorOf<ContentSpecNode*>* const derivedNodes, |
| const int derivedScope, |
| ContentSpecNode* const baseSpecNode, |
| ValueVectorOf<ContentSpecNode*>* 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<ComplexTypeInfo*>* 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 |
