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

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

Updates for build

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