source: icXML/icXML-devel/src/xercesc/internal/XTemplateSerializer.cpp @ 2722

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

Original Xerces files with import mods for icxercesc

File size: 70.3 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
20// ---------------------------------------------------------------------------
21//  Includes
22// ---------------------------------------------------------------------------
23#include <xercesc/internal/XTemplateSerializer.hpp>
24#include <icxercesc/framework/XMLGrammarPool.hpp>
25#include <xercesc/validators/common/Grammar.hpp>
26
27#include <stdio.h>
28#include <stdlib.h>
29#include <assert.h>
30
31XERCES_CPP_NAMESPACE_BEGIN
32
33/***
34 * internal class meant to be comsumed by XTemplateSerializer only
35 * the size can not grow
36 ***/
37#ifdef XERCES_DEBUG_SORT_GRAMMAR
38
39class KeySet : public XMemory
40{
41public:
42    // -----------------------------------------------------------------------
43    //  Contructors and Destructor
44    // -----------------------------------------------------------------------
45    KeySet
46    (
47      const XMLCh* const         strKey
48    , const int                  intKey1
49    , const int                  intKey2
50    ,       MemoryManager* const manager
51    );
52
53    ~KeySet();
54
55    // -----------------------------------------------------------------------
56    //  Public operators
57    // -----------------------------------------------------------------------
58    inline void getKeys(const XMLCh*&, int&, int&) const;
59           void print() const;
60
61    // -----------------------------------------------------------------------
62    //  Unimplemented constructors and operators
63    // -----------------------------------------------------------------------
64    KeySet(const KeySet&);
65    KeySet& operator=(const KeySet&);
66
67    // -----------------------------------------------------------------------
68    //  Data members
69    //  reference only
70    // -----------------------------------------------------------------------
71    const XMLCh* const    fStrKey;
72    const int             fIntKey1;
73    const int             fIntKey2;
74          MemoryManager*  fMemoryManager;
75
76};
77
78KeySet::KeySet(const XMLCh* const         strKey
79             , const int                  intKey1
80             , const int                  intKey2
81             ,       MemoryManager* const manager)
82:fStrKey(strKey)
83,fIntKey1(intKey1)
84,fIntKey2(intKey2)
85,fMemoryManager(manager)
86{
87}
88
89KeySet::~KeySet()
90{
91}
92
93inline
94void KeySet::getKeys(const XMLCh*& strKey, int& intKey1, int& intKey2) const
95{
96    strKey  = fStrKey;
97    intKey1 = fIntKey1;
98    intKey2 = fIntKey2;
99}
100
101void KeySet::print() const
102{
103    char* tmpStr = XMLString::transcode(fStrKey, fMemoryManager);
104    printf("tmpStr=<%s>, intKey1=<%d>, intKey2=<%d>\n", tmpStr, fIntKey1, fIntKey2);
105    XMLString::release(&tmpStr, fMemoryManager);
106}
107
108static int compareKeySet(const void* keyl, const void* keyr)
109{
110    const KeySet* pairl=*(const KeySet**)keyl;
111    const KeySet* pairr=*(const KeySet**)keyr;
112
113    const XMLCh* strKeyl   = 0;
114    int          intKeyl_1 = 0;
115    int          intKeyl_2 = 0;
116    pairl->getKeys(strKeyl, intKeyl_1, intKeyl_2);
117
118    const XMLCh* strKeyr   = 0;
119    int          intKeyr_1 = 0;
120    int          intKeyr_2 = 0;
121    pairr->getKeys(strKeyr, intKeyr_1, intKeyr_2);
122
123    int compareValue = XMLString::compareString(strKeyl, strKeyr);
124
125    if (compareValue !=0)
126        return compareValue;
127
128    compareValue = intKeyl_1 - intKeyr_1;
129    if (compareValue !=0)
130        return compareValue;
131
132    return (intKeyl_2 - intKeyr_2);
133
134}
135
136class SortArray : public XMemory
137{
138private :
139    // -----------------------------------------------------------------------
140    //  Contructors and Destructor
141    // -----------------------------------------------------------------------
142    SortArray
143    (
144          const XMLSize_t            size
145        ,       MemoryManager* const manager
146    );
147
148        ~SortArray();
149
150    // -----------------------------------------------------------------------
151    //  Public operators
152    // -----------------------------------------------------------------------
153    inline const KeySet* elementAt(const XMLSize_t index)       const;
154           void  addElement(const KeySet* const keySet);
155           void  sort();
156           void  dump() const;
157
158    // -----------------------------------------------------------------------
159    //  Unimplemented constructors and operators
160    // -----------------------------------------------------------------------
161    SortArray(const SortArray&);
162    SortArray& operator=(const SortArray&);
163
164    // -----------------------------------------------------------------------
165    //  Data members
166    // -----------------------------------------------------------------------
167          XMLSize_t       fCur;      //point to the current available slot
168          XMLSize_t       fSize;
169    const KeySet**        fElemList;  //owning objects
170          MemoryManager*  fMemoryManager;
171
172    friend class XTemplateSerializer;
173
174};
175
176SortArray::SortArray(const XMLSize_t            size
177                   ,       MemoryManager* const manager )
178:fCur(0)
179,fSize(size)
180,fMemoryManager(manager)
181{
182    fElemList = (const KeySet**) fMemoryManager->allocate(size * sizeof (KeySet*));
183}
184
185SortArray::~SortArray()
186{
187    for (XMLSize_t i=0; i< fSize; i++)
188        delete fElemList[i];
189
190    fMemoryManager->deallocate(fElemList);
191}
192
193inline
194const KeySet* SortArray::elementAt(const XMLSize_t index) const
195{
196    assert(index < fCur);
197    return fElemList[index];
198}
199
200void SortArray::addElement(const KeySet* const keySet)
201{
202    assert(fCur < fSize);
203    fElemList[fCur++]=keySet;
204}
205
206void SortArray::sort()
207{
208    assert(fCur == fSize);
209    //dump();
210    qsort(fElemList, fSize, sizeof (KeySet*), compareKeySet);
211    //dump();
212}
213
214void  SortArray::dump() const
215{
216    printf("\n fSize=<%d>, fCur=<%d>\n", fSize, fCur);
217    for (XMLSize_t i = 0; i < fCur; i++)
218        fElemList[i]->print();
219}
220
221#define GET_NEXT_KEYSET()                            \
222    const KeySet* keySet  = sortArray.elementAt(i);  \
223    const XMLCh*  strKey  = 0;                       \
224    int           intKey1 = 0;                       \
225    int           intKey2 = 0;                       \
226    keySet->getKeys(strKey, intKey1, intKey2);
227
228#define SORT_KEYSET_ONEKEY(MM)                                   \
229   SortArray sortArray(itemNumber, MM);                          \
230   while (e.hasMoreElements())                                   \
231   {                                                             \
232       KeySet* keySet = new (MM) KeySet((XMLCh*) e.nextElementKey(), 0, 0, MM); \
233       sortArray.addElement(keySet);                             \
234   }                                                             \
235   sortArray.sort();
236
237#define SORT_KEYSET_TWOKEYS(MM)                                  \
238   SortArray sortArray(itemNumber, MM);                          \
239   while (e.hasMoreElements())                                   \
240   {                                                             \
241       XMLCh*     strKey;                                        \
242       int        intKey;                                        \
243       e.nextElementKey((void*&)strKey, intKey);                 \
244       KeySet* keySet = new (MM) KeySet(strKey, intKey, 0, MM);  \
245       sortArray.addElement(keySet);                             \
246   }                                                             \
247   sortArray.sort();
248
249#endif
250
251/**********************************************************
252 *
253 * ValueVectorOf
254 *
255 *   SchemaElementDecl*
256 *   unsigned int
257 *
258 ***********************************************************/
259void XTemplateSerializer::storeObject(ValueVectorOf<SchemaElementDecl*>* const objToStore
260                                    , XSerializeEngine&                        serEng)
261{
262    if (serEng.needToStoreObject(objToStore))
263    {
264        XMLSize_t vectorSize = objToStore->size();
265        serEng.writeSize (vectorSize);
266
267        for ( XMLSize_t i = 0; i < vectorSize; i++)
268        {
269            SchemaElementDecl*& data = objToStore->elementAt(i);
270            serEng<<data;
271        }
272    }
273}
274
275void XTemplateSerializer::loadObject(ValueVectorOf<SchemaElementDecl*>**       objToLoad
276                                   , int                                       initSize
277                                   , bool                                      toCallDestructor
278                                   , XSerializeEngine&                         serEng)
279{
280    if (serEng.needToLoadObject((void**)objToLoad))
281    {
282        if (!*objToLoad)
283        {
284            if (initSize < 0)
285                initSize = 16;
286
287            *objToLoad = new (serEng.getMemoryManager())
288                             ValueVectorOf<SchemaElementDecl*>(
289                                                               initSize
290                                                             , serEng.getMemoryManager()
291                                                             , toCallDestructor
292                                                             );
293        }
294
295        serEng.registerObject(*objToLoad);
296
297        XMLSize_t vectorSize = 0;
298        serEng.readSize (vectorSize);
299
300        for (XMLSize_t i = 0; i < vectorSize; i++)
301        {
302            SchemaElementDecl* data;
303            serEng>>data;
304            (*objToLoad)->addElement(data);
305        }
306    }
307}
308
309void XTemplateSerializer::storeObject(ValueVectorOf<unsigned int>* const objToStore
310                                    , XSerializeEngine&                  serEng)
311{
312    if (serEng.needToStoreObject(objToStore))
313    {
314        XMLSize_t vectorSize = objToStore->size();
315        serEng.writeSize (vectorSize);
316
317        for (XMLSize_t i = 0; i < vectorSize; i++)
318        {
319            unsigned int& data = objToStore->elementAt(i);
320            serEng<<data;
321        }
322    }
323}
324
325void XTemplateSerializer::loadObject(ValueVectorOf<unsigned int>**       objToLoad
326                                   , int                                 initSize
327                                   , bool                                toCallDestructor
328                                   , XSerializeEngine&                   serEng)
329{
330    if (serEng.needToLoadObject((void**)objToLoad))
331    {
332        if (!*objToLoad)
333        {
334            if (initSize < 0)
335                initSize = 16;
336
337            *objToLoad = new (serEng.getMemoryManager())
338                             ValueVectorOf<unsigned int>(
339                                                         initSize
340                                                       , serEng.getMemoryManager()
341                                                       , toCallDestructor
342                                                       );
343        }
344
345        serEng.registerObject(*objToLoad);
346
347        XMLSize_t vectorSize = 0;
348        serEng.readSize (vectorSize);
349
350        for (XMLSize_t i = 0; i < vectorSize; i++)
351        {
352            unsigned int data;
353            serEng>>data;
354            (*objToLoad)->addElement(data);
355        }
356    }
357
358}
359
360/**********************************************************
361 *
362 * RefArrayVectorOf
363 *
364 *   XMLCh
365 *
366 ***********************************************************/
367
368void XTemplateSerializer::storeObject(RefArrayVectorOf<XMLCh>* const objToStore
369                                    , XSerializeEngine&              serEng)
370{
371    if (serEng.needToStoreObject(objToStore))
372    {
373        XMLSize_t vectorSize = objToStore->size();
374        serEng.writeSize (vectorSize);
375
376        for (XMLSize_t i = 0; i < vectorSize; i++)
377        {
378            serEng.writeString(objToStore->elementAt(i));
379        }
380    }
381
382}
383
384void XTemplateSerializer::loadObject(RefArrayVectorOf<XMLCh>**  objToLoad
385                                   , int                        initSize
386                                   , bool                       toAdopt
387                                   , XSerializeEngine&          serEng)
388{
389
390    if (serEng.needToLoadObject((void**)objToLoad))
391    {
392        if (!*objToLoad)
393        {
394            if (initSize < 0)
395                initSize = 16;
396
397            *objToLoad = new (serEng.getMemoryManager())
398                             RefArrayVectorOf<XMLCh>(
399                                                     initSize
400                                                   , toAdopt
401                                                   , serEng.getMemoryManager()
402                                                   );
403        }
404
405        serEng.registerObject(*objToLoad);
406
407        XMLSize_t vectorSize = 0;
408        serEng.readSize (vectorSize);
409
410        for (XMLSize_t i = 0; i < vectorSize; i++)
411        {
412            XMLCh* data;
413            serEng.readString(data);
414            (*objToLoad)->addElement(data);
415        }
416    }
417
418}
419
420/**********************************************************
421 *
422 * RefVectorOf
423 *
424 *   SchemaAttDef
425 *   SchemaElementDecl
426 *   ContentSpecNode
427 *   IC_Field
428 *   DatatypeValidator
429 *   IdentityConstraint
430 *   XMLNumber
431 *   XercesLocationPath
432 *   XercesStep
433 *
434 ***********************************************************/
435
436void XTemplateSerializer::storeObject(RefVectorOf<SchemaAttDef>* const objToStore
437                                    , XSerializeEngine&                serEng)
438{
439
440    if (serEng.needToStoreObject(objToStore))
441    {
442
443        XMLSize_t vectorLength = objToStore->size();
444        serEng.writeSize (vectorLength);
445
446        for ( XMLSize_t i = 0; i < vectorLength; i++)
447        {
448            SchemaAttDef* data = objToStore->elementAt(i);
449            serEng<<data;
450        }
451
452    }
453
454}
455
456void XTemplateSerializer::loadObject(RefVectorOf<SchemaAttDef>** objToLoad
457                                   , int                         initSize
458                                   , bool                        toAdopt
459                                   , XSerializeEngine&           serEng)
460{
461
462    if (serEng.needToLoadObject((void**)objToLoad))
463    {
464
465        if (!*objToLoad)
466        {
467            if (initSize < 0)
468                initSize = 16;
469
470            *objToLoad = new (serEng.getMemoryManager())
471                             RefVectorOf<SchemaAttDef>(
472                                                       initSize
473                                                     , toAdopt
474                                                     , serEng.getMemoryManager()
475                                                     );
476        }
477
478        serEng.registerObject(*objToLoad);
479
480        XMLSize_t vectorLength = 0;
481        serEng.readSize (vectorLength);
482        for (XMLSize_t i = 0 ; i < vectorLength; i++)
483        {
484            SchemaAttDef* data;
485            serEng>>data;
486            (*objToLoad)->addElement(data);
487        }
488
489    }
490
491}
492
493void XTemplateSerializer::storeObject(RefVectorOf<SchemaElementDecl>* const objToStore
494                                    , XSerializeEngine&                     serEng)
495{
496
497    if (serEng.needToStoreObject(objToStore))
498    {
499
500        XMLSize_t vectorLength = objToStore->size();
501        serEng.writeSize (vectorLength);
502
503        for ( XMLSize_t i = 0; i < vectorLength; i++)
504        {
505            SchemaElementDecl* data = objToStore->elementAt(i);
506            serEng<<data;
507        }
508
509    }
510
511}
512
513void XTemplateSerializer::loadObject(RefVectorOf<SchemaElementDecl>** objToLoad
514                                   , int                              initSize
515                                   , bool                             toAdopt
516                                   , XSerializeEngine&                serEng)
517{
518
519    if (serEng.needToLoadObject((void**)objToLoad))
520    {
521        if (!*objToLoad)
522        {
523            if (initSize < 0)
524                initSize = 16;
525
526            *objToLoad = new (serEng.getMemoryManager())
527                             RefVectorOf<SchemaElementDecl>(
528                                                            initSize
529                                                          , toAdopt
530                                                          , serEng.getMemoryManager()
531                                                          );
532        }
533
534        serEng.registerObject(*objToLoad);
535
536        XMLSize_t vectorLength = 0;
537        serEng.readSize (vectorLength);
538        for (XMLSize_t i = 0 ; i < vectorLength; i++)
539        {
540            SchemaElementDecl* data;
541            serEng>>data;
542            (*objToLoad)->addElement(data);
543        }
544    }
545
546}
547
548void XTemplateSerializer::storeObject(RefVectorOf<ContentSpecNode>* const objToStore
549                                    , XSerializeEngine&                   serEng)
550{
551
552    if (serEng.needToStoreObject(objToStore))
553    {
554        XMLSize_t vectorLength = objToStore->size();
555        serEng.writeSize (vectorLength);
556
557        for ( XMLSize_t i = 0; i < vectorLength; i++)
558        {
559            ContentSpecNode* data = objToStore->elementAt(i);
560            serEng<<data;
561        }
562    }
563
564}
565
566void XTemplateSerializer::loadObject(RefVectorOf<ContentSpecNode>** objToLoad
567                                   , int                            initSize
568                                   , bool                           toAdopt
569                                   , XSerializeEngine&              serEng)
570{
571
572    if (serEng.needToLoadObject((void**)objToLoad))
573    {
574        if (!*objToLoad)
575        {
576            if (initSize < 0)
577                initSize = 16;
578
579            *objToLoad = new (serEng.getMemoryManager())
580                             RefVectorOf<ContentSpecNode>(
581                                                          initSize
582                                                        , toAdopt
583                                                        , serEng.getMemoryManager()
584                                                        );
585        }
586
587        serEng.registerObject(*objToLoad);
588
589        XMLSize_t vectorLength = 0;
590        serEng.readSize (vectorLength);
591        for (XMLSize_t i = 0 ; i < vectorLength; i++)
592        {
593            ContentSpecNode* data;
594            serEng>>data;
595            (*objToLoad)->addElement(data);
596        }
597    }
598
599}
600
601void XTemplateSerializer::storeObject(RefVectorOf<IC_Field>* const objToStore
602                                    , XSerializeEngine&            serEng)
603{
604
605    if (serEng.needToStoreObject(objToStore))
606    {
607        XMLSize_t vectorLength = objToStore->size();
608        serEng.writeSize (vectorLength);
609
610        for ( XMLSize_t i = 0; i < vectorLength; i++)
611        {
612            IC_Field* data = objToStore->elementAt(i);
613            serEng<<data;
614        }
615    }
616
617}
618
619void XTemplateSerializer::loadObject(RefVectorOf<IC_Field>** objToLoad
620                                   , int                     initSize
621                                   , bool                    toAdopt
622                                   , XSerializeEngine&       serEng)
623{
624
625    if (serEng.needToLoadObject((void**)objToLoad))
626    {
627        if (!*objToLoad)
628        {
629            if (initSize < 0)
630                initSize = 16;
631
632            *objToLoad = new (serEng.getMemoryManager())
633                             RefVectorOf<IC_Field>(
634                                                   initSize
635                                                 , toAdopt
636                                                 , serEng.getMemoryManager()
637                                                 );
638        }
639
640        serEng.registerObject(*objToLoad);
641
642        XMLSize_t vectorLength = 0;
643        serEng.readSize (vectorLength);
644        for (XMLSize_t i = 0 ; i < vectorLength; i++)
645        {
646            IC_Field* data;
647            serEng>>data;
648            (*objToLoad)->addElement(data);
649        }
650    }
651
652}
653
654void XTemplateSerializer::storeObject(RefVectorOf<DatatypeValidator>* const objToStore
655                                    , XSerializeEngine&                      serEng)
656{
657
658    if (serEng.needToStoreObject(objToStore))
659    {
660        XMLSize_t vectorLength = objToStore->size();
661        serEng.writeSize (vectorLength);
662
663        for ( XMLSize_t i = 0; i < vectorLength; i++)
664        {
665            DatatypeValidator* data = objToStore->elementAt(i);
666            DatatypeValidator::storeDV(serEng, data);
667        }
668    }
669
670}
671
672void XTemplateSerializer::loadObject(RefVectorOf<DatatypeValidator>** objToLoad
673                                   , int                               initSize
674                                   , bool                              toAdopt
675                                   , XSerializeEngine&                 serEng)
676{
677
678    if (serEng.needToLoadObject((void**)objToLoad))
679    {
680        if (!*objToLoad)
681        {
682            if (initSize < 0)
683                initSize = 16;
684
685            *objToLoad = new (serEng.getMemoryManager())
686                             RefVectorOf<DatatypeValidator>(
687                                                            initSize
688                                                          , toAdopt
689                                                          , serEng.getMemoryManager()
690                                                           );
691        }
692
693        serEng.registerObject(*objToLoad);
694
695        XMLSize_t vectorLength = 0;
696        serEng.readSize (vectorLength);
697        for (XMLSize_t i = 0 ; i < vectorLength; i++)
698        {
699            DatatypeValidator*  data;
700            data = DatatypeValidator::loadDV(serEng);
701            (*objToLoad)->addElement(data);
702        }
703    }
704
705}
706
707void XTemplateSerializer::storeObject(RefVectorOf<IdentityConstraint>* const objToStore
708                                    , XSerializeEngine&                       serEng)
709{
710
711    if (serEng.needToStoreObject(objToStore))
712    {
713        XMLSize_t vectorLength = objToStore->size();
714        serEng.writeSize (vectorLength);
715
716        for ( XMLSize_t i = 0; i < vectorLength; i++)
717        {
718            IdentityConstraint* data = objToStore->elementAt(i);
719            IdentityConstraint::storeIC(serEng, data);
720        }
721    }
722
723}
724
725void XTemplateSerializer::loadObject(RefVectorOf<IdentityConstraint>** objToLoad
726                                   , int                                initSize
727                                   , bool                               toAdopt
728                                   , XSerializeEngine&                  serEng)
729{
730
731    if (serEng.needToLoadObject((void**)objToLoad))
732    {
733        if (!*objToLoad)
734        {
735            if (initSize < 0)
736                initSize = 16;
737
738            *objToLoad = new (serEng.getMemoryManager())
739                             RefVectorOf<IdentityConstraint>(
740                                                             initSize
741                                                           , toAdopt
742                                                           , serEng.getMemoryManager()
743                                                            );
744        }
745
746        serEng.registerObject(*objToLoad);
747
748        XMLSize_t vectorLength = 0;
749        serEng.readSize (vectorLength);
750        for (XMLSize_t i = 0 ; i < vectorLength; i++)
751        {
752            IdentityConstraint*  data;
753            data = IdentityConstraint::loadIC(serEng);
754            (*objToLoad)->addElement(data);
755        }
756    }
757
758}
759
760void XTemplateSerializer::storeObject(RefVectorOf<XMLNumber>* const objToStore
761                                    , XSerializeEngine&             serEng)
762{
763
764    if (serEng.needToStoreObject(objToStore))
765    {
766        XMLSize_t vectorLength = objToStore->size();
767        serEng.writeSize (vectorLength);
768
769        for ( XMLSize_t i = 0; i < vectorLength; i++)
770        {
771            XMLNumber* data = objToStore->elementAt(i);
772            serEng<<data;
773        }
774    }
775
776}
777
778void XTemplateSerializer::loadObject(RefVectorOf<XMLNumber>** objToLoad
779                                   , int                       initSize
780                                   , bool                      toAdopt
781                                   , XMLNumber::NumberType     numType
782                                   , XSerializeEngine&         serEng)
783{
784
785    if (serEng.needToLoadObject((void**)objToLoad))
786    {
787        if (!*objToLoad)
788        {
789            if (initSize < 0)
790                initSize = 16;
791
792            *objToLoad = new (serEng.getMemoryManager())
793                             RefVectorOf<XMLNumber>(
794                                                    initSize
795                                                  , toAdopt
796                                                  , serEng.getMemoryManager()
797                                                   );
798        }
799
800        serEng.registerObject(*objToLoad);
801
802        XMLSize_t vectorLength = 0;
803        serEng.readSize (vectorLength);
804        for (XMLSize_t i = 0 ; i < vectorLength; i++)
805        {
806            XMLNumber*  data;
807            data = XMLNumber::loadNumber(numType , serEng);
808            (*objToLoad)->addElement(data);
809        }
810    }
811
812}
813
814void XTemplateSerializer::storeObject(RefVectorOf<XercesLocationPath>* const objToStore
815                                    , XSerializeEngine&                      serEng)
816{
817
818    if (serEng.needToStoreObject(objToStore))
819    {
820        XMLSize_t vectorLength = objToStore->size();
821        serEng.writeSize (vectorLength);
822
823        for ( XMLSize_t i = 0; i < vectorLength; i++)
824        {
825            XercesLocationPath* data = objToStore->elementAt(i);
826            serEng<<data;
827        }
828    }
829
830}
831
832void XTemplateSerializer::loadObject(RefVectorOf<XercesLocationPath>** objToLoad
833                                   , int                               initSize
834                                   , bool                              toAdopt
835                                   , XSerializeEngine&                 serEng)
836{
837
838    if (serEng.needToLoadObject((void**)objToLoad))
839    {
840        if (!*objToLoad)
841        {
842            if (initSize < 0)
843                initSize = 16;
844
845            *objToLoad = new (serEng.getMemoryManager())
846                             RefVectorOf<XercesLocationPath>(
847                                                             initSize
848                                                           , toAdopt
849                                                           , serEng.getMemoryManager()
850                                                            );
851        }
852
853        serEng.registerObject(*objToLoad);
854
855        XMLSize_t vectorLength = 0;
856        serEng.readSize (vectorLength);
857        for (XMLSize_t i = 0 ; i < vectorLength; i++)
858        {
859            XercesLocationPath*  data;
860            serEng>>data;
861            (*objToLoad)->addElement(data);
862        }
863    }
864
865}
866
867void XTemplateSerializer::storeObject(RefVectorOf<XercesStep>* const objToStore
868                                    , XSerializeEngine&              serEng)
869{
870
871    if (serEng.needToStoreObject(objToStore))
872    {
873        XMLSize_t vectorLength = objToStore->size();
874        serEng.writeSize (vectorLength);
875
876        for (XMLSize_t i = 0; i < vectorLength; i++)
877        {
878            XercesStep* data = objToStore->elementAt(i);
879            serEng<<data;
880        }
881    }
882
883}
884
885void XTemplateSerializer::loadObject(RefVectorOf<XercesStep>** objToLoad
886                                   , int                       initSize
887                                   , bool                      toAdopt
888                                   , XSerializeEngine&         serEng)
889{
890
891    if (serEng.needToLoadObject((void**)objToLoad))
892    {
893        if (!*objToLoad)
894        {
895            if (initSize < 0)
896                initSize = 16;
897
898            *objToLoad = new (serEng.getMemoryManager())
899                             RefVectorOf<XercesStep>(
900                                                     initSize
901                                                   , toAdopt
902                                                   , serEng.getMemoryManager()
903                                                    );
904        }
905
906        serEng.registerObject(*objToLoad);
907
908        XMLSize_t vectorLength = 0;
909        serEng.readSize (vectorLength);
910        for (XMLSize_t i = 0 ; i < vectorLength; i++)
911        {
912            XercesStep*  data;
913            serEng>>data;
914            (*objToLoad)->addElement(data);
915        }
916    }
917
918}
919
920/**********************************************************
921 *
922 * RefHashTableOf
923 *
924 *   KVStringPair
925 *   XMLAttDef
926 *   DTDAttDef
927 *   ComplexTypeInfo
928 *   XercesGroupInfo
929 *   XercesAttGroupInfo
930 *   XMLRefInfo
931 *   DatatypeValidator
932 *   Grammar
933 *   XSAnnotation
934 *
935 ***********************************************************/
936void XTemplateSerializer::storeObject(RefHashTableOf<KVStringPair>* const objToStore
937                                    , XSerializeEngine&                    serEng)
938{
939
940    if (serEng.needToStoreObject(objToStore))
941    {
942        serEng.writeSize (objToStore->getHashModulus());
943
944        RefHashTableOfEnumerator<KVStringPair> e(objToStore, false, objToStore->getMemoryManager());
945        XMLSize_t itemNumber = 0;
946
947        while (e.hasMoreElements())
948        {
949            e.nextElement();
950            itemNumber++;
951        }
952
953        serEng.writeSize (itemNumber);
954        e.Reset();
955
956#ifdef XERCES_DEBUG_SORT_GRAMMAR
957        //to sort the key
958        SORT_KEYSET_ONEKEY(serEng.getMemoryManager())
959
960        //to store the data
961        for (XMLSize_t i=0; i < itemNumber; i++)
962        {
963            GET_NEXT_KEYSET()
964
965            KVStringPair* data = objToStore->get(strKey);
966            serEng<<data;
967        }
968#else
969        while (e.hasMoreElements())
970        {
971            KVStringPair* data = objToStore->get(e.nextElementKey());
972            serEng<<data;
973        }
974#endif
975    }
976}
977
978void XTemplateSerializer::loadObject(RefHashTableOf<KVStringPair>** objToLoad
979                                   , int
980                                   , bool                           toAdopt
981                                   , XSerializeEngine&              serEng)
982{
983
984    if (serEng.needToLoadObject((void**)objToLoad))
985    {
986        XMLSize_t hashModulus;
987        serEng.readSize (hashModulus);
988
989        if (!*objToLoad)
990        {
991            *objToLoad = new (serEng.getMemoryManager())
992                             RefHashTableOf<KVStringPair>(
993                                                          hashModulus
994                                                        , toAdopt
995                                                        , serEng.getMemoryManager()
996                                                         );
997        }
998
999        serEng.registerObject(*objToLoad);
1000
1001        XMLSize_t itemNumber = 0;
1002        serEng.readSize (itemNumber);
1003
1004        for (XMLSize_t itemIndex = 0; itemIndex < itemNumber; itemIndex++)
1005        {
1006            KVStringPair*  data;
1007            serEng>>data;
1008
1009            (*objToLoad)->put((void*)data->getKey(), data);
1010        }
1011    }
1012}
1013
1014void XTemplateSerializer::storeObject(RefHashTableOf<XMLAttDef>* const objToStore
1015                                    , XSerializeEngine&                serEng)
1016{
1017    if (serEng.needToStoreObject(objToStore))
1018    {
1019        serEng.writeSize (objToStore->getHashModulus());
1020
1021        RefHashTableOfEnumerator<XMLAttDef> e(objToStore, false, objToStore->getMemoryManager());
1022        XMLSize_t itemNumber = 0;
1023
1024        while (e.hasMoreElements())
1025        {
1026            e.nextElement();
1027            itemNumber++;
1028        }
1029
1030        serEng.writeSize (itemNumber);
1031        e.Reset();
1032
1033#ifdef XERCES_DEBUG_SORT_GRAMMAR
1034        //to sort the key
1035        SORT_KEYSET_ONEKEY(serEng.getMemoryManager())
1036
1037        //to store the data
1038        for (XMLSize_t i=0; i < itemNumber; i++)
1039        {
1040            GET_NEXT_KEYSET()
1041
1042            XMLAttDef* data = objToStore->get(strKey);
1043            serEng<<data;
1044        }
1045#else
1046        while (e.hasMoreElements())
1047        {
1048            XMLAttDef* data = objToStore->get(e.nextElementKey());
1049            serEng<<data;
1050        }
1051#endif
1052    }
1053}
1054
1055void XTemplateSerializer::loadObject(RefHashTableOf<XMLAttDef>** objToLoad
1056                                   , int
1057                                   , bool                        toAdopt
1058                                   , XSerializeEngine&           serEng)
1059{
1060
1061    if (serEng.needToLoadObject((void**)objToLoad))
1062    {
1063
1064        XMLSize_t hashModulus;
1065        serEng.readSize (hashModulus);
1066
1067        if (!*objToLoad)
1068        {
1069            *objToLoad = new (serEng.getMemoryManager())
1070                             RefHashTableOf<XMLAttDef>(
1071                                                       hashModulus
1072                                                     , toAdopt
1073                                                     , serEng.getMemoryManager()
1074                                                      );
1075        }
1076
1077        serEng.registerObject(*objToLoad);
1078
1079        XMLSize_t itemNumber = 0;
1080        serEng.readSize (itemNumber);
1081
1082        for (XMLSize_t itemIndex = 0; itemIndex < itemNumber; itemIndex++)
1083        {
1084            //This is used solely by SchemaGrammar and by all means it must be
1085            //SchemaAttDef, ideally we may change it to RefHashTableOf<SchemaAttDef>
1086            //later on.
1087            //Affected files IGXMLScanner, SGXMLScanner, SchemaGrammar, TraverseSchema
1088            //XMLAttDef*  data;
1089            SchemaAttDef*  data;
1090            serEng>>data;
1091
1092            (*objToLoad)->put((void*)data->getAttName()->getLocalPart(), data);
1093        }
1094    }
1095}
1096
1097void XTemplateSerializer::storeObject(RefHashTableOf<DTDAttDef>* const objToStore
1098                                    , XSerializeEngine&                serEng)
1099{
1100    if (serEng.needToStoreObject(objToStore))
1101    {
1102        serEng.writeSize (objToStore->getHashModulus());
1103
1104        RefHashTableOfEnumerator<DTDAttDef> e(objToStore, false, objToStore->getMemoryManager());
1105        XMLSize_t itemNumber = 0;
1106
1107        while (e.hasMoreElements())
1108        {
1109            e.nextElement();
1110            itemNumber++;
1111        }
1112
1113        serEng.writeSize (itemNumber);
1114        e.Reset();
1115
1116#ifdef XERCES_DEBUG_SORT_GRAMMAR
1117        //to sort the key
1118        SORT_KEYSET_ONEKEY(serEng.getMemoryManager())
1119
1120        //to store the data
1121        for (XMLSize_t i=0; i < itemNumber; i++)
1122        {
1123            GET_NEXT_KEYSET()
1124
1125            DTDAttDef* data = objToStore->get(strKey);
1126            serEng<<data;
1127        }
1128#else
1129        while (e.hasMoreElements())
1130        {
1131            DTDAttDef* data = objToStore->get(e.nextElementKey());
1132            serEng<<data;
1133        }
1134#endif
1135    }
1136}
1137
1138void XTemplateSerializer::loadObject(RefHashTableOf<DTDAttDef>** objToLoad
1139                                   , int
1140                                   , bool                        toAdopt
1141                                   , XSerializeEngine&           serEng)
1142{
1143
1144    if (serEng.needToLoadObject((void**)objToLoad))
1145    {
1146
1147        XMLSize_t hashModulus;
1148        serEng.readSize (hashModulus);
1149
1150        if (!*objToLoad)
1151        {
1152            *objToLoad = new (serEng.getMemoryManager())
1153                             RefHashTableOf<DTDAttDef>(
1154                                                       hashModulus
1155                                                     , toAdopt
1156                                                     , serEng.getMemoryManager()
1157                                                      );
1158        }
1159
1160        serEng.registerObject(*objToLoad);
1161
1162        XMLSize_t itemNumber = 0;
1163        serEng.readSize (itemNumber);
1164
1165        for (XMLSize_t itemIndex = 0; itemIndex < itemNumber; itemIndex++)
1166        {
1167            DTDAttDef*  data;
1168            serEng>>data;
1169
1170            (*objToLoad)->put((void*)data->getFullName(), data);
1171        }
1172    }
1173}
1174
1175void XTemplateSerializer::storeObject(RefHashTableOf<ComplexTypeInfo>* const objToStore
1176                                    , XSerializeEngine&                      serEng)
1177{
1178    if (serEng.needToStoreObject(objToStore))
1179    {
1180        serEng.writeSize (objToStore->getHashModulus());
1181
1182        RefHashTableOfEnumerator<ComplexTypeInfo> e(objToStore, false, objToStore->getMemoryManager());
1183        XMLSize_t itemNumber = 0;
1184
1185        while (e.hasMoreElements())
1186        {
1187            e.nextElement();
1188            itemNumber++;
1189        }
1190
1191        serEng.writeSize (itemNumber);
1192        e.Reset();
1193
1194#ifdef XERCES_DEBUG_SORT_GRAMMAR
1195        //to sort the key
1196        SORT_KEYSET_ONEKEY(serEng.getMemoryManager())
1197
1198        //to store the data
1199        for (XMLSize_t i=0; i < itemNumber; i++)
1200        {
1201            GET_NEXT_KEYSET()
1202
1203            ComplexTypeInfo* data = objToStore->get(strKey);
1204            serEng<<data;
1205        }
1206#else
1207        while (e.hasMoreElements())
1208        {
1209            ComplexTypeInfo* data = objToStore->get(e.nextElementKey());
1210            serEng<<data;
1211        }
1212#endif
1213    }
1214}
1215
1216void XTemplateSerializer::loadObject(RefHashTableOf<ComplexTypeInfo>** objToLoad
1217                                   , int
1218                                   , bool                              toAdopt
1219                                   , XSerializeEngine&                 serEng)
1220{
1221    if (serEng.needToLoadObject((void**)objToLoad))
1222    {
1223        XMLSize_t hashModulus;
1224        serEng.readSize (hashModulus);
1225
1226        if (!*objToLoad)
1227        {
1228            *objToLoad = new (serEng.getMemoryManager())
1229                             RefHashTableOf<ComplexTypeInfo>(
1230                                                             hashModulus
1231                                                           , toAdopt
1232                                                           , serEng.getMemoryManager()
1233                                                           );
1234        }
1235
1236        serEng.registerObject(*objToLoad);
1237
1238        XMLSize_t itemNumber = 0;
1239        serEng.readSize (itemNumber);
1240
1241        for (XMLSize_t itemIndex = 0; itemIndex < itemNumber; itemIndex++)
1242        {
1243            ComplexTypeInfo*  data;
1244            serEng>>data;
1245
1246           (*objToLoad)->put((void*)data->getTypeName(), data);
1247        }
1248    }
1249}
1250
1251void XTemplateSerializer::storeObject(RefHashTableOf<XercesGroupInfo>* const objToStore
1252                                    , XSerializeEngine&                      serEng)
1253{
1254    if (serEng.needToStoreObject(objToStore))
1255    {
1256        serEng.writeSize (objToStore->getHashModulus());
1257
1258        RefHashTableOfEnumerator<XercesGroupInfo> e(objToStore, false, objToStore->getMemoryManager());
1259        XMLSize_t itemNumber = 0;
1260
1261        while (e.hasMoreElements())
1262        {
1263            e.nextElement();
1264            itemNumber++;
1265        }
1266
1267        serEng.writeSize (itemNumber);
1268        e.Reset();
1269
1270#ifdef XERCES_DEBUG_SORT_GRAMMAR
1271        //to sort the key
1272        SORT_KEYSET_ONEKEY(serEng.getMemoryManager())
1273
1274        //to store the data
1275        for (XMLSize_t i=0; i < itemNumber; i++)
1276        {
1277            GET_NEXT_KEYSET()
1278
1279            unsigned int id  = serEng.getStringPool()->getId(strKey);
1280            serEng<<id;
1281
1282            XercesGroupInfo* data = objToStore->get(strKey);
1283            serEng<<data;
1284        }
1285#else
1286        while (e.hasMoreElements())
1287        {
1288            XMLCh*       key = (XMLCh*) e.nextElementKey();
1289            unsigned int id  = serEng.getStringPool()->getId(key);
1290
1291           // key = StringPool->getValueForId(XercesGroupInfo::getNameSpaceId())
1292           //     + chComma
1293           //     + StringPool->getValueForId(XercesGroupInfo::getNameId())
1294           //
1295           // and the key is guranteed in the StringPool
1296           //
1297           //
1298           //  if (id == 0)
1299           //  {
1300           //      throw exception
1301           //   }
1302           //
1303
1304            serEng<<id;
1305
1306            XercesGroupInfo* data = objToStore->get(key);
1307            serEng<<data;
1308        }
1309#endif
1310    }
1311}
1312
1313void XTemplateSerializer::loadObject(RefHashTableOf<XercesGroupInfo>** objToLoad
1314                                   , int
1315                                   , bool                              toAdopt
1316                                   , XSerializeEngine&                 serEng)
1317{
1318    if (serEng.needToLoadObject((void**)objToLoad))
1319    {
1320        XMLSize_t hashModulus;
1321        serEng.readSize (hashModulus);
1322
1323        if (!*objToLoad)
1324        {
1325            *objToLoad = new (serEng.getMemoryManager())
1326                             RefHashTableOf<XercesGroupInfo>(
1327                                                             hashModulus
1328                                                           , toAdopt
1329                                                           , serEng.getMemoryManager()
1330                                                           );
1331        }
1332
1333        serEng.registerObject(*objToLoad);
1334
1335        XMLSize_t itemNumber = 0;
1336        serEng.readSize (itemNumber);
1337
1338        for (XMLSize_t itemIndex = 0; itemIndex < itemNumber; itemIndex++)
1339        {
1340            unsigned int id;
1341            serEng>>id;
1342
1343            XMLCh* key = (XMLCh*) serEng.getStringPool()->getValueForId(id);
1344
1345            XercesGroupInfo*  data;
1346            serEng>>data;
1347
1348            (*objToLoad)->put((void*)key, data);
1349        }
1350    }
1351}
1352
1353void XTemplateSerializer::storeObject(RefHashTableOf<XercesAttGroupInfo>* const objToStore
1354                                    , XSerializeEngine&                         serEng)
1355{
1356
1357    if (serEng.needToStoreObject(objToStore))
1358    {
1359        serEng.writeSize (objToStore->getHashModulus());
1360
1361        RefHashTableOfEnumerator<XercesAttGroupInfo> e(objToStore, false, objToStore->getMemoryManager());
1362        XMLSize_t itemNumber = 0;
1363
1364        while (e.hasMoreElements())
1365        {
1366            e.nextElement();
1367            itemNumber++;
1368        }
1369
1370        serEng.writeSize (itemNumber);
1371        e.Reset();
1372
1373#ifdef XERCES_DEBUG_SORT_GRAMMAR
1374        //to sort the key
1375        SORT_KEYSET_ONEKEY(serEng.getMemoryManager())
1376
1377        //to store the data
1378        for (XMLSize_t i=0; i < itemNumber; i++)
1379        {
1380            GET_NEXT_KEYSET()
1381
1382            XercesAttGroupInfo* data = objToStore->get(strKey);
1383            serEng<<data;
1384        }
1385#else
1386        while (e.hasMoreElements())
1387        {
1388            XercesAttGroupInfo* data = objToStore->get(e.nextElementKey());
1389            serEng<<data;
1390        }
1391#endif
1392    }
1393}
1394
1395void XTemplateSerializer::loadObject(RefHashTableOf<XercesAttGroupInfo>** objToLoad
1396                                   , int
1397                                   , bool                                 toAdopt
1398                                   , XSerializeEngine&                    serEng)
1399{
1400    if (serEng.needToLoadObject((void**)objToLoad))
1401    {
1402        XMLSize_t hashModulus;
1403        serEng.readSize (hashModulus);
1404
1405        if (!*objToLoad)
1406        {
1407            *objToLoad = new (serEng.getMemoryManager())
1408                             RefHashTableOf<XercesAttGroupInfo>(
1409                                                                hashModulus
1410                                                              , toAdopt
1411                                                              , serEng.getMemoryManager()
1412                                                              );
1413        }
1414
1415        serEng.registerObject(*objToLoad);
1416
1417        XMLSize_t itemNumber = 0;
1418        serEng.readSize (itemNumber);
1419
1420        for (XMLSize_t itemIndex = 0; itemIndex < itemNumber; itemIndex++)
1421        {
1422            XercesAttGroupInfo*  data;
1423            serEng>>data;
1424
1425            XMLCh* key = (XMLCh*) serEng.getStringPool()->getValueForId(data->getNameId());
1426            (*objToLoad)->put((void*)key, data);
1427        }
1428    }
1429}
1430
1431void XTemplateSerializer::storeObject(RefHashTableOf<XMLRefInfo>* const objToStore
1432                                    , XSerializeEngine&                 serEng)
1433{
1434    if (serEng.needToStoreObject(objToStore))
1435    {
1436        serEng.writeSize (objToStore->getHashModulus());
1437
1438        RefHashTableOfEnumerator<XMLRefInfo> e(objToStore, false, objToStore->getMemoryManager());
1439        XMLSize_t itemNumber = 0;
1440
1441        while (e.hasMoreElements())
1442        {
1443            e.nextElement();
1444            itemNumber++;
1445        }
1446
1447        serEng.writeSize (itemNumber);
1448        e.Reset();
1449
1450#ifdef XERCES_DEBUG_SORT_GRAMMAR
1451        //to sort the key
1452        SORT_KEYSET_ONEKEY(serEng.getMemoryManager())
1453
1454        //to store the data
1455        for (XMLSize_t i=0; i < itemNumber; i++)
1456        {
1457            GET_NEXT_KEYSET()
1458
1459            serEng.writeString(strKey);
1460
1461            XMLRefInfo* data = objToStore->get(strKey);
1462            serEng<<data;
1463        }
1464#else
1465        while (e.hasMoreElements())
1466        {
1467            XMLCh*     key  = (XMLCh*) e.nextElementKey();
1468            serEng.writeString(key);
1469
1470            XMLRefInfo* data = objToStore->get(key);
1471            serEng<<data;
1472        }
1473#endif
1474    }
1475}
1476
1477void XTemplateSerializer::loadObject(RefHashTableOf<XMLRefInfo>** objToLoad
1478                                   , int
1479                                   , bool                         toAdopt
1480                                   , XSerializeEngine&            serEng)
1481{
1482    if (serEng.needToLoadObject((void**)objToLoad))
1483    {
1484        XMLSize_t hashModulus;
1485        serEng.readSize (hashModulus);
1486
1487        if (!*objToLoad)
1488        {
1489            *objToLoad = new (serEng.getMemoryManager())
1490                             RefHashTableOf<XMLRefInfo>(
1491                                                        hashModulus
1492                                                      , toAdopt
1493                                                      , serEng.getMemoryManager()
1494                                                      );
1495        }
1496
1497        serEng.registerObject(*objToLoad);
1498
1499        XMLSize_t itemNumber = 0;
1500        serEng.readSize (itemNumber);
1501
1502        for (XMLSize_t itemIndex = 0; itemIndex < itemNumber; itemIndex++)
1503        {
1504            XMLCh*      key;
1505            serEng.readString(key);
1506
1507            XMLRefInfo*  data;
1508            serEng>>data;
1509
1510            (*objToLoad)->put((void*)key, data);
1511        }
1512    }
1513}
1514
1515void XTemplateSerializer::storeObject(RefHashTableOf<DatatypeValidator>* const objToStore
1516                                    , XSerializeEngine&                        serEng)
1517{
1518
1519    if (serEng.needToStoreObject(objToStore))
1520    {
1521
1522        serEng.writeSize (objToStore->getHashModulus());
1523
1524        RefHashTableOfEnumerator<DatatypeValidator> e(objToStore, false, objToStore->getMemoryManager());
1525        XMLSize_t itemNumber = 0;
1526
1527        while (e.hasMoreElements())
1528        {
1529            e.nextElement();
1530            itemNumber++;
1531        }
1532
1533        serEng.writeSize (itemNumber);
1534        e.Reset();
1535
1536#ifdef XERCES_DEBUG_SORT_GRAMMAR
1537        //to sort the key
1538        SORT_KEYSET_ONEKEY(serEng.getMemoryManager())
1539
1540        //to store the data
1541        for (XMLSize_t i=0; i < itemNumber; i++)
1542        {
1543            GET_NEXT_KEYSET()
1544
1545            DatatypeValidator* data = objToStore->get(strKey);
1546            DatatypeValidator::storeDV(serEng, data);
1547        }
1548#else
1549        while (e.hasMoreElements())
1550        {
1551            /***
1552             * to do: verify valid id
1553             *
1554             *    XMLCh*  key = (XMLCh*) e.nextElementKey();
1555             *    unsigned int id = serEng.getStringPool()->getId(key);
1556             *    if (id == 0)
1557             *        throw exception
1558             ***/
1559            DatatypeValidator* data = objToStore->get(e.nextElementKey());
1560            DatatypeValidator::storeDV(serEng, data);
1561        }
1562#endif
1563    }
1564}
1565
1566void XTemplateSerializer::loadObject(RefHashTableOf<DatatypeValidator>** objToLoad
1567                                   , int
1568                                   , bool                                toAdopt
1569                                   , XSerializeEngine&                   serEng)
1570{
1571    if (serEng.needToLoadObject((void**)objToLoad))
1572    {
1573        XMLSize_t hashModulus;
1574        serEng.readSize (hashModulus);
1575
1576        if (!*objToLoad)
1577        {
1578            *objToLoad = new (serEng.getMemoryManager())
1579                             RefHashTableOf<DatatypeValidator>(
1580                                                               hashModulus
1581                                                             , toAdopt
1582                                                             , serEng.getMemoryManager()
1583                                                             );
1584        }
1585
1586        serEng.registerObject(*objToLoad);
1587
1588        XMLSize_t itemNumber = 0;
1589        serEng.readSize (itemNumber);
1590
1591        for (XMLSize_t itemIndex = 0; itemIndex < itemNumber; itemIndex++)
1592        {
1593            DatatypeValidator*  data;
1594            data = DatatypeValidator::loadDV(serEng);
1595
1596            /***
1597             *   restore the key
1598             ***/
1599            XMLCh*       typeUri   = (XMLCh*) data->getTypeUri();
1600            XMLCh*       typeLocal = (XMLCh*) data->getTypeLocalName();
1601            XMLSize_t    uriLen    = XMLString::stringLen(typeUri);
1602            XMLSize_t    localLen  = XMLString::stringLen(typeLocal);
1603            XMLCh*       typeKey   = (XMLCh*) serEng.getMemoryManager()->allocate
1604                                     (
1605                                       (uriLen + localLen + 2) * sizeof(XMLCh)
1606                                     );
1607            // "typeuri,typeLocal"
1608            XMLString::moveChars(typeKey, typeUri, uriLen+1);
1609            typeKey[uriLen] = chComma;
1610            XMLString::moveChars(&typeKey[uriLen+1], typeLocal, localLen+1);
1611            typeKey[uriLen + localLen + 1] = chNull;
1612            ArrayJanitor<XMLCh> janName(typeKey, serEng.getMemoryManager());
1613
1614            /*
1615             * get the string from string pool
1616             *
1617             *  to do:
1618             ***/
1619            unsigned int id = serEng.getStringPool()->getId(typeKey);
1620            XMLCh* refKey = (XMLCh*) serEng.getStringPool()->getValueForId(id);
1621
1622            (*objToLoad)->put((void*)refKey, data);
1623        }
1624    }
1625}
1626
1627void XTemplateSerializer::storeObject(RefHashTableOf<Grammar>* const objToStore
1628                                    , XSerializeEngine&              serEng)
1629{
1630    if (serEng.needToStoreObject(objToStore))
1631    {
1632        serEng.writeSize (objToStore->getHashModulus());
1633
1634        RefHashTableOfEnumerator<Grammar> e(objToStore, false, objToStore->getMemoryManager());
1635        XMLSize_t itemNumber = 0;
1636
1637        while (e.hasMoreElements())
1638        {
1639            e.nextElement();
1640            itemNumber++;
1641        }
1642
1643        serEng.writeSize (itemNumber);
1644        e.Reset();
1645
1646#ifdef XERCES_DEBUG_SORT_GRAMMAR
1647        //to sort the key
1648        SORT_KEYSET_ONEKEY(serEng.getMemoryManager())
1649
1650        //to store the data
1651        for (XMLSize_t i=0; i < itemNumber; i++)
1652        {
1653            GET_NEXT_KEYSET()
1654
1655            Grammar* data = objToStore->get(strKey);
1656            Grammar::storeGrammar(serEng, data);
1657        }
1658#else
1659        while (e.hasMoreElements())
1660        {
1661            Grammar* data = objToStore->get(e.nextElementKey());
1662            Grammar::storeGrammar(serEng, data);
1663        }
1664#endif
1665
1666    }
1667}
1668
1669void XTemplateSerializer::loadObject(RefHashTableOf<Grammar>** objToLoad
1670                                   , int
1671                                   , bool                      toAdopt
1672                                   , XSerializeEngine&         serEng)
1673{
1674    if (serEng.needToLoadObject((void**)objToLoad))
1675    {
1676        XMLSize_t hashModulus;
1677        serEng.readSize (hashModulus);
1678
1679        if (!*objToLoad)
1680        {
1681            *objToLoad = new (serEng.getMemoryManager())
1682                             RefHashTableOf<Grammar>(
1683                                                     hashModulus
1684                                                   , toAdopt
1685                                                   , serEng.getMemoryManager()
1686                                                   );
1687        }
1688
1689        serEng.registerObject(*objToLoad);
1690
1691        XMLSize_t itemNumber = 0;
1692        serEng.readSize (itemNumber);
1693
1694        for (XMLSize_t itemIndex = 0; itemIndex < itemNumber; itemIndex++)
1695        {
1696            Grammar*  data;
1697            data = Grammar::loadGrammar(serEng);
1698
1699            XMLCh* key = (XMLCh*) data->getGrammarDescription()->getGrammarKey();
1700            (*objToLoad)->put(key, data);
1701        }
1702    }
1703}
1704
1705
1706void XTemplateSerializer::storeObject(RefHashTableOf<XSAnnotation, PtrHasher>* const objToStore
1707                                    , XSerializeEngine&              serEng)
1708{
1709    if (serEng.needToStoreObject(objToStore))
1710    {
1711        serEng.writeSize (objToStore->getHashModulus());
1712
1713        RefHashTableOfEnumerator<XSAnnotation, PtrHasher> e(objToStore, false, objToStore->getMemoryManager());
1714
1715#ifdef XERCES_DEBUG_SORT_GRAMMAR
1716        //get the total item number
1717        unsigned int   itemNumber = 0;
1718        while (e.hasMoreElements())
1719        {
1720            void* key = e.nextElementKey();
1721            XSerializeEngine::XSerializedObjectId_t keyId = serEng.lookupStorePool(key);
1722
1723            if (keyId)
1724                itemNumber++;
1725        }
1726
1727        serEng.writeSize (itemNumber);
1728        e.Reset();
1729
1730        //to sort the key
1731        //though keyId is not supposed to be involved in compare
1732        //we merely use the KeySet to encap both the string key and keyid
1733        SortArray sortArray(itemNumber, objToStore->getMemoryManager());
1734        while (e.hasMoreElements())
1735        {
1736            void* key = e.nextElementKey();
1737            XSerializeEngine::XSerializedObjectId_t keyId = serEng.lookupStorePool(key);
1738
1739            if (keyId)
1740            {
1741                KeySet* keySet =
1742                    new (objToStore->getMemoryManager()) KeySet((XMLCh*)key, keyId, 0, objToStore->getMemoryManager());
1743                sortArray.addElement(keySet);
1744            }
1745
1746        }
1747
1748        sortArray.sort();
1749
1750        //to store the data
1751        for (XMLSize_t i=0; i < itemNumber; i++)
1752        {
1753            GET_NEXT_KEYSET()
1754
1755            XSerializeEngine::XSerializedObjectId_t keyId = (XSerializeEngine::XSerializedObjectId_t)intKey1;
1756            XSAnnotation* data = objToStore->get(strKey);
1757
1758            serEng<<keyId;
1759            serEng<<data;
1760        }
1761#else
1762        ValueVectorOf<XSerializeEngine::XSerializedObjectId_t> ids(16, serEng.getMemoryManager());
1763        ValueVectorOf<void*> keys(16, serEng.getMemoryManager());
1764
1765        while (e.hasMoreElements())
1766        {
1767            void* key = e.nextElementKey();
1768            XSerializeEngine::XSerializedObjectId_t keyId = serEng.lookupStorePool(key);
1769
1770            if (keyId)
1771            {
1772                ids.addElement(keyId);
1773                keys.addElement(key);
1774            }
1775        }
1776
1777        XMLSize_t itemNumber = ids.size();
1778        serEng.writeSize (itemNumber);
1779
1780        for (XMLSize_t i=0; i<itemNumber; i++)
1781        {
1782            XSerializeEngine::XSerializedObjectId_t keyId = ids.elementAt(i);
1783            XSAnnotation* data = objToStore->get(keys.elementAt(i));
1784            serEng<<keyId;
1785            serEng<<data;
1786        }
1787#endif
1788    }
1789}
1790
1791void XTemplateSerializer::loadObject(RefHashTableOf<XSAnnotation, PtrHasher>** objToLoad
1792                                   , int
1793                                   , bool                           toAdopt
1794                                   , XSerializeEngine&              serEng)
1795{
1796    if (serEng.needToLoadObject((void**)objToLoad))
1797    {
1798        XMLSize_t hashModulus;
1799        serEng.readSize (hashModulus);
1800
1801        if (!*objToLoad)
1802        {
1803            *objToLoad = new (serEng.getMemoryManager())
1804                              RefHashTableOf<XSAnnotation, PtrHasher>(
1805                              hashModulus
1806                            , toAdopt
1807                            , serEng.getMemoryManager()
1808                              );
1809        }
1810
1811        serEng.registerObject(*objToLoad);
1812
1813        XMLSize_t itemNumber = 0;
1814        serEng.readSize (itemNumber);
1815
1816        XMLSize_t itemIndex;
1817        XSerializeEngine::XSerializedObjectId_t keyId;
1818        void* key;
1819        XSAnnotation*  data;
1820        if (!serEng.fGrammarPool->getIgnoreSerializedAnnotations()) {
1821            for (itemIndex = 0; itemIndex < itemNumber; itemIndex++)
1822            {
1823                serEng>>keyId;
1824                key = serEng.lookupLoadPool(keyId);
1825                serEng>>data;
1826                (*objToLoad)->put(key, data);
1827            }
1828        }
1829        else {
1830            for (itemIndex = 0; itemIndex < itemNumber; itemIndex++)
1831            {
1832                serEng>>keyId;
1833                key = serEng.lookupLoadPool(keyId);
1834                serEng>>data;
1835                delete data;
1836            }
1837        }
1838    }
1839}
1840
1841/**********************************************************
1842 *
1843 * RefHash2KeysTableOf
1844 *
1845 *   SchemaAttDef
1846 *   ElemVector
1847 *
1848 ***********************************************************/
1849void XTemplateSerializer::storeObject(RefHash2KeysTableOf<SchemaAttDef>* const objToStore
1850                                    , XSerializeEngine&                        serEng)
1851{
1852    if (serEng.needToStoreObject(objToStore))
1853    {
1854        serEng.writeSize (objToStore->getHashModulus());
1855
1856        XMLSize_t itemNumber = 0;
1857
1858        RefHash2KeysTableOfEnumerator<SchemaAttDef> e(objToStore, false, objToStore->getMemoryManager());
1859
1860        while (e.hasMoreElements())
1861        {
1862            e.nextElement();
1863            itemNumber++;
1864        }
1865
1866        serEng.writeSize (itemNumber);
1867        e.Reset();
1868
1869#ifdef XERCES_DEBUG_SORT_GRAMMAR
1870        //to sort the key
1871        SORT_KEYSET_TWOKEYS(serEng.getMemoryManager())
1872
1873        //to store the data
1874        for (XMLSize_t i=0; i < itemNumber; i++)
1875        {
1876            GET_NEXT_KEYSET()
1877
1878            SchemaAttDef* data = objToStore->get(strKey, intKey1);
1879            serEng<<data;
1880
1881        }
1882#else
1883
1884        while (e.hasMoreElements())
1885        {
1886            void*       key1;
1887            int        key2;
1888            e.nextElementKey(key1, key2);
1889
1890            SchemaAttDef* data = objToStore->get(key1, key2);
1891            serEng<<data;
1892
1893        }
1894#endif
1895    }
1896
1897}
1898
1899void XTemplateSerializer::loadObject(RefHash2KeysTableOf<SchemaAttDef>** objToLoad
1900                                   , int
1901                                   , bool                                toAdopt
1902                                   , XSerializeEngine&                   serEng)
1903{
1904    if (serEng.needToLoadObject((void**)objToLoad))
1905    {
1906        XMLSize_t hashModulus;
1907        serEng.readSize (hashModulus);
1908
1909        if (!*objToLoad)
1910        {
1911            *objToLoad = new (serEng.getMemoryManager())
1912                             RefHash2KeysTableOf<SchemaAttDef>(
1913                                                               hashModulus
1914                                                             , toAdopt
1915                                                             , serEng.getMemoryManager()
1916                                                             );
1917        }
1918
1919        serEng.registerObject(*objToLoad);
1920
1921        XMLSize_t itemNumber = 0;
1922        serEng.readSize (itemNumber);
1923
1924        for (XMLSize_t itemIndex = 0; itemIndex < itemNumber; itemIndex++)
1925        {
1926            SchemaAttDef*  data;
1927            serEng>>data;
1928
1929            XMLCh* key1 = data->getAttName()->getLocalPart();
1930            int    key2 = data->getAttName()->getURI();
1931            //key2==data->getId()
1932            (*objToLoad)->put((void*)key1, key2, data);
1933
1934        }
1935
1936    }
1937
1938}
1939
1940void XTemplateSerializer::storeObject(RefHash2KeysTableOf<ElemVector>* const objToStore
1941                                    , XSerializeEngine&                      serEng)
1942{
1943    if (serEng.needToStoreObject(objToStore))
1944    {
1945        serEng.writeSize (objToStore->getHashModulus());
1946
1947        XMLSize_t itemNumber = 0;
1948
1949        RefHash2KeysTableOfEnumerator<ElemVector> e(objToStore, false, objToStore->getMemoryManager());
1950
1951        while (e.hasMoreElements())
1952        {
1953            e.nextElement();
1954            itemNumber++;
1955        }
1956
1957        serEng.writeSize (itemNumber);
1958        e.Reset();
1959
1960#ifdef XERCES_DEBUG_SORT_GRAMMAR
1961
1962        //to sort the key
1963        SORT_KEYSET_TWOKEYS(serEng.getMemoryManager())
1964
1965        //to store the data
1966        for (XMLSize_t i=0; i < itemNumber; i++)
1967        {
1968            GET_NEXT_KEYSET()
1969
1970            serEng.writeString(strKey);
1971            serEng<<intKey1;
1972
1973            ElemVector* data = objToStore->get(strKey, intKey1);
1974            storeObject(data, serEng);
1975        }
1976#else
1977
1978        while (e.hasMoreElements())
1979        {
1980            void*      key1;
1981            int        key2;
1982
1983            e.nextElementKey(key1, key2);
1984            serEng.writeString((const XMLCh*)key1);
1985            serEng<<key2;
1986
1987            ElemVector* data = objToStore->get(key1, key2);
1988            storeObject(data, serEng);
1989
1990        }
1991#endif
1992    }
1993
1994}
1995
1996void XTemplateSerializer::loadObject(RefHash2KeysTableOf<ElemVector>**      objToLoad
1997                                   , int
1998                                   , bool                                    toAdopt
1999                                   , XSerializeEngine&                       serEng)
2000{
2001    if (serEng.needToLoadObject((void**)objToLoad))
2002    {
2003        XMLSize_t hashModulus;
2004        serEng.readSize (hashModulus);
2005
2006        if (!*objToLoad)
2007        {
2008            *objToLoad = new (serEng.getMemoryManager())
2009                             RefHash2KeysTableOf<ElemVector>(
2010                                                               hashModulus
2011                                                             , toAdopt
2012                                                             , serEng.getMemoryManager()
2013                                                             );
2014        }
2015
2016        serEng.registerObject(*objToLoad);
2017
2018        XMLSize_t itemNumber = 0;
2019        serEng.readSize (itemNumber);
2020
2021        for (XMLSize_t itemIndex = 0; itemIndex < itemNumber; itemIndex++)
2022        {
2023            XMLCh*      key1;
2024            serEng.readString(key1);
2025
2026            int         key2;
2027            serEng>>key2;
2028
2029            ElemVector*  data = 0;
2030
2031            //don't call destructor
2032            loadObject(&data, 8, false, serEng);
2033
2034            /***
2035             *
2036             *  There must be one element in the vector whose
2037             *  susbititutionGroupElem matches the (key1,key2)
2038             *
2039             ***/
2040
2041            // bool FOUND=false;
2042
2043            XMLSize_t vectorSize = data->size();
2044            for ( XMLSize_t i = 0; i < vectorSize; i++)
2045            {
2046                SchemaElementDecl*& elem   = data->elementAt(i);
2047                SchemaElementDecl*  subElem = elem->getSubstitutionGroupElem();
2048                XMLCh* elemName = subElem->getBaseName();
2049                int    uri      = subElem->getURI();
2050                if (XMLString::equals(elemName, key1) &&
2051                    (uri == key2)                       )
2052                {
2053                    //release the temp
2054                    serEng.getMemoryManager()->deallocate(key1);
2055                    key1 = elemName;
2056                    //FOUND=true;
2057                    break;
2058                }
2059            }
2060
2061            /***
2062             * if (!FOUND)
2063             * {
2064             *     throw exception
2065             * }
2066             ***/
2067
2068            (*objToLoad)->put((void*)key1, key2, data);
2069
2070        }
2071
2072    }
2073}
2074
2075/**********************************************************
2076 *
2077 * RefHash3KeysIdPool
2078 *
2079 *   SchemaElementDecl
2080 *
2081 *   maintain the same order through id
2082 ***********************************************************/
2083void XTemplateSerializer::storeObject(RefHash3KeysIdPool<SchemaElementDecl>* const objToStore
2084                                    , XSerializeEngine&                            serEng)
2085{
2086    if (serEng.needToStoreObject(objToStore))
2087    {
2088        serEng.writeSize (objToStore->getHashModulus());
2089
2090        RefHash3KeysIdPoolEnumerator<SchemaElementDecl> e(objToStore, false, objToStore->getMemoryManager());
2091
2092        serEng.writeSize (e.size());
2093
2094        void*  strkey;
2095        int    key1;
2096        int    key2;
2097        /* Update to store key2 separately as for the putGroupElemDecl the key is not the
2098           enclosing scope but another value. */
2099        while (e.hasMoreKeys())
2100        {
2101            e.nextElementKey(strkey, key1, key2);
2102            serEng<<key2;
2103            SchemaElementDecl* data = objToStore->getByKey(strkey, key1, key2);
2104            serEng<<data;
2105        }
2106    }
2107
2108}
2109
2110void XTemplateSerializer::loadObject(RefHash3KeysIdPool<SchemaElementDecl>** objToLoad
2111                                   , int
2112                                   , bool                                    toAdopt
2113                                   , int                                     initSize2
2114                                   , XSerializeEngine&                       serEng)
2115{
2116    if (serEng.needToLoadObject((void**)objToLoad))
2117    {
2118        XMLSize_t hashModulus;
2119        serEng.readSize (hashModulus);
2120
2121        if (!*objToLoad)
2122        {
2123            *objToLoad = new (serEng.getMemoryManager())
2124                             RefHash3KeysIdPool<SchemaElementDecl>(
2125                                                                   hashModulus
2126                                                                 , toAdopt
2127                                                                 , initSize2
2128                                                                 , serEng.getMemoryManager());
2129        }
2130
2131        serEng.registerObject(*objToLoad);
2132
2133        XMLSize_t itemNumber = 0;
2134        serEng.readSize (itemNumber);
2135
2136        int scopeKey;
2137        SchemaElementDecl*  elemDecl;
2138        for (XMLSize_t itemIndex = 0; itemIndex < itemNumber; itemIndex++)
2139        {
2140            serEng>>scopeKey;
2141            serEng>>elemDecl;
2142
2143           (*objToLoad)->put(elemDecl->getBaseName()
2144                            , elemDecl->getURI()
2145                            , scopeKey
2146                            , elemDecl);
2147        }
2148
2149    }
2150
2151}
2152
2153/**********************************************************
2154 *
2155 * NameIdPool
2156 *    no NameIdPool::nextElementKey()
2157 *
2158 *   DTDElementDecl
2159 *   DTDEntityDecl
2160 *   XMLNotationDecl
2161 *
2162 *   maintain the same order through id
2163 ***********************************************************/
2164void XTemplateSerializer::storeObject(NameIdPool<DTDElementDecl>* const objToStore
2165                                    , XSerializeEngine&                 serEng)
2166{
2167    if (serEng.needToStoreObject(objToStore))
2168    {
2169        NameIdPoolEnumerator<DTDElementDecl> e(objToStore, objToStore->getMemoryManager());
2170
2171        serEng<<(unsigned int)e.size();
2172
2173        while (e.hasMoreElements())
2174        {
2175            DTDElementDecl& data = e.nextElement();
2176            data.serialize(serEng);
2177        }
2178    }
2179
2180}
2181
2182void XTemplateSerializer::loadObject(NameIdPool<DTDElementDecl>** objToLoad
2183                                   , int                          initSize
2184                                   , int                          initSize2
2185                                   , XSerializeEngine&            serEng)
2186{
2187    if (serEng.needToLoadObject((void**)objToLoad))
2188    {
2189        if (!*objToLoad)
2190        {
2191            if (initSize < 0)
2192                initSize = 16;
2193
2194            *objToLoad = new (serEng.getMemoryManager())
2195                             NameIdPool<DTDElementDecl>(
2196                                                        initSize
2197                                                      , initSize2
2198                                                      , serEng.getMemoryManager()
2199                                                      );
2200        }
2201
2202        serEng.registerObject(*objToLoad);
2203
2204        unsigned int itemNumber = 0;
2205        serEng >> itemNumber;
2206
2207        for (unsigned int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
2208        {
2209            DTDElementDecl*  data = new (serEng.getMemoryManager())
2210                                    DTDElementDecl(serEng.getMemoryManager());
2211            data->serialize(serEng);
2212            (*objToLoad)->put(data);
2213        }
2214    }
2215}
2216
2217void XTemplateSerializer::storeObject(NameIdPool<DTDEntityDecl>* const objToStore
2218                                    , XSerializeEngine&                 serEng)
2219{
2220    if (serEng.needToStoreObject(objToStore))
2221    {
2222        NameIdPoolEnumerator<DTDEntityDecl> e(objToStore, objToStore->getMemoryManager());
2223
2224        serEng<<(unsigned int)e.size();
2225
2226        while (e.hasMoreElements())
2227        {
2228            DTDEntityDecl& data = e.nextElement();
2229            data.serialize(serEng);
2230        }
2231    }
2232}
2233
2234void XTemplateSerializer::loadObject(NameIdPool<DTDEntityDecl>** objToLoad
2235                                   , int                          initSize
2236                                   , int                          initSize2
2237                                   , XSerializeEngine&            serEng)
2238{
2239    if (serEng.needToLoadObject((void**)objToLoad))
2240    {
2241        if (!*objToLoad)
2242        {
2243            if (initSize < 0)
2244                initSize = 16;
2245
2246            *objToLoad = new (serEng.getMemoryManager())
2247                             NameIdPool<DTDEntityDecl>(
2248                                                       initSize
2249                                                     , initSize2
2250                                                     , serEng.getMemoryManager()
2251                                                     );
2252        }
2253
2254        serEng.registerObject(*objToLoad);
2255
2256        unsigned int itemNumber = 0;
2257        serEng >> itemNumber;
2258
2259        for (unsigned int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
2260        {
2261            DTDEntityDecl*  data = new (serEng.getMemoryManager())
2262                                   DTDEntityDecl(serEng.getMemoryManager());
2263            data->serialize(serEng);
2264            (*objToLoad)->put(data);
2265        }
2266    }
2267}
2268
2269void XTemplateSerializer::storeObject(NameIdPool<XMLNotationDecl>* const objToStore
2270                                    , XSerializeEngine&                  serEng)
2271{
2272    if (serEng.needToStoreObject(objToStore))
2273    {
2274        NameIdPoolEnumerator<XMLNotationDecl> e(objToStore, objToStore->getMemoryManager());
2275
2276        serEng<<(unsigned int)e.size();
2277
2278        while (e.hasMoreElements())
2279        {
2280            XMLNotationDecl& data = e.nextElement();
2281            data.serialize(serEng);
2282        }
2283    }
2284}
2285
2286void XTemplateSerializer::loadObject(NameIdPool<XMLNotationDecl>** objToLoad
2287                                   , int                          initSize
2288                                   , int                          initSize2
2289                                   , XSerializeEngine&            serEng)
2290{
2291
2292    if (serEng.needToLoadObject((void**)objToLoad))
2293    {
2294        if (!*objToLoad)
2295        {
2296            if (initSize < 0)
2297                initSize = 16;
2298
2299            *objToLoad = new (serEng.getMemoryManager())
2300                             NameIdPool<XMLNotationDecl>(
2301                                                         initSize
2302                                                       , initSize2
2303                                                       , serEng.getMemoryManager()
2304                                                       );
2305        }
2306
2307        serEng.registerObject(*objToLoad);
2308
2309        unsigned int itemNumber = 0;
2310        serEng >> itemNumber;
2311
2312        for (unsigned int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
2313        {
2314            XMLNotationDecl*  data = new (serEng.getMemoryManager())
2315                                     XMLNotationDecl(serEng.getMemoryManager());
2316            data->serialize(serEng);
2317            (*objToLoad)->put(data);
2318        }
2319    }
2320}
2321
2322XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.