source: NonGTP/Xerces/xerces/include/xercesc/sax2/DefaultHandler.hpp @ 358

Revision 358, 26.6 KB checked in by bittner, 19 years ago (diff)

xerces added

Line 
1/*
2 * Copyright 1999-2000,2004 The Apache Software Foundation.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/*
18 * $Log: DefaultHandler.hpp,v $
19 * Revision 1.8  2004/09/08 13:56:20  peiyongz
20 * Apache License Version 2.0
21 *
22 * Revision 1.7  2004/01/29 11:46:32  cargilld
23 * Code cleanup changes to get rid of various compiler diagnostic messages.
24 *
25 * Revision 1.6  2003/12/02 14:33:13  amassari
26 * Don't use the word "exception" as a variable name, as VC 7.1 complains about it
27 *
28 * Revision 1.5  2002/11/04 14:55:45  tng
29 * C++ Namespace Support.
30 *
31 * Revision 1.4  2002/08/20 16:53:56  tng
32 * [Bug 6251] Info during compilation.
33 *
34 * Revision 1.3  2002/06/06 20:38:45  tng
35 * Document Fix: document that the returned object from resolveEntity is owned by the parser
36 *
37 * Revision 1.2  2002/02/20 18:17:02  tng
38 * [Bug 5977] Warnings on generating apiDocs.
39 *
40 * Revision 1.1.1.1  2002/02/01 22:22:09  peiyongz
41 * sane_include
42 *
43 * Revision 1.6  2002/01/28 17:08:33  knoaman
44 * SAX2-ext's DeclHandler support.
45 *
46 * Revision 1.5  2001/11/13 13:24:05  tng
47 * Fix documentation for DefaultHandler.
48 *
49 * Revision 1.4  2000/12/22 15:17:01  tng
50 * SAX2-ext's LexicalHandler support added by David Bertoni.
51 *
52 * Revision 1.3  2000/08/14 18:56:14  aruna1
53 * Virtual parameter inconsistency fixed
54 *
55 * Revision 1.2  2000/08/07 18:21:27  jpolast
56 * change SAX_EXPORT module to SAX2_EXPORT
57 *
58 * Revision 1.1  2000/08/02 18:02:34  jpolast
59 * initial checkin of sax2 implementation
60 * submitted by Simon Fell (simon@fell.com)
61 * and Joe Polastre (jpolast@apache.org)
62 *
63 *
64 */
65
66
67#ifndef DEFAULTHANDLER_HPP
68#define DEFAULTHANDLER_HPP
69
70#include <xercesc/sax2/ContentHandler.hpp>
71#include <xercesc/sax2/LexicalHandler.hpp>
72#include <xercesc/sax2/DeclHandler.hpp>
73#include <xercesc/sax/DTDHandler.hpp>
74#include <xercesc/sax/EntityResolver.hpp>
75#include <xercesc/sax/ErrorHandler.hpp>
76#include <xercesc/sax/SAXParseException.hpp>
77
78XERCES_CPP_NAMESPACE_BEGIN
79
80class Locator;
81class Attributes;
82
83/**
84  * Default base class for SAX2 handlers.
85  *
86  * <p>This class implements the default behaviour for SAX2
87  * interfaces: EntityResolver, DTDHandler, ContentHandler,
88  * ErrorHandler, LexicalHandler, and DeclHandler.</p>
89  *
90  * <p>Application writers can extend this class when they need to
91  * implement only part of an interface; parser writers can
92  * instantiate this class to provide default handlers when the
93  * application has not supplied its own.</p>
94  *
95  * <p>Note that the use of this class is optional.</p>
96  *
97  * @see EntityResolver#EntityResolver
98  * @see DTDHandler#DTDHandler
99  * @see ContentHandler#ContentHandler
100  * @see ErrorHandler#ErrorHandler
101  * @see LexicalHandler#LexicalHandler
102  * @see DeclHandler#DeclHandler
103  */
104
105class SAX2_EXPORT DefaultHandler :
106
107    public EntityResolver,
108        public DTDHandler,
109        public ContentHandler,
110    public ErrorHandler,
111    public LexicalHandler,
112    public DeclHandler
113{
114public:
115  /** @name Default handlers for the DocumentHandler interface */
116    //@{
117  /**
118    * Receive notification of character data inside an element.
119    *
120    * <p>By default, do nothing.  Application writers may override this
121    * method to take specific actions for each chunk of character data
122    * (such as adding the data to a node or buffer, or printing it to
123    * a file).</p>
124    *
125    * @param chars The characters.
126    * @param length The number of characters to use from the
127    *               character array.
128    * @exception SAXException Any SAX exception, possibly
129    *            wrapping another exception.
130    * @see DocumentHandler#characters
131    */
132    virtual void characters
133    (
134        const   XMLCh* const    chars
135        , const unsigned int    length
136    );
137
138  /**
139    * Receive notification of the end of the document.
140    *
141    * <p>By default, do nothing.  Application writers may override this
142    * method in a subclass to take specific actions at the beginning
143    * of a document (such as finalising a tree or closing an output
144    * file).</p>
145    *
146    * @exception SAXException Any SAX exception, possibly
147    *            wrapping another exception.
148    * @see DocumentHandler#endDocument
149    */
150    virtual void endDocument();
151
152  /**
153    * Receive notification of the end of an element.
154    *
155    * <p>By default, do nothing.  Application writers may override this
156    * method in a subclass to take specific actions at the end of
157    * each element (such as finalising a tree node or writing
158    * output to a file).</p>
159    *
160    * @param uri The URI of the asscioated namespace for this element
161        * @param localname The local part of the element name
162        * @param qname The QName of this element
163    * @exception SAXException Any SAX exception, possibly
164    *            wrapping another exception.
165    * @see DocumentHandler#endElement
166    */
167    virtual void endElement
168        (
169                const XMLCh* const uri,
170                const XMLCh* const localname,
171                const XMLCh* const qname
172        );
173
174  /**
175    * Receive notification of ignorable whitespace in element content.
176    *
177    * <p>By default, do nothing.  Application writers may override this
178    * method to take specific actions for each chunk of ignorable
179    * whitespace (such as adding data to a node or buffer, or printing
180    * it to a file).</p>
181    *
182    * @param chars The whitespace characters.
183    * @param length The number of characters to use from the
184    *               character array.
185    * @exception SAXException Any SAX exception, possibly
186    *            wrapping another exception.
187    * @see DocumentHandler#ignorableWhitespace
188    */
189    virtual void ignorableWhitespace
190    (
191        const   XMLCh* const    chars
192        , const unsigned int    length
193    );
194
195  /**
196    * Receive notification of a processing instruction.
197    *
198    * <p>By default, do nothing.  Application writers may override this
199    * method in a subclass to take specific actions for each
200    * processing instruction, such as setting status variables or
201    * invoking other methods.</p>
202    *
203    * @param target The processing instruction target.
204    * @param data The processing instruction data, or null if
205    *             none is supplied.
206    * @exception SAXException Any SAX exception, possibly
207    *            wrapping another exception.
208    * @see DocumentHandler#processingInstruction
209    */
210    virtual void processingInstruction
211    (
212        const   XMLCh* const    target
213        , const XMLCh* const    data
214    );
215
216    /**
217    * Reset the Docuemnt object on its reuse
218    *
219    * @see DocumentHandler#resetDocument
220    */
221    virtual void resetDocument();
222    //@}
223
224    /** @name Default implementation of DocumentHandler interface */
225
226    //@{
227  /**
228    * Receive a Locator object for document events.
229    *
230    * <p>By default, do nothing.  Application writers may override this
231    * method in a subclass if they wish to store the locator for use
232    * with other document events.</p>
233    *
234    * @param locator A locator for all SAX document events.
235    * @see DocumentHandler#setDocumentLocator
236    * @see Locator
237    */
238    virtual void setDocumentLocator(const Locator* const locator);
239
240  /**
241    * Receive notification of the beginning of the document.
242    *
243    * <p>By default, do nothing.  Application writers may override this
244    * method in a subclass to take specific actions at the beginning
245    * of a document (such as allocating the root node of a tree or
246    * creating an output file).</p>
247    *
248    * @exception SAXException Any SAX exception, possibly
249    *            wrapping another exception.
250    * @see DocumentHandler#startDocument
251    */
252    virtual void startDocument();
253
254  /**
255    * Receive notification of the start of an element.
256    *
257    * <p>By default, do nothing.  Application writers may override this
258    * method in a subclass to take specific actions at the start of
259    * each element (such as allocating a new tree node or writing
260    * output to a file).</p>
261    *
262    * @param uri The URI of the asscioated namespace for this element
263        * @param localname the local part of the element name
264        * @param qname the QName of this element
265    * @param attrs The specified or defaulted attributes.
266    * @exception SAXException Any SAX exception, possibly
267    *            wrapping another exception.
268    * @see DocumentHandler#startElement
269    */
270    virtual void startElement
271    (
272        const   XMLCh* const    uri,
273        const   XMLCh* const    localname,
274        const   XMLCh* const    qname
275        , const Attributes&     attrs
276    );
277
278  /**
279    * Receive notification of the start of an namespace prefix mapping.
280    *
281    * <p>By default, do nothing.  Application writers may override this
282    * method in a subclass to take specific actions at the start of
283    * each namespace prefix mapping.</p>
284    *
285        * NOTE : The current Implementation of SAX2Parser will _NEVER_ call this
286        *
287    * @param prefix The namespace prefix used
288    * @param uri The namespace URI used.
289    * @exception SAXException Any SAX exception, possibly
290    *            wrapping another exception.
291    * @see DocumentHandler#startPrefixMapping
292    */
293        virtual void startPrefixMapping
294        (
295                const   XMLCh* const    prefix,
296                const   XMLCh* const    uri
297        ) ;
298
299  /**
300    * Receive notification of the end of an namespace prefix mapping.
301    *
302    * <p>By default, do nothing.  Application writers may override this
303    * method in a subclass to take specific actions at the end of
304    * each namespace prefix mapping.</p>
305    *
306        * NOTE : The current Implementation of SAX2Parser will _NEVER_ call this
307        *
308    * @param prefix The namespace prefix used
309    * @exception SAXException Any SAX exception, possibly
310    *            wrapping another exception.
311    * @see DocumentHandler#endPrefixMapping
312    */
313        virtual void endPrefixMapping
314        (
315                const   XMLCh* const    prefix
316        ) ;
317
318  /**
319    * Receive notification of a skipped entity
320    *
321    * <p>The parser will invoke this method once for each entity
322        * skipped.  All processors may skip external entities,
323        * depending on the values of the features:<br>
324        * http://xml.org/sax/features/external-general-entities<br>
325        * http://xml.org/sax/features/external-parameter-entities</p>
326    *
327        * <p>Introduced with SAX2</p>
328        *
329    * @param name The name of the skipped entity.  If it is a parameter entity,
330        * the name will begin with %, and if it is the external DTD subset,
331        * it will be the string [dtd].
332    * @exception SAXException Any SAX exception, possibly
333    *            wrapping another exception.
334    */
335        virtual void skippedEntity
336        (
337                const   XMLCh* const    name
338        ) ;
339
340    //@}
341
342    /** @name Default implementation of the EntityResolver interface. */
343
344    //@{
345  /**
346    * Resolve an external entity.
347    *
348    * <p>Always return null, so that the parser will use the system
349    * identifier provided in the XML document.  This method implements
350    * the SAX default behaviour: application writers can override it
351    * in a subclass to do special translations such as catalog lookups
352    * or URI redirection.</p>
353    *
354    * @param publicId The public identifer, or null if none is
355    *                 available.
356    * @param systemId The system identifier provided in the XML
357    *                 document.
358    * @return The new input source, or null to require the
359    *         default behaviour.
360    *         The returned InputSource is owned by the parser which is
361    *         responsible to clean up the memory.
362    * @exception SAXException Any SAX exception, possibly
363    *            wrapping another exception.
364    * @see EntityResolver#resolveEntity
365    */
366    virtual InputSource* resolveEntity
367    (
368        const   XMLCh* const    publicId
369        , const XMLCh* const    systemId
370    );
371
372    //@}
373
374    /** @name Default implementation of the ErrorHandler interface */
375    //@{
376   /**
377    * Receive notification of a recoverable parser error.
378    *
379    * <p>The default implementation does nothing.  Application writers
380    * may override this method in a subclass to take specific actions
381    * for each error, such as inserting the message in a log file or
382    * printing it to the console.</p>
383    *
384    * @param exc The warning information encoded as an exception.
385    * @exception SAXException Any SAX exception, possibly
386    *            wrapping another exception.
387    * @see ErrorHandler#warning
388    * @see SAXParseException#SAXParseException
389    */
390    virtual void error(const SAXParseException& exc);
391
392  /**
393    * Report a fatal XML parsing error.
394    *
395    * <p>The default implementation throws a SAXParseException.
396    * Application writers may override this method in a subclass if
397    * they need to take specific actions for each fatal error (such as
398    * collecting all of the errors into a single report): in any case,
399    * the application must stop all regular processing when this
400    * method is invoked, since the document is no longer reliable, and
401    * the parser may no longer report parsing events.</p>
402    *
403    * @param exc The error information encoded as an exception.
404    * @exception SAXException Any SAX exception, possibly
405    *            wrapping another exception.
406    * @see ErrorHandler#fatalError
407    * @see SAXParseException#SAXParseException
408    */
409    virtual void fatalError(const SAXParseException& exc);
410
411  /**
412    * Receive notification of a parser warning.
413    *
414    * <p>The default implementation does nothing.  Application writers
415    * may override this method in a subclass to take specific actions
416    * for each warning, such as inserting the message in a log file or
417    * printing it to the console.</p>
418    *
419    * @param exc The warning information encoded as an exception.
420    * @exception SAXException Any SAX exception, possibly
421    *            wrapping another exception.
422    * @see ErrorHandler#warning
423    * @see SAXParseException#SAXParseException
424    */
425    virtual void warning(const SAXParseException& exc);
426
427    /**
428    * Reset the Error handler object on its reuse
429    *
430    * @see ErrorHandler#resetErrors
431    */
432    virtual void resetErrors();
433
434    //@}
435
436
437    /** @name Default implementation of DTDHandler interface. */
438    //@{
439
440  /**
441    * Receive notification of a notation declaration.
442    *
443    * <p>By default, do nothing.  Application writers may override this
444    * method in a subclass if they wish to keep track of the notations
445    * declared in a document.</p>
446    *
447    * @param name The notation name.
448    * @param publicId The notation public identifier, or null if not
449    *                 available.
450    * @param systemId The notation system identifier.
451    * @see DTDHandler#notationDecl
452    */
453    virtual void notationDecl
454    (
455        const   XMLCh* const    name
456        , const XMLCh* const    publicId
457        , const XMLCh* const    systemId
458    );
459
460    /**
461    * Reset the DTD object on its reuse
462    *
463    * @see DTDHandler#resetDocType
464    */
465    virtual void resetDocType();
466
467  /**
468    * Receive notification of an unparsed entity declaration.
469    *
470    * <p>By default, do nothing.  Application writers may override this
471    * method in a subclass to keep track of the unparsed entities
472    * declared in a document.</p>
473    *
474    * @param name The entity name.
475    * @param publicId The entity public identifier, or null if not
476    *                 available.
477    * @param systemId The entity system identifier.
478    * @param notationName The name of the associated notation.
479    * @see DTDHandler#unparsedEntityDecl
480    */
481    virtual void unparsedEntityDecl
482    (
483        const   XMLCh* const    name
484        , const XMLCh* const    publicId
485        , const XMLCh* const    systemId
486        , const XMLCh* const    notationName
487    );
488    //@}
489
490
491    /** @name Default implementation of LexicalHandler interface. */
492
493    //@{
494   /**
495    * Receive notification of comments.
496    *
497    * <p>The Parser will call this method to report each occurence of
498    * a comment in the XML document.</p>
499    *
500    * <p>The application must not attempt to read from the array
501    * outside of the specified range.</p>
502    *
503    * @param chars The characters from the XML document.
504    * @param length The number of characters to read from the array.
505    * @exception SAXException Any SAX exception, possibly
506    *            wrapping another exception.
507    */
508    virtual void comment
509    (
510        const   XMLCh* const    chars
511        , const unsigned int    length
512    );
513
514  /**
515    * Receive notification of the end of a CDATA section.
516    *
517    * <p>The SAX parser will invoke this method at the end of
518    * each CDATA parsed.</p>
519    *
520    * @exception SAXException Any SAX exception, possibly
521    *            wrapping another exception.
522    */
523    virtual void endCDATA ();
524
525  /**
526    * Receive notification of the end of the DTD declarations.
527    *
528    * <p>The SAX parser will invoke this method at the end of the
529    * DTD</p>
530    *
531    * @exception SAXException Any SAX exception, possibly
532    *            wrapping another exception.
533    */
534    virtual void endDTD ();
535
536  /**
537    * Receive notification of the end of an entity.
538    *
539    * <p>The SAX parser will invoke this method at the end of an
540    * entity</p>
541    *
542    * @param name The name of the entity that is ending.
543    * @exception SAXException Any SAX exception, possibly
544    *            wrapping another exception.
545    */
546    virtual void endEntity (const XMLCh* const name);
547
548  /**
549    * Receive notification of the start of a CDATA section.
550    *
551    * <p>The SAX parser will invoke this method at the start of
552    * each CDATA parsed.</p>
553    *
554    * @exception SAXException Any SAX exception, possibly
555    *            wrapping another exception.
556    */
557    virtual void startCDATA ();
558
559  /**
560    * Receive notification of the start of the DTD declarations.
561    *
562    * <p>The SAX parser will invoke this method at the start of the
563    * DTD</p>
564    *
565    * @param name The document type name.
566    * @param publicId The declared public identifier for the external DTD subset, or null if none was declared.
567    * @param systemId The declared system identifier for the external DTD subset, or null if none was declared.
568    * @exception SAXException Any SAX exception, possibly
569    *            wrapping another exception.
570    */
571    virtual void startDTD
572    (
573        const   XMLCh* const    name
574        , const   XMLCh* const    publicId
575        , const   XMLCh* const    systemId
576    );
577
578  /**
579    * Receive notification of the start of an entity.
580    *
581    * <p>The SAX parser will invoke this method at the start of an
582    * entity</p>
583    *
584    * @param name The name of the entity that is starting.
585    * @exception SAXException Any SAX exception, possibly
586    *            wrapping another exception.
587    */
588    virtual void startEntity (const XMLCh* const name);
589
590    //@}
591
592    /** @name Default implementation of DeclHandler interface. */
593
594    //@{
595
596   /**
597    * Report an element type declaration.
598    *
599    * <p>The content model will consist of the string "EMPTY", the string
600    * "ANY", or a parenthesised group, optionally followed by an occurrence
601    * indicator. The model will be normalized so that all parameter entities
602    * are fully resolved and all whitespace is removed,and will include the
603    * enclosing parentheses. Other normalization (such as removing redundant
604    * parentheses or simplifying occurrence indicators) is at the discretion
605    * of the parser.</p>
606    *
607    * @param name The element type name.
608    * @param model The content model as a normalized string.
609    * @exception SAXException Any SAX exception, possibly
610    *            wrapping another exception.
611    */
612    virtual void elementDecl
613    (
614        const   XMLCh* const    name
615        , const XMLCh* const    model
616    );
617
618   /**
619    * Report an attribute type declaration.
620    *
621    * <p>Only the effective (first) declaration for an attribute will
622    * be reported.</p>
623    *
624    * @param eName The name of the associated element.
625    * @param aName The name of the attribute.
626    * @param type A string representing the attribute type.
627    * @param mode A string representing the attribute defaulting mode ("#IMPLIED", "#REQUIRED", or "#FIXED") or null if none of these applies.
628    * @param value A string representing the attribute's default value, or null if there is none.
629    * @exception SAXException Any SAX exception, possibly
630    *            wrapping another exception.
631    */
632    virtual void attributeDecl
633    (
634        const   XMLCh* const    eName
635        , const XMLCh* const    aName
636        , const XMLCh* const    type
637        , const XMLCh* const    mode
638        , const XMLCh* const    value
639    );
640
641   /**
642    * Report an internal entity declaration.
643    *
644    * <p>Only the effective (first) declaration for each entity will be
645    * reported. All parameter entities in the value will be expanded, but
646    * general entities will not.</p>
647    *
648    * @param name The name of the entity. If it is a parameter entity, the name will begin with '%'.
649    * @param value The replacement text of the entity.
650    * @exception SAXException Any SAX exception, possibly
651    *            wrapping another exception.
652    */
653    virtual void internalEntityDecl
654    (
655        const   XMLCh* const    name
656        , const XMLCh* const    value
657    );
658
659   /**
660    * Report a parsed external entity declaration.
661    *
662    * <p>Only the effective (first) declaration for each entity will
663    * be reported.</p>
664    *
665    * @param name The name of the entity. If it is a parameter entity, the name will begin with '%'.
666    * @param publicId The The declared public identifier of the entity, or null if none was declared.
667    * @param systemId The declared system identifier of the entity.
668    * @exception SAXException Any SAX exception, possibly
669    *            wrapping another exception.
670    */
671    virtual void externalEntityDecl
672    (
673        const   XMLCh* const    name
674        , const XMLCh* const    publicId
675        , const XMLCh* const    systemId
676    );
677
678    //@}
679
680    DefaultHandler() {};
681    virtual ~DefaultHandler() {};
682
683private:
684        // -----------------------------------------------------------------------
685    //  Unimplemented constructors and operators
686    // -----------------------------------------------------------------------
687    DefaultHandler(const DefaultHandler&);
688    DefaultHandler& operator=(const DefaultHandler&);   
689};
690
691
692// ---------------------------------------------------------------------------
693//  HandlerBase: Inline default implementations
694// ---------------------------------------------------------------------------
695inline void DefaultHandler::characters(const   XMLCh* const
696                                       ,const   unsigned int)
697{
698}
699
700inline void DefaultHandler::endDocument()
701{
702}
703
704inline void DefaultHandler::endElement(const    XMLCh* const
705                                                                                , const XMLCh* const
706                                                                                , const XMLCh* const)
707{
708}
709
710inline void DefaultHandler::error(const SAXParseException&)
711{
712}
713
714inline void DefaultHandler::fatalError(const SAXParseException& exc)
715{
716    throw exc;
717}
718
719inline void
720DefaultHandler::ignorableWhitespace( const   XMLCh* const
721                                    , const unsigned int)
722{
723}
724
725inline void DefaultHandler::notationDecl(  const   XMLCh* const
726                                                                                        , const XMLCh* const
727                                                                                        , const XMLCh* const)
728{
729}
730
731inline void
732DefaultHandler::processingInstruction( const   XMLCh* const
733                                                                                , const XMLCh* const)
734{
735}
736
737inline void DefaultHandler::resetErrors()
738{
739}
740
741inline void DefaultHandler::resetDocument()
742{
743}
744
745inline void DefaultHandler::resetDocType()
746{
747}
748
749inline InputSource*
750DefaultHandler::resolveEntity( const   XMLCh* const
751                                                                , const XMLCh* const)
752{
753    return 0;
754}
755
756inline void
757DefaultHandler::unparsedEntityDecl(const   XMLCh* const
758                                                                        , const XMLCh* const
759                                                                        , const XMLCh* const
760                                                                        , const XMLCh* const)
761{
762}
763
764inline void DefaultHandler::setDocumentLocator(const Locator* const)
765{
766}
767
768inline void DefaultHandler::startDocument()
769{
770}
771
772inline void
773DefaultHandler::startElement(  const     XMLCh* const
774                                                                , const   XMLCh* const
775                                                                , const   XMLCh* const
776                                                                , const   Attributes&
777)
778{
779}
780
781inline void DefaultHandler::warning(const SAXParseException&)
782{
783}
784
785inline void DefaultHandler::startPrefixMapping ( const  XMLCh* const
786                                                                                                ,const  XMLCh* const)
787{
788}
789
790inline void DefaultHandler::endPrefixMapping ( const    XMLCh* const)
791{
792}
793
794inline void DefaultHandler::skippedEntity ( const       XMLCh* const)
795{
796}
797
798inline void DefaultHandler::comment(  const   XMLCh* const
799                                       , const unsigned int)
800{
801}
802
803inline void DefaultHandler::endCDATA ()
804{
805}
806
807inline void DefaultHandler::endDTD ()
808{
809}
810
811inline void DefaultHandler::endEntity (const XMLCh* const)
812{
813}
814
815inline void DefaultHandler::startCDATA ()
816{
817}
818
819inline void DefaultHandler::startDTD(  const   XMLCh* const
820                                        , const   XMLCh* const
821                                        , const   XMLCh* const)
822{
823}
824
825inline void DefaultHandler::startEntity (const XMLCh* const)
826{
827}
828
829inline void DefaultHandler::attributeDecl(const XMLCh* const,
830                                          const XMLCh* const,
831                                          const XMLCh* const,
832                                          const XMLCh* const,
833                                          const XMLCh* const)
834{
835}
836
837inline void DefaultHandler::elementDecl(const XMLCh* const,
838                                        const XMLCh* const)
839{
840}
841
842inline void DefaultHandler::externalEntityDecl(const XMLCh* const,
843                                               const XMLCh* const,
844                                               const XMLCh* const)
845{
846}
847
848inline void DefaultHandler::internalEntityDecl(const XMLCh* const,
849                                               const XMLCh* const)
850{
851}
852
853XERCES_CPP_NAMESPACE_END
854
855#endif // ! DEFAULTHANDLER_HPP
Note: See TracBrowser for help on using the repository browser.