| /* |
| * 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: SAX2XMLFilterImpl.cpp 568078 2007-08-21 11:43:25Z amassari $ |
| */ |
| |
| #include <xercesc/parsers/SAX2XMLFilterImpl.hpp> |
| |
| XERCES_CPP_NAMESPACE_BEGIN |
| |
| SAX2XMLFilterImpl::SAX2XMLFilterImpl(SAX2XMLReader* parent) : |
| fParentReader(0) |
| , fDocHandler(0) |
| , fDTDHandler(0) |
| , fEntityResolver(0) |
| , fErrorHandler(0) |
| { |
| setParent(parent); |
| } |
| |
| SAX2XMLFilterImpl::~SAX2XMLFilterImpl() |
| { |
| } |
| |
| // --------------------------------------------------------------------------- |
| // SAX2XMLFilterImpl: XMLFilter impl |
| // --------------------------------------------------------------------------- |
| void SAX2XMLFilterImpl::setParent(SAX2XMLReader* parent) |
| { |
| if(fParentReader) |
| { |
| fParentReader->setEntityResolver(0); |
| fParentReader->setDTDHandler(0); |
| fParentReader->setContentHandler(0); |
| fParentReader->setErrorHandler(0); |
| } |
| fParentReader=parent; |
| if(fParentReader) |
| { |
| fParentReader->setEntityResolver(this); |
| fParentReader->setDTDHandler(this); |
| fParentReader->setContentHandler(this); |
| fParentReader->setErrorHandler(this); |
| } |
| } |
| |
| bool SAX2XMLFilterImpl::getExitOnFirstFatalError() const |
| { |
| if(fParentReader) |
| fParentReader->getExitOnFirstFatalError(); |
| return false; |
| } |
| |
| bool SAX2XMLFilterImpl::getValidationConstraintFatal() const |
| { |
| if(fParentReader) |
| fParentReader->getValidationConstraintFatal(); |
| return false; |
| } |
| |
| Grammar* SAX2XMLFilterImpl::getRootGrammar() |
| { |
| if(fParentReader) |
| fParentReader->getRootGrammar(); |
| return NULL; |
| } |
| |
| const XMLCh* SAX2XMLFilterImpl::getURIText(unsigned int uriId) const |
| { |
| if(fParentReader) |
| fParentReader->getURIText(uriId); |
| return NULL; |
| } |
| |
| unsigned int SAX2XMLFilterImpl::getSrcOffset() const |
| { |
| if(fParentReader) |
| fParentReader->getSrcOffset(); |
| return 0; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // SAX2XMLFilterImpl Validator functions |
| // --------------------------------------------------------------------------- |
| void SAX2XMLFilterImpl::setValidator(XMLValidator* valueToAdopt) |
| { |
| if(fParentReader) |
| fParentReader->setValidator(valueToAdopt); |
| } |
| |
| XMLValidator* SAX2XMLFilterImpl::getValidator() const |
| { |
| if(fParentReader) |
| return fParentReader->getValidator(); |
| return 0; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // SAX2XMLReader Interface |
| // --------------------------------------------------------------------------- |
| int SAX2XMLFilterImpl::getErrorCount() const |
| { |
| if(fParentReader) |
| return fParentReader->getErrorCount(); |
| return 0; |
| } |
| |
| void SAX2XMLFilterImpl::setExitOnFirstFatalError(const bool newState) |
| { |
| if(fParentReader) |
| fParentReader->setExitOnFirstFatalError(newState); |
| } |
| |
| void SAX2XMLFilterImpl::setValidationConstraintFatal(const bool newState) |
| { |
| if(fParentReader) |
| fParentReader->setValidationConstraintFatal(newState); |
| } |
| |
| void SAX2XMLFilterImpl::parse (const InputSource& source) |
| { |
| if(fParentReader) |
| fParentReader->parse(source); |
| } |
| |
| void SAX2XMLFilterImpl::parse (const XMLCh* const systemId) |
| { |
| if(fParentReader) |
| fParentReader->parse(systemId); |
| } |
| |
| void SAX2XMLFilterImpl::parse (const char* const systemId) |
| { |
| if(fParentReader) |
| fParentReader->parse(systemId); |
| } |
| |
| // --------------------------------------------------------------------------- |
| // SAX2XMLFilterImpl: Progressive parse methods |
| // --------------------------------------------------------------------------- |
| bool SAX2XMLFilterImpl::parseFirst( const XMLCh* const systemId |
| , XMLPScanToken& toFill) |
| { |
| if(fParentReader) |
| return fParentReader->parseFirst(systemId, toFill); |
| return false; |
| } |
| |
| bool SAX2XMLFilterImpl::parseFirst( const char* const systemId |
| , XMLPScanToken& toFill) |
| { |
| if(fParentReader) |
| fParentReader->parseFirst(systemId, toFill); |
| return false; |
| } |
| |
| bool SAX2XMLFilterImpl::parseFirst( const InputSource& source |
| , XMLPScanToken& toFill) |
| { |
| if(fParentReader) |
| fParentReader->parseFirst(source, toFill); |
| return false; |
| } |
| |
| bool SAX2XMLFilterImpl::parseNext(XMLPScanToken& token) |
| { |
| if(fParentReader) |
| fParentReader->parseNext(token); |
| return false; |
| } |
| |
| void SAX2XMLFilterImpl::parseReset(XMLPScanToken& token) |
| { |
| if(fParentReader) |
| fParentReader->parseReset(token); |
| } |
| |
| // --------------------------------------------------------------------------- |
| // SAX2XMLFilterImpl: Features and Properties |
| // --------------------------------------------------------------------------- |
| |
| void SAX2XMLFilterImpl::setFeature(const XMLCh* const name, const bool value) |
| { |
| if(fParentReader) |
| fParentReader->setFeature(name,value); |
| } |
| |
| bool SAX2XMLFilterImpl::getFeature(const XMLCh* const name) const |
| { |
| if(fParentReader) |
| return fParentReader->getFeature(name); |
| return false; |
| } |
| |
| void SAX2XMLFilterImpl::setProperty(const XMLCh* const name, void* value) |
| { |
| if(fParentReader) |
| fParentReader->setProperty(name,value); |
| } |
| |
| void* SAX2XMLFilterImpl::getProperty(const XMLCh* const name) const |
| { |
| if(fParentReader) |
| return fParentReader->getProperty(name); |
| return NULL; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // SAX2XMLFilterImpl: Grammar preparsing |
| // --------------------------------------------------------------------------- |
| Grammar* SAX2XMLFilterImpl::loadGrammar(const char* const systemId, |
| const short grammarType, |
| const bool toCache) |
| { |
| if(fParentReader) |
| return fParentReader->loadGrammar(systemId, grammarType, toCache); |
| return NULL; |
| } |
| |
| Grammar* SAX2XMLFilterImpl::loadGrammar(const XMLCh* const systemId, |
| const short grammarType, |
| const bool toCache) |
| { |
| if(fParentReader) |
| return fParentReader->loadGrammar(systemId, grammarType, toCache); |
| return NULL; |
| } |
| |
| Grammar* SAX2XMLFilterImpl::loadGrammar(const InputSource& source, |
| const short grammarType, |
| const bool toCache) |
| { |
| if(fParentReader) |
| return fParentReader->loadGrammar(source, grammarType, toCache); |
| return NULL; |
| } |
| |
| void SAX2XMLFilterImpl::resetCachedGrammarPool() |
| { |
| if(fParentReader) |
| fParentReader->resetCachedGrammarPool(); |
| } |
| |
| void SAX2XMLFilterImpl::setInputBufferSize(const size_t bufferSize) |
| { |
| if(fParentReader) |
| fParentReader->setInputBufferSize(bufferSize); |
| } |
| |
| Grammar* SAX2XMLFilterImpl::getGrammar(const XMLCh* const nameSpaceKey) |
| { |
| if(fParentReader) |
| return fParentReader->getGrammar(nameSpaceKey); |
| return NULL; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Implementation of the EntityResolver interface |
| // ----------------------------------------------------------------------- |
| InputSource* SAX2XMLFilterImpl::resolveEntity(const XMLCh* const publicId |
| , const XMLCh* const systemId) |
| { |
| if(fEntityResolver) |
| return fEntityResolver->resolveEntity(publicId, systemId); |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Implementation of the DTDHandler interface |
| // ----------------------------------------------------------------------- |
| void SAX2XMLFilterImpl::notationDecl( const XMLCh* const name |
| , const XMLCh* const publicId |
| , const XMLCh* const systemId) |
| { |
| if(fDTDHandler) |
| fDTDHandler->notationDecl(name, publicId, systemId); |
| } |
| |
| void SAX2XMLFilterImpl::unparsedEntityDecl(const XMLCh* const name |
| , const XMLCh* const publicId |
| , const XMLCh* const systemId |
| , const XMLCh* const notationName) |
| { |
| if(fDTDHandler) |
| fDTDHandler->unparsedEntityDecl(name, publicId, systemId, notationName); |
| } |
| |
| void SAX2XMLFilterImpl::resetDocType() |
| { |
| if(fDTDHandler) |
| fDTDHandler->resetDocType(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Implementation of the ContentHandler interface |
| // ----------------------------------------------------------------------- |
| |
| void SAX2XMLFilterImpl::characters(const XMLCh* const chars |
| , const unsigned int length) |
| { |
| if(fDocHandler) |
| fDocHandler->characters(chars, length); |
| } |
| |
| void SAX2XMLFilterImpl::endDocument() |
| { |
| if(fDocHandler) |
| fDocHandler->endDocument(); |
| } |
| |
| void SAX2XMLFilterImpl::endElement(const XMLCh* const uri |
| , const XMLCh* const localname |
| , const XMLCh* const qname) |
| { |
| if(fDocHandler) |
| fDocHandler->endElement(uri, localname, qname); |
| } |
| |
| void SAX2XMLFilterImpl::ignorableWhitespace(const XMLCh* const chars |
| , const unsigned int length) |
| { |
| if(fDocHandler) |
| fDocHandler->ignorableWhitespace(chars, length); |
| } |
| |
| void SAX2XMLFilterImpl::processingInstruction(const XMLCh* const target |
| , const XMLCh* const data) |
| { |
| if(fDocHandler) |
| fDocHandler->processingInstruction(target, data); |
| } |
| |
| void SAX2XMLFilterImpl::setDocumentLocator(const Locator* const locator) |
| { |
| if(fDocHandler) |
| fDocHandler->setDocumentLocator(locator); |
| } |
| |
| void SAX2XMLFilterImpl::startDocument() |
| { |
| if(fDocHandler) |
| fDocHandler->startDocument(); |
| } |
| |
| void SAX2XMLFilterImpl::startElement(const XMLCh* const uri |
| , const XMLCh* const localname |
| , const XMLCh* const qname |
| , const Attributes& attrs) |
| { |
| if(fDocHandler) |
| fDocHandler->startElement(uri, localname, qname, attrs); |
| } |
| |
| void SAX2XMLFilterImpl::startPrefixMapping(const XMLCh* const prefix |
| , const XMLCh* const uri) |
| { |
| if(fDocHandler) |
| fDocHandler->startPrefixMapping(prefix, uri); |
| } |
| |
| void SAX2XMLFilterImpl::endPrefixMapping(const XMLCh* const prefix) |
| { |
| if(fDocHandler) |
| fDocHandler->endPrefixMapping(prefix); |
| } |
| |
| void SAX2XMLFilterImpl::skippedEntity(const XMLCh* const name) |
| { |
| if(fDocHandler) |
| fDocHandler->skippedEntity(name); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Implementation of the ErrorHandler interface |
| // ----------------------------------------------------------------------- |
| |
| void SAX2XMLFilterImpl::warning(const SAXParseException& exc) |
| { |
| if(fErrorHandler) |
| fErrorHandler->warning(exc); |
| } |
| |
| void SAX2XMLFilterImpl::error(const SAXParseException& exc) |
| { |
| if(fErrorHandler) |
| fErrorHandler->error(exc); |
| } |
| |
| void SAX2XMLFilterImpl::fatalError(const SAXParseException& exc) |
| { |
| if(fErrorHandler) |
| fErrorHandler->fatalError(exc); |
| } |
| |
| void SAX2XMLFilterImpl::resetErrors() |
| { |
| if(fErrorHandler) |
| fErrorHandler->resetErrors(); |
| } |
| |
| XERCES_CPP_NAMESPACE_END |
| |
