| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * Copyright (c) 1999 The Apache Software Foundation. All rights |
| * reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. The end-user documentation included with the redistribution, |
| * if any, must include the following acknowledgment: |
| * "This product includes software developed by the |
| * Apache Software Foundation (http://www.apache.org/)." |
| * Alternately, this acknowledgment may appear in the software itself, |
| * if and wherever such third-party acknowledgments normally appear. |
| * |
| * 4. The names "Xerces" and "Apache Software Foundation" must |
| * not be used to endorse or promote products derived from this |
| * software without prior written permission. For written |
| * permission, please contact apache\@apache.org. |
| * |
| * 5. Products derived from this software may not be called "Apache", |
| * nor may "Apache" appear in their name, without prior written |
| * permission of the Apache Software Foundation. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
| * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation, and was |
| * originally based on software copyright (c) 1999, International |
| * Business Machines, Inc., http://www.ibm.com . For more information |
| * on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| |
| /** |
| * $Log$ |
| * Revision 1.1 1999/11/09 01:08:38 twl |
| * Initial revision |
| * |
| * Revision 1.4 1999/11/08 20:44:41 rahul |
| * Swat for adding in Product name and CVS comment log variable. |
| * |
| */ |
| |
| |
| #if !defined(XMLVALIDATOR_HPP) |
| #define XMLVALIDATOR_HPP |
| |
| #include <util/XML4CDefs.hpp> |
| #include <util/XMLEnumerator.hpp> |
| #include <util/RefHashTableOf.hpp> |
| #include <framework/XMLAttr.hpp> |
| #include <framework/XMLValidityCodes.hpp> |
| #include <framework/XMLRefInfo.hpp> |
| |
| class ReaderMgr; |
| class XMLBuffer; |
| class XMLBufferMgr; |
| class XMLElementDecl; |
| class XMLEntityDecl; |
| class XMLEntityHandler; |
| class XMLErrorReporter; |
| class XMLNotationDecl; |
| class XMLMsgLoader; |
| class XMLScanner; |
| |
| |
| // |
| // This abstract class provides the interface for all validators. This is |
| // the simple amount of API that all validators must honor, in order for |
| // the scanner to use them to do validation. All validators will actually |
| // contain much more functionality than is accessible via this common API, |
| // but that functionality requires that you know what type of validator you |
| // are dealing with. |
| // |
| // Basically, at this level, the primary concern is to be able to query |
| // core information about elements and attributes. Adding decls to the |
| // validator requires that you go through the derived interface because they |
| // all have their own decl types. At this level, we can return information |
| // via the base decl classes, from which each validator derives its own |
| // decl classes. |
| // |
| |
| class XMLPARSER_EXPORT XMLValidator |
| { |
| public: |
| // ----------------------------------------------------------------------- |
| // Class specific types |
| // ----------------------------------------------------------------------- |
| enum Constants |
| { |
| Success = -1 |
| , BadParent = -2 |
| , BadChild = -3 |
| }; |
| |
| |
| enum LookupOpts |
| { |
| AddIfNotFound |
| , FailIfNotFound |
| }; |
| |
| |
| // ----------------------------------------------------------------------- |
| // Constructors are hidden, just the virtual destructor is exposed |
| // ----------------------------------------------------------------------- |
| virtual ~XMLValidator() |
| { |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Getter methods |
| // ----------------------------------------------------------------------- |
| unsigned int getEmptyNamespaceId() const; |
| unsigned int getGlobalNamespaceId() const; |
| unsigned int getUnknownNamespaceId() const; |
| unsigned int getXMLNamespaceId() const; |
| unsigned int getXMLNSNamespaceId() const; |
| |
| |
| // ----------------------------------------------------------------------- |
| // Setter methods |
| // |
| // setScannerInfo() is called by the scanner to tell the validator |
| // about the stuff it needs to have access to. |
| // ----------------------------------------------------------------------- |
| void setScannerInfo |
| ( |
| XMLScanner* const owningScanner |
| , ReaderMgr* const readerMgr |
| , XMLBufferMgr* const bufMgr |
| ); |
| |
| void setErrorReporter |
| ( |
| XMLErrorReporter* const errorReporter |
| ); |
| |
| |
| // ----------------------------------------------------------------------- |
| // The virtual validator interface |
| // ----------------------------------------------------------------------- |
| virtual int addOrFindNSId |
| ( |
| const XMLCh* const uriText |
| ) = 0; |
| |
| virtual int checkContent |
| ( |
| const unsigned int elemId |
| , const unsigned int* childIds |
| , const unsigned int childCount |
| ) = 0; |
| |
| virtual bool checkRootElement |
| ( |
| const unsigned int elemId |
| ) = 0; |
| |
| virtual void faultInAttr |
| ( |
| XMLAttr& toFill |
| , const XMLAttDef& attDef |
| ) const = 0; |
| |
| virtual const XMLElementDecl* findElemDecl |
| ( |
| const unsigned int uriId |
| , const XMLCh* const baseName |
| , const XMLCh* const qName |
| , const LookupOpts options |
| , bool& wasAdded |
| ) const = 0; |
| |
| virtual XMLElementDecl* findElemDecl |
| ( |
| const unsigned int uriId |
| , const XMLCh* const baseName |
| , const XMLCh* const qName |
| , const LookupOpts options |
| , bool& wasAdded |
| ) = 0; |
| |
| virtual const XMLEntityDecl* findEntityDecl |
| ( |
| const XMLCh* const entName |
| , const bool isPE |
| ) const = 0; |
| |
| virtual XMLEntityDecl* findEntityDecl |
| ( |
| const XMLCh* const entName |
| , const bool isPE |
| ) = 0; |
| |
| virtual unsigned int findElemId |
| ( |
| const unsigned int uriId |
| , const XMLCh* const baseName |
| , const XMLCh* const qName |
| ) const = 0; |
| |
| virtual const XMLNotationDecl* findNotationDecl |
| ( |
| const XMLCh* const notName |
| ) const = 0; |
| |
| virtual XMLNotationDecl* findNotationDecl |
| ( |
| const XMLCh* const notName |
| ) = 0; |
| |
| virtual unsigned int findNSId |
| ( |
| const XMLCh* const nsName |
| ) const = 0; |
| |
| virtual const XMLElementDecl* getElemDecl |
| ( |
| const unsigned int elemId |
| ) const = 0; |
| |
| virtual XMLElementDecl* getElemDecl |
| ( |
| const unsigned int elemId |
| ) = 0; |
| |
| virtual bool getURIText |
| ( |
| const unsigned int uriId |
| , XMLBuffer& uriBufToFill |
| ) const = 0; |
| |
| virtual void postParseValidation() = 0; |
| |
| virtual void reset() = 0; |
| |
| virtual bool requiresNamespaces() const = 0; |
| |
| virtual void validateAttrValue |
| ( |
| const XMLAttDef& attDef |
| , const XMLCh* const attrValue |
| ) = 0; |
| |
| |
| // ----------------------------------------------------------------------- |
| // Virtual DTD handler interface. If handlesDTD() returns true, then |
| // scanDTD() will be called when a DOCTYPE is seen. |
| // ----------------------------------------------------------------------- |
| virtual bool handlesDTD() const = 0; |
| virtual void scanDTD(const bool reuseValidator) = 0; |
| |
| |
| // ----------------------------------------------------------------------- |
| // Error emitter methods |
| // ----------------------------------------------------------------------- |
| void emitError(const XML4CValid::Codes toEmit); |
| void emitError |
| ( |
| const XML4CValid::Codes toEmit |
| , const XMLCh* const text1 |
| , const XMLCh* const text2 = 0 |
| , const XMLCh* const text3 = 0 |
| , const XMLCh* const text4 = 0 |
| ); |
| void emitError |
| ( |
| const XML4CValid::Codes toEmit |
| , const char* const text1 |
| , const char* const text2 = 0 |
| , const char* const text3 = 0 |
| , const char* const text4 = 0 |
| ); |
| |
| |
| |
| protected : |
| // ----------------------------------------------------------------------- |
| // Hidden constructors |
| // ----------------------------------------------------------------------- |
| XMLValidator |
| ( |
| XMLErrorReporter* const errReporter = 0 |
| ); |
| |
| |
| // ----------------------------------------------------------------------- |
| // Protected getters |
| // ----------------------------------------------------------------------- |
| const XMLBufferMgr* getBufMgr() const; |
| XMLBufferMgr* getBufMgr(); |
| const ReaderMgr* getReaderMgr() const; |
| ReaderMgr* getReaderMgr(); |
| const XMLScanner* getScanner() const; |
| XMLScanner* getScanner(); |
| |
| |
| // ----------------------------------------------------------------------- |
| // Protected methods |
| // ----------------------------------------------------------------------- |
| void setBaseFields |
| ( |
| const unsigned int emptyNamespaceId |
| , const unsigned int globalNamespaceId |
| , const unsigned int unknownNamespaceId |
| , const unsigned int xmlNamespaceId |
| , const unsigned int xmlNSNamespaceId |
| ); |
| |
| |
| private : |
| // ----------------------------------------------------------------------- |
| // Unimplemented Constructors and Operators |
| // ----------------------------------------------------------------------- |
| XMLValidator(const XMLValidator&); |
| void operator=(const XMLValidator&); |
| |
| |
| // ----------------------------------------------------------------------- |
| // Private data members |
| // |
| // fEmptyNamespaceId |
| // This is the id of the empty namespace URI. This is a special one |
| // because of the xmlns="" type of deal. We have to quickly sense |
| // that its the empty namespace. |
| // |
| // fErrorReporter |
| // The error reporter we are to use, if any. |
| // |
| // fGlobalNamespaceId |
| // This is the id of the namespace URI which is assigned to the |
| // global namespace. Its for debug purposes only, since there is no |
| // real global namespace URI. Its set by the derived class. |
| // |
| // fUnknownNamespaceId |
| // This is the id of the namespace URI which is assigned to the |
| // global namespace. Its for debug purposes only, since there is no |
| // real global namespace URI. Its set by the derived class. |
| // |
| // fXMLNamespaceId |
| // fXMLNSNamespaceId |
| // These are the ids of the namespace URIs which are assigned to the |
| // 'xml' and 'xmlns' special prefixes. The former is officially |
| // defined but the latter is not, so we just provide one for debug |
| // purposes. |
| // ----------------------------------------------------------------------- |
| XMLBufferMgr* fBufMgr; |
| unsigned int fEmptyNamespaceId; |
| XMLErrorReporter* fErrorReporter; |
| unsigned int fGlobalNamespaceId; |
| ReaderMgr* fReaderMgr; |
| XMLScanner* fScanner; |
| unsigned int fUnknownNamespaceId; |
| unsigned int fXMLNamespaceId; |
| unsigned int fXMLNSNamespaceId; |
| |
| }; |
| |
| |
| // --------------------------------------------------------------------------- |
| // XMLValidator: Getter methods |
| // --------------------------------------------------------------------------- |
| inline unsigned int XMLValidator::getEmptyNamespaceId() const |
| { |
| return fEmptyNamespaceId; |
| } |
| |
| inline unsigned int XMLValidator::getGlobalNamespaceId() const |
| { |
| return fGlobalNamespaceId; |
| } |
| |
| inline unsigned int XMLValidator::getUnknownNamespaceId() const |
| { |
| return fUnknownNamespaceId; |
| } |
| |
| inline unsigned int XMLValidator::getXMLNamespaceId() const |
| { |
| return fXMLNamespaceId; |
| } |
| |
| inline unsigned int XMLValidator::getXMLNSNamespaceId() const |
| { |
| return fXMLNSNamespaceId; |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Setter methods |
| // ----------------------------------------------------------------------- |
| inline void |
| XMLValidator::setScannerInfo(XMLScanner* const owningScanner |
| , ReaderMgr* const readerMgr |
| , XMLBufferMgr* const bufMgr) |
| { |
| // We don't own any of these, we just reference them |
| fScanner = owningScanner; |
| fReaderMgr = readerMgr; |
| fBufMgr = bufMgr; |
| } |
| |
| inline void |
| XMLValidator::setErrorReporter(XMLErrorReporter* const errorReporter) |
| { |
| fErrorReporter = errorReporter; |
| } |
| |
| |
| // --------------------------------------------------------------------------- |
| // XMLValidator: Protected getter |
| // --------------------------------------------------------------------------- |
| inline const XMLBufferMgr* XMLValidator::getBufMgr() const |
| { |
| return fBufMgr; |
| } |
| |
| inline XMLBufferMgr* XMLValidator::getBufMgr() |
| { |
| return fBufMgr; |
| } |
| |
| inline const ReaderMgr* XMLValidator::getReaderMgr() const |
| { |
| return fReaderMgr; |
| } |
| |
| inline ReaderMgr* XMLValidator::getReaderMgr() |
| { |
| return fReaderMgr; |
| } |
| |
| inline const XMLScanner* XMLValidator::getScanner() const |
| { |
| return fScanner; |
| } |
| |
| inline XMLScanner* XMLValidator::getScanner() |
| { |
| return fScanner; |
| } |
| |
| |
| // --------------------------------------------------------------------------- |
| // XMLValidator: Protected methods |
| // --------------------------------------------------------------------------- |
| inline void |
| XMLValidator::setBaseFields(const unsigned int emptyNamespaceId |
| , const unsigned int globalNamespaceId |
| , const unsigned int unknownNamespaceId |
| , const unsigned int xmlNamespaceId |
| , const unsigned int xmlNSNamespaceId) |
| { |
| fEmptyNamespaceId = emptyNamespaceId; |
| fGlobalNamespaceId = globalNamespaceId; |
| fUnknownNamespaceId = unknownNamespaceId; |
| fXMLNamespaceId = xmlNamespaceId; |
| fXMLNSNamespaceId = xmlNSNamespaceId; |
| } |
| |
| #endif |
