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

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

Updates for build

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