source: icXML/icXML-devel/src/icxercesc/validators/schema/SchemaGrammar.hpp @ 3106

Last change on this file since 3106 was 3106, checked in by cameron, 6 years ago

SchemaGrammar? files

File size: 20.4 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: SchemaGrammar.hpp 883376 2009-11-23 15:45:23Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_SCHEMAGRAMMAR_HPP)
23#define XERCESC_INCLUDE_GUARD_SCHEMAGRAMMAR_HPP
24
25#include <xercesc/framework/XMLNotationDecl.hpp>
26#include <xercesc/util/RefHash3KeysIdPool.hpp>
27#include <xercesc/util/NameIdPool.hpp>
28#include <xercesc/util/StringPool.hpp>
29#include <icxercesc/validators/common/Grammar.hpp>
30#include <xercesc/validators/schema/SchemaElementDecl.hpp>
31#include <xercesc/util/ValueVectorOf.hpp>
32#include <xercesc/validators/datatype/IDDatatypeValidator.hpp>
33#include <icxercesc/validators/datatype/DatatypeValidatorFactory.hpp>
34#include <xercesc/framework/XMLSchemaDescription.hpp>
35#include <xercesc/framework/ValidationContext.hpp>
36#include <icxmlc/XMLConfig.hpp>
37
38XERCES_CPP_NAMESPACE_BEGIN
39
40//
41// This class stores the Schema information
42//  NOTE: Schemas are not namespace aware, so we just use regular NameIdPool
43//  data structures to store element and attribute decls. They are all set
44//  to be in the global namespace and the full QName is used as the base name
45//  of the decl. This means that all the URI parameters below are expected
46//  to be null pointers (and anything else will cause an exception.)
47//
48
49// ---------------------------------------------------------------------------
50//  Forward Declarations
51// ---------------------------------------------------------------------------
52class ComplexTypeInfo;
53class XercesGroupInfo;
54class XercesAttGroupInfo;
55class XSAnnotation;
56
57// ---------------------------------------------------------------------------
58//  typedef declaration
59// ---------------------------------------------------------------------------
60typedef ValueVectorOf<SchemaElementDecl*> ElemVector;
61
62
63class VALIDATORS_EXPORT SchemaGrammar : public Grammar
64{
65public:
66        // -----------------------------------------------------------------------
67        //  Constructors and Destructor
68        // -----------------------------------------------------------------------
69        SchemaGrammar(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
70        virtual ~SchemaGrammar();
71
72        // -----------------------------------------------------------------------
73        //  Implementation of Virtual Interface
74        // -----------------------------------------------------------------------
75        virtual Grammar::GrammarType getGrammarType() const;
76        virtual const XMLCh* getTargetNamespace() const;
77
78        // this method should only be used while the grammar is being
79        // constructed, not while it is being used
80        // in a validation episode!
81        virtual XMLElementDecl* findOrAddElemDecl
82        (
83                const   unsigned int    uriId
84                , const XMLCh* const    baseName
85                , const XMLCh* const    prefixName
86                , const XMLCh* const    qName
87                , unsigned int          scope
88                ,       bool&           wasAdded
89        ) ;
90
91        virtual XMLSize_t getElemId
92        (
93                const   unsigned int    uriId
94                , const XMLCh* const    baseName
95                , const XMLCh* const    qName
96                , unsigned int          scope
97        )   const ;
98
99        virtual const XMLElementDecl* getElemDecl
100        (
101                const   unsigned int    uriId
102                , const XMLCh* const    baseName
103                , const XMLCh* const    qName
104                , unsigned int          scope
105        )   const ;
106
107        virtual XMLElementDecl* getElemDecl
108        (
109                const   unsigned int    uriId
110                , const XMLCh* const    baseName
111                , const XMLCh* const    qName
112                , unsigned int          scope
113        );
114
115        virtual const XMLElementDecl* getElemDecl
116        (
117                const   unsigned int    elemId
118        )   const;
119
120        virtual XMLElementDecl* getElemDecl
121        (
122                const   unsigned int    elemId
123        );
124
125        virtual const XMLNotationDecl* getNotationDecl
126        (
127                const   XMLCh* const    notName
128        )   const;
129
130        virtual XMLNotationDecl* getNotationDecl
131        (
132                const   XMLCh* const    notName
133        );
134
135        virtual bool getValidated() const;
136
137        virtual XMLElementDecl* putElemDecl
138        (
139                const   unsigned int    uriId
140                , const XMLCh* const    baseName
141                , const XMLCh* const    prefixName
142                , const XMLCh* const    qName
143                , unsigned int          scope
144                , const bool            notDeclared = false
145        );
146
147        virtual XMLSize_t putElemDecl
148        (
149                XMLElementDecl* const elemDecl
150                , const bool          notDeclared = false
151        )   ;
152
153        virtual XMLSize_t putNotationDecl
154        (
155                XMLNotationDecl* const notationDecl
156        )   const;
157
158        virtual void setValidated(const bool newState);
159
160        virtual void reset();
161
162        // -----------------------------------------------------------------------
163        //  Getter methods
164        // -----------------------------------------------------------------------
165        RefHash3KeysIdPoolEnumerator<SchemaElementDecl> getElemEnumerator() const;
166        NameIdPoolEnumerator<XMLNotationDecl> getNotationEnumerator() const;
167        RefHashTableOf<XMLAttDef>* getAttributeDeclRegistry() const;
168        RefHashTableOf<ComplexTypeInfo>* getComplexTypeRegistry() const;
169        RefHashTableOf<XercesGroupInfo>* getGroupInfoRegistry() const;
170        RefHashTableOf<XercesAttGroupInfo>* getAttGroupInfoRegistry() const;
171        DatatypeValidatorFactory* getDatatypeRegistry();
172        RefHash2KeysTableOf<ElemVector>* getValidSubstitutionGroups() const;
173
174        // @deprecated
175        ValidationContext*          getValidationContext() const;
176
177        // -----------------------------------------------------------------------
178        //  Setter methods
179        // -----------------------------------------------------------------------
180        void setTargetNamespace(const XMLCh* const targetNamespace);
181        void setAttributeDeclRegistry(RefHashTableOf<XMLAttDef>* const attReg);
182        void setComplexTypeRegistry(RefHashTableOf<ComplexTypeInfo>* const other);
183        void setGroupInfoRegistry(RefHashTableOf<XercesGroupInfo>* const other);
184        void setAttGroupInfoRegistry(RefHashTableOf<XercesAttGroupInfo>* const other);
185        void setValidSubstitutionGroups(RefHash2KeysTableOf<ElemVector>* const);
186
187        virtual void                    setGrammarDescription( XMLGrammarDescription*);
188        virtual XMLGrammarDescription*  getGrammarDescription() const;
189
190        // -----------------------------------------------------------------------
191        //  Helper methods
192        // -----------------------------------------------------------------------
193        XMLSize_t putGroupElemDecl
194        (
195                XMLElementDecl* const elemDecl
196        )   const;
197
198        // -----------------------------------------------------------------------
199        // Annotation management methods
200        // -----------------------------------------------------------------------
201        /**
202          * Add annotation to the list of annotations for a given key
203          */
204        void putAnnotation(void* key, XSAnnotation* const annotation);
205
206        /**
207          * Add global annotation
208          *
209          * Note: XSAnnotation acts as a linked list
210          */
211        void addAnnotation(XSAnnotation* const annotation);
212
213        /**
214         * Retrieve the annotation that is associated with the specified key
215         *
216         * @param  key   represents a schema component object (i.e. SchemaGrammar)
217         * @return XSAnnotation associated with the key object
218         */
219        XSAnnotation* getAnnotation(const void* const key);
220
221        /**
222         * Retrieve the annotation that is associated with the specified key
223         *
224         * @param  key   represents a schema component object (i.e. SchemaGrammar)
225         * @return XSAnnotation associated with the key object
226         */
227        const XSAnnotation* getAnnotation(const void* const key) const;
228
229        /**
230          * Get global annotation
231          */
232        XSAnnotation* getAnnotation();
233        const XSAnnotation* getAnnotation() const;
234
235        /**
236          * Get annotation hash table, to enumerate through them
237          */
238        RefHashTableOf<XSAnnotation, PtrHasher>*  getAnnotations();
239        const RefHashTableOf<XSAnnotation, PtrHasher>*  getAnnotations() const;
240
241        /**
242         * Get/set scope count.
243         */
244        unsigned int getScopeCount () const;
245        void setScopeCount (unsigned int);
246
247        /**
248         * Get/set anonymous type count.
249         */
250        unsigned int getAnonTypeCount () const;
251        void setAnonTypeCount (unsigned int);
252
253        /***
254         * Support for Serialization/De-serialization
255         ***/
256        DECL_XSERIALIZABLE(SchemaGrammar)
257
258private:
259        // -----------------------------------------------------------------------
260        //  Unimplemented constructors and operators
261        // -----------------------------------------------------------------------
262        SchemaGrammar(const SchemaGrammar&);
263        SchemaGrammar& operator=(const SchemaGrammar&);
264
265        // -----------------------------------------------------------------------
266        //  Helper methods
267        // -----------------------------------------------------------------------
268        void cleanUp();
269
270        // -----------------------------------------------------------------------
271        //  Private data members
272        //
273        //  fElemDeclPool
274        //      This is the element decl pool. It contains all of the elements
275        //      declared in the Schema (and their associated attributes.)
276        //
277        //  fElemNonDeclPool
278        //      This is the element decl pool that is is populated as new elements
279        //      are seen in the XML document (not declared in the Schema), and they
280        //      are given default characteristics.
281        //
282        //  fGroupElemDeclPool
283        //      This is the element decl pool for elements in a group that are
284        //      referenced in different scope. It contains all of the elements
285        //      declared in the Schema (and their associated attributes.)
286        //
287        //  fNotationDeclPool
288        //      This is a pool of NotationDecl objects, which contains all of the
289        //      notations declared in the Schema.
290        //
291        //  fTargetNamespace
292        //      Target name space for this grammar.
293        //
294        //  fAttributeDeclRegistry
295        //      Global attribute declarations
296        //
297        //  fComplexTypeRegistry
298        //      Stores complexType declaration info
299        //
300        //  fGroupInfoRegistry
301        //      Stores global <group> declaration info
302        //
303        //  fAttGroupInfoRegistry
304        //      Stores global <attributeGroup> declaration info
305        //
306        //  fDatatypeRegistry
307        //      Datatype validator factory
308        //
309        //  fValidSubstitutionGroups
310        //      Valid list of elements that can substitute a given element
311        //
312        //  fIDRefList
313        //      List of ids of schema declarations extracted during schema grammar
314        //      traversal
315        //
316        //  fValidated
317        //      Indicates if the content of the Grammar has been pre-validated
318        //      or not (UPA checking, etc.). When using a cached grammar, no need
319        //      for pre content validation.
320        //
321        //  fGramDesc: adopted
322        //
323        // -----------------------------------------------------------------------
324        XMLCh*                                                                          fTargetNamespace;
325        RefHash3KeysIdPool<SchemaElementDecl>*          fElemDeclPool;
326        RefHash3KeysIdPool<SchemaElementDecl>*          fElemNonDeclPool;
327        RefHash3KeysIdPool<SchemaElementDecl>*          fGroupElemDeclPool;
328        NameIdPool<XMLNotationDecl>*                            fNotationDeclPool;
329        RefHashTableOf<XMLAttDef>*                                      fAttributeDeclRegistry;
330        RefHashTableOf<ComplexTypeInfo>*                        fComplexTypeRegistry;
331        RefHashTableOf<XercesGroupInfo>*                        fGroupInfoRegistry;
332        RefHashTableOf<XercesAttGroupInfo>*                     fAttGroupInfoRegistry;
333        RefHash2KeysTableOf<ElemVector>*                        fValidSubstitutionGroups;
334        // @deprecated
335        ValidationContext*                                                      fValidationContext;
336        MemoryManager*                                                          fMemoryManager;
337        XMLSchemaDescription*                                           fGramDesc;
338        RefHashTableOf<XSAnnotation, PtrHasher>*        fAnnotations;
339
340        bool                                                                            fValidated;
341        DatatypeValidatorFactory                                        fDatatypeRegistry;
342
343        unsigned int                                                            fScopeCount;
344        unsigned int                                                            fAnonTypeCount;
345};
346
347// ---------------------------------------------------------------------------
348//  SchemaGrammar: Getter methods
349// ---------------------------------------------------------------------------
350inline RefHash3KeysIdPoolEnumerator<SchemaElementDecl>
351SchemaGrammar::getElemEnumerator() const
352{
353        return RefHash3KeysIdPoolEnumerator<SchemaElementDecl>(fElemDeclPool, false, fMemoryManager);
354}
355
356inline NameIdPoolEnumerator<XMLNotationDecl>
357SchemaGrammar::getNotationEnumerator() const
358{
359        return NameIdPoolEnumerator<XMLNotationDecl>(fNotationDeclPool, fMemoryManager);
360}
361
362inline RefHashTableOf<XMLAttDef>* SchemaGrammar::getAttributeDeclRegistry() const
363{
364        return fAttributeDeclRegistry;
365}
366
367inline RefHashTableOf<ComplexTypeInfo>*
368SchemaGrammar::getComplexTypeRegistry() const
369{
370        return fComplexTypeRegistry;
371}
372
373inline RefHashTableOf<XercesGroupInfo>*
374SchemaGrammar::getGroupInfoRegistry() const
375{
376        return fGroupInfoRegistry;
377}
378
379inline RefHashTableOf<XercesAttGroupInfo>*
380SchemaGrammar::getAttGroupInfoRegistry() const
381{
382        return fAttGroupInfoRegistry;
383}
384
385inline DatatypeValidatorFactory* SchemaGrammar::getDatatypeRegistry()
386{
387        return &fDatatypeRegistry;
388}
389
390inline RefHash2KeysTableOf<ElemVector>*
391SchemaGrammar::getValidSubstitutionGroups() const
392{
393        return fValidSubstitutionGroups;
394}
395
396// @deprecated
397inline ValidationContext* SchemaGrammar::getValidationContext() const
398{
399        return fValidationContext;
400}
401
402inline XMLGrammarDescription* SchemaGrammar::getGrammarDescription() const
403{
404        return fGramDesc;
405}
406
407inline XSAnnotation* SchemaGrammar::getAnnotation(const void* const key)
408{
409        return fAnnotations->get(key);
410}
411
412inline const XSAnnotation* SchemaGrammar::getAnnotation(const void* const key) const
413{
414        return fAnnotations->get(key);
415}
416
417inline XSAnnotation* SchemaGrammar::getAnnotation()
418{
419        return fAnnotations->get(this);
420}
421
422inline const XSAnnotation* SchemaGrammar::getAnnotation() const
423{
424        return fAnnotations->get(this);
425}
426
427inline RefHashTableOf<XSAnnotation, PtrHasher>* SchemaGrammar::getAnnotations()
428{
429        return fAnnotations;
430}
431
432inline const RefHashTableOf<XSAnnotation, PtrHasher>* SchemaGrammar::getAnnotations() const
433{
434        return fAnnotations;
435}
436// -----------------------------------------------------------------------
437//  Setter methods
438// -----------------------------------------------------------------------
439inline void SchemaGrammar::setTargetNamespace(const XMLCh* const targetNamespace)
440{
441        if (fTargetNamespace)
442                fMemoryManager->deallocate(fTargetNamespace);//delete [] fTargetNamespace;
443        fTargetNamespace = XMLString::replicate(targetNamespace, fMemoryManager);
444}
445
446inline void
447SchemaGrammar::setAttributeDeclRegistry(RefHashTableOf<XMLAttDef>* const attReg)
448{
449        fAttributeDeclRegistry = attReg;
450}
451
452inline void
453SchemaGrammar::setComplexTypeRegistry(RefHashTableOf<ComplexTypeInfo>* const other)
454{
455        fComplexTypeRegistry = other;
456}
457
458inline void
459SchemaGrammar::setGroupInfoRegistry(RefHashTableOf<XercesGroupInfo>* const other)
460{
461        fGroupInfoRegistry = other;
462}
463
464inline void
465SchemaGrammar::setAttGroupInfoRegistry(RefHashTableOf<XercesAttGroupInfo>* const other)
466{
467        fAttGroupInfoRegistry = other;
468}
469
470inline void
471SchemaGrammar::setValidSubstitutionGroups(RefHash2KeysTableOf<ElemVector>* const other)
472{
473        fValidSubstitutionGroups = other;
474}
475
476// ---------------------------------------------------------------------------
477//  SchemaGrammar: Virtual methods
478// ---------------------------------------------------------------------------
479inline Grammar::GrammarType SchemaGrammar::getGrammarType() const
480{
481        return Grammar::SchemaGrammarType;
482}
483
484inline const XMLCh* SchemaGrammar::getTargetNamespace() const
485{
486        return fTargetNamespace;
487}
488
489// Element Decl
490inline XMLSize_t SchemaGrammar::getElemId
491(
492        const   unsigned int    uriId
493        , const XMLCh* const    baseName
494        , const XMLCh* const
495        , unsigned int          scope
496) const
497{
498        //
499        //  In this case, we don't return zero to mean 'not found', so we have to
500        //  map it to the official not found value if we don't find it.
501        //
502        const SchemaElementDecl* decl = fElemDeclPool->getByKey(baseName, uriId, scope);
503        if (!decl)
504        {
505                decl = fGroupElemDeclPool->getByKey(baseName, uriId, scope);
506                if (!decl)
507                {
508                        return XMLElementDecl::fgInvalidElemId;
509                }
510        }
511        return decl->getId();
512}
513
514inline const XMLElementDecl* SchemaGrammar::getElemDecl
515(
516        const   unsigned int    uriId
517        , const XMLCh* const    baseName
518        , const XMLCh* const
519        , unsigned int          scope
520) const
521{
522        const SchemaElementDecl* decl = fElemDeclPool->getByKey(baseName, uriId, scope);
523        if (!decl)
524        {
525                decl = fGroupElemDeclPool->getByKey(baseName, uriId, scope);
526
527                if (!decl && fElemNonDeclPool)
528                {
529                        decl = fElemNonDeclPool->getByKey(baseName, uriId, scope);
530                }
531        }
532
533        return decl;
534}
535
536inline XMLElementDecl* SchemaGrammar::getElemDecl
537(
538        const   unsigned int    uriId
539        , const XMLCh* const    baseName
540        , const XMLCh* const
541        , unsigned int          scope
542)
543{
544        SchemaElementDecl* decl = fElemDeclPool->getByKey(baseName, uriId, scope);
545        if (!decl)
546        {
547                decl = fGroupElemDeclPool->getByKey(baseName, uriId, scope);
548
549                if (!decl && fElemNonDeclPool)
550                        decl = fElemNonDeclPool->getByKey(baseName, uriId, scope);
551        }
552
553        return decl;
554}
555
556inline const XMLElementDecl* SchemaGrammar::getElemDecl(const unsigned int elemId) const
557{
558        // Look up this element decl by id
559        const SchemaElementDecl* decl = fElemDeclPool->getById(elemId);
560
561        if (!decl)
562                decl = fGroupElemDeclPool->getById(elemId);
563
564        return decl;
565}
566
567inline XMLElementDecl* SchemaGrammar::getElemDecl(const unsigned int elemId)
568{
569        // Look up this element decl by id
570        SchemaElementDecl* decl = fElemDeclPool->getById(elemId);
571
572        if (!decl)
573                decl = fGroupElemDeclPool->getById(elemId);
574
575        return decl;
576}
577
578inline XMLSize_t
579SchemaGrammar::putElemDecl(XMLElementDecl* const elemDecl,
580                                                   const bool notDeclared)
581{
582        const SchemaElementDecl * schemaDecl = (const SchemaElementDecl *)elemDecl;
583        const XMLCh * baseName = schemaDecl->getBaseName();
584
585        if (notDeclared)
586        {
587                if (!fElemNonDeclPool)
588                {
589                        fElemNonDeclPool = new (fMemoryManager)RefHash3KeysIdPool<SchemaElementDecl>(29, true, 128, fMemoryManager);
590                }
591                return fElemNonDeclPool->put((void*)(baseName), schemaDecl->getURI(), schemaDecl->getEnclosingScope(), (SchemaElementDecl*)elemDecl);
592        }
593
594        return fElemDeclPool->put((void*)(baseName), schemaDecl->getURI(), schemaDecl->getEnclosingScope(), (SchemaElementDecl*)elemDecl);
595}
596
597inline XMLSize_t SchemaGrammar::putGroupElemDecl (XMLElementDecl* const elemDecl)   const
598{
599        const SchemaElementDecl * schemaDecl = (const SchemaElementDecl *)elemDecl;
600        const XMLCh * baseName = schemaDecl->getBaseName();
601
602        return fGroupElemDeclPool->put((void*)(baseName), schemaDecl->getURI(), schemaDecl->getEnclosingScope(), (SchemaElementDecl*)elemDecl);
603}
604
605// Notation Decl
606inline const XMLNotationDecl* SchemaGrammar::getNotationDecl(const XMLCh* const notName) const
607{
608        return fNotationDeclPool->getByKey(notName);
609}
610
611inline XMLNotationDecl* SchemaGrammar::getNotationDecl(const XMLCh* const notName)
612{
613        return fNotationDeclPool->getByKey(notName);
614}
615
616inline XMLSize_t SchemaGrammar::putNotationDecl(XMLNotationDecl* const notationDecl)   const
617{
618        return fNotationDeclPool->put(notationDecl);
619}
620
621inline bool SchemaGrammar::getValidated() const
622{
623        return fValidated;
624}
625
626inline void SchemaGrammar::setValidated(const bool newState)
627{
628        fValidated = newState;
629}
630
631inline unsigned int
632SchemaGrammar::getScopeCount () const
633{
634  return fScopeCount;
635}
636
637inline void
638SchemaGrammar::setScopeCount (unsigned int scopeCount)
639{
640  fScopeCount = scopeCount;
641}
642
643inline unsigned int
644SchemaGrammar::getAnonTypeCount () const
645{
646  return fAnonTypeCount;
647}
648
649inline void
650SchemaGrammar::setAnonTypeCount (unsigned int count)
651{
652  fAnonTypeCount = count;
653}
654
655#ifdef PRINT_DEBUG_MESSAGE
656
657inline static std::ostream & operator << (std::ostream & out, const NameIdPoolEnumerator<XMLNotationDecl> & iterator)
658{
659    if (iterator.hasMoreElements())
660        {
661                char leadingChar = '<';
662                NameIdPoolEnumerator<XMLNotationDecl> * itr =
663                        const_cast<NameIdPoolEnumerator<XMLNotationDecl>*>(&iterator);
664                do
665                {
666                        out << leadingChar << &(itr->nextElement());
667                        leadingChar = ',';
668                }
669                while (iterator.hasMoreElements());
670                out << '>';
671        }
672        return out;
673}
674
675inline static std::ostream & operator << (std::ostream & out, const RefHash3KeysIdPoolEnumerator<SchemaElementDecl> & iterator)
676{
677        out << "{ElemList:";
678    if (iterator.hasMoreElements())
679        {
680                RefHash3KeysIdPoolEnumerator<SchemaElementDecl> * itr =
681                        const_cast<RefHash3KeysIdPoolEnumerator<SchemaElementDecl>*>(&iterator);
682                out << &(itr->nextElement());
683                while (iterator.hasMoreElements())
684                {
685                        out << ',' << &(itr->nextElement());
686                }
687        }
688        out << '}';
689
690        return out;
691}
692
693inline static std::ostream & operator << (std::ostream & out, const SchemaGrammar * grammar)
694{
695        out << "[SchemaGrammar:";
696        if (!grammar)
697        {
698                out << "NULL";
699        }
700        else
701        {
702                out << (const XMLSchemaDescription*)grammar->getGrammarDescription()
703                        << ',' << grammar->getGrammarType()
704                        << ',' << grammar->getElemEnumerator()
705                        << ',' << grammar->getNotationEnumerator()
706                        << ',' << grammar->getComplexTypeRegistry();
707        }
708        out << ']';
709        return out;
710}
711#endif
712
713XERCES_CPP_NAMESPACE_END
714
715#endif
Note: See TracBrowser for help on using the repository browser.