source: icXML/icXML-devel/src/xercesc/validators/schema/SchemaElementDecl.hpp @ 2736

Last change on this file since 2736 was 2736, checked in by cameron, 7 years ago

icxml versions of SchemaValidator?.cpp, ComplexTypeInfo?.hpp

File size: 13.5 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 <xercesc/validators/common/Grammar.hpp>
27#include <icxercesc/validators/schema/ComplexTypeInfo.hpp>
28#include <xercesc/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    // -----------------------------------------------------------------------
104    //  Getter methods
105    // -----------------------------------------------------------------------
106    const SchemaAttDef* getAttDef(const XMLCh* const baseName, const int uriId) const;
107    SchemaAttDef* getAttDef(const XMLCh* const baseName, const int uriId);
108    const SchemaAttDef* getAttWildCard() const;
109    SchemaAttDef* getAttWildCard();
110    ModelTypes getModelType() const;
111    PSVIDefs::PSVIScope getPSVIScope() const;
112    DatatypeValidator* getDatatypeValidator() const;
113    unsigned int getEnclosingScope() const;
114    int getFinalSet() const;
115    int getBlockSet() const;
116    int getMiscFlags() const;
117    XMLCh* getDefaultValue() const;
118    ComplexTypeInfo* getComplexTypeInfo() const;
119    virtual bool isGlobalDecl() const;
120    SchemaElementDecl* getSubstitutionGroupElem() const;
121
122    // -----------------------------------------------------------------------
123    //  Setter methods
124    // -----------------------------------------------------------------------
125    void setModelType(const SchemaElementDecl::ModelTypes toSet);
126    void setPSVIScope(const PSVIDefs::PSVIScope toSet);
127    void setDatatypeValidator(DatatypeValidator* newDatatypeValidator);
128    void setEnclosingScope(const unsigned int enclosingScope);
129    void setFinalSet(const int finalSet);
130    void setBlockSet(const int blockSet);
131    void setMiscFlags(const int flags);
132    void setDefaultValue(const XMLCh* const value);
133    void setComplexTypeInfo(ComplexTypeInfo* const typeInfo);   
134    void setAttWildCard(SchemaAttDef* const attWildCard);
135    void setSubstitutionGroupElem(SchemaElementDecl* const elemDecl); 
136
137    // -----------------------------------------------------------------------
138    //  IC methods
139    // -----------------------------------------------------------------------
140    void addIdentityConstraint(IdentityConstraint* const ic);
141    XMLSize_t getIdentityConstraintCount() const;
142    IdentityConstraint* getIdentityConstraintAt(XMLSize_t index) const;
143
144    /***
145     * Support for Serialization/De-serialization
146     ***/
147    DECL_XSERIALIZABLE(SchemaElementDecl)
148
149    virtual XMLElementDecl::objectType  getObjectType() const;
150
151private :
152    // -----------------------------------------------------------------------
153    //  Unimplemented constructors and operators
154    // -----------------------------------------------------------------------
155    SchemaElementDecl(const SchemaElementDecl&);
156    SchemaElementDecl& operator=(const SchemaElementDecl&);
157
158    // -----------------------------------------------------------------------
159    //  Private data members
160    //
161    //  fModelType
162    //      The content model type of this element. This tells us what kind
163    //      of content model to create.
164    //
165    //  fDatatypeValidator
166    //      The DatatypeValidator used to validate this element type.
167    //
168    //  fEnclosingScope
169    //      The enclosing scope where this element is declared.
170    //
171    //  fFinalSet
172    //      The value set of the 'final' attribute.
173    //
174    //  fBlockSet
175    //      The value set of the 'block' attribute.
176    //
177    //  fMiscFlags
178    //      Stores 'abstract/nullable' values
179    //
180    //  fDefaultValue
181    //      The default/fixed value
182    //
183    //  fComplexTypeInfo
184    //      Stores complex type information
185    //      (no need to delete - handled by schema grammar)
186    //
187    //  fAttDefs
188    //      The list of attributes that are faulted in for this element
189    //      when ComplexTypeInfo does not exist.  We want to keep track
190    //      of these faulted in attributes to avoid duplicate redundant
191    //      error.     
192    //         
193    //  fIdentityConstraints
194    //      Store information about an element identity constraints.
195    //
196    //  fAttWildCard
197    //      Store wildcard attribute in the case of an element with a type of
198    //      'anyType'.
199    //
200    //  fSubstitutionGroupElem
201    //      The substitution group element declaration.   
202    // -----------------------------------------------------------------------
203
204    // -----------------------------------------------------------------------
205    ModelTypes                         fModelType;
206    PSVIDefs::PSVIScope                fPSVIScope;
207
208    unsigned int                       fEnclosingScope;
209    int                                fFinalSet;
210    int                                fBlockSet;
211    int                                fMiscFlags;   
212    XMLCh*                             fDefaultValue;
213    ComplexTypeInfo*                   fComplexTypeInfo;
214    RefHash2KeysTableOf<SchemaAttDef>* fAttDefs;               
215    RefVectorOf<IdentityConstraint>*   fIdentityConstraints;
216    SchemaAttDef*                      fAttWildCard;
217    SchemaElementDecl*                 fSubstitutionGroupElem;
218    DatatypeValidator*                 fDatatypeValidator; 
219};
220
221// ---------------------------------------------------------------------------
222//  SchemaElementDecl: XMLElementDecl virtual interface implementation
223// ---------------------------------------------------------------------------
224inline ContentSpecNode* SchemaElementDecl::getContentSpec()
225{
226    if (fComplexTypeInfo != 0) {
227        return fComplexTypeInfo->getContentSpec();
228    }
229
230    return 0;
231}
232
233inline const ContentSpecNode* SchemaElementDecl::getContentSpec() const
234{
235    if (fComplexTypeInfo != 0) {
236        return fComplexTypeInfo->getContentSpec();
237    }
238
239    return 0;
240}
241
242inline void
243SchemaElementDecl::setContentSpec(ContentSpecNode*)
244{
245    //Handled by complexType
246}
247
248inline XMLContentModel* SchemaElementDecl::getContentModel()
249{
250    if (fComplexTypeInfo != 0) {
251        return fComplexTypeInfo->getContentModel();
252    }
253    return 0;
254}
255
256inline void
257SchemaElementDecl::setContentModel(XMLContentModel* const)
258{
259    //Handled by complexType
260}
261
262
263// ---------------------------------------------------------------------------
264//  SchemaElementDecl: Getter methods
265// ---------------------------------------------------------------------------
266inline SchemaElementDecl::ModelTypes SchemaElementDecl::getModelType() const
267{
268    if (fComplexTypeInfo) {
269        return (SchemaElementDecl::ModelTypes) fComplexTypeInfo->getContentType();
270    }
271
272    return fModelType;
273}
274
275inline PSVIDefs::PSVIScope SchemaElementDecl::getPSVIScope() const
276{
277    return fPSVIScope;
278}
279
280inline DatatypeValidator* SchemaElementDecl::getDatatypeValidator() const
281{
282    return fDatatypeValidator;
283}
284
285inline unsigned int SchemaElementDecl::getEnclosingScope() const
286{
287    return fEnclosingScope;
288}
289
290inline int SchemaElementDecl::getFinalSet() const
291{
292    return fFinalSet;
293}
294
295inline int SchemaElementDecl::getBlockSet() const
296{
297    return fBlockSet;
298}
299
300inline int SchemaElementDecl::getMiscFlags() const
301{
302    return fMiscFlags;
303}
304
305inline XMLCh* SchemaElementDecl::getDefaultValue() const
306{
307    return fDefaultValue;
308}
309
310inline ComplexTypeInfo* SchemaElementDecl::getComplexTypeInfo() const
311{
312    return fComplexTypeInfo;
313}
314
315inline const SchemaAttDef* SchemaElementDecl::getAttWildCard() const {
316    return fAttWildCard;
317}
318
319inline SchemaAttDef* SchemaElementDecl::getAttWildCard() {
320    return fAttWildCard;
321}
322
323inline bool SchemaElementDecl::isGlobalDecl() const {
324
325    return (fEnclosingScope == Grammar::TOP_LEVEL_SCOPE);
326}
327
328inline SchemaElementDecl*
329SchemaElementDecl::getSubstitutionGroupElem() const {
330
331    return fSubstitutionGroupElem;
332}
333
334// ---------------------------------------------------------------------------
335//  SchemaElementDecl: Setter methods
336// ---------------------------------------------------------------------------
337inline void
338SchemaElementDecl::setModelType(const SchemaElementDecl::ModelTypes toSet)
339{
340    fModelType = toSet;
341}
342
343inline void
344SchemaElementDecl::setPSVIScope(const PSVIDefs::PSVIScope toSet)
345{
346    fPSVIScope = toSet;
347}
348
349inline void SchemaElementDecl::setDatatypeValidator(DatatypeValidator* newDatatypeValidator)
350{
351    fDatatypeValidator = newDatatypeValidator;
352}
353
354inline void SchemaElementDecl::setEnclosingScope(const unsigned int newEnclosingScope)
355{
356    fEnclosingScope = newEnclosingScope;
357}
358
359inline void SchemaElementDecl::setFinalSet(const int finalSet)
360{
361    fFinalSet = finalSet;
362}
363
364inline void SchemaElementDecl::setBlockSet(const int blockSet)
365{
366    fBlockSet = blockSet;
367}
368
369inline void SchemaElementDecl::setMiscFlags(const int flags)
370{
371    fMiscFlags = flags;
372}
373
374inline void SchemaElementDecl::setDefaultValue(const XMLCh* const value)
375{
376    if (fDefaultValue) {
377        getMemoryManager()->deallocate(fDefaultValue);//delete[] fDefaultValue;
378    }
379
380    fDefaultValue = XMLString::replicate(value, getMemoryManager());
381}
382
383inline void
384SchemaElementDecl::setComplexTypeInfo(ComplexTypeInfo* const typeInfo)
385{
386    fComplexTypeInfo = typeInfo;
387}
388
389inline void
390SchemaElementDecl::setAttWildCard(SchemaAttDef* const attWildCard) {
391
392    if (fAttWildCard)
393        delete fAttWildCard;
394
395    fAttWildCard = attWildCard;
396}
397
398inline void
399SchemaElementDecl::setSubstitutionGroupElem(SchemaElementDecl* const elemDecl) {
400
401    fSubstitutionGroupElem = elemDecl;
402}
403
404// ---------------------------------------------------------------------------
405//  SchemaElementDecl: IC methods
406// ---------------------------------------------------------------------------
407inline void
408SchemaElementDecl::addIdentityConstraint(IdentityConstraint* const ic) {
409
410    if (!fIdentityConstraints) {
411        fIdentityConstraints = new (getMemoryManager()) RefVectorOf<IdentityConstraint>(16, true, getMemoryManager());
412    }
413
414    fIdentityConstraints->addElement(ic);
415}
416
417inline XMLSize_t SchemaElementDecl::getIdentityConstraintCount() const {
418
419    if (fIdentityConstraints) {
420        return fIdentityConstraints->size();
421    }
422
423    return 0;
424}
425
426inline IdentityConstraint*
427SchemaElementDecl::getIdentityConstraintAt(XMLSize_t index) const {
428
429    if (fIdentityConstraints) {
430        return fIdentityConstraints->elementAt(index);
431    }
432
433    return 0;
434}
435
436XERCES_CPP_NAMESPACE_END
437
438#endif
Note: See TracBrowser for help on using the repository browser.