source: icXML/icXML-devel/src/xercesc/parsers/SAX2XMLFilterImpl.cpp

Last change on this file was 2722, checked in by cameron, 7 years ago

Original Xerces files with import mods for icxercesc

File size: 12.0 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: SAX2XMLFilterImpl.cpp 673975 2008-07-04 09:23:56Z borisk $
20 */
21
22#include <xercesc/parsers/SAX2XMLFilterImpl.hpp>
23
24XERCES_CPP_NAMESPACE_BEGIN
25
26SAX2XMLFilterImpl::SAX2XMLFilterImpl(SAX2XMLReader* parent) :
27    fParentReader(0)
28    , fDocHandler(0)
29    , fDTDHandler(0)
30    , fEntityResolver(0)
31    , fErrorHandler(0)
32{
33    setParent(parent);
34}
35
36SAX2XMLFilterImpl::~SAX2XMLFilterImpl()
37{
38}
39
40// ---------------------------------------------------------------------------
41//  SAX2XMLFilterImpl: XMLFilter impl
42// ---------------------------------------------------------------------------
43void SAX2XMLFilterImpl::setParent(SAX2XMLReader* parent)
44{
45    if(fParentReader)
46    {
47        fParentReader->setEntityResolver(0);
48        fParentReader->setDTDHandler(0);
49        fParentReader->setContentHandler(0);
50        fParentReader->setErrorHandler(0);
51    }
52    fParentReader=parent;
53    if(fParentReader)
54    {
55        fParentReader->setEntityResolver(this);
56        fParentReader->setDTDHandler(this);
57        fParentReader->setContentHandler(this);
58        fParentReader->setErrorHandler(this);
59    }
60}
61
62bool SAX2XMLFilterImpl::getExitOnFirstFatalError() const
63{
64    if(fParentReader)
65        fParentReader->getExitOnFirstFatalError();
66    return false;
67}
68
69bool SAX2XMLFilterImpl::getValidationConstraintFatal() const
70{
71    if(fParentReader)
72        fParentReader->getValidationConstraintFatal();
73    return false;
74}
75
76Grammar* SAX2XMLFilterImpl::getRootGrammar()
77{
78    if(fParentReader)
79        fParentReader->getRootGrammar();
80    return NULL;
81}
82
83const XMLCh* SAX2XMLFilterImpl::getURIText(unsigned int uriId) const
84{
85    if(fParentReader)
86        fParentReader->getURIText(uriId);
87    return NULL;
88}
89
90XMLFilePos SAX2XMLFilterImpl::getSrcOffset() const
91{
92    if(fParentReader)
93        fParentReader->getSrcOffset();
94    return 0;
95}
96
97// ---------------------------------------------------------------------------
98//  SAX2XMLFilterImpl Validator functions
99// ---------------------------------------------------------------------------
100void SAX2XMLFilterImpl::setValidator(XMLValidator* valueToAdopt)
101{
102    if(fParentReader)
103        fParentReader->setValidator(valueToAdopt);
104}
105
106XMLValidator* SAX2XMLFilterImpl::getValidator() const
107{
108    if(fParentReader)
109        return fParentReader->getValidator();
110        return 0;
111}
112
113// ---------------------------------------------------------------------------
114//  SAX2XMLReader Interface
115// ---------------------------------------------------------------------------
116XMLSize_t SAX2XMLFilterImpl::getErrorCount() const
117{
118    if(fParentReader)
119        return fParentReader->getErrorCount();
120    return 0;
121}
122
123void SAX2XMLFilterImpl::setExitOnFirstFatalError(const bool newState)
124{
125    if(fParentReader)
126        fParentReader->setExitOnFirstFatalError(newState);
127}
128
129void SAX2XMLFilterImpl::setValidationConstraintFatal(const bool newState)
130{
131    if(fParentReader)
132        fParentReader->setValidationConstraintFatal(newState);
133}
134
135void SAX2XMLFilterImpl::parse (const   InputSource&    source)
136{
137    if(fParentReader)
138        fParentReader->parse(source);
139}
140
141void SAX2XMLFilterImpl::parse (const   XMLCh* const    systemId)
142{
143    if(fParentReader)
144        fParentReader->parse(systemId);
145}
146
147void SAX2XMLFilterImpl::parse (const   char* const     systemId)
148{
149    if(fParentReader)
150        fParentReader->parse(systemId);
151}
152
153// ---------------------------------------------------------------------------
154//  SAX2XMLFilterImpl: Progressive parse methods
155// ---------------------------------------------------------------------------
156bool SAX2XMLFilterImpl::parseFirst( const   XMLCh* const    systemId
157                            ,       XMLPScanToken&  toFill)
158{
159    if(fParentReader)
160        return fParentReader->parseFirst(systemId, toFill);
161    return false;
162}
163
164bool SAX2XMLFilterImpl::parseFirst( const   char* const     systemId
165                            ,       XMLPScanToken&  toFill)
166{
167    if(fParentReader)
168        fParentReader->parseFirst(systemId, toFill);
169    return false;
170}
171
172bool SAX2XMLFilterImpl::parseFirst( const   InputSource&    source
173                            ,       XMLPScanToken&  toFill)
174{
175    if(fParentReader)
176        fParentReader->parseFirst(source, toFill);
177    return false;
178}
179
180bool SAX2XMLFilterImpl::parseNext(XMLPScanToken& token)
181{
182    if(fParentReader)
183        fParentReader->parseNext(token);
184    return false;
185}
186
187void SAX2XMLFilterImpl::parseReset(XMLPScanToken& token)
188{
189    if(fParentReader)
190        fParentReader->parseReset(token);
191}
192
193// ---------------------------------------------------------------------------
194//  SAX2XMLFilterImpl: Features and Properties
195// ---------------------------------------------------------------------------
196
197void SAX2XMLFilterImpl::setFeature(const XMLCh* const name, const bool value)
198{
199    if(fParentReader)
200        fParentReader->setFeature(name,value);
201}
202
203bool SAX2XMLFilterImpl::getFeature(const XMLCh* const name) const
204{
205    if(fParentReader)
206        return fParentReader->getFeature(name);
207    return false;
208}
209
210void SAX2XMLFilterImpl::setProperty(const XMLCh* const name, void* value)
211{
212    if(fParentReader)
213        fParentReader->setProperty(name,value);
214}
215
216void* SAX2XMLFilterImpl::getProperty(const XMLCh* const name) const
217{
218    if(fParentReader)
219        return fParentReader->getProperty(name);
220    return NULL;
221}
222
223// ---------------------------------------------------------------------------
224//  SAX2XMLFilterImpl: Grammar preparsing
225// ---------------------------------------------------------------------------
226Grammar* SAX2XMLFilterImpl::loadGrammar(const char* const systemId,
227                                        const Grammar::GrammarType grammarType,
228                                        const bool toCache)
229{
230    if(fParentReader)
231        return fParentReader->loadGrammar(systemId, grammarType, toCache);
232    return NULL;
233}
234
235Grammar* SAX2XMLFilterImpl::loadGrammar(const XMLCh* const systemId,
236                                        const Grammar::GrammarType grammarType,
237                                        const bool toCache)
238{
239    if(fParentReader)
240        return fParentReader->loadGrammar(systemId, grammarType, toCache);
241    return NULL;
242}
243
244Grammar* SAX2XMLFilterImpl::loadGrammar(const InputSource& source,
245                                        const Grammar::GrammarType grammarType,
246                                        const bool toCache)
247{
248    if(fParentReader)
249        return fParentReader->loadGrammar(source, grammarType, toCache);
250    return NULL;
251}
252
253void SAX2XMLFilterImpl::resetCachedGrammarPool()
254{
255    if(fParentReader)
256        fParentReader->resetCachedGrammarPool();
257}
258
259void SAX2XMLFilterImpl::setInputBufferSize(const XMLSize_t bufferSize)
260{
261    if(fParentReader)
262        fParentReader->setInputBufferSize(bufferSize);
263}
264
265Grammar* SAX2XMLFilterImpl::getGrammar(const XMLCh* const nameSpaceKey)
266{
267    if(fParentReader)
268        return fParentReader->getGrammar(nameSpaceKey);
269    return NULL;
270}
271
272// -----------------------------------------------------------------------
273//  Implementation of the EntityResolver interface
274// -----------------------------------------------------------------------
275InputSource* SAX2XMLFilterImpl::resolveEntity(const XMLCh* const    publicId
276                                            , const XMLCh* const    systemId)
277{
278    if(fEntityResolver)
279        return fEntityResolver->resolveEntity(publicId, systemId);
280    return 0;
281}
282
283// -----------------------------------------------------------------------
284//  Implementation of the DTDHandler interface
285// -----------------------------------------------------------------------
286void SAX2XMLFilterImpl::notationDecl( const XMLCh* const    name
287                                    , const XMLCh* const    publicId
288                                    , const XMLCh* const    systemId)
289{
290    if(fDTDHandler)
291        fDTDHandler->notationDecl(name, publicId, systemId);
292}
293
294void SAX2XMLFilterImpl::unparsedEntityDecl(const XMLCh* const    name
295                                         , const XMLCh* const    publicId
296                                         , const XMLCh* const    systemId
297                                         , const XMLCh* const    notationName)
298{
299    if(fDTDHandler)
300        fDTDHandler->unparsedEntityDecl(name, publicId, systemId, notationName);
301}
302
303void SAX2XMLFilterImpl::resetDocType()
304{
305    if(fDTDHandler)
306        fDTDHandler->resetDocType();
307}
308
309// -----------------------------------------------------------------------
310//  Implementation of the ContentHandler interface
311// -----------------------------------------------------------------------
312
313void SAX2XMLFilterImpl::characters(const XMLCh* const    chars
314                                 , const XMLSize_t       length)
315{
316    if(fDocHandler)
317        fDocHandler->characters(chars, length);
318}
319
320void SAX2XMLFilterImpl::endDocument()
321{
322    if(fDocHandler)
323        fDocHandler->endDocument();
324}
325
326void SAX2XMLFilterImpl::endElement(const XMLCh* const uri
327                                         , const XMLCh* const localname
328                                         , const XMLCh* const qname)
329{
330    if(fDocHandler)
331        fDocHandler->endElement(uri, localname, qname);
332}
333
334void SAX2XMLFilterImpl::ignorableWhitespace(const XMLCh* const    chars
335                                          , const XMLSize_t       length)
336{
337    if(fDocHandler)
338        fDocHandler->ignorableWhitespace(chars, length);
339}
340
341void SAX2XMLFilterImpl::processingInstruction(const XMLCh* const    target
342                                            , const XMLCh* const    data)
343{
344    if(fDocHandler)
345        fDocHandler->processingInstruction(target, data);
346}
347
348void SAX2XMLFilterImpl::setDocumentLocator(const Locator* const locator)
349{
350    if(fDocHandler)
351        fDocHandler->setDocumentLocator(locator);
352}
353
354void SAX2XMLFilterImpl::startDocument()
355{
356    if(fDocHandler)
357        fDocHandler->startDocument();
358}
359
360void SAX2XMLFilterImpl::startElement(const   XMLCh* const    uri
361                                   , const   XMLCh* const    localname
362                                   , const   XMLCh* const    qname
363                                   , const   Attributes&     attrs)
364{
365    if(fDocHandler)
366        fDocHandler->startElement(uri, localname, qname, attrs);
367}
368
369void SAX2XMLFilterImpl::startPrefixMapping(const        XMLCh* const    prefix
370                                        ,  const        XMLCh* const    uri)
371{
372    if(fDocHandler)
373        fDocHandler->startPrefixMapping(prefix, uri);
374}
375
376void SAX2XMLFilterImpl::endPrefixMapping(const XMLCh* const     prefix)
377{
378    if(fDocHandler)
379        fDocHandler->endPrefixMapping(prefix);
380}
381
382void SAX2XMLFilterImpl::skippedEntity(const     XMLCh* const    name)
383{
384    if(fDocHandler)
385        fDocHandler->skippedEntity(name);
386}
387
388// -----------------------------------------------------------------------
389//  Implementation of the ErrorHandler interface
390// -----------------------------------------------------------------------
391
392void SAX2XMLFilterImpl::warning(const SAXParseException& exc)
393{
394    if(fErrorHandler)
395        fErrorHandler->warning(exc);
396}
397
398void SAX2XMLFilterImpl::error(const SAXParseException& exc)
399{
400    if(fErrorHandler)
401        fErrorHandler->error(exc);
402}
403
404void SAX2XMLFilterImpl::fatalError(const SAXParseException& exc)
405{
406    if(fErrorHandler)
407        fErrorHandler->fatalError(exc);
408}
409
410void SAX2XMLFilterImpl::resetErrors()
411{
412    if(fErrorHandler)
413        fErrorHandler->resetErrors();
414}
415
416XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.