source: icXML/icXML-devel/src/icxercesc/validators/schema/ComplexTypeInfo.hpp @ 3157

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

Fixes for icXML 0.9

File size: 15.9 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: ComplexTypeInfo.hpp 932887 2010-04-11 13:04:59Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_COMPLEXTYPEINFO_HPP)
23#define XERCESC_INCLUDE_GUARD_COMPLEXTYPEINFO_HPP
24
25
26/**
27  * The class act as a place holder to store complex type information.
28  *
29  * The class is intended for internal use.
30  */
31
32// ---------------------------------------------------------------------------
33//  Includes
34// ---------------------------------------------------------------------------
35#include <icxercesc/util/XMLString.hpp>
36#include <xercesc/util/RefHash2KeysTableOf.hpp>
37#include <xercesc/util/RefVectorOf.hpp>
38#include <icxercesc/framework/XMLElementDecl.hpp>
39#include <icxercesc/framework/XMLContentModel.hpp>
40#include <icxercesc/validators/schema/SchemaAttDef.hpp>
41#include <icxercesc/validators/schema/SchemaAttDefList.hpp>
42#include <xercesc/internal/XSerializable.hpp>
43#include <icxmlc/XMLConfig.hpp>
44
45XERCES_CPP_NAMESPACE_BEGIN
46
47
48// ---------------------------------------------------------------------------
49//  Forward Declarations
50// ---------------------------------------------------------------------------
51class DatatypeValidator;
52class ContentSpecNode;
53// class SchemaAttDefList;
54class SchemaElementDecl;
55class XSDLocator;
56class XMLNamespaceResolver;
57
58class VALIDATORS_EXPORT ComplexTypeInfo : public XSerializable, public XMemory
59{
60public:
61        // -----------------------------------------------------------------------
62        //  Public Constructors/Destructor
63        // -----------------------------------------------------------------------
64        ComplexTypeInfo(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
65        ~ComplexTypeInfo();
66
67        // -----------------------------------------------------------------------
68        //  Getter methods
69        // -----------------------------------------------------------------------
70        bool                     getAbstract() const;
71        bool                     getAdoptContentSpec() const;
72        bool                     containsAttWithTypeId() const;
73        bool                     getPreprocessed() const;
74        int                      getDerivedBy() const;
75        int                      getBlockSet() const;
76        int                      getFinalSet() const;
77        unsigned int             getScopeDefined() const;
78        unsigned int             getElementId() const;
79        int                      getContentType() const;
80        XMLSize_t                elementCount() const;
81        XMLCh*                   getTypeName() const;
82        DatatypeValidator*       getBaseDatatypeValidator() const;
83        DatatypeValidator*       getDatatypeValidator() const;
84        ComplexTypeInfo*         getBaseComplexTypeInfo() const;
85        ContentSpecNode*         getContentSpec() const;
86        const SchemaAttDef*      getAttWildCard() const;
87        SchemaAttDef*            getAttWildCard();
88        const SchemaAttDef*      getAttDef(const XMLCh* const baseName,
89                                                                           const int uriId) const;
90        SchemaAttDef*            getAttDef(const XMLCh* const baseName,
91                                                                           const int uriId);
92        XMLAttDefList&           getAttDefList() const;
93        const SchemaElementDecl* elementAt(const XMLSize_t index) const;
94        SchemaElementDecl*       elementAt(const XMLSize_t index);
95        XMLContentModel*         getContentModel(const bool checkUPA = false);
96        const XMLCh*             getFormattedContentModel ()   const;
97        XSDLocator*              getLocator() const;
98        const XMLCh*             getTypeLocalName() const;
99        const XMLCh*             getTypeUri() const;
100
101        /**
102         * returns true if this type is anonymous
103         **/
104        bool getAnonymous() const;
105
106        // -----------------------------------------------------------------------
107        //  Setter methods
108        // -----------------------------------------------------------------------
109        void setAbstract(const bool isAbstract);
110        void setAdoptContentSpec(const bool toAdopt);
111        void setAttWithTypeId(const bool value);
112        void setPreprocessed(const bool aValue = true);
113        void setDerivedBy(const int derivedBy);
114        void setBlockSet(const int blockSet);
115        void setFinalSet(const int finalSet);
116        void setScopeDefined(const unsigned int scopeDefined);
117        void setElementId(const unsigned int elemId);
118        void setTypeName(const XMLCh* const typeName);
119        void setContentType(const int contentType);
120        void setBaseDatatypeValidator(DatatypeValidator* const baseValidator);
121        void setDatatypeValidator(DatatypeValidator* const validator);
122        void setBaseComplexTypeInfo(ComplexTypeInfo* const typeInfo);
123        void setContentSpec(ContentSpecNode* const toAdopt);
124        void setAttWildCard(SchemaAttDef* const toAdopt);
125        void addAttDef(SchemaAttDef* const toAdd);
126        void addElement(SchemaElementDecl* const toAdd);
127        void setLocator(XSDLocator* const aLocator);
128
129        /**
130         * sets this type to be anonymous
131         **/
132        void setAnonymous();
133
134        // -----------------------------------------------------------------------
135        //  Helper methods
136        // -----------------------------------------------------------------------
137        bool hasAttDefs() const;
138        bool contains(const XMLCh* const attName);
139
140        void checkUniqueParticleAttribution
141        (
142                SchemaGrammar*                   const pGrammar
143          , GrammarResolver*             const pGrammarResolver
144          , XMLNamespaceResolver*    const pUriResolver
145          , XMLValidator*                        const pValidator
146        );
147
148        /**
149          * Return a singleton that represents 'anyType'
150          *
151          * @param emptyNSId the uri id of the empty namespace
152          */
153        static ComplexTypeInfo* getAnyType(unsigned int emptyNSId);
154
155        /**
156          *  Notification that lazy data has been deleted
157          */
158        static void reinitAnyType();
159
160        /** @@@ DEPRECATED @@@ **/
161        void checkUniqueParticleAttribution
162        (
163                SchemaGrammar*    const pGrammar
164          , GrammarResolver*  const pGrammarResolver
165          , XMLStringPool*    const pStringPool
166          , XMLValidator*     const pValidator
167        );
168
169        /***
170         * Support for Serialization/De-serialization
171         ***/
172        DECL_XSERIALIZABLE(ComplexTypeInfo)
173
174private:
175        // -----------------------------------------------------------------------
176        //  Unimplemented constructors and operators
177        // -----------------------------------------------------------------------
178        ComplexTypeInfo(const ComplexTypeInfo& elemInfo);
179        ComplexTypeInfo& operator= (const ComplexTypeInfo& other);
180
181        // -----------------------------------------------------------------------
182        //  Private helper methods
183        // -----------------------------------------------------------------------
184        void faultInAttDefList() const;
185        bool useRepeatingLeafNodes(ContentSpecNode* particle);
186        XMLContentModel* makeContentModel(bool checkUPA = false);
187        XMLCh* formatContentModel () const ;
188        ContentSpecNode* expandContentModel(ContentSpecNode* const curNode, int minOccurs, int maxOccurs, bool bAllowCompactSyntax);
189        ContentSpecNode* convertContentSpecTree(ContentSpecNode* const curNode, bool checkUPA, bool bAllowCompactSyntax);
190        void resizeContentSpecOrgURI();
191
192        // -----------------------------------------------------------------------
193        //  Private data members
194        // -----------------------------------------------------------------------
195        bool                               fAnonymous;
196        bool                               fAbstract;
197        bool                               fAdoptContentSpec;
198        bool                               fAttWithTypeId;
199        bool                               fPreprocessed;
200        int                                fDerivedBy;
201        int                                fBlockSet;
202        int                                fFinalSet;
203        unsigned int                       fScopeDefined;
204        int                                fContentType;
205
206        unsigned int                       fElementId;
207        unsigned int                       fUniqueURI;
208        unsigned int                       fContentSpecOrgURISize;
209
210        XMLCh*                             fTypeName;
211        XMLCh*                             fTypeLocalName;
212        XMLCh*                             fTypeUri;
213        DatatypeValidator*                 fBaseDatatypeValidator;
214        DatatypeValidator*                 fDatatypeValidator;
215        ComplexTypeInfo*                   fBaseComplexTypeInfo;
216        ContentSpecNode*                   fContentSpec;
217        SchemaAttDef*                      fAttWildCard;
218    SchemaAttDefList                   fAttList;
219        RefVectorOf<SchemaElementDecl>*    fElements;
220        // TODO: should this really be a hash table? is it populated enough to be worthwhile?
221//      RefHash2KeysTableOf<SchemaAttDef>* fAttDefs;
222        XMLContentModel*                   fContentModel;
223        XMLCh*                             fFormattedModel;
224        unsigned int*                      fContentSpecOrgURI;
225        XSDLocator*                        fLocator;
226        MemoryManager*                     fMemoryManager;
227
228        static ComplexTypeInfo*            fAnyType;
229
230        friend class XMLInitializer;
231};
232
233// ---------------------------------------------------------------------------
234//  ComplexTypeInfo: Getter methods
235// ---------------------------------------------------------------------------
236inline bool ComplexTypeInfo::getAbstract() const {
237
238        return fAbstract;
239}
240
241inline bool ComplexTypeInfo::getAdoptContentSpec() const {
242
243        return fAdoptContentSpec;
244}
245
246inline bool ComplexTypeInfo::containsAttWithTypeId() const {
247
248        return fAttWithTypeId;
249}
250
251inline bool ComplexTypeInfo::getPreprocessed() const {
252
253        return fPreprocessed;
254}
255
256inline int ComplexTypeInfo::getDerivedBy() const {
257
258        return fDerivedBy;
259}
260
261inline int ComplexTypeInfo::getBlockSet() const {
262
263        return fBlockSet;
264}
265
266inline int ComplexTypeInfo::getFinalSet() const {
267
268        return fFinalSet;
269}
270
271inline unsigned int ComplexTypeInfo::getScopeDefined() const {
272
273        return fScopeDefined;
274}
275
276inline unsigned int ComplexTypeInfo::getElementId() const {
277
278        return fElementId;
279}
280
281inline int ComplexTypeInfo::getContentType() const {
282
283        return fContentType;
284}
285
286inline XMLSize_t ComplexTypeInfo::elementCount() const {
287
288        if (fElements) {
289                return fElements->size();
290        }
291
292        return 0;
293}
294
295inline XMLCh* ComplexTypeInfo::getTypeName() const {
296        return fTypeName;
297}
298
299inline DatatypeValidator* ComplexTypeInfo::getBaseDatatypeValidator() const {
300
301        return fBaseDatatypeValidator;
302}
303
304inline DatatypeValidator* ComplexTypeInfo::getDatatypeValidator() const {
305
306        return fDatatypeValidator;
307}
308
309inline ComplexTypeInfo* ComplexTypeInfo::getBaseComplexTypeInfo() const {
310
311        return fBaseComplexTypeInfo;
312}
313
314inline ContentSpecNode* ComplexTypeInfo::getContentSpec() const {
315
316        return fContentSpec;
317}
318
319inline const SchemaAttDef* ComplexTypeInfo::getAttWildCard() const {
320
321        return fAttWildCard;
322}
323
324inline SchemaAttDef* ComplexTypeInfo::getAttWildCard() {
325
326        return fAttWildCard;
327}
328
329inline const SchemaAttDef* ComplexTypeInfo::getAttDef(const XMLCh* const baseName, const int uriId) const
330{
331    return static_cast<const SchemaAttDef*>(fAttList.findAttDefLocalPart(uriId, baseName));
332//      return fAttDefs->get(baseName, uriId);
333}
334
335inline SchemaAttDef* ComplexTypeInfo::getAttDef(const XMLCh* const baseName, const int uriId)
336{
337    return static_cast<SchemaAttDef*>(fAttList.findAttDefLocalPart(uriId, baseName));
338    // return fAttDefs->get(baseName, uriId);
339}
340
341inline SchemaElementDecl*
342ComplexTypeInfo::elementAt(const XMLSize_t index) {
343
344        if (!fElements) {
345                return 0; // REVISIT - need to throw an exception
346        }
347
348        return fElements->elementAt(index);
349}
350
351inline const SchemaElementDecl*
352ComplexTypeInfo::elementAt(const XMLSize_t index) const {
353
354        if (!fElements) {
355                return 0; // REVISIT - need to throw an exception
356        }
357
358        return fElements->elementAt(index);
359}
360
361inline XMLContentModel* ComplexTypeInfo::getContentModel(const bool checkUPA)
362{
363        if (!fContentModel && fContentSpec)
364                fContentModel = makeContentModel(checkUPA);
365
366        return fContentModel;
367}
368
369inline XSDLocator* ComplexTypeInfo::getLocator() const
370{
371        return fLocator;
372}
373
374inline bool ComplexTypeInfo::getAnonymous() const {
375        return fAnonymous;
376}
377
378inline const XMLCh* ComplexTypeInfo::getTypeLocalName() const
379{
380        return fTypeLocalName;
381}
382
383inline const XMLCh* ComplexTypeInfo::getTypeUri() const
384{
385   return fTypeUri;
386}
387
388// ---------------------------------------------------------------------------
389//  ComplexTypeInfo: Setter methods
390// ---------------------------------------------------------------------------
391inline void ComplexTypeInfo::setAbstract(const bool isAbstract) {
392
393        fAbstract = isAbstract;
394}
395
396inline void ComplexTypeInfo::setAdoptContentSpec(const bool toAdopt) {
397
398        fAdoptContentSpec = toAdopt;
399}
400
401inline void ComplexTypeInfo::setAttWithTypeId(const bool value) {
402
403        fAttWithTypeId = value;
404}
405
406inline void ComplexTypeInfo::setPreprocessed(const bool aValue) {
407
408        fPreprocessed = aValue;
409}
410
411inline void ComplexTypeInfo::setDerivedBy(const int derivedBy) {
412
413        fDerivedBy = derivedBy;
414}
415
416inline void ComplexTypeInfo::setBlockSet(const int blockSet) {
417
418        fBlockSet = blockSet;
419}
420
421inline void ComplexTypeInfo::setFinalSet(const int finalSet) {
422
423        fFinalSet = finalSet;
424}
425
426inline void ComplexTypeInfo::setScopeDefined(const unsigned int scopeDefined) {
427
428        fScopeDefined = scopeDefined;
429}
430
431inline void ComplexTypeInfo::setElementId(const unsigned int elemId) {
432
433        fElementId = elemId;
434}
435
436inline void
437ComplexTypeInfo::setContentType(const int contentType) {
438
439        fContentType = contentType;
440}
441
442inline void
443ComplexTypeInfo::setBaseDatatypeValidator(DatatypeValidator* const validator) {
444
445        fBaseDatatypeValidator = validator;
446}
447
448inline void
449ComplexTypeInfo::setDatatypeValidator(DatatypeValidator* const validator) {
450
451        fDatatypeValidator = validator;
452}
453
454inline void
455ComplexTypeInfo::setBaseComplexTypeInfo(ComplexTypeInfo* const typeInfo) {
456
457        fBaseComplexTypeInfo = typeInfo;
458}
459
460inline void ComplexTypeInfo::setAttWildCard(SchemaAttDef* const toAdopt) {
461
462        if (fAttWildCard) {
463           delete fAttWildCard;
464        }
465
466        fAttWildCard = toAdopt;
467}
468
469inline void ComplexTypeInfo::setAnonymous() {
470        fAnonymous = true;
471}
472
473// ---------------------------------------------------------------------------
474//  ComplexTypeInfo: Helper methods
475// ---------------------------------------------------------------------------
476inline bool ComplexTypeInfo::hasAttDefs() const
477{
478    return !fAttList.isEmpty();
479    // return !fAttDefs->isEmpty();
480}
481
482inline bool ComplexTypeInfo::contains(const XMLCh* const attName)
483{
484    SchemaAttDef** list = fAttList.fArray;
485
486    for (XMLSize_t i = 0; i < fAttList.fCount; i++)
487    {
488        if (XMLString::equals(attName, list[i]->getAttName()->getLocalPart()))
489        {
490            return true;
491        }
492    }
493
494//      RefHash2KeysTableOfEnumerator<SchemaAttDef> enumDefs(fAttDefs, false, fMemoryManager);
495
496//      while (enumDefs.hasMoreElements()) {
497
498//              if (XMLString::equals(attName, enumDefs.nextElement().getAttName()->getLocalPart())) {
499//                      return true;
500//              }
501//      }
502
503        return false;
504}
505
506#ifdef PRINT_DEBUG_MESSAGE
507
508static std::ostream & operator << (std::ostream & out, const ContentSpecNode * node);
509
510static std::ostream & operator << (std::ostream & out, const ComplexTypeInfo* typeInfo)
511{
512        if (typeInfo)
513        {
514                out << "(ComplexTypeInfo:"
515                                << typeInfo->getTypeName()
516                                << ',' << typeInfo->getTypeUri()
517                                << ',' << typeInfo->getContentType()
518                                << ':' << typeInfo->getContentSpec()
519                                << ')';
520        }
521        return out;
522}
523
524static std::ostream & operator << (std::ostream & out, RefHashTableOfEnumerator<ComplexTypeInfo> & iterator)
525{
526        if (!iterator.hasMoreElements())
527        {
528                char leadingChar = '{';
529                do
530                {
531                        const ComplexTypeInfo * item = &iterator.nextElement();
532                        out << leadingChar << item;
533                        leadingChar = ',';
534                }
535                while (iterator.hasMoreElements());
536                out << '}';
537        }
538        return out;
539}
540
541static std::ostream & operator << (std::ostream & out, RefHashTableOf<ComplexTypeInfo> * table)
542{
543        if (table && !table->isEmpty())
544        {
545                RefHashTableOfEnumerator<ComplexTypeInfo> iterator(table);
546                out << iterator;
547        }
548        return out;
549}
550
551#endif
552
553XERCES_CPP_NAMESPACE_END
554
555#endif
556
557/**
558  * End of file ComplexTypeInfo.hpp
559  */
560
Note: See TracBrowser for help on using the repository browser.