diff --git a/src/xercesc/internal/XTemplateSerializer.cpp b/src/xercesc/internal/XTemplateSerializer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7a2ef41a9ea2510233f986358a59ac52c8fe467f
--- /dev/null
+++ b/src/xercesc/internal/XTemplateSerializer.cpp
@@ -0,0 +1,1772 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ * Copyright (c) 2003 The Apache Software Foundation. All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. The end-user documentation included with the redistribution,
+ * if any, must include the following acknowledgment:
+ * "This product includes software developed by the
+ * Apache Software Foundation (http://www.apache.org/)."
+ * Alternately, this acknowledgment may appear in the software itself,
+ * if and wherever such third-party acknowledgments normally appear.
+ *
+ * 4. The names "Xerces" and "Apache Software Foundation" must
+ * not be used to endorse or promote products derived from this
+ * software without prior written permission. For written
+ * permission, please contact apache\@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache",
+ * nor may "Apache" appear in their name, without prior written
+ * permission of the Apache Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation, and was
+ * originally based on software copyright (c) 1999, International
+ * Business Machines, Inc., http://www.ibm.com . For more information
+ * on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ */
+
+/*
+ * $Id$
+ * $Log$
+ * Revision 1.1 2003/10/17 21:07:49 peiyongz
+ * To support Template object serialization/deserialization
+ *
+ *
+ */
+
+
+// ---------------------------------------------------------------------------
+// Includes
+// ---------------------------------------------------------------------------
+#include <xercesc/internal/XSerializeEngine.hpp>
+#include <xercesc/internal/XTemplateSerializer.hpp>
+
+XERCES_CPP_NAMESPACE_BEGIN
+
+/**********************************************************
+ *
+ * ValueVectorOf
+ *
+ * SchemaElementDecl*
+ * unsigned int
+ *
+ ***********************************************************/
+void XTemplateSerializer::storeObject(ValueVectorOf<SchemaElementDecl*>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int vectorSize = objToStore->size();
+ serEng<<vectorSize;
+
+ for ( int i = 0; i < vectorSize; i++)
+ {
+ SchemaElementDecl*& data = objToStore->elementAt(i);
+ serEng<<data;
+ }
+ }
+}
+
+void XTemplateSerializer::loadObject(ValueVectorOf<SchemaElementDecl*>** objToLoad
+ , int initSize
+ , bool toCallDestructor
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ ValueVectorOf<SchemaElementDecl*>(
+ initSize
+ , serEng.getMemoryManager()
+ , toCallDestructor
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int vectorSize = 0;
+ serEng>>vectorSize;
+
+ for ( int i = 0; i < vectorSize; i++)
+ {
+ SchemaElementDecl* data;
+ serEng>>data;
+ (*objToLoad)->addElement(data);
+ }
+ }
+
+}
+
+void XTemplateSerializer::storeObject(ValueVectorOf<unsigned int>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int vectorSize = objToStore->size();
+ serEng<<vectorSize;
+
+ for ( int i = 0; i < vectorSize; i++)
+ {
+ unsigned int& data = objToStore->elementAt(i);
+ serEng<<data;
+ }
+ }
+}
+
+void XTemplateSerializer::loadObject(ValueVectorOf<unsigned int>** objToLoad
+ , int initSize
+ , bool toCallDestructor
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ ValueVectorOf<unsigned int>(
+ initSize
+ , serEng.getMemoryManager()
+ , toCallDestructor
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int vectorSize = 0;
+ serEng>>vectorSize;
+
+ for ( int i = 0; i < vectorSize; i++)
+ {
+ unsigned int data;
+ serEng>>data;
+ (*objToLoad)->addElement(data);
+ }
+ }
+
+}
+
+/**********************************************************
+ *
+ * RefArrayVectorOf
+ *
+ * XMLCh
+ *
+ ***********************************************************/
+
+void XTemplateSerializer::storeObject(RefArrayVectorOf<XMLCh>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int vectorSize = objToStore->size();
+ serEng<<vectorSize;
+
+ for ( int i = 0; i < vectorSize; i++)
+ {
+ serEng.writeString(objToStore->elementAt(i));
+ }
+ }
+
+}
+
+void XTemplateSerializer::loadObject(RefArrayVectorOf<XMLCh>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefArrayVectorOf<XMLCh>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int vectorSize = 0;
+ serEng>>vectorSize;
+
+ for ( int i = 0; i < vectorSize; i++)
+ {
+ XMLCh* data;
+ serEng.readString(data);
+ (*objToLoad)->addElement(data);
+ }
+ }
+
+}
+
+/**********************************************************
+ *
+ * RefVectorOf
+ *
+ * SchemaAttDef
+ * SchemaElementDecl
+ * ContentSpecNode
+ * IC_Field
+ * DatatypeValidator
+ * IdentityConstraint
+ * XMLNumber
+ * XercesLocationPath
+ * XercesStep
+ *
+ ***********************************************************/
+
+void XTemplateSerializer::storeObject(RefVectorOf<SchemaAttDef>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int vectorLength = objToStore->size();
+ serEng<<vectorLength;
+
+ for ( int i = 0; i < vectorLength; i++)
+ {
+ SchemaAttDef* data = objToStore->elementAt(i);
+ serEng<<data;
+ }
+ }
+
+}
+
+void XTemplateSerializer::loadObject(RefVectorOf<SchemaAttDef>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefVectorOf<SchemaAttDef>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int vectorLength = 0;
+ serEng>>vectorLength;
+ for ( int i = 0 ; i < vectorLength; i++)
+ {
+ SchemaAttDef* data;
+ serEng>>data;
+ (*objToLoad)->addElement(data);
+ }
+ }
+
+}
+
+void XTemplateSerializer::storeObject(RefVectorOf<SchemaElementDecl>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int vectorLength = objToStore->size();
+ serEng<<vectorLength;
+
+ for ( int i = 0; i < vectorLength; i++)
+ {
+ SchemaElementDecl* data = objToStore->elementAt(i);
+ serEng<<data;
+ }
+ }
+
+}
+
+void XTemplateSerializer::loadObject(RefVectorOf<SchemaElementDecl>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefVectorOf<SchemaElementDecl>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int vectorLength = 0;
+ serEng>>vectorLength;
+ for ( int i = 0 ; i < vectorLength; i++)
+ {
+ SchemaElementDecl* data;
+ serEng>>data;
+ (*objToLoad)->addElement(data);
+ }
+ }
+
+}
+
+void XTemplateSerializer::storeObject(RefVectorOf<ContentSpecNode>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int vectorLength = objToStore->size();
+ serEng<<vectorLength;
+
+ for ( int i = 0; i < vectorLength; i++)
+ {
+ ContentSpecNode* data = objToStore->elementAt(i);
+ serEng<<data;
+ }
+ }
+
+}
+
+void XTemplateSerializer::loadObject(RefVectorOf<ContentSpecNode>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefVectorOf<ContentSpecNode>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int vectorLength = 0;
+ serEng>>vectorLength;
+ for ( int i = 0 ; i < vectorLength; i++)
+ {
+ ContentSpecNode* data;
+ serEng>>data;
+ (*objToLoad)->addElement(data);
+ }
+ }
+
+}
+
+void XTemplateSerializer::storeObject(RefVectorOf<IC_Field>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int vectorLength = objToStore->size();
+ serEng<<vectorLength;
+
+ for ( int i = 0; i < vectorLength; i++)
+ {
+ IC_Field* data = objToStore->elementAt(i);
+ serEng<<data;
+ }
+ }
+
+}
+
+void XTemplateSerializer::loadObject(RefVectorOf<IC_Field>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefVectorOf<IC_Field>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int vectorLength = 0;
+ serEng>>vectorLength;
+ for ( int i = 0 ; i < vectorLength; i++)
+ {
+ IC_Field* data;
+ serEng>>data;
+ (*objToLoad)->addElement(data);
+ }
+ }
+
+}
+
+void XTemplateSerializer::storeObject(RefVectorOf<DatatypeValidator>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int vectorLength = objToStore->size();
+ serEng<<vectorLength;
+
+ for ( int i = 0; i < vectorLength; i++)
+ {
+ DatatypeValidator* data = objToStore->elementAt(i);
+ DatatypeValidator::storeDV(serEng, data);
+ }
+ }
+
+}
+
+void XTemplateSerializer::loadObject(RefVectorOf<DatatypeValidator>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefVectorOf<DatatypeValidator>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int vectorLength = 0;
+ serEng>>vectorLength;
+ for ( int i = 0 ; i < vectorLength; i++)
+ {
+ DatatypeValidator* data;
+ data = DatatypeValidator::loadDV(serEng);
+ (*objToLoad)->addElement(data);
+ }
+ }
+
+}
+
+void XTemplateSerializer::storeObject(RefVectorOf<IdentityConstraint>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int vectorLength = objToStore->size();
+ serEng<<vectorLength;
+
+ for ( int i = 0; i < vectorLength; i++)
+ {
+ IdentityConstraint* data = objToStore->elementAt(i);
+ IdentityConstraint::storeIC(serEng, data);
+ }
+ }
+
+}
+
+void XTemplateSerializer::loadObject(RefVectorOf<IdentityConstraint>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefVectorOf<IdentityConstraint>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int vectorLength = 0;
+ serEng>>vectorLength;
+ for ( int i = 0 ; i < vectorLength; i++)
+ {
+ IdentityConstraint* data;
+ data = IdentityConstraint::loadIC(serEng);
+ (*objToLoad)->addElement(data);
+ }
+ }
+
+}
+
+void XTemplateSerializer::storeObject(RefVectorOf<XMLNumber>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int vectorLength = objToStore->size();
+ serEng<<vectorLength;
+
+ for ( int i = 0; i < vectorLength; i++)
+ {
+ XMLNumber* data = objToStore->elementAt(i);
+ serEng<<data;
+ }
+ }
+
+}
+
+void XTemplateSerializer::loadObject(RefVectorOf<XMLNumber>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XMLNumber::NumberType numType
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefVectorOf<XMLNumber>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int vectorLength = 0;
+ serEng>>vectorLength;
+ for ( int i = 0 ; i < vectorLength; i++)
+ {
+ XMLNumber* data;
+ data = XMLNumber::loadNumber(numType , serEng);
+ (*objToLoad)->addElement(data);
+ }
+ }
+
+}
+
+void XTemplateSerializer::storeObject(RefVectorOf<XercesLocationPath>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int vectorLength = objToStore->size();
+ serEng<<vectorLength;
+
+ for ( int i = 0; i < vectorLength; i++)
+ {
+ XercesLocationPath* data = objToStore->elementAt(i);
+ serEng<<data;
+ }
+ }
+
+}
+
+void XTemplateSerializer::loadObject(RefVectorOf<XercesLocationPath>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefVectorOf<XercesLocationPath>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int vectorLength = 0;
+ serEng>>vectorLength;
+ for ( int i = 0 ; i < vectorLength; i++)
+ {
+ XercesLocationPath* data;
+ serEng>>data;
+ (*objToLoad)->addElement(data);
+ }
+ }
+
+}
+
+void XTemplateSerializer::storeObject(RefVectorOf<XercesStep>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int vectorLength = objToStore->size();
+ serEng<<vectorLength;
+
+ for ( int i = 0; i < vectorLength; i++)
+ {
+ XercesStep* data = objToStore->elementAt(i);
+ serEng<<data;
+ }
+ }
+
+}
+
+void XTemplateSerializer::loadObject(RefVectorOf<XercesStep>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefVectorOf<XercesStep>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int vectorLength = 0;
+ serEng>>vectorLength;
+ for ( int i = 0 ; i < vectorLength; i++)
+ {
+ XercesStep* data;
+ serEng>>data;
+ (*objToLoad)->addElement(data);
+ }
+ }
+
+}
+
+/**********************************************************
+ *
+ * RefHasbTableOf
+ *
+ * KVStringPair
+ * XMLAttDef
+ * DTDAttDef
+ * ComplexTypeInfo
+ * XercesGroupInfo
+ * XercesAttGroupInfo
+ * XMLRefInfo
+ * DatatypeValidator
+ *
+ ***********************************************************/
+void XTemplateSerializer::storeObject(RefHashTableOf<KVStringPair>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ RefHashTableOfEnumerator<KVStringPair> e(objToStore);
+ int itemNumber = 0;
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ XMLCh* key = (XMLCh*) e.nextElementKey();
+ serEng.writeString(key);
+
+ KVStringPair* data = objToStore->get(key);
+ serEng<<data;
+ }
+ }
+}
+
+void XTemplateSerializer::loadObject(RefHashTableOf<KVStringPair>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefHashTableOf<KVStringPair>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ XMLCh* key;
+ serEng.readString(key);
+
+ KVStringPair* data;
+ serEng>>data;
+
+ (*objToLoad)->put((void*)key, data);
+ }
+ }
+}
+
+void XTemplateSerializer::storeObject(RefHashTableOf<XMLAttDef>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ RefHashTableOfEnumerator<XMLAttDef> e(objToStore);
+ int itemNumber = 0;
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ XMLCh* key = (XMLCh*) e.nextElementKey();
+ serEng.writeString(key);
+
+ XMLAttDef* data = objToStore->get(key);
+ serEng<<data;
+ }
+ }
+}
+
+void XTemplateSerializer::loadObject(RefHashTableOf<XMLAttDef>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefHashTableOf<XMLAttDef>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ XMLCh* key;
+ serEng.readString(key);
+
+ //This is used solely by SchemaGrammar and by all means it must be
+ //SchemaAttDef, ideally we may change it to RefHashTableOf<SchemaAttDef>
+ //later on.
+ //Affected files IGXMLScanner, SGXMLScanner, SchemaGrammar, TraverseSchema
+ //XMLAttDef* data;
+ SchemaAttDef* data;
+ serEng>>data;
+
+ (*objToLoad)->put((void*)key, data);
+ }
+ }
+}
+
+void XTemplateSerializer::storeObject(RefHashTableOf<DTDAttDef>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ RefHashTableOfEnumerator<DTDAttDef> e(objToStore);
+ int itemNumber = 0;
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ XMLCh* key = (XMLCh*) e.nextElementKey();
+ serEng.writeString(key);
+
+ DTDAttDef* data = objToStore->get(key);
+ serEng<<data;
+ }
+ }
+}
+
+void XTemplateSerializer::loadObject(RefHashTableOf<DTDAttDef>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefHashTableOf<DTDAttDef>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ XMLCh* key;
+ serEng.readString(key);
+
+ DTDAttDef* data;
+ serEng>>data;
+
+ //key==data->getFullName()
+ (*objToLoad)->put((void*)key, data);
+ }
+ }
+}
+
+void XTemplateSerializer::storeObject(RefHashTableOf<ComplexTypeInfo>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ RefHashTableOfEnumerator<ComplexTypeInfo> e(objToStore);
+ int itemNumber = 0;
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ XMLCh* key = (XMLCh*) e.nextElementKey();
+ serEng.writeString(key);
+
+ ComplexTypeInfo* data = objToStore->get(key);
+ serEng<<data;
+ }
+ }
+}
+
+void XTemplateSerializer::loadObject(RefHashTableOf<ComplexTypeInfo>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefHashTableOf<ComplexTypeInfo>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ XMLCh* key;
+ serEng.readString(key);
+
+ ComplexTypeInfo* data;
+ serEng>>data;
+
+ //key==data->getTypeName()
+ (*objToLoad)->put((void*)key, data);
+ }
+ }
+}
+
+void XTemplateSerializer::storeObject(RefHashTableOf<XercesGroupInfo>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ RefHashTableOfEnumerator<XercesGroupInfo> e(objToStore);
+ int itemNumber = 0;
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ XMLCh* key = (XMLCh*) e.nextElementKey();
+ serEng.writeString(key);
+
+ XercesGroupInfo* data = objToStore->get(key);
+ serEng<<data;
+ }
+ }
+}
+
+void XTemplateSerializer::loadObject(RefHashTableOf<XercesGroupInfo>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefHashTableOf<XercesGroupInfo>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ XMLCh* key;
+ serEng.readString(key);
+
+ XercesGroupInfo* data;
+ serEng>>data;
+
+ (*objToLoad)->put((void*)key, data);
+ }
+ }
+}
+
+void XTemplateSerializer::storeObject(RefHashTableOf<XercesAttGroupInfo>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ RefHashTableOfEnumerator<XercesAttGroupInfo> e(objToStore);
+ int itemNumber = 0;
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ XMLCh* key = (XMLCh*) e.nextElementKey();
+ serEng.writeString(key);
+
+ XercesAttGroupInfo* data = objToStore->get(key);
+ serEng<<data;
+ }
+ }
+}
+
+void XTemplateSerializer::loadObject(RefHashTableOf<XercesAttGroupInfo>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefHashTableOf<XercesAttGroupInfo>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ XMLCh* key;
+ serEng.readString(key);
+
+ XercesAttGroupInfo* data;
+ serEng>>data;
+
+ (*objToLoad)->put((void*)key, data);
+ }
+ }
+}
+
+void XTemplateSerializer::storeObject(RefHashTableOf<XMLRefInfo>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ RefHashTableOfEnumerator<XMLRefInfo> e(objToStore);
+ int itemNumber = 0;
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ XMLCh* key = (XMLCh*) e.nextElementKey();
+ serEng.writeString(key);
+
+ XMLRefInfo* data = objToStore->get(key);
+ serEng<<data;
+ }
+ }
+}
+
+void XTemplateSerializer::loadObject(RefHashTableOf<XMLRefInfo>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefHashTableOf<XMLRefInfo>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ XMLCh* key;
+ serEng.readString(key);
+
+ XMLRefInfo* data;
+ serEng>>data;
+
+ (*objToLoad)->put((void*)key, data);
+ }
+ }
+}
+
+void XTemplateSerializer::storeObject(RefHashTableOf<DatatypeValidator>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ RefHashTableOfEnumerator<DatatypeValidator> e(objToStore);
+ int itemNumber = 0;
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ XMLCh* key = (XMLCh*) e.nextElementKey();
+ serEng.writeString(key);
+
+ DatatypeValidator* data = objToStore->get(key);
+ DatatypeValidator::storeDV(serEng, data);
+ }
+ }
+}
+
+void XTemplateSerializer::loadObject(RefHashTableOf<DatatypeValidator>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefHashTableOf<DatatypeValidator>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ XMLCh* key;
+ serEng.readString(key);
+
+ DatatypeValidator* data;
+ data = DatatypeValidator::loadDV(serEng);
+
+ (*objToLoad)->put((void*)key, data);
+ }
+ }
+}
+
+
+/**********************************************************
+ *
+ * RefHash2KeysTableOf
+ *
+ * SchemaAttDef
+ * ElemVector
+ *
+ ***********************************************************/
+void XTemplateSerializer::storeObject(RefHash2KeysTableOf<SchemaAttDef>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int itemNumber = 0;
+
+ RefHash2KeysTableOfEnumerator<SchemaAttDef> e(objToStore);
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ XMLCh* key1;
+ int key2;
+
+ e.nextElementKey((void*&)key1, key2);
+ serEng.writeString(key1);
+ serEng<<key2;
+
+ XMLAttDef* data = objToStore->get(key1, key2);
+ serEng<<data;
+
+ }
+
+ }
+
+}
+
+void XTemplateSerializer::loadObject(RefHash2KeysTableOf<SchemaAttDef>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefHash2KeysTableOf<SchemaAttDef>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ XMLCh* key1;
+ serEng.readString(key1);
+
+ int key2;
+ serEng>>key2;
+
+ SchemaAttDef* data;
+ serEng>>data;
+
+ //key1==data->getAttName()->getLocalPart()
+ //key2==data->getId()
+ (*objToLoad)->put((void*)key1, key2, data);
+
+ }
+
+ }
+
+}
+
+void XTemplateSerializer::storeObject(RefHash2KeysTableOf<ElemVector>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int itemNumber = 0;
+
+ RefHash2KeysTableOfEnumerator<ElemVector> e(objToStore);
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ XMLCh* key1;
+ int key2;
+
+ e.nextElementKey((void*&)key1, key2);
+ serEng.writeString(key1);
+ serEng<<key2;
+
+ ElemVector* data = objToStore->get(key1, key2);
+
+ storeObject(data, serEng);
+
+ }
+
+ }
+
+}
+
+void XTemplateSerializer::loadObject(RefHash2KeysTableOf<ElemVector>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefHash2KeysTableOf<ElemVector>(
+ initSize
+ , toAdopt
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ XMLCh* key1;
+ serEng.readString(key1);
+
+ int key2;
+ serEng>>key2;
+
+ ElemVector* data;
+
+ loadObject(&data, 8, false, serEng);
+
+ (*objToLoad)->put((void*)key1, key2, data);
+
+ }
+
+ }
+}
+
+/**********************************************************
+ *
+ * RefHash3KeysIdPool
+ *
+ * SchemaElementDecl
+ *
+ ***********************************************************/
+void XTemplateSerializer::storeObject(RefHash3KeysIdPool<SchemaElementDecl>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int itemNumber = 0;
+ RefHash3KeysIdPoolEnumerator<SchemaElementDecl> e(objToStore);
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ //there is no e.nextElementKey() for RefHash3KeysIdPoolEnumerator
+ SchemaElementDecl& attDef = e.nextElement();
+ attDef.serialize(serEng);
+ }
+
+ }
+
+}
+
+void XTemplateSerializer::loadObject(RefHash3KeysIdPool<SchemaElementDecl>** objToLoad
+ , int initSize
+ , bool toAdopt
+ , int initSize2
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ RefHash3KeysIdPool<SchemaElementDecl>(
+ initSize
+ , toAdopt
+ , initSize2
+ , serEng.getMemoryManager());
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ SchemaElementDecl* elemDecl = new (serEng.getMemoryManager())
+ SchemaElementDecl(serEng.getMemoryManager());
+ elemDecl->serialize(serEng);
+ (*objToLoad)->put(elemDecl->getBaseName()
+ , elemDecl->getURI()
+ , elemDecl->getEnclosingScope()
+ , elemDecl);
+ }
+
+ }
+
+}
+
+/**********************************************************
+ *
+ * NameIdPool
+ * no NameIdPool::nextElementKey()
+ *
+ * DTDElementDecl
+ * DTDEntityDecl
+ * XMLNotationDecl
+ *
+ ***********************************************************/
+void XTemplateSerializer::storeObject(NameIdPool<DTDElementDecl>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int itemNumber = 0;
+ NameIdPoolEnumerator<DTDElementDecl> e(objToStore);
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ DTDElementDecl& data = e.nextElement();
+ data.serialize(serEng);
+ }
+
+ }
+
+}
+
+void XTemplateSerializer::loadObject(NameIdPool<DTDElementDecl>** objToLoad
+ , int initSize
+ , int initSize2
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ NameIdPool<DTDElementDecl>(
+ initSize
+ , initSize2
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ DTDElementDecl* data = new (serEng.getMemoryManager())
+ DTDElementDecl(serEng.getMemoryManager());
+ data->serialize(serEng);
+ (*objToLoad)->put(data);
+ }
+
+ }
+
+}
+
+void XTemplateSerializer::storeObject(NameIdPool<DTDEntityDecl>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int itemNumber = 0;
+ NameIdPoolEnumerator<DTDEntityDecl> e(objToStore);
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ DTDEntityDecl& data = e.nextElement();
+ data.serialize(serEng);
+ }
+
+ }
+
+}
+
+void XTemplateSerializer::loadObject(NameIdPool<DTDEntityDecl>** objToLoad
+ , int initSize
+ , int initSize2
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ NameIdPool<DTDEntityDecl>(
+ initSize
+ , initSize2
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ DTDEntityDecl* data = new (serEng.getMemoryManager())
+ DTDEntityDecl(serEng.getMemoryManager());
+ data->serialize(serEng);
+ (*objToLoad)->put(data);
+ }
+
+ }
+
+}
+
+void XTemplateSerializer::storeObject(NameIdPool<XMLNotationDecl>* const objToStore
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToStoreObject(objToStore))
+ {
+ int itemNumber = 0;
+ NameIdPoolEnumerator<XMLNotationDecl> e(objToStore);
+
+ while (e.hasMoreElements())
+ {
+ e.nextElement();
+ itemNumber++;
+ }
+
+ serEng<<itemNumber;
+ e.Reset();
+
+ while (e.hasMoreElements())
+ {
+ XMLNotationDecl& data = e.nextElement();
+ data.serialize(serEng);
+ }
+
+ }
+
+}
+
+void XTemplateSerializer::loadObject(NameIdPool<XMLNotationDecl>** objToLoad
+ , int initSize
+ , int initSize2
+ , XSerializeEngine& serEng)
+{
+
+ if (serEng.needToLoadObject((void**)objToLoad))
+ {
+ if (!*objToLoad)
+ {
+ if (initSize < 0)
+ initSize = 16;
+
+ *objToLoad = new (serEng.getMemoryManager())
+ NameIdPool<XMLNotationDecl>(
+ initSize
+ , initSize2
+ , serEng.getMemoryManager()
+ );
+ }
+
+ serEng.registerObject(*objToLoad);
+
+ int itemNumber = 0;
+ serEng>>itemNumber;
+
+ for (int itemIndex = 0; itemIndex < itemNumber; itemIndex++)
+ {
+ XMLNotationDecl* data = new (serEng.getMemoryManager())
+ XMLNotationDecl(serEng.getMemoryManager());
+ data->serialize(serEng);
+ (*objToLoad)->put(data);
+ }
+
+ }
+
+}
+
+XERCES_CPP_NAMESPACE_END
+
diff --git a/src/xercesc/internal/XTemplateSerializer.hpp b/src/xercesc/internal/XTemplateSerializer.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..37d60468d18954521ab29214587136ad0446354c
--- /dev/null
+++ b/src/xercesc/internal/XTemplateSerializer.hpp
@@ -0,0 +1,391 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ * Copyright (c) 2003 The Apache Software Foundation. All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. The end-user documentation included with the redistribution,
+ * if any, must include the following acknowledgment:
+ * "This product includes software developed by the
+ * Apache Software Foundation (http://www.apache.org/)."
+ * Alternately, this acknowledgment may appear in the software itself,
+ * if and wherever such third-party acknowledgments normally appear.
+ *
+ * 4. The names "Xerces" and "Apache Software Foundation" must
+ * not be used to endorse or promote products derived from this
+ * software without prior written permission. For written
+ * permission, please contact apache\@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache",
+ * nor may "Apache" appear in their name, without prior written
+ * permission of the Apache Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation, and was
+ * originally based on software copyright (c) 1999, International
+ * Business Machines, Inc., http://www.ibm.com . For more information
+ * on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ */
+
+/*
+ * $Log$
+ * Revision 1.1 2003/10/17 21:07:49 peiyongz
+ * To support Template object serialization/deserialization
+ *
+ * $Id$
+ *
+ */
+
+#if !defined(XTEMPLATE_SERIALIZER_HPP)
+#define XTEMPLATE_SERIALIZER_HPP
+
+#include <xercesc/util/ValueVectorOf.hpp>
+#include <xercesc/util/RefArrayVectorOf.hpp>
+#include <xercesc/util/RefVectorOf.hpp>
+#include <xercesc/util/RefHashTableOf.hpp>
+#include <xercesc/util/RefHash2KeysTableOf.hpp>
+#include <xercesc/util/RefHash3KeysIdPool.hpp>
+#include <xercesc/util/NameIdPool.hpp>
+
+#include <xercesc/framework/XMLNotationDecl.hpp>
+#include <xercesc/framework/XMLRefInfo.hpp>
+#include <xercesc/util/XMLNumber.hpp>
+#include <xercesc/validators/common/ContentSpecNode.hpp>
+#include <xercesc/validators/DTD/DTDAttDef.hpp>
+#include <xercesc/validators/DTD/DTDElementDecl.hpp>
+#include <xercesc/validators/DTD/DTDEntityDecl.hpp>
+#include <xercesc/validators/schema/SchemaAttDef.hpp>
+#include <xercesc/validators/schema/SchemaElementDecl.hpp>
+#include <xercesc/validators/schema/XercesGroupInfo.hpp>
+#include <xercesc/validators/schema/XercesAttGroupInfo.hpp>
+#include <xercesc/validators/schema/SchemaGrammar.hpp>
+#include <xercesc/validators/schema/identity/IC_Field.hpp>
+#include <xercesc/validators/schema/identity/IdentityConstraint.hpp>
+#include <xercesc/validators/schema/identity/XercesXPath.hpp>
+
+XERCES_CPP_NAMESPACE_BEGIN
+
+class XMLUTIL_EXPORT XTemplateSerializer
+{
+public:
+
+ /**********************************************************
+ *
+ * ValueVectorOf
+ *
+ * SchemaElementDecl*
+ * unsigned int
+ *
+ ***********************************************************/
+ static void storeObject(ValueVectorOf<SchemaElementDecl*>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(ValueVectorOf<SchemaElementDecl*>** tempObjToRead
+ , int initSize
+ , bool toCallDestructor
+ , XSerializeEngine& serEng);
+
+ static void storeObject(ValueVectorOf<unsigned int>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(ValueVectorOf<unsigned int>** tempObjToRead
+ , int initSize
+ , bool toCallDestructor
+ , XSerializeEngine& serEng);
+
+ /**********************************************************
+ *
+ * RefArrayVectorOf
+ *
+ * XMLCh
+ *
+ ***********************************************************/
+ static void storeObject(RefArrayVectorOf<XMLCh>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefArrayVectorOf<XMLCh>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ /**********************************************************
+ *
+ * RefVectorOf
+ *
+ * SchemaAttDef
+ * SchemaElementDecl
+ * ContentSpecNode
+ * IC_Field
+ * DatatypeValidator
+ * IdentityConstraint
+ * XMLNumber
+ * XercesLocationPath
+ * XercesStep
+ *
+ ***********************************************************/
+ static void storeObject(RefVectorOf<SchemaAttDef>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefVectorOf<SchemaAttDef>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefVectorOf<SchemaElementDecl>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefVectorOf<SchemaElementDecl>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefVectorOf<ContentSpecNode>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefVectorOf<ContentSpecNode>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefVectorOf<IC_Field>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefVectorOf<IC_Field>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefVectorOf<DatatypeValidator>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefVectorOf<DatatypeValidator>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefVectorOf<IdentityConstraint>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefVectorOf<IdentityConstraint>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefVectorOf<XMLNumber>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefVectorOf<XMLNumber>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XMLNumber::NumberType numType
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefVectorOf<XercesLocationPath>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefVectorOf<XercesLocationPath>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefVectorOf<XercesStep>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefVectorOf<XercesStep>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ /**********************************************************
+ *
+ * RefHashTableOf
+ *
+ * KVStringPair
+ * XMLAttDef
+ * DTDAttDef
+ * ComplexTypeInfo
+ * XercesGroupInfo
+ * XercesAttGroupInfo
+ * XMLRefInfo
+ * DatatypeValidator
+ *
+ ***********************************************************/
+ static void storeObject(RefHashTableOf<KVStringPair>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefHashTableOf<KVStringPair>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefHashTableOf<XMLAttDef>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefHashTableOf<XMLAttDef>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefHashTableOf<DTDAttDef>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefHashTableOf<DTDAttDef>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefHashTableOf<ComplexTypeInfo>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefHashTableOf<ComplexTypeInfo>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefHashTableOf<XercesGroupInfo>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefHashTableOf<XercesGroupInfo>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefHashTableOf<XercesAttGroupInfo>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefHashTableOf<XercesAttGroupInfo>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefHashTableOf<XMLRefInfo>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefHashTableOf<XMLRefInfo>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefHashTableOf<DatatypeValidator>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefHashTableOf<DatatypeValidator>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+
+ /**********************************************************
+ *
+ * RefHash2KeysTableOf
+ *
+ * SchemaAttDef
+ * ElemVector
+ *
+ ***********************************************************/
+ static void storeObject(RefHash2KeysTableOf<SchemaAttDef>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefHash2KeysTableOf<SchemaAttDef>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ static void storeObject(RefHash2KeysTableOf<ElemVector>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefHash2KeysTableOf<ElemVector>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , XSerializeEngine& serEng);
+
+ /**********************************************************
+ *
+ * RefHash3KeysIdPool
+ *
+ * SchemaElementDecl
+ *
+ ***********************************************************/
+ static void storeObject(RefHash3KeysIdPool<SchemaElementDecl>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(RefHash3KeysIdPool<SchemaElementDecl>** tempObjToRead
+ , int initSize
+ , bool toAdopt
+ , int initSize2
+ , XSerializeEngine& serEng);
+
+ /**********************************************************
+ *
+ * NameIdPool
+ *
+ * DTDElementDecl
+ * DTDEntityDecl
+ * XMLNotationDecl
+ *
+ ***********************************************************/
+ static void storeObject(NameIdPool<DTDElementDecl>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(NameIdPool<DTDElementDecl>** tempObjToRead
+ , int initSize
+ , int initSize2
+ , XSerializeEngine& serEng);
+
+ static void storeObject(NameIdPool<DTDEntityDecl>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(NameIdPool<DTDEntityDecl>** tempObjToRead
+ , int initSize
+ , int initSize2
+ , XSerializeEngine& serEng);
+
+ static void storeObject(NameIdPool<XMLNotationDecl>* const tempObjToWrite
+ , XSerializeEngine& serEng);
+
+ static void loadObject(NameIdPool<XMLNotationDecl>** tempObjToRead
+ , int initSize
+ , int initSize2
+ , XSerializeEngine& serEng);
+
+private:
+ // -----------------------------------------------------------------------
+ // Unimplemented constructors and operators
+ // -----------------------------------------------------------------------
+ ~XTemplateSerializer();
+ XTemplateSerializer();
+ XTemplateSerializer(const XTemplateSerializer&);
+ XTemplateSerializer& operator=(const XTemplateSerializer&);
+
+};
+
+XERCES_CPP_NAMESPACE_END
+
+#endif