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

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

Additional files for icXML 0.9

File size: 17.1 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 ComplexTypeInfo::setTypeName(const XMLCh* const typeName) {
443
444        fMemoryManager->deallocate(fTypeName);//delete [] fTypeName;
445        fMemoryManager->deallocate(fTypeLocalName);//delete [] fTypeLocalName;
446        fMemoryManager->deallocate(fTypeUri);//delete [] fTypeUri;
447
448        if (typeName)
449        {
450                fTypeName = XMLString::replicate(typeName, fMemoryManager);
451
452                int index = XMLString::indexOf(fTypeName, chComma);
453                XMLSize_t length = XMLString::stringLen(fTypeName);
454                fTypeLocalName = (XMLCh*) fMemoryManager->allocate
455                (
456                        (length - index + 1) * sizeof(XMLCh)
457                ); //new XMLCh[length - index + 1];
458                XMLString::subString(fTypeLocalName, fTypeName, index + 1, length, fMemoryManager);
459
460                fTypeUri = (XMLCh*) fMemoryManager->allocate
461                (
462                        (index + 1) * sizeof(XMLCh)
463                ); //new XMLCh[index + 1];
464                XMLString::subString(fTypeUri, fTypeName, 0, index, fMemoryManager);
465        }
466        else
467        {
468                fTypeName = fTypeLocalName = fTypeUri = 0;
469        }
470}
471
472inline void
473ComplexTypeInfo::setBaseDatatypeValidator(DatatypeValidator* const validator) {
474
475        fBaseDatatypeValidator = validator;
476}
477
478inline void
479ComplexTypeInfo::setDatatypeValidator(DatatypeValidator* const validator) {
480
481        fDatatypeValidator = validator;
482}
483
484inline void
485ComplexTypeInfo::setBaseComplexTypeInfo(ComplexTypeInfo* const typeInfo) {
486
487        fBaseComplexTypeInfo = typeInfo;
488}
489
490inline void ComplexTypeInfo::addElement(SchemaElementDecl* const elem) {
491
492        if (!fElements) {
493                fElements = new (fMemoryManager) RefVectorOf<SchemaElementDecl>(8, false, fMemoryManager);
494        }
495        else if (fElements->containsElement(elem)) {
496                return;
497        }
498
499        fElements->addElement(elem);
500}
501
502inline void ComplexTypeInfo::setAttWildCard(SchemaAttDef* const toAdopt) {
503
504        if (fAttWildCard) {
505           delete fAttWildCard;
506        }
507
508        fAttWildCard = toAdopt;
509}
510
511inline void ComplexTypeInfo::setAnonymous() {
512        fAnonymous = true;
513}
514
515// ---------------------------------------------------------------------------
516//  ComplexTypeInfo: Helper methods
517// ---------------------------------------------------------------------------
518inline bool ComplexTypeInfo::hasAttDefs() const
519{
520    return !fAttList->isEmpty();
521    // return !fAttDefs->isEmpty();
522}
523
524inline bool ComplexTypeInfo::contains(const XMLCh* const attName)
525{
526    SchemaAttDef** list = fAttList->fArray;
527
528    for (XMLSize_t i = 0; i < fAttList->fCount; i++)
529    {
530        if (XMLString::equals(attName, list[i]->getAttName()->getLocalPart()))
531        {
532            return true;
533        }
534    }
535
536//      RefHash2KeysTableOfEnumerator<SchemaAttDef> enumDefs(fAttDefs, false, fMemoryManager);
537
538//      while (enumDefs.hasMoreElements()) {
539
540//              if (XMLString::equals(attName, enumDefs.nextElement().getAttName()->getLocalPart())) {
541//                      return true;
542//              }
543//      }
544
545        return false;
546}
547
548#ifdef PRINT_DEBUG_MESSAGE
549
550static std::ostream & operator << (std::ostream & out, const ContentSpecNode * node);
551
552static std::ostream & operator << (std::ostream & out, const ComplexTypeInfo* typeInfo)
553{
554        if (typeInfo)
555        {
556                out << "(ComplexTypeInfo:"
557                                << typeInfo->getTypeName()
558                                << ',' << typeInfo->getTypeUri()
559                                << ',' << typeInfo->getContentType()
560                                << ':' << typeInfo->getContentSpec()
561                                << ')';
562        }
563        return out;
564}
565
566static std::ostream & operator << (std::ostream & out, RefHashTableOfEnumerator<ComplexTypeInfo> & iterator)
567{
568        if (!iterator.hasMoreElements())
569        {
570                char leadingChar = '{';
571                do
572                {
573                        const ComplexTypeInfo * item = &iterator.nextElement();
574                        out << leadingChar << item;
575                        leadingChar = ',';
576                }
577                while (iterator.hasMoreElements());
578                out << '}';
579        }
580        return out;
581}
582
583static std::ostream & operator << (std::ostream & out, RefHashTableOf<ComplexTypeInfo> * table)
584{
585        if (table && !table->isEmpty())
586        {
587                RefHashTableOfEnumerator<ComplexTypeInfo> iterator(table);
588                out << iterator;
589        }
590        return out;
591}
592
593#endif
594
595XERCES_CPP_NAMESPACE_END
596
597#endif
598
599/**
600  * End of file ComplexTypeInfo.hpp
601  */
602
Note: See TracBrowser for help on using the repository browser.