source: icXML/icXML-devel/src/icxercesc/validators/schema/SchemaElementDecl.hpp @ 3564

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

Changes to icxercesc files

File size: 14.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: SchemaElementDecl.hpp 932887 2010-04-11 13:04:59Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_SCHEMAELEMENTDECL_HPP)
23#define XERCESC_INCLUDE_GUARD_SCHEMAELEMENTDECL_HPP
24
25#include <icxercesc/util/QName.hpp>
26#include <icxercesc/validators/common/Grammar.hpp>
27#include <icxercesc/validators/schema/ComplexTypeInfo.hpp>
28#include <icxercesc/validators/schema/identity/IdentityConstraint.hpp>
29#include <xercesc/validators/datatype/DatatypeValidator.hpp>
30#include <xercesc/validators/schema/PSVIDefs.hpp>
31
32XERCES_CPP_NAMESPACE_BEGIN
33
34class ContentSpecNode;
35class SchemaAttDefList;
36class XMLStringPool;
37
38//
39//  This class is a derivative of the basic element decl. This one implements
40//  the virtuals so that they work for a Schema.
41//
42class VALIDATORS_EXPORT SchemaElementDecl : public XMLElementDecl
43{
44public :
45
46        // -----------------------------------------------------------------------
47        //  Class specific types
48        //
49        //  ModelTypes
50        //      Indicates the type of content model that an element has. This
51        //      indicates how the content model is represented and validated.
52        // -----------------------------------------------------------------------
53        enum ModelTypes
54        {
55                Empty
56                , Any
57                , Mixed_Simple
58                , Mixed_Complex
59                , Children
60                , Simple
61                , ElementOnlyEmpty
62                , ModelTypes_Count
63        };
64
65        // -----------------------------------------------------------------------
66        //  Constructors and Destructor
67        // -----------------------------------------------------------------------
68    SchemaElementDecl(XMLStringPool* const stringManager, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
69
70        SchemaElementDecl
71        (
72          const XMLCh* const    prefix
73        , const XMLCh* const    localPart
74        , const int             uriId
75        , XMLStringPool * const stringManager
76        , const ModelTypes      modelType = Any
77        , const unsigned int    enclosingScope = Grammar::TOP_LEVEL_SCOPE
78        , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager
79        );
80
81    SchemaElementDecl
82    (
83          const QName* const   elementName
84        , const ModelTypes     modelType = Any
85        , const unsigned int   enclosingScope = Grammar::TOP_LEVEL_SCOPE
86        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
87    );
88
89        ~SchemaElementDecl();
90
91    // -----------------------------------------------------------------------
92    //  Deprecated Constructors
93    // -----------------------------------------------------------------------
94    SchemaElementDecl(MemoryManager* const manager);
95
96    SchemaElementDecl
97    (
98          const XMLCh* const   prefix
99        , const XMLCh* const   localPart
100        , const int            uriId
101        , const ModelTypes     modelType = Any
102        , const unsigned int   enclosingScope = Grammar::TOP_LEVEL_SCOPE
103        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
104    );
105
106        // -----------------------------------------------------------------------
107        //  The virtual element decl interface
108        // -----------------------------------------------------------------------
109        virtual XMLAttDefList& getAttDefList() const;
110        virtual CharDataOpts getCharDataOpts() const;
111        virtual bool hasAttDefs() const;
112        virtual const ContentSpecNode* getContentSpec() const;
113        virtual ContentSpecNode* getContentSpec();
114        virtual void setContentSpec(ContentSpecNode* toAdopt);
115        virtual XMLContentModel* getContentModel();
116        virtual void setContentModel(XMLContentModel* const newModelToAdopt);
117        virtual const XMLCh* getFormattedContentModel ()   const;
118
119        // -----------------------------------------------------------------------
120        //  Getter methods
121        // -----------------------------------------------------------------------
122        const SchemaAttDef* getAttDef(const XMLCh* const baseName, const int uriId) const;
123        SchemaAttDef* getAttDef(const XMLCh* const baseName, const int uriId);
124        const SchemaAttDef* getAttWildCard() const;
125        SchemaAttDef* getAttWildCard();
126        ModelTypes getModelType() const;
127        PSVIDefs::PSVIScope getPSVIScope() const;
128        DatatypeValidator* getDatatypeValidator() const;
129        unsigned int getEnclosingScope() const;
130        int getFinalSet() const;
131        int getBlockSet() const;
132        int getMiscFlags() const;
133        XMLCh* getDefaultValue() const;
134        ComplexTypeInfo* getComplexTypeInfo() const;
135        virtual bool isGlobalDecl() const;
136        SchemaElementDecl* getSubstitutionGroupElem() const;
137
138        // -----------------------------------------------------------------------
139        //  Setter methods
140        // -----------------------------------------------------------------------
141        void setModelType(const SchemaElementDecl::ModelTypes toSet);
142        void setPSVIScope(const PSVIDefs::PSVIScope toSet);
143        void setDatatypeValidator(DatatypeValidator* newDatatypeValidator);
144        void setEnclosingScope(const unsigned int enclosingScope);
145        void setFinalSet(const int finalSet);
146        void setBlockSet(const int blockSet);
147        void setMiscFlags(const int flags);
148        void setDefaultValue(const XMLCh* const value);
149        void setComplexTypeInfo(ComplexTypeInfo* const typeInfo);
150        void setAttWildCard(SchemaAttDef* const attWildCard);
151        void setSubstitutionGroupElem(SchemaElementDecl* const elemDecl);
152
153        // -----------------------------------------------------------------------
154        //  IC methods
155        // -----------------------------------------------------------------------
156        void addIdentityConstraint(IdentityConstraint* const ic);
157        XMLSize_t getIdentityConstraintCount() const;
158        IdentityConstraint* getIdentityConstraintAt(XMLSize_t index) const;
159
160        /***
161         * Support for Serialization/De-serialization
162         ***/
163        DECL_XSERIALIZABLE(SchemaElementDecl)
164
165        virtual XMLElementDecl::objectType  getObjectType() const;
166
167private :
168        // -----------------------------------------------------------------------
169        //  Unimplemented constructors and operators
170        // -----------------------------------------------------------------------
171        SchemaElementDecl(const SchemaElementDecl&);
172        SchemaElementDecl& operator=(const SchemaElementDecl&);
173
174        // -----------------------------------------------------------------------
175        //  Private data members
176        //
177        //  fModelType
178        //      The content model type of this element. This tells us what kind
179        //      of content model to create.
180        //
181        //  fDatatypeValidator
182        //      The DatatypeValidator used to validate this element type.
183        //
184        //  fEnclosingScope
185        //      The enclosing scope where this element is declared.
186        //
187        //  fFinalSet
188        //      The value set of the 'final' attribute.
189        //
190        //  fBlockSet
191        //      The value set of the 'block' attribute.
192        //
193        //  fMiscFlags
194        //      Stores 'abstract/nullable' values
195        //
196        //  fDefaultValue
197        //      The default/fixed value
198        //
199        //  fComplexTypeInfo
200        //      Stores complex type information
201        //      (no need to delete - handled by schema grammar)
202        //
203        //  fAttDefs
204        //      The list of attributes that are faulted in for this element
205        //      when ComplexTypeInfo does not exist.  We want to keep track
206        //      of these faulted in attributes to avoid duplicate redundant
207        //      error.
208        //
209        //  fIdentityConstraints
210        //      Store information about an element identity constraints.
211        //
212        //  fAttWildCard
213        //      Store wildcard attribute in the case of an element with a type of
214        //      'anyType'.
215        //
216        //  fSubstitutionGroupElem
217        //      The substitution group element declaration.
218        // -----------------------------------------------------------------------
219
220        // -----------------------------------------------------------------------
221        ModelTypes                         fModelType;
222        PSVIDefs::PSVIScope                fPSVIScope;
223
224        unsigned int                       fEnclosingScope;
225        int                                fFinalSet;
226        int                                fBlockSet;
227        int                                fMiscFlags;
228        XMLCh*                             fDefaultValue;
229        ComplexTypeInfo*                   fComplexTypeInfo;
230        RefHash2KeysTableOf<SchemaAttDef>* fAttDefs;
231        RefVectorOf<IdentityConstraint>*   fIdentityConstraints;
232        SchemaAttDef*                      fAttWildCard;
233        SchemaElementDecl*                 fSubstitutionGroupElem;
234        DatatypeValidator*                 fDatatypeValidator;
235};
236
237// ---------------------------------------------------------------------------
238//  SchemaElementDecl: XMLElementDecl virtual interface implementation
239// ---------------------------------------------------------------------------
240inline ContentSpecNode* SchemaElementDecl::getContentSpec()
241{
242        if (fComplexTypeInfo != 0) {
243                return fComplexTypeInfo->getContentSpec();
244        }
245
246        return 0;
247}
248
249inline const ContentSpecNode* SchemaElementDecl::getContentSpec() const
250{
251        if (fComplexTypeInfo != 0) {
252                return fComplexTypeInfo->getContentSpec();
253        }
254
255        return 0;
256}
257
258inline void
259SchemaElementDecl::setContentSpec(ContentSpecNode*)
260{
261        //Handled by complexType
262}
263
264inline XMLContentModel* SchemaElementDecl::getContentModel()
265{
266        if (fComplexTypeInfo != 0) {
267                return fComplexTypeInfo->getContentModel();
268        }
269        return 0;
270}
271
272inline void
273SchemaElementDecl::setContentModel(XMLContentModel* const)
274{
275        //Handled by complexType
276}
277
278
279// ---------------------------------------------------------------------------
280//  SchemaElementDecl: Getter methods
281// ---------------------------------------------------------------------------
282inline SchemaElementDecl::ModelTypes SchemaElementDecl::getModelType() const
283{
284        if (fComplexTypeInfo) {
285                return (SchemaElementDecl::ModelTypes) fComplexTypeInfo->getContentType();
286        }
287
288        return fModelType;
289}
290
291inline PSVIDefs::PSVIScope SchemaElementDecl::getPSVIScope() const
292{
293        return fPSVIScope;
294}
295
296inline DatatypeValidator* SchemaElementDecl::getDatatypeValidator() const
297{
298        return fDatatypeValidator;
299}
300
301inline unsigned int SchemaElementDecl::getEnclosingScope() const
302{
303        return fEnclosingScope;
304}
305
306inline int SchemaElementDecl::getFinalSet() const
307{
308        return fFinalSet;
309}
310
311inline int SchemaElementDecl::getBlockSet() const
312{
313        return fBlockSet;
314}
315
316inline int SchemaElementDecl::getMiscFlags() const
317{
318        return fMiscFlags;
319}
320
321inline XMLCh* SchemaElementDecl::getDefaultValue() const
322{
323        return fDefaultValue;
324}
325
326inline ComplexTypeInfo* SchemaElementDecl::getComplexTypeInfo() const
327{
328        return fComplexTypeInfo;
329}
330
331inline const SchemaAttDef* SchemaElementDecl::getAttWildCard() const
332{
333        return fAttWildCard;
334}
335
336inline SchemaAttDef* SchemaElementDecl::getAttWildCard()
337{
338        return fAttWildCard;
339}
340
341inline bool SchemaElementDecl::isGlobalDecl() const
342{
343        return (fEnclosingScope == Grammar::TOP_LEVEL_SCOPE);
344}
345
346inline SchemaElementDecl*
347SchemaElementDecl::getSubstitutionGroupElem() const
348{
349        return fSubstitutionGroupElem;
350}
351
352// ---------------------------------------------------------------------------
353//  SchemaElementDecl: Setter methods
354// ---------------------------------------------------------------------------
355inline void
356SchemaElementDecl::setModelType(const SchemaElementDecl::ModelTypes toSet)
357{
358        fModelType = toSet;
359}
360
361inline void
362SchemaElementDecl::setPSVIScope(const PSVIDefs::PSVIScope toSet)
363{
364        fPSVIScope = toSet;
365}
366
367inline void SchemaElementDecl::setDatatypeValidator(DatatypeValidator* newDatatypeValidator)
368{
369        fDatatypeValidator = newDatatypeValidator;
370}
371
372inline void SchemaElementDecl::setEnclosingScope(const unsigned int newEnclosingScope)
373{
374        fEnclosingScope = newEnclosingScope;
375}
376
377inline void SchemaElementDecl::setFinalSet(const int finalSet)
378{
379        fFinalSet = finalSet;
380}
381
382inline void SchemaElementDecl::setBlockSet(const int blockSet)
383{
384        fBlockSet = blockSet;
385}
386
387inline void SchemaElementDecl::setMiscFlags(const int flags)
388{
389        fMiscFlags = flags;
390}
391
392inline void SchemaElementDecl::setDefaultValue(const XMLCh* const value)
393{
394        if (fDefaultValue) {
395                getMemoryManager()->deallocate(fDefaultValue);//delete[] fDefaultValue;
396        }
397
398        fDefaultValue = XMLString::replicate(value, getMemoryManager());
399}
400
401inline void
402SchemaElementDecl::setComplexTypeInfo(ComplexTypeInfo* const typeInfo)
403{
404        fComplexTypeInfo = typeInfo;
405}
406
407inline void
408SchemaElementDecl::setAttWildCard(SchemaAttDef* const attWildCard)
409{
410    delete fAttWildCard;
411        fAttWildCard = attWildCard;
412}
413
414inline void
415SchemaElementDecl::setSubstitutionGroupElem(SchemaElementDecl* const elemDecl)
416{
417        fSubstitutionGroupElem = elemDecl;
418}
419
420// ---------------------------------------------------------------------------
421//  SchemaElementDecl: IC methods
422// ---------------------------------------------------------------------------
423inline void
424SchemaElementDecl::addIdentityConstraint(IdentityConstraint* const ic)
425{
426    if (unlikely(!fIdentityConstraints))
427    {
428                fIdentityConstraints = new (getMemoryManager()) RefVectorOf<IdentityConstraint>(16, true, getMemoryManager());
429        }
430        fIdentityConstraints->addElement(ic);
431}
432
433inline XMLSize_t SchemaElementDecl::getIdentityConstraintCount() const
434{
435    return fIdentityConstraints ? fIdentityConstraints->size() : 0;
436}
437
438inline IdentityConstraint*
439SchemaElementDecl::getIdentityConstraintAt(XMLSize_t index) const
440{
441    assert (fIdentityConstraints);
442    return fIdentityConstraints->elementAt(index);;
443}
444
445#ifdef PRINT_DEBUG_MESSAGE
446static std::ostream & operator << (std::ostream & out, const SchemaElementDecl & elemDecl)
447{
448    out << '('
449        << elemDecl.getFullName()
450        << ',';
451
452    switch (elemDecl.getModelType())
453    {
454        case SchemaElementDecl::Empty: out << "Empty"; break;
455        case SchemaElementDecl::Any: out << "Any"; break;
456        case SchemaElementDecl::Mixed_Simple: out << "Mixed_Simple"; break;
457        case SchemaElementDecl::Mixed_Complex: out << "Mixed_Complex"; break;
458        case SchemaElementDecl::Children: out << "Children"; break;
459        case SchemaElementDecl::Simple: out << "Simple"; break;
460        case SchemaElementDecl::ElementOnlyEmpty: out << "ElementOnlyEmpty"; break;
461    }
462
463    out << ',';
464
465    switch (elemDecl.getCreateReason())
466    {
467        case XMLElementDecl::NoReason: out << "NoReason"; break;
468        case XMLElementDecl::Declared: out << "Declared"; break;
469        case XMLElementDecl::AttList: out << "AttList"; break;
470        case XMLElementDecl::InContentModel: out << "InContentModel"; break;
471        case XMLElementDecl::AsRootElem: out << "AsRootElem"; break;
472        case XMLElementDecl::JustFaultIn: out << "JustFaultIn"; break;
473    }
474
475    out << ',' << elemDecl.getURI()
476        << ',' << elemDecl.getEnclosingScope()
477        << ')';
478    return out;
479}
480
481static std::ostream & operator << (std::ostream & out, const SchemaElementDecl * elemDecl)
482{
483    if (likely(elemDecl != 0))
484        {
485        out << *elemDecl;
486        }
487        return out;
488}
489#endif
490
491XERCES_CPP_NAMESPACE_END
492
493#endif
Note: See TracBrowser for help on using the repository browser.