source: icXML/icXML-devel/src/xercesc/validators/schema/ComplexTypeInfo.hpp @ 2722

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

Original Xerces files with import mods for icxercesc

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