source: icXML/icXML-devel/src/icxercesc/framework/XMLGrammarPoolImpl.cpp @ 2721

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

Fix imports in icXML modified Xerces files

File size: 9.4 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: XMLGrammarPoolImpl.cpp 676823 2008-07-15 07:57:44Z borisk $
20 */
21
22
23// ---------------------------------------------------------------------------
24//  Includes
25// ---------------------------------------------------------------------------
26#include <icxercesc/framework/XMLGrammarPoolImpl.hpp>
27#include <xercesc/internal/XSerializeEngine.hpp>
28#include <xercesc/internal/XTemplateSerializer.hpp>
29#include <xercesc/validators/DTD/DTDGrammar.hpp>
30#include <xercesc/validators/DTD/XMLDTDDescriptionImpl.hpp>
31#include <xercesc/validators/schema/SchemaGrammar.hpp>
32#include <xercesc/validators/schema/XMLSchemaDescriptionImpl.hpp>
33#include <xercesc/util/OutOfMemoryException.hpp>
34#include <xercesc/util/SynchronizedStringPool.hpp>
35
36XERCES_CPP_NAMESPACE_BEGIN
37
38// private function used to update fXSModel
39void XMLGrammarPoolImpl::createXSModel()
40{
41        delete fXSModel;
42        fXSModel = 0;
43        fXSModel = new (getMemoryManager()) XSModel(this, getMemoryManager());
44        fXSModelIsValid = true;
45}
46
47// ---------------------------------------------------------------------------
48//  XMLGrammarPoolImpl: constructor and destructor
49// ---------------------------------------------------------------------------
50XMLGrammarPoolImpl::XMLGrammarPoolImpl(MemoryManager* const memMgr)
51:XMLGrammarPool(memMgr)
52,fGrammarRegistry(0)
53,fStringPool(0)
54,fSynchronizedStringPool(0)
55,fXSModel(0)
56,fLocked(false)
57,fXSModelIsValid(false)
58{
59        fGrammarRegistry = new (memMgr) RefHashTableOf<Grammar>(29, true, memMgr);
60        fStringPool = new (memMgr) XMLStringPool(109, memMgr);
61}
62
63XMLGrammarPoolImpl::~XMLGrammarPoolImpl()
64{
65        delete fGrammarRegistry;
66        delete fStringPool;
67        delete fSynchronizedStringPool;
68        delete fXSModel;
69}
70
71// -----------------------------------------------------------------------
72// Implementation of Grammar Pool Interface
73// -----------------------------------------------------------------------
74bool XMLGrammarPoolImpl::cacheGrammar(Grammar* const               gramToCache )
75{
76        if(fLocked || !gramToCache)
77                return false;
78
79        const XMLCh* grammarKey = gramToCache->getGrammarDescription()->getGrammarKey();
80
81        if (fGrammarRegistry->containsKey(grammarKey))
82        {
83                return false;
84        }
85
86        fGrammarRegistry->put((void*) grammarKey, gramToCache);
87
88        if (fXSModelIsValid && gramToCache->getGrammarType() == Grammar::SchemaGrammarType)
89        {
90                fXSModelIsValid = false;
91        }
92        return true;
93}
94
95Grammar* XMLGrammarPoolImpl::retrieveGrammar(XMLGrammarDescription* const gramDesc)
96{
97        if (!gramDesc)
98                return 0;
99
100        /***
101         * This implementation simply use GrammarKey
102         */
103        return fGrammarRegistry->get(gramDesc->getGrammarKey());
104}
105
106Grammar* XMLGrammarPoolImpl::orphanGrammar(const XMLCh* const nameSpaceKey)
107{
108        if (!fLocked)
109        {
110                Grammar* grammar = fGrammarRegistry->orphanKey(nameSpaceKey);
111                if (fXSModelIsValid && grammar && grammar->getGrammarType() == Grammar::SchemaGrammarType)
112                {
113                        fXSModelIsValid = false;
114                }
115                return grammar;
116        }
117        return 0;
118}
119
120RefHashTableOfEnumerator<Grammar>
121XMLGrammarPoolImpl::getGrammarEnumerator() const
122{
123        return RefHashTableOfEnumerator<Grammar>(fGrammarRegistry, false, fGrammarRegistry->getMemoryManager());
124}
125
126
127bool XMLGrammarPoolImpl::clear()
128{
129        if (!fLocked)
130        {
131                fGrammarRegistry->removeAll();
132
133                fXSModelIsValid = false;
134                if (fXSModel)
135                {
136                        delete fXSModel;
137                        fXSModel = 0;
138                }
139                return true;
140        }
141        return false;
142}
143
144void XMLGrammarPoolImpl::lockPool()
145{
146        if (!fLocked)
147        {
148                fLocked = true;
149                MemoryManager *memMgr = getMemoryManager();
150                if(!fSynchronizedStringPool)
151                {
152                        fSynchronizedStringPool = new (memMgr) XMLSynchronizedStringPool(fStringPool, 109, memMgr);
153                }
154                if (!fXSModelIsValid)
155                {
156                        createXSModel();
157                }
158        }
159}
160
161void XMLGrammarPoolImpl::unlockPool()
162{
163        if (fLocked)
164        {
165                fLocked = false;
166                if (fSynchronizedStringPool)
167                {
168                        fSynchronizedStringPool->flushAll();
169                        // if user calls Lock again, need to have null fSynchronizedStringPool
170                        delete fSynchronizedStringPool;
171                        fSynchronizedStringPool = 0;
172                }
173                fXSModelIsValid = false;
174                if (fXSModel)
175                {
176                        delete fXSModel;
177                        fXSModel = 0;
178                }
179        }
180}
181
182// -----------------------------------------------------------------------
183// Implementation of Factory Interface
184// -----------------------------------------------------------------------
185DTDGrammar*  XMLGrammarPoolImpl::createDTDGrammar()
186{
187        return new (getMemoryManager()) DTDGrammar(getMemoryManager());
188}
189
190SchemaGrammar* XMLGrammarPoolImpl::createSchemaGrammar()
191{
192        return new (getMemoryManager()) SchemaGrammar(getMemoryManager());
193}
194
195XMLDTDDescription*  XMLGrammarPoolImpl::createDTDDescription(const XMLCh* const systemId)
196{
197        return new (getMemoryManager()) XMLDTDDescriptionImpl(systemId, getMemoryManager());
198}
199
200XMLSchemaDescription* XMLGrammarPoolImpl::createSchemaDescription(const XMLCh* const targetNamespace)
201{
202        return new (getMemoryManager()) XMLSchemaDescriptionImpl(targetNamespace, getMemoryManager());
203}
204
205XSModel *XMLGrammarPoolImpl::getXSModel(bool& XSModelWasChanged)
206{
207        XSModelWasChanged = false;
208        if (fLocked || fXSModelIsValid)
209                return fXSModel;
210
211        createXSModel();
212        XSModelWasChanged = true;
213        return fXSModel;
214}
215
216XMLStringPool *XMLGrammarPoolImpl::getStringPool()
217{
218        if (fLocked)
219                return fSynchronizedStringPool;
220        return fStringPool;
221}
222
223// -----------------------------------------------------------------------
224// serialization and deserialization support
225// -----------------------------------------------------------------------
226/***
227 *
228 * don't serialize
229 *
230 *   XMLSynchronizedStringPool*  fSynchronizedStringPool;
231 */
232
233/***
234 *   .non-empty gramamrRegistry
235 ***/
236void XMLGrammarPoolImpl::serializeGrammars(BinOutputStream* const binOut)
237{
238        RefHashTableOfEnumerator<Grammar> grammarEnum(fGrammarRegistry, false, getMemoryManager());
239        if (!(grammarEnum.hasMoreElements()))
240        {
241                ThrowXMLwithMemMgr(XSerializationException, XMLExcepts::XSer_GrammarPool_Empty, getMemoryManager());
242        }
243
244        XSerializeEngine  serEng(binOut, this);
245
246        //version information
247        serEng<<(unsigned int)XERCES_GRAMMAR_SERIALIZATION_LEVEL;
248
249        //lock status
250        serEng<<fLocked;
251
252        //StringPool, don't use <<
253        fStringPool->serialize(serEng);
254
255        /***
256         * Serialize RefHashTableOf<Grammar>*    fGrammarRegistry;
257         ***/
258        XTemplateSerializer::storeObject(fGrammarRegistry, serEng);
259}
260
261/***
262 *   .empty stringPool
263 *   .empty gramamrRegistry
264 ***/
265void XMLGrammarPoolImpl::deserializeGrammars(BinInputStream* const binIn)
266{
267        MemoryManager *memMgr = getMemoryManager();
268        unsigned int stringCount = fStringPool->getStringCount();
269        if (stringCount)
270        {
271                /***
272                 * it contains only the four predefined one, that is ok
273                 * but we need to reset the string before deserialize it
274                 *
275                 ***/
276                if ( stringCount <= 4 )
277                {
278                        fStringPool->flushAll();
279                }
280                else
281                {
282                        ThrowXMLwithMemMgr(XSerializationException, XMLExcepts::XSer_StringPool_NotEmpty, memMgr);
283                }
284        }
285
286        RefHashTableOfEnumerator<Grammar> grammarEnum(fGrammarRegistry, false, memMgr);
287        if (grammarEnum.hasMoreElements())
288        {
289                ThrowXMLwithMemMgr(XSerializationException, XMLExcepts::XSer_GrammarPool_NotEmpty, memMgr);
290        }
291
292        // This object will take care of cleaning up if an exception is
293        // thrown during deserialization.
294        JanitorMemFunCall<XMLGrammarPoolImpl>   cleanup(this, &XMLGrammarPoolImpl::cleanUp);
295
296        try
297        {
298                XSerializeEngine  serEng(binIn, this);
299
300                //version information
301                unsigned int  StorerLevel;
302                serEng>>StorerLevel;
303                serEng.fStorerLevel = StorerLevel;
304
305                // The storer level must match the loader level.
306                //
307                if (StorerLevel != (unsigned int)XERCES_GRAMMAR_SERIALIZATION_LEVEL)
308                {
309                        XMLCh     StorerLevelChar[5];
310                        XMLCh     LoaderLevelChar[5];
311                        XMLString::binToText(StorerLevel,                          StorerLevelChar,   4, 10, memMgr);
312                        XMLString::binToText(XERCES_GRAMMAR_SERIALIZATION_LEVEL,   LoaderLevelChar,   4, 10, memMgr);
313
314                        ThrowXMLwithMemMgr2(XSerializationException
315                                        , XMLExcepts::XSer_Storer_Loader_Mismatch
316                                        , StorerLevelChar
317                                        , LoaderLevelChar
318                                        , memMgr);
319                }
320
321                //lock status
322                serEng>>fLocked;
323
324                //StringPool, don't use >>
325                fStringPool->serialize(serEng);
326
327                /***
328                 * Deserialize RefHashTableOf<Grammar>*    fGrammarRegistry;
329                 ***/
330                XTemplateSerializer::loadObject(&fGrammarRegistry, 29, true, serEng);
331
332        }
333        catch(const OutOfMemoryException&)
334        {
335                // This is a special case, because we don't want
336                // to execute cleanup code on out-of-memory
337                // conditions.
338                cleanup.release();
339
340                throw;
341        }
342
343        // Everything is OK, so we can release the cleanup object.
344        cleanup.release();
345
346        if (fLocked)
347        {
348                createXSModel();
349        }
350}
351
352
353void
354XMLGrammarPoolImpl::cleanUp()
355{
356        fLocked = false;
357
358        clear();
359}
360
361// @@ DEPRECATED @@ this function is renamed to getStringPool to highlight the fact it is NOT a URI
362// string pool, but rather a general string pool.
363XMLStringPool *XMLGrammarPoolImpl::getURIStringPool()
364{
365        DEPRECATED_FEATURE_IN_ICXML;
366}
367
368XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.