source: icXML/icXML-devel/src/xercesc/validators/schema/SchemaElementDecl.cpp @ 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: 8.0 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.cpp 609971 2008-01-08 13:30:47Z amassari $
20 */
21
22
23// ---------------------------------------------------------------------------
24//  Includes
25// ---------------------------------------------------------------------------
26#include <icxercesc/util/XMLString.hpp>
27#include <xercesc/util/XMLUniDefs.hpp>
28#include <xercesc/util/XMLUni.hpp>
29#include <icxercesc/validators/schema/SchemaAttDefList.hpp>
30#include <xercesc/validators/schema/SchemaElementDecl.hpp>
31#include <xercesc/validators/schema/identity/IdentityConstraint.hpp>
32
33#include <xercesc/internal/XTemplateSerializer.hpp>
34
35XERCES_CPP_NAMESPACE_BEGIN
36
37// ---------------------------------------------------------------------------
38//  SchemaElementDecl: Constructors and Destructor
39// ---------------------------------------------------------------------------
40SchemaElementDecl::SchemaElementDecl(MemoryManager* const manager) :
41    XMLElementDecl(manager)
42    , fModelType(Any)
43    , fPSVIScope(PSVIDefs::SCP_ABSENT)
44    , fEnclosingScope(Grammar::TOP_LEVEL_SCOPE)
45    , fFinalSet(0)
46    , fBlockSet(0)   
47    , fMiscFlags(0)
48    , fDefaultValue(0)
49    , fComplexTypeInfo(0)
50    , fAttDefs(0)       
51    , fIdentityConstraints(0)
52    , fAttWildCard(0)
53    , fSubstitutionGroupElem(0)
54    , fDatatypeValidator(0)   
55{
56}
57
58SchemaElementDecl::SchemaElementDecl(const XMLCh* const                  prefix
59                                   , const XMLCh* const                  localPart
60                                   , const int                           uriId
61                                   , const SchemaElementDecl::ModelTypes type
62                                   , const unsigned int                  enclosingScope
63                                   , MemoryManager* const                manager) :
64    XMLElementDecl(manager)
65    , fModelType(type)
66    , fPSVIScope(PSVIDefs::SCP_ABSENT)
67    , fEnclosingScope(enclosingScope)
68    , fFinalSet(0)
69    , fBlockSet(0)   
70    , fMiscFlags(0)
71    , fDefaultValue(0)
72    , fComplexTypeInfo(0)
73    , fAttDefs(0)         
74    , fIdentityConstraints(0)
75    , fAttWildCard(0)
76    , fSubstitutionGroupElem(0)
77    , fDatatypeValidator(0)
78{
79    setElementName(prefix, localPart, uriId);
80}
81
82SchemaElementDecl::SchemaElementDecl(const QName* const                  elementName
83                                   , const SchemaElementDecl::ModelTypes type
84                                   , const unsigned int                  enclosingScope
85                                   , MemoryManager* const                manager) :
86    XMLElementDecl(manager)
87    , fModelType(type)
88    , fPSVIScope(PSVIDefs::SCP_ABSENT)
89    , fEnclosingScope(enclosingScope)
90    , fFinalSet(0)
91    , fBlockSet(0)   
92    , fMiscFlags(0)
93    , fDefaultValue(0)
94    , fComplexTypeInfo(0)
95    , fAttDefs(0)       
96    , fIdentityConstraints(0)
97    , fAttWildCard(0)
98    , fSubstitutionGroupElem(0)
99    , fDatatypeValidator(0)
100{
101    setElementName(elementName);
102}
103
104SchemaElementDecl::~SchemaElementDecl()
105{
106    getMemoryManager()->deallocate(fDefaultValue);//delete [] fDefaultValue;
107    delete fAttDefs;
108    delete fIdentityConstraints;
109    delete fAttWildCard;
110}
111
112
113// ---------------------------------------------------------------------------
114//  SchemaElementDecl: XMLElementDecl virtual interface implementation
115// ---------------------------------------------------------------------------
116XMLAttDefList& SchemaElementDecl::getAttDefList() const
117{
118    if (!fComplexTypeInfo)
119        {
120        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::DV_InvalidOperation, getMemoryManager());
121    }
122
123        return fComplexTypeInfo->getAttDefList();
124}
125
126
127XMLElementDecl::CharDataOpts SchemaElementDecl::getCharDataOpts() const
128{
129    SchemaElementDecl::ModelTypes modelType = fModelType;
130
131    if (fComplexTypeInfo) {
132        modelType = (SchemaElementDecl::ModelTypes) fComplexTypeInfo->getContentType();
133    }
134
135    XMLElementDecl::CharDataOpts retVal;
136    switch(modelType)
137    {
138        case Children :
139        case ElementOnlyEmpty :
140            retVal = XMLElementDecl::SpacesOk;
141            break;
142
143        case Empty :
144            retVal = XMLElementDecl::NoCharData;
145            break;
146
147        default :
148            retVal = XMLElementDecl::AllCharData;
149            break;
150    }
151    return retVal;
152}
153
154
155bool SchemaElementDecl::hasAttDefs() const
156{
157    if (fComplexTypeInfo) {
158        return fComplexTypeInfo->hasAttDefs();
159    }
160
161    // If the collection hasn't been faulted in, then no att defs
162    return false;
163
164}
165
166const XMLCh*
167SchemaElementDecl::getFormattedContentModel() const
168{
169    if (fComplexTypeInfo) {
170        return fComplexTypeInfo->getFormattedContentModel();
171    }
172    return 0;
173}
174
175// ---------------------------------------------------------------------------
176//  SchemaElementDecl: Getter methods
177// ---------------------------------------------------------------------------
178const SchemaAttDef* SchemaElementDecl::getAttDef(const XMLCh* const baseName, const int uriId) const
179{
180    if (fComplexTypeInfo) {
181        return fComplexTypeInfo->getAttDef(baseName, uriId);
182    }
183
184    // If no complex type, then return a null
185    return 0;
186
187}
188
189SchemaAttDef* SchemaElementDecl::getAttDef(const XMLCh* const baseName, const int uriId)
190{
191    if (fComplexTypeInfo) {
192        return fComplexTypeInfo->getAttDef(baseName, uriId);
193    }
194
195    // If no complex type, then return a null
196    return 0;
197}
198
199/***
200 * Support for Serialization/De-serialization
201 ***/
202
203IMPL_XSERIALIZABLE_TOCREATE(SchemaElementDecl)
204
205void SchemaElementDecl::serialize(XSerializeEngine& serEng)
206{
207
208    XMLElementDecl::serialize(serEng);
209
210    if (serEng.isStoring())
211    {
212        serEng<<(int)fModelType;
213        serEng<<(int)fPSVIScope;       
214
215        serEng<<fEnclosingScope;
216        serEng<<fFinalSet;
217        serEng<<fBlockSet;
218        serEng<<fMiscFlags;
219
220        serEng.writeString(fDefaultValue);
221
222        serEng<<fComplexTypeInfo;
223
224        /***
225         * Serialize RefHash2KeysTableOf<SchemaAttDef>* fAttDefs;
226         ***/
227
228        XTemplateSerializer::storeObject(fAttDefs, serEng);       
229       
230        /***
231         * Serialize RefVectorOf<IdentityConstraint>*   fIdentityConstraints;
232         ***/
233        XTemplateSerializer::storeObject(fIdentityConstraints, serEng);
234
235        serEng<<fAttWildCard;
236        serEng<<fSubstitutionGroupElem;
237        DatatypeValidator::storeDV(serEng, fDatatypeValidator);               
238    }
239    else
240    {
241        int i;
242        serEng>>i;
243        fModelType = (ModelTypes)i;
244        serEng>>i;
245        fPSVIScope = (PSVIDefs::PSVIScope)i;   
246
247        serEng>>fEnclosingScope;
248        serEng>>fFinalSet;
249        serEng>>fBlockSet;
250        serEng>>fMiscFlags;
251
252        serEng.readString(fDefaultValue);
253
254        serEng>>fComplexTypeInfo;
255
256        /***
257         * DeSerialize RefHash2KeysTableOf<SchemaAttDef>* fAttDefs;
258         ***/
259        XTemplateSerializer::loadObject(&fAttDefs, 29, true, serEng);               
260
261        /***
262         * DeSerialize RefVectorOf<IdentityConstraint>*   fIdentityConstraints;
263         ***/
264        XTemplateSerializer::loadObject(&fIdentityConstraints, 16, true, serEng);
265
266        serEng>>fAttWildCard;
267        serEng>>fSubstitutionGroupElem;
268        fDatatypeValidator = DatatypeValidator::loadDV(serEng);
269    }
270}
271
272XMLElementDecl::objectType  SchemaElementDecl::getObjectType() const
273{
274    return Schema;
275}
276
277XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.