source: icXML/icXML-devel/src/xercesc/validators/schema/SchemaGrammar.cpp @ 2734

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

icXML version of SchemaSymbols?

File size: 12.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: SchemaGrammar.cpp 883376 2009-11-23 15:45:23Z borisk $
20 */
21
22// ---------------------------------------------------------------------------
23//  Includes
24// ---------------------------------------------------------------------------
25#include <xercesc/validators/schema/SchemaGrammar.hpp>
26#include <xercesc/validators/schema/ComplexTypeInfo.hpp>
27#include <icxercesc/validators/schema/SchemaSymbols.hpp>
28#include <xercesc/validators/schema/XercesGroupInfo.hpp>
29#include <xercesc/validators/schema/XercesAttGroupInfo.hpp>
30#include <xercesc/validators/schema/XMLSchemaDescriptionImpl.hpp>
31#include <xercesc/util/OutOfMemoryException.hpp>
32#include <xercesc/framework/psvi/XSAnnotation.hpp>
33
34#include <xercesc/internal/XTemplateSerializer.hpp>
35#include <icxercesc/internal/ValidationContextImpl.hpp>
36
37XERCES_CPP_NAMESPACE_BEGIN
38
39typedef JanitorMemFunCall<SchemaGrammar>    CleanupType;
40
41// ---------------------------------------------------------------------------
42//  SchemaGrammar: Constructors and Destructor
43// ---------------------------------------------------------------------------
44SchemaGrammar::SchemaGrammar(MemoryManager* const manager) :
45    fTargetNamespace(0)
46    , fElemDeclPool(0)
47    , fElemNonDeclPool(0)
48    , fGroupElemDeclPool(0)
49    , fNotationDeclPool(0)
50    , fAttributeDeclRegistry(0)
51    , fComplexTypeRegistry(0)
52    , fGroupInfoRegistry(0)
53    , fAttGroupInfoRegistry(0)
54    , fValidSubstitutionGroups(0)
55    , fValidationContext(0)
56    , fMemoryManager(manager)
57    , fGramDesc(0)
58    , fAnnotations(0)
59    , fValidated(false)
60    , fDatatypeRegistry(manager)
61    , fScopeCount (0)
62    , fAnonTypeCount (0)
63{
64    CleanupType cleanup(this, &SchemaGrammar::cleanUp);
65
66    //
67    //  Init all the pool members.
68    //
69    //  <TBD> Investigate what the optimum values would be for the various
70    //  pools.
71    //
72    fElemDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(109, true, 128, fMemoryManager);
73
74    try {
75        // should not be necessary now that grammars, once built,
76        // are read-only
77        // fElemNonDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(29, true, 128, fMemoryManager);
78        fGroupElemDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(109, false, 128, fMemoryManager);
79        fNotationDeclPool = new (fMemoryManager) NameIdPool<XMLNotationDecl>(109, 128, fMemoryManager);
80        fValidationContext = new (fMemoryManager) ValidationContextImpl(fMemoryManager);
81
82        //REVISIT: use grammarPool to create
83        fGramDesc = new (fMemoryManager) XMLSchemaDescriptionImpl(XMLUni::fgXMLNSURIName, fMemoryManager);
84
85        // Create annotation table
86        fAnnotations = new (fMemoryManager) RefHashTableOf<XSAnnotation, PtrHasher>
87        (
88            29, true, fMemoryManager
89        );
90
91        //
92        //  Call our own reset method. This lets us have the pool setup stuff
93        //  done in just one place (because this stame setup stuff has to be
94        //  done every time we are reset.)
95        //
96        reset();
97    }
98    catch(const OutOfMemoryException&)
99    {
100        cleanup.release();
101
102        throw;
103    }
104
105    cleanup.release();
106}
107
108SchemaGrammar::~SchemaGrammar()
109{
110    cleanUp();
111}
112
113
114// -----------------------------------------------------------------------
115//  Virtual methods
116// -----------------------------------------------------------------------
117XMLElementDecl* SchemaGrammar::findOrAddElemDecl (const   unsigned int    uriId
118        , const XMLCh* const    baseName
119        , const XMLCh* const    prefixName
120        , const XMLCh* const    qName
121        , unsigned int          scope
122        ,       bool&           wasAdded )
123{
124    // See it it exists
125    SchemaElementDecl* retVal = (SchemaElementDecl*) getElemDecl(uriId, baseName, qName, scope);
126
127    // if not, then add this in
128    if (!retVal)
129    {
130        retVal = new (fMemoryManager) SchemaElementDecl
131        (
132            prefixName
133            , baseName
134            , uriId
135            , SchemaElementDecl::Any
136            , Grammar::TOP_LEVEL_SCOPE
137            , fMemoryManager
138        );
139        if(!fElemNonDeclPool)
140            fElemNonDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(29, true, 128, fMemoryManager);
141        const XMLSize_t elemId = fElemNonDeclPool->put((void*)retVal->getBaseName(), uriId, scope, retVal);
142        retVal->setId(elemId);
143        wasAdded = true;
144    }
145     else
146    {
147        wasAdded = false;
148    }
149    return retVal;
150}
151
152XMLElementDecl* SchemaGrammar::putElemDecl (const   unsigned int    uriId
153        , const XMLCh* const    baseName
154        , const XMLCh* const    prefixName
155        , const XMLCh* const
156        , unsigned int          scope
157        , const bool            notDeclared)
158{
159    SchemaElementDecl* retVal = new (fMemoryManager) SchemaElementDecl
160    (
161        prefixName
162        , baseName
163        , uriId
164        , SchemaElementDecl::Any
165        , Grammar::TOP_LEVEL_SCOPE
166        , fMemoryManager
167    );
168    if(notDeclared)
169    {
170        if(!fElemNonDeclPool)
171            fElemNonDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(29, true, 128, fMemoryManager);
172        retVal->setId(fElemNonDeclPool->put((void*)retVal->getBaseName(), uriId, scope, retVal));
173    } else
174    {
175        retVal->setId(fElemDeclPool->put((void*)retVal->getBaseName(), uriId, scope, retVal));
176    }
177    return retVal;
178}
179
180void SchemaGrammar::reset()
181{
182    //
183    //  We need to reset all of the pools.
184    //
185    fElemDeclPool->removeAll();
186    if(fElemNonDeclPool)
187        fElemNonDeclPool->removeAll();
188    fGroupElemDeclPool->removeAll();
189    fNotationDeclPool->removeAll();
190    fAnnotations->removeAll();
191    fValidated = false;
192}
193
194
195void SchemaGrammar::cleanUp()
196{
197    delete fElemDeclPool;
198    if(fElemNonDeclPool)
199        delete fElemNonDeclPool;
200    delete fGroupElemDeclPool;
201    delete fNotationDeclPool;
202    fMemoryManager->deallocate(fTargetNamespace);//delete [] fTargetNamespace;
203    delete fAttributeDeclRegistry;
204    delete fComplexTypeRegistry;
205    delete fGroupInfoRegistry;
206    delete fAttGroupInfoRegistry;
207    delete fValidSubstitutionGroups;
208    delete fValidationContext;
209    delete fGramDesc;
210    delete fAnnotations;
211}
212
213void SchemaGrammar::setGrammarDescription(XMLGrammarDescription* gramDesc)
214{
215    if ((!gramDesc) ||
216        (gramDesc->getGrammarType() != Grammar::SchemaGrammarType))
217        return;
218
219    if (fGramDesc)
220        delete fGramDesc;
221
222    //adopt the grammar Description
223    fGramDesc = (XMLSchemaDescription*) gramDesc;
224}
225
226// ---------------------------------------------------------------------------
227//  SchemaGrammar: Helper methods
228// ---------------------------------------------------------------------------
229void SchemaGrammar::putAnnotation(void* key, XSAnnotation* const annotation)
230{
231    fAnnotations->put(key, annotation);
232}
233
234void SchemaGrammar::addAnnotation(XSAnnotation* const annotation)
235{
236    XSAnnotation* lAnnot = fAnnotations->get(this);
237
238    if (lAnnot)
239        lAnnot->setNext(annotation);
240    else
241        fAnnotations->put(this, annotation);
242}
243
244/***
245 * Support for Serialization/De-serialization
246 ***/
247
248IMPL_XSERIALIZABLE_TOCREATE(SchemaGrammar)
249
250void SchemaGrammar::serialize(XSerializeEngine& serEng)
251{
252
253    /***
254     * don't serialize ValidationContext* fValidationContext;
255     *                                    fElemNonDeclPool
256     ***/
257
258    Grammar::serialize(serEng);
259
260    if (serEng.isStoring())
261    {
262        //serialize DatatypeValidatorFactory first
263        fDatatypeRegistry.serialize(serEng);
264
265        /***
266         *
267         * Serialize RefHash3KeysIdPool<SchemaElementDecl>* fElemDeclPool;
268         * Serialize RefHash3KeysIdPool<SchemaElementDecl>* fGroupElemDeclPool;
269         *
270        ***/
271        XTemplateSerializer::storeObject(fElemDeclPool, serEng);
272        XTemplateSerializer::storeObject(fGroupElemDeclPool, serEng);
273
274        /***
275         * Serialize NameIdPool<XMLNotationDecl>*           fNotationDeclPool;
276         ***/
277        XTemplateSerializer::storeObject(fNotationDeclPool, serEng);
278
279        /***
280         *
281         * Serialize RefHashTableOf<XMLAttDef>*             fAttributeDeclRegistry;
282         * Serialize RefHashTableOf<ComplexTypeInfo>*       fComplexTypeRegistry;
283         * Serialize RefHashTableOf<XercesGroupInfo>*       fGroupInfoRegistry;
284         * Serialize RefHashTableOf<XercesAttGroupInfo>*    fAttGroupInfoRegistry;
285         * Serialize RefHashTableOf<XMLRefInfo>*            fIDRefList;
286         *
287         ***/
288
289        XTemplateSerializer::storeObject(fAttributeDeclRegistry, serEng);
290        XTemplateSerializer::storeObject(fComplexTypeRegistry, serEng);
291        XTemplateSerializer::storeObject(fGroupInfoRegistry, serEng);
292        XTemplateSerializer::storeObject(fAttGroupInfoRegistry, serEng);
293
294        /***
295         * Serialize RefHash2KeysTableOf<ElemVector>*       fValidSubstitutionGroups;
296         ***/
297        XTemplateSerializer::storeObject(fValidSubstitutionGroups, serEng);
298
299        /***
300         * Serialize RefHashTableOf<XSAnnotation>*       fAnnotations;
301         ***/
302        XTemplateSerializer::storeObject(fAnnotations, serEng);
303
304        serEng.writeString(fTargetNamespace);
305        serEng<<fValidated;
306
307        /***
308         * serialize() method shall be used to store object
309         * which has been created in ctor
310         ***/
311        fGramDesc->serialize(serEng);
312
313    }
314    else
315    {
316        fDatatypeRegistry.serialize(serEng);
317
318        /***
319         *
320         * Deserialize RefHash3KeysIdPool<SchemaElementDecl>* fElemDeclPool;
321         * Deserialize RefHash3KeysIdPool<SchemaElementDecl>* fGroupElemDeclPool;
322         *
323        ***/
324        XTemplateSerializer::loadObject(&fElemDeclPool, 109, true, 128, serEng);
325        XTemplateSerializer::loadObject(&fGroupElemDeclPool, 109, true, 128, serEng);
326
327        /***
328         * Deserialize NameIdPool<XMLNotationDecl>*           fNotationDeclPool;
329         ***/
330        XTemplateSerializer::loadObject(&fNotationDeclPool, 109, 128, serEng);
331
332        /***
333         *
334         * Deserialize RefHashTableOf<XMLAttDef>*             fAttributeDeclRegistry;
335         * Deserialize RefHashTableOf<ComplexTypeInfo>*       fComplexTypeRegistry;
336         * Deserialize RefHashTableOf<XercesGroupInfo>*       fGroupInfoRegistry;
337         * Deserialize RefHashTableOf<XercesAttGroupInfo>*    fAttGroupInfoRegistry;
338         * Deserialize RefHashTableOf<XMLRefInfo>*            fIDRefList;
339         *
340         ***/
341
342        XTemplateSerializer::loadObject(&fAttributeDeclRegistry, 29, true, serEng);
343        XTemplateSerializer::loadObject(&fComplexTypeRegistry, 29, true, serEng);
344        XTemplateSerializer::loadObject(&fGroupInfoRegistry, 13, true, serEng);
345        XTemplateSerializer::loadObject(&fAttGroupInfoRegistry, 13, true, serEng);
346
347        /***
348         * Deserialize RefHash2KeysTableOf<ElemVector>*       fValidSubstitutionGroups;
349         ***/
350        XTemplateSerializer::loadObject(&fValidSubstitutionGroups, 29, true, serEng);
351
352        /***
353         * Deserialize RefHashTableOf<XSAnnotation>*       fAnnotations;
354         ***/
355        XTemplateSerializer::loadObject(&fAnnotations, 29, true, serEng);
356
357        serEng.readString(fTargetNamespace);
358        serEng>>fValidated;
359
360        /***
361         * serialize() method shall be used to load object
362         * which has been created in ctor
363         ***/
364        fGramDesc->serialize(serEng);
365
366    }
367}
368
369XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.