https://bugs.internet2.edu/jira/browse/CPPXT-10

git-svn-id: https://svn.middleware.georgetown.edu/cpp-xmltooling/branches/REL_1_0@495 de75baf8-a10c-0410-a50a-987c0e22f00f

diff --git a/xmltooling/XMLObjectBuilder.h b/xmltooling/XMLObjectBuilder.h
index 80fa690..ef54e17 100644 (file)
--- a/xmltooling/XMLObjectBuilder.h
+++ b/xmltooling/XMLObjectBuilder.h
@@ -1,206 +1,207 @@
-/*
- *  Copyright 2001-2007 Internet2
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @file xmltooling/XMLObjectBuilder.h
- * 
- * Factory interface for XMLObjects.
- */
-
-#ifndef __xmltooling_xmlobjbuilder_h__
-#define __xmltooling_xmlobjbuilder_h__
-
-#include <map>
-#include <xmltooling/QName.h>
-#include <xmltooling/XMLObject.h>
-#include <xmltooling/util/XMLHelper.h>
-
-#if defined (_MSC_VER)
-    #pragma warning( push )
-    #pragma warning( disable : 4250 4251 )
-#endif
-
-namespace xmltooling {
-
-    /**
-     * A factory interface for obtaining XMLObjects.
-     * Subclasses MAY supply additional factory methods.
-     */
-    class XMLTOOL_API XMLObjectBuilder
-    {
-    MAKE_NONCOPYABLE(XMLObjectBuilder);
-    public:
-        virtual ~XMLObjectBuilder() {}
-        
-        /**
-         * Creates an empty XMLObject with a particular element name.
-         * <p>The results are undefined if localName is NULL or empty.
-         * 
-         * @param nsURI         namespace URI for element
-         * @param localName     local name of element
-         * @param prefix        prefix of element name
-         * @param schemaType    xsi:type of the object
-         * @return the empty XMLObject
-         */
-        virtual XMLObject* buildObject(
-            const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const QName* schemaType=NULL
-            ) const=0;
-
-        /**
-         * Creates an empty XMLObject with a particular element name.
-         * 
-         * @param q     QName of element for object
-         * @return the empty XMLObject
-         */
-        XMLObject* buildFromQName(const QName& q) const {
-            return buildObject(q.getNamespaceURI(),q.getLocalPart(),q.getPrefix());
-        }
-
-        /**
-         * Creates an unmarshalled XMLObject from a DOM Element.
-         * 
-         * @param element       the unmarshalling source
-         * @param bindDocument  true iff the XMLObject should take ownership of the DOM Document
-         * @return the unmarshalled XMLObject
-         */
-        XMLObject* buildFromElement(xercesc::DOMElement* element, bool bindDocument=false) const {
-            std::auto_ptr<XMLObject> ret(
-                buildObject(element->getNamespaceURI(),element->getLocalName(),element->getPrefix(),XMLHelper::getXSIType(element))
-                );
-            ret->unmarshall(element,bindDocument);
-            return ret.release();
-        }
-
-        /**
-         * Creates an unmarshalled XMLObject from the root of a DOM Document.
-         * 
-         * @param doc           the unmarshalling source
-         * @param bindDocument  true iff the XMLObject should take ownership of the DOM Document
-         * @return the unmarshalled XMLObject
-         */
-        XMLObject* buildFromDocument(xercesc::DOMDocument* doc, bool bindDocument=true) const {
-            return buildFromElement(doc->getDocumentElement(),bindDocument);
-        }
-
-        /**
-         * Creates an unmarshalled XMLObject using the default build method, if a builder can be found.
-         * 
-         * @param element       the unmarshalling source
-         * @param bindDocument  true iff the new XMLObject should take ownership of the DOM Document
-         * @return  the unmarshalled object or NULL if no builder is available 
-         */
-        static XMLObject* buildOneFromElement(xercesc::DOMElement* element, bool bindDocument=false) {
-            const XMLObjectBuilder* b=getBuilder(element);
-            return b ? b->buildFromElement(element,bindDocument) : NULL;
-        }
-
-        /**
-         * Retrieves an XMLObjectBuilder using the key it was registered with.
-         * 
-         * @param key the key used to register the builder
-         * @return the builder or NULL
-         */
-        static const XMLObjectBuilder* getBuilder(const QName& key) {
-            std::map<QName,XMLObjectBuilder*>::const_iterator i=m_map.find(key);
-            return (i==m_map.end()) ? NULL : i->second;
-        }
-
-        /**
-         * Retrieves an XMLObjectBuilder for a given DOM element.
-         * If no match is found, the default builder is returned, if any.
-         * 
-         * @param element the element for which to locate a builder
-         * @return the builder or NULL
-         */
-        static const XMLObjectBuilder* getBuilder(const xercesc::DOMElement* element);
-
-        /**
-         * Retrieves the default XMLObjectBuilder for DOM elements
-         * 
-         * @return the default builder or NULL
-         */
-        static const XMLObjectBuilder* getDefaultBuilder() {
-            return m_default;
-        }
-
-        /**
-         * Gets an immutable list of all the builders currently registered.
-         * 
-         * @return list of all the builders currently registered
-         */
-        static const std::map<QName,XMLObjectBuilder*>& getBuilders() {
-            return m_map;
-        }
-    
-        /**
-         * Registers a new builder for the given key.
-         * 
-         * @param builderKey the key used to retrieve this builder later
-         * @param builder the builder
-         */
-        static void registerBuilder(const QName& builderKey, XMLObjectBuilder* builder) {
-            deregisterBuilder(builderKey);
-            m_map[builderKey]=builder;
-        }
-
-        /**
-         * Registers a default builder
-         * 
-         * @param builder the default builder
-         */
-        static void registerDefaultBuilder(XMLObjectBuilder* builder) {
-            deregisterDefaultBuilder();
-            m_default=builder;
-        }
-
-        /**
-         * Deregisters a builder.
-         * 
-         * @param builderKey the key for the builder to be deregistered
-         */
-        static void deregisterBuilder(const QName& builderKey) {
-            delete getBuilder(builderKey);
-            m_map.erase(builderKey);
-        }
-
-        /**
-         * Deregisters default builder.
-         */
-        static void deregisterDefaultBuilder() {
-            delete m_default;
-            m_default=NULL;
-        }
-
-        /**
-         * Unregisters and destroys all registered builders. 
-         */
-        static void destroyBuilders();
-
-    protected:
-        XMLObjectBuilder() {}
-    
-    private:
-        static std::map<QName,XMLObjectBuilder*> m_map;
-        static XMLObjectBuilder* m_default;
-    };
-
-};
-
-#if defined (_MSC_VER)
-    #pragma warning( pop )
-#endif
-
-#endif /* __xmltooling_xmlobjbuilder_h__ */
+/*\r
+ *  Copyright 2001-2007 Internet2\r
+ * \r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ *     http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ */\r
+\r
+/**\r
+ * @file xmltooling/XMLObjectBuilder.h\r
+ * \r
+ * Factory interface for XMLObjects.\r
+ */\r
+\r
+#ifndef __xmltooling_xmlobjbuilder_h__\r
+#define __xmltooling_xmlobjbuilder_h__\r
+\r
+#include <map>\r
+#include <memory>\r
+#include <xmltooling/QName.h>\r
+#include <xmltooling/XMLObject.h>\r
+#include <xmltooling/util/XMLHelper.h>\r
+\r
+#if defined (_MSC_VER)\r
+    #pragma warning( push )\r
+    #pragma warning( disable : 4250 4251 )\r
+#endif\r
+\r
+namespace xmltooling {\r
+\r
+    /**\r
+     * A factory interface for obtaining XMLObjects.\r
+     * Subclasses MAY supply additional factory methods.\r
+     */\r
+    class XMLTOOL_API XMLObjectBuilder\r
+    {\r
+    MAKE_NONCOPYABLE(XMLObjectBuilder);\r
+    public:\r
+        virtual ~XMLObjectBuilder() {}\r
+        \r
+        /**\r
+         * Creates an empty XMLObject with a particular element name.\r
+         * <p>The results are undefined if localName is NULL or empty.\r
+         * \r
+         * @param nsURI         namespace URI for element\r
+         * @param localName     local name of element\r
+         * @param prefix        prefix of element name\r
+         * @param schemaType    xsi:type of the object\r
+         * @return the empty XMLObject\r
+         */\r
+        virtual XMLObject* buildObject(\r
+            const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const QName* schemaType=NULL\r
+            ) const=0;\r
+\r
+        /**\r
+         * Creates an empty XMLObject with a particular element name.\r
+         * \r
+         * @param q     QName of element for object\r
+         * @return the empty XMLObject\r
+         */\r
+        XMLObject* buildFromQName(const QName& q) const {\r
+            return buildObject(q.getNamespaceURI(),q.getLocalPart(),q.getPrefix());\r
+        }\r
+\r
+        /**\r
+         * Creates an unmarshalled XMLObject from a DOM Element.\r
+         * \r
+         * @param element       the unmarshalling source\r
+         * @param bindDocument  true iff the XMLObject should take ownership of the DOM Document\r
+         * @return the unmarshalled XMLObject\r
+         */\r
+        XMLObject* buildFromElement(xercesc::DOMElement* element, bool bindDocument=false) const {\r
+            std::auto_ptr<XMLObject> ret(\r
+                buildObject(element->getNamespaceURI(),element->getLocalName(),element->getPrefix(),XMLHelper::getXSIType(element))\r
+                );\r
+            ret->unmarshall(element,bindDocument);\r
+            return ret.release();\r
+        }\r
+\r
+        /**\r
+         * Creates an unmarshalled XMLObject from the root of a DOM Document.\r
+         * \r
+         * @param doc           the unmarshalling source\r
+         * @param bindDocument  true iff the XMLObject should take ownership of the DOM Document\r
+         * @return the unmarshalled XMLObject\r
+         */\r
+        XMLObject* buildFromDocument(xercesc::DOMDocument* doc, bool bindDocument=true) const {\r
+            return buildFromElement(doc->getDocumentElement(),bindDocument);\r
+        }\r
+\r
+        /**\r
+         * Creates an unmarshalled XMLObject using the default build method, if a builder can be found.\r
+         * \r
+         * @param element       the unmarshalling source\r
+         * @param bindDocument  true iff the new XMLObject should take ownership of the DOM Document\r
+         * @return  the unmarshalled object or NULL if no builder is available \r
+         */\r
+        static XMLObject* buildOneFromElement(xercesc::DOMElement* element, bool bindDocument=false) {\r
+            const XMLObjectBuilder* b=getBuilder(element);\r
+            return b ? b->buildFromElement(element,bindDocument) : NULL;\r
+        }\r
+\r
+        /**\r
+         * Retrieves an XMLObjectBuilder using the key it was registered with.\r
+         * \r
+         * @param key the key used to register the builder\r
+         * @return the builder or NULL\r
+         */\r
+        static const XMLObjectBuilder* getBuilder(const QName& key) {\r
+            std::map<QName,XMLObjectBuilder*>::const_iterator i=m_map.find(key);\r
+            return (i==m_map.end()) ? NULL : i->second;\r
+        }\r
+\r
+        /**\r
+         * Retrieves an XMLObjectBuilder for a given DOM element.\r
+         * If no match is found, the default builder is returned, if any.\r
+         * \r
+         * @param element the element for which to locate a builder\r
+         * @return the builder or NULL\r
+         */\r
+        static const XMLObjectBuilder* getBuilder(const xercesc::DOMElement* element);\r
+\r
+        /**\r
+         * Retrieves the default XMLObjectBuilder for DOM elements\r
+         * \r
+         * @return the default builder or NULL\r
+         */\r
+        static const XMLObjectBuilder* getDefaultBuilder() {\r
+            return m_default;\r
+        }\r
+\r
+        /**\r
+         * Gets an immutable list of all the builders currently registered.\r
+         * \r
+         * @return list of all the builders currently registered\r
+         */\r
+        static const std::map<QName,XMLObjectBuilder*>& getBuilders() {\r
+            return m_map;\r
+        }\r
+    \r
+        /**\r
+         * Registers a new builder for the given key.\r
+         * \r
+         * @param builderKey the key used to retrieve this builder later\r
+         * @param builder the builder\r
+         */\r
+        static void registerBuilder(const QName& builderKey, XMLObjectBuilder* builder) {\r
+            deregisterBuilder(builderKey);\r
+            m_map[builderKey]=builder;\r
+        }\r
+\r
+        /**\r
+         * Registers a default builder\r
+         * \r
+         * @param builder the default builder\r
+         */\r
+        static void registerDefaultBuilder(XMLObjectBuilder* builder) {\r
+            deregisterDefaultBuilder();\r
+            m_default=builder;\r
+        }\r
+\r
+        /**\r
+         * Deregisters a builder.\r
+         * \r
+         * @param builderKey the key for the builder to be deregistered\r
+         */\r
+        static void deregisterBuilder(const QName& builderKey) {\r
+            delete getBuilder(builderKey);\r
+            m_map.erase(builderKey);\r
+        }\r
+\r
+        /**\r
+         * Deregisters default builder.\r
+         */\r
+        static void deregisterDefaultBuilder() {\r
+            delete m_default;\r
+            m_default=NULL;\r
+        }\r
+\r
+        /**\r
+         * Unregisters and destroys all registered builders. \r
+         */\r
+        static void destroyBuilders();\r
+\r
+    protected:\r
+        XMLObjectBuilder() {}\r
+    \r
+    private:\r
+        static std::map<QName,XMLObjectBuilder*> m_map;\r
+        static XMLObjectBuilder* m_default;\r
+    };\r
+\r
+};\r
+\r
+#if defined (_MSC_VER)\r
+    #pragma warning( pop )\r
+#endif\r
+\r
+#endif /* __xmltooling_xmlobjbuilder_h__ */\r

diff --git a/xmltooling/base.h b/xmltooling/base.h
index b6d3ba3..450c37f 100644 (file)
--- a/xmltooling/base.h
+++ b/xmltooling/base.h
@@ -1,1576 +1,1578 @@
-/*
- *  Copyright 2001-2007 Internet2
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @file xmltooling/base.h
- * 
- * Base header file definitions
- * Must be included prior to including any other header
- */
-
-#ifndef __xmltooling_base_h__
-#define __xmltooling_base_h__
-
-#if defined (_MSC_VER) || defined(__BORLANDC__)
-  #include <xmltooling/config_pub_win32.h>
-#else
-  #include <xmltooling/config_pub.h>
-#endif
-
-#ifdef XMLTOOLING_LITE
-# define XMLTOOLING_NO_XMLSEC 1
-#endif
-
-// Windows and GCC4 Symbol Visibility Macros
-#ifdef WIN32
-  #define XMLTOOL_IMPORT __declspec(dllimport)
-  #define XMLTOOL_EXPORT __declspec(dllexport)
-  #define XMLTOOL_DLLLOCAL
-  #define XMLTOOL_DLLPUBLIC
-#else
-  #define XMLTOOL_IMPORT
-  #ifdef GCC_HASCLASSVISIBILITY
-    #define XMLTOOL_EXPORT __attribute__ ((visibility("default")))
-    #define XMLTOOL_DLLLOCAL __attribute__ ((visibility("hidden")))
-    #define XMLTOOL_DLLPUBLIC __attribute__ ((visibility("default")))
-  #else
-    #define XMLTOOL_EXPORT
-    #define XMLTOOL_DLLLOCAL
-    #define XMLTOOL_DLLPUBLIC
-  #endif
-#endif
-
-// Define XMLTOOL_API for DLL builds
-#ifdef XMLTOOLING_EXPORTS
-  #define XMLTOOL_API XMLTOOL_EXPORT
-#else
-  #define XMLTOOL_API XMLTOOL_IMPORT
-#endif
-
-// Throwable classes must always be visible on GCC in all binaries
-#ifdef WIN32
-  #define XMLTOOL_EXCEPTIONAPI(api) api
-#elif defined(GCC_HASCLASSVISIBILITY)
-  #define XMLTOOL_EXCEPTIONAPI(api) XMLTOOL_EXPORT
-#else
-  #define XMLTOOL_EXCEPTIONAPI(api)
-#endif
-
-#ifdef _MSC_VER
-    #define XMLTOOLING_DOXYGEN(desc) /##** desc */
-#else
-    #define XMLTOOLING_DOXYGEN(desc)
-#endif
-
-/**
- * Blocks copy c'tor and assignment operator for a class.
- */
-#define MAKE_NONCOPYABLE(type) \
-    private: \
-        type(const type&); \
-        type& operator=(const type&)
-
-#ifndef DOXYGEN_SKIP
-#ifndef NULL
-#define NULL    0
-#endif
-#define UNICODE_LITERAL_1(a) {xercesc::chLatin_##a, xercesc::chNull}
-#define UNICODE_LITERAL_2(a,b) {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chNull}
-#define UNICODE_LITERAL_3(a,b,c) {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chNull}
-#define UNICODE_LITERAL_4(a,b,c,d) {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chNull}
-#define UNICODE_LITERAL_5(a,b,c,d,e) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chNull}
-#define UNICODE_LITERAL_6(a,b,c,d,e,f) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chNull}
-#define UNICODE_LITERAL_7(a,b,c,d,e,f,g) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chNull}
-#define UNICODE_LITERAL_8(a,b,c,d,e,f,g,h) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chNull}
-#define UNICODE_LITERAL_9(a,b,c,d,e,f,g,h,i) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, xercesc::chNull}
-#define UNICODE_LITERAL_10(a,b,c,d,e,f,g,h,i,j) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chNull}
-#define UNICODE_LITERAL_11(a,b,c,d,e,f,g,h,i,j,k) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chNull}
-#define UNICODE_LITERAL_12(a,b,c,d,e,f,g,h,i,j,k,l) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chNull}
-#define UNICODE_LITERAL_13(a,b,c,d,e,f,g,h,i,j,k,l,m) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chNull}
-#define UNICODE_LITERAL_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chNull}
-#define UNICODE_LITERAL_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chNull}
-#define UNICODE_LITERAL_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chNull}
-#define UNICODE_LITERAL_17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chNull}
-#define UNICODE_LITERAL_18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, xercesc::chNull}
-#define UNICODE_LITERAL_19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chNull}
-#define UNICODE_LITERAL_20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chNull}
-#define UNICODE_LITERAL_21(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chNull}
-#define UNICODE_LITERAL_22(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chNull}
-#define UNICODE_LITERAL_23(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chNull}
-#define UNICODE_LITERAL_24(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chNull}
-#define UNICODE_LITERAL_25(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chNull}
-#define UNICODE_LITERAL_26(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, xercesc::chNull}
-#define UNICODE_LITERAL_27(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \
-        xercesc::chLatin_##aa, xercesc::chNull}
-#define UNICODE_LITERAL_28(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \
-        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chNull}
-#define UNICODE_LITERAL_29(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \
-        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chLatin_##cc, xercesc::chNull}
-#define UNICODE_LITERAL_30(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \
-        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chLatin_##cc, xercesc::chLatin_##dd, xercesc::chNull}
-#define UNICODE_LITERAL_31(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd,ee) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \
-        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chLatin_##cc, xercesc::chLatin_##dd, xercesc::chLatin_##ee, xercesc::chNull}
-#define UNICODE_LITERAL_32(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd,ee,ff) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \
-        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chLatin_##cc, xercesc::chLatin_##dd, xercesc::chLatin_##ee, xercesc::chLatin_##ff, xercesc::chNull}
-#define UNICODE_LITERAL_33(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd,ee,ff,gg) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \
-        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chLatin_##cc, xercesc::chLatin_##dd, xercesc::chLatin_##ee, xercesc::chLatin_##ff, xercesc::chLatin_##gg, xercesc::chNull}
-#define UNICODE_LITERAL_34(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd,ee,ff,gg,hh) \
-    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \
-        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \
-        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \
-        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chLatin_##cc, xercesc::chLatin_##dd, xercesc::chLatin_##ee, xercesc::chLatin_##ff, xercesc::chLatin_##gg, xercesc::chLatin_##hh, xercesc::chNull}
-#endif /* DOXYGEN_SKIP */
-
-/**
- * Begins the declaration of an XMLObject specialization for an abstract element/type.
- * Basic boilerplate includes a protected constructor, empty virtual destructor,
- * and Unicode constants for the default associated element's name and prefix.
- * 
- * @param linkage   linkage specifier for the class
- * @param cname     the name of the class to declare
- * @param base      the base class to derive from using public virtual inheritance
- * @param desc      documentation comment for class
- */
-#define DECL_XMLOBJECT_ABSTRACT(linkage,cname,base,desc) \
-    XMLTOOLING_DOXYGEN(desc) \
-    class linkage cname : public virtual base { \
-    protected: \
-        cname() {} \
-    public: \
-        virtual ~cname() {} \
-        XMLTOOLING_DOXYGEN(Element local name) \
-        static const XMLCh LOCAL_NAME[]; \
-    }
-
-/**
- * Begins the declaration of an XMLObject specialization.
- * Basic boilerplate includes a protected constructor, empty virtual destructor,
- * and Unicode constants for the default associated element's name and prefix.
- * 
- * @param linkage   linkage specifier for the class
- * @param cname     the name of the class to declare
- * @param base      the base class to derive from using public virtual inheritance
- * @param desc      documentation comment for class
- */
-#define BEGIN_XMLOBJECT(linkage,cname,base,desc) \
-    XMLTOOLING_DOXYGEN(desc) \
-    class linkage cname : public virtual base { \
-    protected: \
-        cname() {} \
-    public: \
-        virtual ~cname() {} \
-        XMLTOOLING_DOXYGEN(Type-specific clone method.) \
-        virtual cname* clone##cname() const=0; \
-        XMLTOOLING_DOXYGEN(Element local name) \
-        static const XMLCh LOCAL_NAME[]
-
-/**
- * Begins the declaration of an XMLObject specialization with two base classes.
- * Basic boilerplate includes a protected constructor, empty virtual destructor,
- * and Unicode constants for the default associated element's name and prefix.
- * 
- * @param linkage   linkage specifier for the class
- * @param cname     the name of the class to declare
- * @param base      the first base class to derive from using public virtual inheritance
- * @param base2     the second base class to derive from using public virtual inheritance
- * @param desc      documentation comment for class
- */
-#define BEGIN_XMLOBJECT2(linkage,cname,base,base2,desc) \
-    XMLTOOLING_DOXYGEN(desc) \
-    class linkage cname : public virtual base, public virtual base2 { \
-    protected: \
-        cname() {} \
-    public: \
-        virtual ~cname() {} \
-        XMLTOOLING_DOXYGEN(Type-specific clone method.) \
-        virtual cname* clone##cname() const=0; \
-        XMLTOOLING_DOXYGEN(Element local name) \
-        static const XMLCh LOCAL_NAME[]
-
-/**
- * Begins the declaration of an XMLObject specialization with three base classes.
- * Basic boilerplate includes a protected constructor, empty virtual destructor,
- * and Unicode constants for the default associated element's name and prefix.
- * 
- * @param linkage   linkage specifier for the class
- * @param cname     the name of the class to declare
- * @param base      the first base class to derive from using public virtual inheritance
- * @param base2     the second base class to derive from using public virtual inheritance
- * @param base3     the third base class to derive from using public virtual inheritance
- * @param desc      documentation comment for class
- */
-#define BEGIN_XMLOBJECT3(linkage,cname,base,base2,base3,desc) \
-    XMLTOOLING_DOXYGEN(desc) \
-    class linkage cname : public virtual base, public virtual base2, public virtual base3 { \
-    protected: \
-        cname() {} \
-    public: \
-        virtual ~cname() {} \
-        XMLTOOLING_DOXYGEN(Type-specific clone method.) \
-        virtual cname* clone##cname() const=0; \
-        XMLTOOLING_DOXYGEN(Element local name) \
-        static const XMLCh LOCAL_NAME[]
-
-/**
- * Begins the declaration of an XMLObject specialization with four base classes.
- * Basic boilerplate includes a protected constructor, empty virtual destructor,
- * and Unicode constants for the default associated element's name and prefix.
- * 
- * @param linkage   linkage specifier for the class
- * @param cname     the name of the class to declare
- * @param base      the first base class to derive from using public virtual inheritance
- * @param base2     the second base class to derive from using public virtual inheritance
- * @param base3     the third base class to derive from using public virtual inheritance
- * @param base4     the fourth base class to derive from using public virtual inheritance
- * @param desc      documentation comment for class
- */
-#define BEGIN_XMLOBJECT4(linkage,cname,base,base2,base3,base4,desc) \
-    XMLTOOLING_DOXYGEN(desc) \
-    class linkage cname : public virtual base, public virtual base2, public virtual base3, public virtual base4 { \
-    protected: \
-        cname() {} \
-    public: \
-        virtual ~cname() {} \
-        XMLTOOLING_DOXYGEN(Type-specific clone method.) \
-        virtual cname* clone##cname() const=0; \
-        XMLTOOLING_DOXYGEN(Element local name) \
-        static const XMLCh LOCAL_NAME[]
-
-/**
- * Begins the declaration of an XMLObject specialization with five base classes.
- * Basic boilerplate includes a protected constructor, empty virtual destructor,
- * and Unicode constants for the default associated element's name and prefix.
- * 
- * @param linkage   linkage specifier for the class
- * @param cname     the name of the class to declare
- * @param base      the first base class to derive from using public virtual inheritance
- * @param base2     the second base class to derive from using public virtual inheritance
- * @param base3     the third base class to derive from using public virtual inheritance
- * @param base4     the fourth base class to derive from using public virtual inheritance
- * @param base5     the fifth base class to derive from using public virtual inheritance
- * @param desc      documentation comment for class
- */
-#define BEGIN_XMLOBJECT5(linkage,cname,base,base2,base3,base4,base5,desc) \
-    XMLTOOLING_DOXYGEN(desc) \
-    class linkage cname : public virtual base, public virtual base2, public virtual base3, public virtual base4, public virtual base5 { \
-    protected: \
-        cname() {} \
-    public: \
-        virtual ~cname() {} \
-        XMLTOOLING_DOXYGEN(Type-specific clone method.) \
-        virtual cname* clone##cname() const=0; \
-        XMLTOOLING_DOXYGEN(Element local name) \
-        static const XMLCh LOCAL_NAME[]
-
-/**
- * Ends the declaration of an XMLObject specialization.
- */
-#define END_XMLOBJECT }
-
-/**
- * Declares a static variable holding the XMLObject's element QName.
- */
-#define DECL_ELEMENT_QNAME \
-    public: \
-        XMLTOOLING_DOXYGEN(Element QName) \
-        static xmltooling::QName ELEMENT_QNAME
-
-/**
- * Declares a static variable holding the XMLObject's schema type QName.
- */
-#define DECL_TYPE_QNAME \
-    public: \
-        XMLTOOLING_DOXYGEN(Type QName) \
-        static xmltooling::QName TYPE_QNAME
-
-/**
- * Implements a static variable holding an XMLObject's element QName.
- * 
- * @param cname             the name of the XMLObject specialization
- * @param namespaceURI      the XML namespace of the default associated element
- * @param namespacePrefix   the XML namespace prefix of the default associated element
- */
-#define IMPL_ELEMENT_QNAME(cname,namespaceURI,namespacePrefix) \
-    xmltooling::QName cname::ELEMENT_QNAME(namespaceURI,cname::LOCAL_NAME,namespacePrefix)
-
-/**
- * Implements a static variable holding an XMLObject's schema type QName.
- * 
- * @param cname             the name of the XMLObject specialization
- * @param namespaceURI      the XML namespace of the default associated element
- * @param namespacePrefix   the XML namespace prefix of the default associated element
- */
-#define IMPL_TYPE_QNAME(cname,namespaceURI,namespacePrefix) \
-    xmltooling::QName cname::TYPE_QNAME(namespaceURI,cname::TYPE_NAME,namespacePrefix)
-
-/**
- * Declares abstract set method for a typed XML attribute.
- * The get method is omitted.
- * 
- * @param proper    the proper name of the attribute
- * @param upcased   the upcased name of the attribute
- * @param type      the attribute's data type
- */
-#define DECL_INHERITED_XMLOBJECT_ATTRIB(proper,upcased,type) \
-    public: \
-        XMLTOOLING_DOXYGEN(proper attribute name) \
-        static const XMLCh upcased##_ATTRIB_NAME[]; \
-        XMLTOOLING_DOXYGEN(Sets the proper attribute.) \
-        virtual void set##proper(const type* proper)=0
-
-/**
- * Declares abstract get/set methods for a typed XML attribute.
- * 
- * @param proper    the proper name of the attribute
- * @param upcased   the upcased name of the attribute
- * @param type      the attribute's data type
- */
-#define DECL_XMLOBJECT_ATTRIB(proper,upcased,type) \
-    public: \
-        XMLTOOLING_DOXYGEN(proper attribute name) \
-        static const XMLCh upcased##_ATTRIB_NAME[]; \
-        XMLTOOLING_DOXYGEN(Returns the proper attribute.) \
-        virtual const type* get##proper() const=0; \
-        XMLTOOLING_DOXYGEN(Sets the proper attribute.) \
-        virtual void set##proper(const type* proper)=0
-
-/**
- * Declares abstract set method for a string XML attribute.
- * The get method is omitted.
- * 
- * @param proper    the proper name of the attribute
- * @param upcased   the upcased name of the attribute
- */
-#define DECL_INHERITED_STRING_ATTRIB(proper,upcased) \
-    DECL_INHERITED_XMLOBJECT_ATTRIB(proper,upcased,XMLCh)
-
-/**
- * Declares abstract get/set methods for a string XML attribute.
- * 
- * @param proper    the proper name of the attribute
- * @param upcased   the upcased name of the attribute
- */
-#define DECL_STRING_ATTRIB(proper,upcased) \
-    DECL_XMLOBJECT_ATTRIB(proper,upcased,XMLCh)
-
-/**
- * Declares abstract set method for a DateTime XML attribute.
- * The get method is omitted.
- * 
- * @param proper    the proper name of the attribute
- * @param upcased   the upcased name of the attribute
- */
-#define DECL_INHERITED_DATETIME_ATTRIB(proper,upcased) \
-    DECL_INHERITED_XMLOBJECT_ATTRIB(proper,upcased,xmltooling::DateTime); \
-    XMLTOOLING_DOXYGEN(Sets the proper attribute.) \
-    virtual void set##proper(time_t proper)=0; \
-    XMLTOOLING_DOXYGEN(Sets the proper attribute.) \
-    virtual void set##proper(const XMLCh* proper)=0
-
-/**
- * Declares abstract get/set methods for a DateTime XML attribute.
- * 
- * @param proper    the proper name of the attribute
- * @param upcased   the upcased name of the attribute
- */
-#define DECL_DATETIME_ATTRIB(proper,upcased) \
-    DECL_XMLOBJECT_ATTRIB(proper,upcased,xmltooling::DateTime); \
-    XMLTOOLING_DOXYGEN(Returns the proper attribute in epoch form.) \
-    virtual time_t get##proper##Epoch() const=0; \
-    XMLTOOLING_DOXYGEN(Sets the proper attribute.) \
-    virtual void set##proper(time_t proper)=0; \
-    XMLTOOLING_DOXYGEN(Sets the proper attribute.) \
-    virtual void set##proper(const XMLCh* proper)=0
-
-/**
- * Declares abstract set method for an integer XML attribute.
- * The get method is omitted.
- * 
- * @param proper    the proper name of the attribute
- * @param upcased   the upcased name of the attribute
- */
-#define DECL_INHERITED_INTEGER_ATTRIB(proper,upcased) \
-    public: \
-        XMLTOOLING_DOXYGEN(proper attribute name) \
-        static const XMLCh upcased##_ATTRIB_NAME[]; \
-        XMLTOOLING_DOXYGEN(Sets the proper attribute using a string value.) \
-        virtual void set##proper(const XMLCh* proper)=0; \
-        XMLTOOLING_DOXYGEN(Sets the proper attribute.) \
-        virtual void set##proper(int proper)=0
-
-/**
- * Declares abstract get/set methods for an integer XML attribute.
- * 
- * @param proper    the proper name of the attribute
- * @param upcased   the upcased name of the attribute
- */
-#define DECL_INTEGER_ATTRIB(proper,upcased) \
-    public: \
-        XMLTOOLING_DOXYGEN(proper attribute name) \
-        static const XMLCh upcased##_ATTRIB_NAME[]; \
-        XMLTOOLING_DOXYGEN(Returns the proper attribute after a NULL indicator.) \
-        virtual std::pair<bool,int> get##proper() const=0; \
-        XMLTOOLING_DOXYGEN(Sets the proper attribute using a string value.) \
-        virtual void set##proper(const XMLCh* proper)=0; \
-        XMLTOOLING_DOXYGEN(Sets the proper attribute.) \
-        virtual void set##proper(int proper)=0
-
-/**
- * Declares abstract get/set methods for a boolean XML attribute.
- * 
- * @param proper    the proper name of the attribute
- * @param upcased   the upcased name of the attribute
- * @param def       the default/presumed value, if no explicit value has been set
- */
-#define DECL_BOOLEAN_ATTRIB(proper,upcased,def) \
-    public: \
-        XMLTOOLING_DOXYGEN(proper attribute name) \
-        static const XMLCh upcased##_ATTRIB_NAME[]; \
-        XMLTOOLING_DOXYGEN(Returns the proper attribute or def if not set.) \
-        bool proper() const { \
-            switch (get##proper()) { \
-                case xmlconstants::XML_BOOL_TRUE: \
-                case xmlconstants::XML_BOOL_ONE: \
-                    return true; \
-                case xmlconstants::XML_BOOL_FALSE: \
-                case xmlconstants::XML_BOOL_ZERO: \
-                    return false; \
-                default: \
-                    return def; \
-            } \
-        } \
-        XMLTOOLING_DOXYGEN(Returns the proper attribute as an explicit enumerated value.) \
-        virtual xmlconstants::xmltooling_bool_t get##proper() const=0; \
-        XMLTOOLING_DOXYGEN(Sets the proper attribute using an enumerated value.) \
-        virtual void proper(xmlconstants::xmltooling_bool_t value)=0; \
-        XMLTOOLING_DOXYGEN(Sets the proper attribute.) \
-        void proper(bool value) { \
-            proper(value ? xmlconstants::XML_BOOL_ONE : xmlconstants::XML_BOOL_ZERO); \
-        } \
-        XMLTOOLING_DOXYGEN(Sets the proper attribute using a string constant.) \
-        void set##proper(const XMLCh* value) { \
-            if (value) { \
-                switch (*value) { \
-                    case xercesc::chLatin_t: \
-                        proper(xmlconstants::XML_BOOL_TRUE); \
-                        break; \
-                    case xercesc::chLatin_f: \
-                        proper(xmlconstants::XML_BOOL_FALSE); \
-                        break; \
-                    case xercesc::chDigit_1: \
-                        proper(xmlconstants::XML_BOOL_ONE); \
-                        break; \
-                    case xercesc::chDigit_0: \
-                        proper(xmlconstants::XML_BOOL_ZERO); \
-                        break; \
-                    default: \
-                        proper(xmlconstants::XML_BOOL_NULL); \
-                } \
-            } \
-            else \
-                proper(xmlconstants::XML_BOOL_NULL); \
-        }
-
-/**
- * Implements get/set methods and a private member for a typed XML attribute.
- * 
- * @param proper    the proper name of the attribute
- * @param type      the attribute's data type
- */
-#define IMPL_XMLOBJECT_ATTRIB(proper,type) \
-    protected: \
-        type* m_##proper; \
-    public: \
-        const type* get##proper() const { \
-            return m_##proper; \
-        } \
-        void set##proper(const type* proper) { \
-            m_##proper = prepareForAssignment(m_##proper,proper); \
-        }
-
-/**
- * Implements get/set methods and a private member for a string XML attribute.
- * 
- * @param proper    the proper name of the attribute
- */
-#define IMPL_STRING_ATTRIB(proper) \
-    IMPL_XMLOBJECT_ATTRIB(proper,XMLCh)
-
-/**
- * Implements get/set methods and a private member for a string XML attribute,
- * plus a getXMLID override.
- * 
- * @param proper    the proper name of the attribute
- */
-#define IMPL_ID_ATTRIB(proper) \
-    IMPL_XMLOBJECT_ATTRIB(proper,XMLCh) \
-    const XMLCh* getXMLID() const { \
-        return m_##proper; \
-    }
-
-/**
- * Implements get/set methods and a private member for a DateTime XML attribute.
- * 
- * @param proper    the proper name of the attribute
- * @param fallback  epoch to return when attribute is NULL
- */
-#define IMPL_DATETIME_ATTRIB(proper,fallback) \
-    protected: \
-        DateTime* m_##proper; \
-        time_t m_##proper##Epoch; \
-    public: \
-        const DateTime* get##proper() const { \
-            return m_##proper; \
-        } \
-        time_t get##proper##Epoch() const { \
-            return m_##proper ? m_##proper##Epoch : fallback; \
-        } \
-        void set##proper(const DateTime* proper) { \
-            m_##proper = prepareForAssignment(m_##proper,proper); \
-            if (m_##proper) \
-                m_##proper##Epoch=m_##proper->getEpoch(); \
-        } \
-        void set##proper(time_t proper) { \
-            m_##proper = prepareForAssignment(m_##proper,proper); \
-            m_##proper##Epoch = proper; \
-        } \
-        void set##proper(const XMLCh* proper) { \
-            m_##proper = prepareForAssignment(m_##proper,proper); \
-            if (m_##proper) \
-                m_##proper##Epoch=m_##proper->getEpoch(); \
-        }
-
-/**
- * Implements get/set methods and a private member for an integer XML attribute.
- * 
- * @param proper    the proper name of the attribute
- */
-#define IMPL_INTEGER_ATTRIB(proper) \
-    protected: \
-        XMLCh* m_##proper; \
-    public: \
-        pair<bool,int> get##proper() const { \
-            return make_pair((m_##proper!=NULL),(m_##proper!=NULL ? xercesc::XMLString::parseInt(m_##proper): 0)); \
-        } \
-        void set##proper(const XMLCh* proper) { \
-            m_##proper = prepareForAssignment(m_##proper,proper); \
-        } \
-        void set##proper(int proper) { \
-            char buf##proper[64]; \
-            sprintf(buf##proper,"%d",proper); \
-            auto_ptr_XMLCh wide##proper(buf##proper); \
-            set##proper(wide##proper.get()); \
-        }
-
-/**
- * Implements get/set methods and a private member for a boolean XML attribute.
- * 
- * @param proper    the proper name of the attribute
- */
-#define IMPL_BOOLEAN_ATTRIB(proper) \
-    protected: \
-        xmlconstants::xmltooling_bool_t m_##proper; \
-    public: \
-        xmlconstants::xmltooling_bool_t get##proper() const { \
-            return m_##proper; \
-        } \
-        void proper(xmlconstants::xmltooling_bool_t value) { \
-            if (m_##proper != value) { \
-                releaseThisandParentDOM(); \
-                m_##proper = value; \
-            } \
-        }
-
-/**
- * Declares abstract set method for a typed XML child object in a foreign namespace.
- * The get method is omitted.
- * 
- * @param proper    the proper name of the child type
- * @param ns        the C++ namespace for the type
- */
-#define DECL_INHERITED_TYPED_FOREIGN_CHILD(proper,ns) \
-    public: \
-        XMLTOOLING_DOXYGEN(Sets the proper child.) \
-        virtual void set##proper(ns::proper* child)=0
-
-/**
- * Declares abstract get/set methods for a typed XML child object in a foreign namespace.
- * 
- * @param proper    the proper name of the child type
- * @param ns        the C++ namespace for the type
- */
-#define DECL_TYPED_FOREIGN_CHILD(proper,ns) \
-    public: \
-        XMLTOOLING_DOXYGEN(Returns the proper child.) \
-        virtual ns::proper* get##proper() const=0; \
-        XMLTOOLING_DOXYGEN(Sets the proper child.) \
-        virtual void set##proper(ns::proper* child)=0
-
-/**
- * Declares abstract set method for a typed XML child object.
- * The get method is omitted.
- * 
- * @param proper    the proper name of the child type
- */
-#define DECL_INHERITED_TYPED_CHILD(proper) \
-    public: \
-        XMLTOOLING_DOXYGEN(Sets the proper child.) \
-        virtual void set##proper(proper* child)=0
-
-/**
- * Declares abstract get/set methods for a typed XML child object.
- * 
- * @param proper    the proper name of the child type
- */
-#define DECL_TYPED_CHILD(proper) \
-    public: \
-        XMLTOOLING_DOXYGEN(Returns the proper child.) \
-        virtual proper* get##proper() const=0; \
-        XMLTOOLING_DOXYGEN(Sets the proper child.) \
-        virtual void set##proper(proper* child)=0
-
-/**
- * Declares abstract get/set methods for a generic XML child object.
- * 
- * @param proper    the proper name of the child
- */
-#define DECL_XMLOBJECT_CHILD(proper) \
-    public: \
-        XMLTOOLING_DOXYGEN(Returns the proper child.) \
-        virtual xmltooling::XMLObject* get##proper() const=0; \
-        XMLTOOLING_DOXYGEN(Sets the proper child.) \
-        virtual void set##proper(xmltooling::XMLObject* child)=0
-
-
-/**
- * Implements get/set methods and a private list iterator member for a typed XML child object.
- * 
- * @param proper    the proper name of the child type
- */
-#define IMPL_TYPED_CHILD(proper) \
-    protected: \
-        proper* m_##proper; \
-        std::list<xmltooling::XMLObject*>::iterator m_pos_##proper; \
-    public: \
-        proper* get##proper() const { \
-            return m_##proper; \
-        } \
-        void set##proper(proper* child) { \
-            prepareForAssignment(m_##proper,child); \
-            *m_pos_##proper = m_##proper = child; \
-        }
-
-/**
- * Implements get/set methods and a private list iterator member for
- * a typed XML child object in a foreign namespace
- * 
- * @param proper    the proper name of the child type
- * @param ns        the C++ namespace for the type
- */
-#define IMPL_TYPED_FOREIGN_CHILD(proper,ns) \
-    protected: \
-        ns::proper* m_##proper; \
-        std::list<xmltooling::XMLObject*>::iterator m_pos_##proper; \
-    public: \
-        ns::proper* get##proper() const { \
-            return m_##proper; \
-        } \
-        void set##proper(ns::proper* child) { \
-            prepareForAssignment(m_##proper,child); \
-            *m_pos_##proper = m_##proper = child; \
-        }
-
-/**
- * Implements get/set methods and a private list iterator member for a generic XML child object.
- * 
- * @param proper    the proper name of the child
- */
-#define IMPL_XMLOBJECT_CHILD(proper) \
-    protected: \
-        xmltooling::XMLObject* m_##proper; \
-        std::list<xmltooling::XMLObject*>::iterator m_pos_##proper; \
-    public: \
-        xmltooling::XMLObject* get##proper() const { \
-            return m_##proper; \
-        } \
-        void set##proper(xmltooling::XMLObject* child) { \
-            prepareForAssignment(m_##proper,child); \
-            *m_pos_##proper = m_##proper = child; \
-        }
-
-/**
- * Declares abstract get/set methods for a typed XML child collection.
- * 
- * @param proper    the proper name of the child type
- */
-#define DECL_TYPED_CHILDREN(proper) \
-    public: \
-        XMLTOOLING_DOXYGEN(Returns modifiable proper collection.) \
-        virtual VectorOf(proper) get##proper##s()=0; \
-        XMLTOOLING_DOXYGEN(Returns reference to immutable proper collection.) \
-        virtual const std::vector<proper*>& get##proper##s() const=0
-
-/**
- * Declares abstract get/set methods for a typed XML child collection in a foreign namespace.
- * 
- * @param proper    the proper name of the child type
- * @param ns        the C++ namespace for the type
- */
-#define DECL_TYPED_FOREIGN_CHILDREN(proper,ns) \
-    public: \
-        XMLTOOLING_DOXYGEN(Returns modifiable proper collection.) \
-        virtual VectorOf(ns::proper) get##proper##s()=0; \
-        XMLTOOLING_DOXYGEN(Returns reference to immutable proper collection.) \
-        virtual const std::vector<ns::proper*>& get##proper##s() const=0
-
-/**
- * Declares abstract get/set methods for a generic XML child collection.
- * 
- * @param proper    the proper name of the child
- */
-#define DECL_XMLOBJECT_CHILDREN(proper) \
-    public: \
-        XMLTOOLING_DOXYGEN(Returns modifiable proper collection.) \
-        virtual VectorOf(xmltooling::XMLObject) get##proper##s()=0; \
-        XMLTOOLING_DOXYGEN(Returns reference to immutable proper collection.) \
-        virtual const std::vector<xmltooling::XMLObject*>& get##proper##s() const=0
-
-/**
- * Implements get method and a private vector member for a typed XML child collection.
- * 
- * @param proper    the proper name of the child type
- * @param fence     insertion fence for new objects of the child collection in backing list
- */
-#define IMPL_TYPED_CHILDREN(proper,fence) \
-    protected: \
-        std::vector<proper*> m_##proper##s; \
-    public: \
-        VectorOf(proper) get##proper##s() { \
-            return VectorOf(proper)(this, m_##proper##s, &m_children, fence); \
-        } \
-        const std::vector<proper*>& get##proper##s() const { \
-            return m_##proper##s; \
-        } 
-
-/**
- * Implements get method and a private vector member for a typed XML child collection
- * in a foreign namespace.
- * 
- * @param proper    the proper name of the child type
- * @param ns        the C++ namespace for the type
- * @param fence     insertion fence for new objects of the child collection in backing list
- */
-#define IMPL_TYPED_FOREIGN_CHILDREN(proper,ns,fence) \
-    protected: \
-        std::vector<ns::proper*> m_##proper##s; \
-    public: \
-        VectorOf(ns::proper) get##proper##s() { \
-            return VectorOf(ns::proper)(this, m_##proper##s, &m_children, fence); \
-        } \
-        const std::vector<ns::proper*>& get##proper##s() const { \
-            return m_##proper##s; \
-        } 
-
-/**
- * Implements get method and a private vector member for a generic XML child collection.
- * 
- * @param proper    the proper name of the child
- * @param fence     insertion fence for new objects of the child collection in backing list
- */
-#define IMPL_XMLOBJECT_CHILDREN(proper,fence) \
-    protected: \
-        std::vector<xmltooling::XMLObject*> m_##proper##s; \
-    public: \
-        VectorOf(xmltooling::XMLObject) get##proper##s() { \
-            return VectorOf(xmltooling::XMLObject)(this, m_##proper##s, &m_children, fence); \
-        } \
-        const std::vector<xmltooling::XMLObject*>& get##proper##s() const { \
-            return m_##proper##s; \
-        } 
-
-/**
- * Implements marshalling for a string attribute
- * 
- * @param proper        the proper name of the attribute
- * @param ucase         the upcased name of the attribute
- * @param namespaceURI  the XML namespace of the attribute
- */
-#define MARSHALL_STRING_ATTRIB(proper,ucase,namespaceURI) \
-    if (m_##proper && *m_##proper) { \
-        domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, m_##proper); \
-    }
-
-/**
- * Implements marshalling for a DateTime attribute
- * 
- * @param proper        the proper name of the attribute
- * @param ucase         the upcased name of the attribute
- * @param namespaceURI  the XML namespace of the attribute
- */
-#define MARSHALL_DATETIME_ATTRIB(proper,ucase,namespaceURI) \
-    if (m_##proper) { \
-        domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, m_##proper->getRawData()); \
-    }
-
-/**
- * Implements marshalling for an integer attribute
- * 
- * @param proper        the proper name of the attribute
- * @param ucase         the upcased name of the attribute
- * @param namespaceURI  the XML namespace of the attribute
- */
-#define MARSHALL_INTEGER_ATTRIB(proper,ucase,namespaceURI) \
-    if (m_##proper && *m_##proper) { \
-        domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, m_##proper); \
-    }
-
-/**
- * Implements marshalling for a boolean attribute
- * 
- * @param proper        the proper name of the attribute
- * @param ucase         the upcased name of the attribute
- * @param namespaceURI  the XML namespace of the attribute
- */
-#define MARSHALL_BOOLEAN_ATTRIB(proper,ucase,namespaceURI) \
-    switch (m_##proper) { \
-        case xmlconstants::XML_BOOL_TRUE: \
-            domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, xmlconstants::XML_TRUE); \
-            break; \
-        case xmlconstants::XML_BOOL_ONE: \
-            domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, xmlconstants::XML_ONE); \
-            break; \
-        case xmlconstants::XML_BOOL_FALSE: \
-            domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, xmlconstants::XML_FALSE); \
-            break; \
-        case xmlconstants::XML_BOOL_ZERO: \
-            domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, xmlconstants::XML_ZERO); \
-            break; \
-        case xmlconstants::XML_BOOL_NULL: \
-            break; \
-    }
-
-/**
- * Implements marshalling for a QName attribute
- * 
- * @param proper        the proper name of the attribute
- * @param ucase         the upcased name of the attribute
- * @param namespaceURI  the XML namespace of the attribute
- */
-#define MARSHALL_QNAME_ATTRIB(proper,ucase,namespaceURI) \
-    if (m_##proper) { \
-        auto_ptr_XMLCh qstr(m_##proper->toString().c_str()); \
-        domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, qstr.get()); \
-    }
-
-/**
- * Implements marshalling for an ID attribute
- * 
- * @param proper        the proper name of the attribute
- * @param ucase         the upcased name of the attribute
- * @param namespaceURI  the XML namespace of the attribute
- */
-#define MARSHALL_ID_ATTRIB(proper,ucase,namespaceURI) \
-    if (m_##proper && *m_##proper) { \
-        domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, m_##proper); \
-        domElement->setIdAttributeNS(namespaceURI, ucase##_ATTRIB_NAME); \
-    }
-
-/**
- * Implements unmarshalling process branch for a string attribute
- * 
- * @param proper        the proper name of the attribute
- * @param ucase         the upcased name of the attribute
- * @param namespaceURI  the XML namespace of the attribute
- */
-#define PROC_STRING_ATTRIB(proper,ucase,namespaceURI) \
-    if (xmltooling::XMLHelper::isNodeNamed(attribute, namespaceURI, ucase##_ATTRIB_NAME)) { \
-        set##proper(attribute->getValue()); \
-        return; \
-    }
-
-/**
- * Implements unmarshalling process branch for an ID attribute
- * 
- * @param proper        the proper name of the attribute
- * @param ucase         the upcased name of the attribute
- * @param namespaceURI  the XML namespace of the attribute
- */
-#define PROC_ID_ATTRIB(proper,ucase,namespaceURI) \
-    if (xmltooling::XMLHelper::isNodeNamed(attribute, namespaceURI, ucase##_ATTRIB_NAME)) { \
-        set##proper(attribute->getValue()); \
-        attribute->getOwnerElement()->setIdAttributeNode(attribute); \
-        return; \
-    }
-
-/**
- * Implements unmarshalling process branch for a DateTime attribute
- * 
- * @param proper        the proper name of the attribute
- * @param ucase         the upcased name of the attribute
- * @param namespaceURI  the XML namespace of the attribute
- */
-#define PROC_DATETIME_ATTRIB(proper,ucase,namespaceURI) \
-    PROC_STRING_ATTRIB(proper,ucase,namespaceURI)
-
-/**
- * Implements unmarshalling process branch for a DateTime attribute
- * 
- * @param proper        the proper name of the attribute
- * @param ucase         the upcased name of the attribute
- * @param namespaceURI  the XML namespace of the attribute
- */
-#define PROC_QNAME_ATTRIB(proper,ucase,namespaceURI) \
-    if (xmltooling::XMLHelper::isNodeNamed(attribute, namespaceURI, ucase##_ATTRIB_NAME)) { \
-        set##proper(XMLHelper::getAttributeValueAsQName(attribute)); \
-        return; \
-    }
-
-/**
- * Implements unmarshalling process branch for an integer attribute
- * 
- * @param proper        the proper name of the attribute
- * @param ucase         the upcased name of the attribute
- * @param namespaceURI  the XML namespace of the attribute
- */
-#define PROC_INTEGER_ATTRIB(proper,ucase,namespaceURI) \
-    PROC_STRING_ATTRIB(proper,ucase,namespaceURI)
-
-/**
- * Implements unmarshalling process branch for a boolean attribute
- * 
- * @param proper        the proper name of the attribute
- * @param ucase         the upcased name of the attribute
- * @param namespaceURI  the XML namespace of the attribute
- */
-#define PROC_BOOLEAN_ATTRIB(proper,ucase,namespaceURI) \
-    PROC_STRING_ATTRIB(proper,ucase,namespaceURI)
-
-/**
- * Implements unmarshalling process branch for typed child collection element
- * 
- * @param proper        the proper name of the child type
- * @param namespaceURI  the XML namespace of the child element
- * @param force         bypass use of hint and just cast down to check child
- */
-#define PROC_TYPED_CHILDREN(proper,namespaceURI,force) \
-    if (force || xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,proper::LOCAL_NAME)) { \
-        proper* typesafe=dynamic_cast<proper*>(childXMLObject); \
-        if (typesafe) { \
-            get##proper##s().push_back(typesafe); \
-            return; \
-        } \
-    }
-
-/**
- * Implements unmarshalling process branch for typed child collection element
- * in a foreign namespace.
- * 
- * @param proper        the proper name of the child type
- * @param ns            the C++ namespace for the type
- * @param namespaceURI  the XML namespace of the child element
- * @param force         bypass use of hint and just cast down to check child
- */
-#define PROC_TYPED_FOREIGN_CHILDREN(proper,ns,namespaceURI,force) \
-    if (force || xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,ns::proper::LOCAL_NAME)) { \
-        ns::proper* typesafe=dynamic_cast<ns::proper*>(childXMLObject); \
-        if (typesafe) { \
-            get##proper##s().push_back(typesafe); \
-            return; \
-        } \
-    }
-
-/**
- * Implements unmarshalling process branch for typed child singleton element
- * 
- * @param proper        the proper name of the child type
- * @param namespaceURI  the XML namespace of the child element
- * @param force         bypass use of hint and just cast down to check child
- */
-#define PROC_TYPED_CHILD(proper,namespaceURI,force) \
-    if (force || xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,proper::LOCAL_NAME)) { \
-        proper* typesafe=dynamic_cast<proper*>(childXMLObject); \
-        if (typesafe && !m_##proper) { \
-            typesafe->setParent(this); \
-            *m_pos_##proper = m_##proper = typesafe; \
-            return; \
-        } \
-    }
-
-/**
- * Implements unmarshalling process branch for typed child singleton element
- * in a foreign namespace.
- * 
- * @param proper        the proper name of the child type
- * @param ns            the C++ namespace for the type
- * @param namespaceURI  the XML namespace of the child element
- * @param force         bypass use of hint and just cast down to check child
- */
-#define PROC_TYPED_FOREIGN_CHILD(proper,ns,namespaceURI,force) \
-    if (force || xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,ns::proper::LOCAL_NAME)) { \
-        ns::proper* typesafe=dynamic_cast<ns::proper*>(childXMLObject); \
-        if (typesafe && !m_##proper) { \
-            typesafe->setParent(this); \
-            *m_pos_##proper = m_##proper = typesafe; \
-            return; \
-        } \
-    }
-
-/**
- * Implements unmarshalling process branch for a generic child singleton element
- * 
- * @param proper        the proper name of the child type
- * @param namespaceURI  the XML namespace of the child element
- */
-#define PROC_XMLOBJECT_CHILD(proper,namespaceURI) \
-    if (xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,proper::LOCAL_NAME)) { \
-        if (!m_##proper) { \
-            childXMLObject->setParent(this); \
-            *m_pos_##proper = m_##proper = childXMLObject; \
-            return; \
-        } \
-    }
-
-/**
- * Declares aliased get/set methods for named XML element simple content.
- * 
- * @param proper    the proper name to label the element's content
- */
-#define DECL_SIMPLE_CONTENT(proper) \
-    XMLTOOLING_DOXYGEN(Returns proper.) \
-    const XMLCh* get##proper() const { \
-        return getTextContent(); \
-    } \
-    XMLTOOLING_DOXYGEN(Sets or clears proper.) \
-    void set##proper(const XMLCh* proper) { \
-        setTextContent(proper); \
-    }
-
-/**
- * Declares aliased get/set methods for named integer XML element content.
- * 
- * @param proper    the proper name to label the element's content
- */
-#define DECL_INTEGER_CONTENT(proper) \
-    XMLTOOLING_DOXYGEN(Returns proper in integer form after a NULL indicator.) \
-    std::pair<bool,int> get##proper() const { \
-        return std::make_pair((getTextContent()!=NULL), (getTextContent()!=NULL ? xercesc::XMLString::parseInt(getTextContent()) : 0)); \
-    } \
-    XMLTOOLING_DOXYGEN(Sets proper.) \
-    void set##proper(int proper) { \
-        char buf[64]; \
-        sprintf(buf,"%d",proper); \
-        xmltooling::auto_ptr_XMLCh widebuf(buf); \
-        setTextContent(widebuf.get()); \
-    } \
-    XMLTOOLING_DOXYGEN(Sets or clears proper.) \
-    void set##proper(const XMLCh* proper) { \
-        setTextContent(proper); \
-    }
-
-/**
- * Implements cloning methods for an XMLObject specialization implementation class.
- * 
- * @param cname    the name of the XMLObject specialization
- */
-#define IMPL_XMLOBJECT_CLONE(cname) \
-    cname* clone##cname() const { \
-        return dynamic_cast<cname*>(clone()); \
-    } \
-    xmltooling::XMLObject* clone() const { \
-        std::auto_ptr<xmltooling::XMLObject> domClone(xmltooling::AbstractDOMCachingXMLObject::clone()); \
-        cname##Impl* ret=dynamic_cast<cname##Impl*>(domClone.get()); \
-        if (ret) { \
-            domClone.release(); \
-            return ret; \
-        } \
-        return new cname##Impl(*this); \
-    }
-
-/**
- * Declares an XMLObject specialization with a simple content model and type,
- * handling it as string data.
- * 
- * @param linkage   linkage specifier for the class
- * @param cname     the name of the XMLObject specialization
- * @param proper    the proper name to label the element's content
- * @param desc      documentation for class
- */
-#define DECL_XMLOBJECT_SIMPLE(linkage,cname,proper,desc) \
-    BEGIN_XMLOBJECT(linkage,cname,xmltooling::XMLObject,desc); \
-        DECL_SIMPLE_CONTENT(proper); \
-    END_XMLOBJECT
-
-/**
- * Declares and defines an implementation class for an XMLObject with
- * a simple content model and type, handling it as string data.
- * 
- * @param linkage   linkage specifier for the class
- * @param cname     the name of the XMLObject specialization
- */
-#define DECL_XMLOBJECTIMPL_SIMPLE(linkage,cname) \
-    class linkage cname##Impl \
-        : public virtual cname, \
-            public xmltooling::AbstractSimpleElement, \
-            public xmltooling::AbstractDOMCachingXMLObject, \
-            public xmltooling::AbstractXMLObjectMarshaller, \
-            public xmltooling::AbstractXMLObjectUnmarshaller \
-    { \
-    public: \
-        virtual ~cname##Impl() {} \
-        cname##Impl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) \
-            : xmltooling::AbstractXMLObject(nsURI, localName, prefix, schemaType) { \
-        } \
-        cname##Impl(const cname##Impl& src) \
-            : xmltooling::AbstractXMLObject(src), \
-                xmltooling::AbstractSimpleElement(src), \
-                xmltooling::AbstractDOMCachingXMLObject(src) {} \
-        IMPL_XMLOBJECT_CLONE(cname) \
-    }
-
-#ifdef HAVE_COVARIANT_RETURNS
-
-/**
- * Begins the declaration of an XMLObjectBuilder specialization.
- * Basic boilerplate includes an empty virtual destructor, and
- * a default builder that defaults the element name.
- * 
- * @param linkage           linkage specifier for the class
- * @param cname             the name of the XMLObject specialization
- * @param namespaceURI      the XML namespace of the default associated element
- * @param namespacePrefix   the XML namespace prefix of the default associated element
- */
-#define BEGIN_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix) \
-    XMLTOOLING_DOXYGEN(Builder for cname objects.) \
-    class linkage cname##Builder : public xmltooling::ConcreteXMLObjectBuilder { \
-    public: \
-        virtual ~cname##Builder() {} \
-        XMLTOOLING_DOXYGEN(Default builder.) \
-        virtual cname* buildObject() const { \
-            return buildObject(namespaceURI,cname::LOCAL_NAME,namespacePrefix); \
-        } \
-        XMLTOOLING_DOXYGEN(Builder that allows element/type override.) \
-        virtual cname* buildObject( \
-            const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const xmltooling::QName* schemaType=NULL \
-            ) const
-
-/**
- * Ends the declaration of an XMLObjectBuilder specialization.
- */
-#define END_XMLOBJECTBUILDER }
-
-/**
- * Declares a generic XMLObjectBuilder specialization.
- * 
- * @param linkage           linkage specifier for the class
- * @param cname             the name of the XMLObject specialization
- * @param namespaceURI      the XML namespace of the default associated element
- * @param namespacePrefix   the XML namespace prefix of the default associated element
- */
- #define DECL_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix) \
-    BEGIN_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix); \
-    XMLTOOLING_DOXYGEN(Singleton builder.) \
-    static cname* build##cname() { \
-        const cname##Builder* b = dynamic_cast<const cname##Builder*>( \
-            XMLObjectBuilder::getBuilder(xmltooling::QName(namespaceURI,cname::LOCAL_NAME)) \
-            ); \
-        if (b) \
-            return b->buildObject(); \
-        throw xmltooling::XMLObjectException("Unable to obtain typed builder for "#cname"."); \
-    } \
-    END_XMLOBJECTBUILDER
-
-/**
- * Implements the standard XMLObjectBuilder specialization function. 
- * 
- * @param cname the name of the XMLObject specialization
- */
-#define IMPL_XMLOBJECTBUILDER(cname) \
-    cname* cname##Builder::buildObject( \
-        const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType \
-        ) const \
-    { \
-        return new cname##Impl(nsURI,localName,prefix,schemaType); \
-    }
-
-#else   /* !HAVE_COVARIANT_RETURNS */
-
-/**
- * Begins the declaration of an XMLObjectBuilder specialization.
- * Basic boilerplate includes an empty virtual destructor, and
- * a default builder that defaults the element name.
- * 
- * @param linkage           linkage specifier for the class
- * @param cname             the name of the XMLObject specialization
- * @param namespaceURI      the XML namespace of the default associated element
- * @param namespacePrefix   the XML namespace prefix of the default associated element
- */
-#define BEGIN_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix) \
-    XMLTOOLING_DOXYGEN(Builder for cname objects.) \
-    class linkage cname##Builder : public xmltooling::ConcreteXMLObjectBuilder { \
-    public: \
-        virtual ~cname##Builder() {} \
-        XMLTOOLING_DOXYGEN(Default builder.) \
-        virtual xmltooling::XMLObject* buildObject() const { \
-            return buildObject(namespaceURI,cname::LOCAL_NAME,namespacePrefix); \
-        } \
-        XMLTOOLING_DOXYGEN(Builder that allows element/type override.) \
-        virtual xmltooling::XMLObject* buildObject( \
-            const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const xmltooling::QName* schemaType=NULL \
-            ) const
-
-/**
- * Ends the declaration of an XMLObjectBuilder specialization.
- */
-#define END_XMLOBJECTBUILDER }
-
-/**
- * Declares a generic XMLObjectBuilder specialization.
- * 
- * @param linkage           linkage specifier for the class
- * @param cname             the name of the XMLObject specialization
- * @param namespaceURI      the XML namespace of the default associated element
- * @param namespacePrefix   the XML namespace prefix of the default associated element
- */
- #define DECL_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix) \
-    BEGIN_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix); \
-    XMLTOOLING_DOXYGEN(Singleton builder.) \
-    static cname* build##cname() { \
-        const cname##Builder* b = dynamic_cast<const cname##Builder*>( \
-            XMLObjectBuilder::getBuilder(xmltooling::QName(namespaceURI,cname::LOCAL_NAME)) \
-            ); \
-        if (b) \
-            return dynamic_cast<cname*>(b->buildObject()); \
-        throw xmltooling::XMLObjectException("Unable to obtain typed builder for "#cname"."); \
-    } \
-    END_XMLOBJECTBUILDER
-
-/**
- * Implements the standard XMLObjectBuilder specialization function. 
- * 
- * @param cname the name of the XMLObject specialization
- */
-#define IMPL_XMLOBJECTBUILDER(cname) \
-    xmltooling::XMLObject* cname##Builder::buildObject( \
-        const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType \
-        ) const \
-    { \
-        return new cname##Impl(nsURI,localName,prefix,schemaType); \
-    }
-
-#endif  /* HAVE_COVARIANT_RETURNS */
-
-/**
- * Begins the declaration of a Schema Validator specialization.
- * 
- * @param linkage           linkage specifier for the class
- * @param cname the base name of the Validator specialization
- */
- #define BEGIN_XMLOBJECTVALIDATOR(linkage,cname) \
-    class linkage cname##SchemaValidator : public xmltooling::Validator \
-    { \
-    public: \
-        virtual ~cname##SchemaValidator() {} \
-        virtual void validate(const xmltooling::XMLObject* xmlObject) const { \
-            const cname* ptr=dynamic_cast<const cname*>(xmlObject); \
-            if (!ptr) \
-                throw xmltooling::ValidationException(#cname"SchemaValidator: unsupported object type ($1).",xmltooling::params(1,typeid(xmlObject).name())); \
-            if (ptr->nil() && (ptr->hasChildren() || ptr->getTextContent())) \
-               throw xmltooling::ValidationException("Object has nil property but with children or content.")
-
-/**
- * Begins the declaration of a Schema Validator specialization subclass.
- * 
- * @param linkage   linkage specifier for the class
- * @param cname     the base name of the Validator specialization
- * @param base      base class for the validator
- */
- #define BEGIN_XMLOBJECTVALIDATOR_SUB(linkage,cname,base) \
-    class linkage cname##SchemaValidator : public base##SchemaValidator \
-    { \
-    public: \
-        virtual ~cname##SchemaValidator() {} \
-        virtual void validate(const xmltooling::XMLObject* xmlObject) const { \
-            const cname* ptr=dynamic_cast<const cname*>(xmlObject); \
-            if (!ptr) \
-                throw xmltooling::ValidationException(#cname"SchemaValidator: unsupported object type ($1).",xmltooling::params(1,typeid(xmlObject).name()));
-
-/**
- * Ends the declaration of a Validator specialization.
- */
-#define END_XMLOBJECTVALIDATOR } }
-
-/**
- * Validator code that checks the object type.
- * 
- * @param cname     the name of the XMLObject specialization
- */
-#define XMLOBJECTVALIDATOR_CHECKTYPE(cname) \
-    const cname* ptr=dynamic_cast<const cname*>(xmlObject); \
-    if (!ptr) \
-        throw xmltooling::ValidationException(#cname"SchemaValidator: unsupported object type ($1).",xmltooling::params(1,typeid(xmlObject).name()))
-
-/**
- * Validator code that checks for a required attribute, content, or singleton.
- * 
- * @param cname     the name of the XMLObject specialization
- * @param proper    the proper name of the attribute, content, or singleton member 
- */
-#define XMLOBJECTVALIDATOR_REQUIRE(cname,proper) \
-    if (!ptr->get##proper()) \
-        throw xmltooling::ValidationException(#cname" must have "#proper".")
-
-/**
- * Validator code that checks for a required integer attribute
- * 
- * @param cname     the name of the XMLObject specialization
- * @param proper    the proper name of the attribute, content, or singleton member 
- */
-#define XMLOBJECTVALIDATOR_REQUIRE_INTEGER(cname,proper) \
-    if (!ptr->get##proper().first) \
-        throw xmltooling::ValidationException(#cname" must have "#proper".")
-
-/**
- * Validator code that checks for one of a pair of
- * required attributes, content, or singletons.
- * 
- * @param cname     the name of the XMLObject specialization
- * @param proper1   the proper name of the first attribute, content, or singleton member 
- * @param proper2   the proper name of the second attribute, content, or singleton member 
- */
-#define XMLOBJECTVALIDATOR_ONEOF(cname,proper1,proper2) \
-    if (!ptr->get##proper1() && !ptr->get##proper2()) \
-        throw xmltooling::ValidationException(#cname" must have "#proper1" or "#proper2".")
-
-/**
- * Validator code that checks for one of a pair of
- * required attributes, content, or singletons, but disallows both.
- * 
- * @param cname     the name of the XMLObject specialization
- * @param proper1   the proper name of the first attribute, content, or singleton member 
- * @param proper2   the proper name of the second attribute, content, or singleton member 
- */
-#define XMLOBJECTVALIDATOR_ONLYONEOF(cname,proper1,proper2) \
-    if ((!ptr->get##proper1() && !ptr->get##proper2()) || (ptr->get##proper1() && ptr->get##proper2())) \
-        throw xmltooling::ValidationException(#cname" must have "#proper1" or "#proper2" but not both.")
-
-/**
- * Validator code that checks for one of a set of three
- * required attributes, content, or singletons.
- * 
- * @param cname     the name of the XMLObject specialization
- * @param proper1   the proper name of the first attribute, content, or singleton member
- * @param proper2   the proper name of the second attribute, content, or singleton member
- * @param proper3   the proper name of the third attribute, content, or singleton member
- */
-#define XMLOBJECTVALIDATOR_ONEOF3(cname,proper1,proper2,proper3) \
-    if (!ptr->get##proper1() && !ptr->get##proper2() && !ptr->get##proper3()) \
-        throw xmltooling::ValidationException(#cname" must have "#proper1", "#proper2", or "#proper3".")
-
-/**
- * Validator code that checks for one of a set of three
- * required attributes, content, or singletons but disallows more than one.
- * 
- * @param cname     the name of the XMLObject specialization
- * @param proper1   the proper name of the first attribute, content, or singleton member
- * @param proper2   the proper name of the second attribute, content, or singleton member
- * @param proper3   the proper name of the third attribute, content, or singleton member
- */
-#define XMLOBJECTVALIDATOR_ONLYONEOF3(cname,proper1,proper2,proper3) \
-    int c##proper1##proper2##proper3=0; \
-    if (ptr->get##proper1()!=NULL) \
-        c##proper1##proper2##proper3++; \
-    if (ptr->get##proper2()!=NULL) \
-        c##proper1##proper2##proper3++; \
-    if (ptr->get##proper3()!=NULL) \
-        c##proper1##proper2##proper3++; \
-    if (c##proper1##proper2##proper3 != 1) \
-        throw xmltooling::ValidationException(#cname" must have only one of "#proper1", "#proper2", or "#proper3".")
-
-/**
- * Validator code that checks a co-constraint (if one present, the other must be)
- * between a pair of attributes, content, or singletons.
- * 
- * @param cname     the name of the XMLObject specialization
- * @param proper1   the proper name of the first attribute, content, or singleton member 
- * @param proper2   the proper name of the second attribute, content, or singleton member 
- */
-#define XMLOBJECTVALIDATOR_NONEORBOTH(cname,proper1,proper2) \
-    if ((ptr->get##proper1() && !ptr->get##proper2()) || (!ptr->get##proper1() && ptr->get##proper2())) \
-        throw xmltooling::ValidationException(#cname" cannot have "#proper1" without "#proper2".")
-
-/**
- * Validator code that checks for a non-empty collection.
- * 
- * @param cname     the name of the XMLObject specialization
- * @param proper    the proper name of the collection item 
- */
-#define XMLOBJECTVALIDATOR_NONEMPTY(cname,proper) \
-    if (ptr->get##proper##s().empty()) \
-        throw xmltooling::ValidationException(#cname" must have at least one "#proper".")
-
-/**
- * Declares/defines a Validator specialization that checks object type and
- * a non-empty simple content model.
- * 
- * @param linkage   linkage specifier for the class
- * @param cname     the name of the XMLObject specialization
- */
-#define XMLOBJECTVALIDATOR_SIMPLE(linkage,cname) \
-    BEGIN_XMLOBJECTVALIDATOR(linkage,cname); \
-        XMLOBJECTVALIDATOR_REQUIRE(cname,TextContent); \
-    END_XMLOBJECTVALIDATOR
-
-#include <utility>
-
-/**
- * @namespace xmltooling
- * Public namespace of XML Tooling library
- */
-namespace xmltooling {
-
-    /**
-     * Template function for cloning a sequence of XMLObjects.
-     * Invokes the clone() member on each element of the input sequence and adds the copy to
-     * the output sequence. Order is preserved.
-     * 
-     * @param in    input sequence to clone
-     * @param out   output sequence to copy cloned pointers into
-     */
-    template<class InputSequence,class OutputSequence> void clone(const InputSequence& in, OutputSequence& out) {
-        for (typename InputSequence::const_iterator i=in.begin(); i!=in.end(); i++) {
-            if (*i)
-                out.push_back((*i)->clone());
-            else
-                out.push_back(*i);
-        }
-    }
-
-    /**
-     * Functor for cleaning up heap objects in containers.
-     */
-    template<class T> struct cleanup
-    {
-        /**
-         * Function operator to delete an object.
-         * 
-         * @param ptr   object to delete
-         */
-        void operator()(T* ptr) {delete ptr;}
-        
-        /**
-         * Function operator to delete an object stored as const.
-         * 
-         * @param ptr   object to delete after casting away const
-         */
-        void operator()(const T* ptr) {delete const_cast<T*>(ptr);}
-    };
-
-    /**
-     * Functor for cleaning up heap objects in key/value containers.
-     */
-    template<class A,class B> struct cleanup_pair
-    {
-        /**
-         * Function operator to delete an object.
-         * 
-         * @param p   a pair in which the second component is the object to delete
-         */
-        void operator()(const std::pair<const A,B*>& p) {delete p.second;}
-    };
-
-    /**
-     * Functor for cleaning up const heap objects in key/value containers.
-     */
-    template<class A,class B> struct cleanup_const_pair
-    {
-        /**
-         * Function operator to delete an object stored as const
-         * 
-         * @param p   a pair in which the second component is the const object to delete
-         */
-        void operator()(const std::pair<const A,const B*>& p) {delete const_cast<B*>(p.second);}
-    };
-};
-
-#endif /* __xmltooling_base_h__ */
+/*\r
+ *  Copyright 2001-2007 Internet2\r
+ * \r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ *     http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ */\r
+\r
+/**\r
+ * @file xmltooling/base.h\r
+ * \r
+ * Base header file definitions\r
+ * Must be included prior to including any other header\r
+ */\r
+\r
+#ifndef __xmltooling_base_h__\r
+#define __xmltooling_base_h__\r
+\r
+#include <typeinfo>\r
+\r
+#if defined (_MSC_VER) || defined(__BORLANDC__)\r
+  #include <xmltooling/config_pub_win32.h>\r
+#else\r
+  #include <xmltooling/config_pub.h>\r
+#endif\r
+\r
+#ifdef XMLTOOLING_LITE\r
+# define XMLTOOLING_NO_XMLSEC 1\r
+#endif\r
+\r
+// Windows and GCC4 Symbol Visibility Macros\r
+#ifdef WIN32\r
+  #define XMLTOOL_IMPORT __declspec(dllimport)\r
+  #define XMLTOOL_EXPORT __declspec(dllexport)\r
+  #define XMLTOOL_DLLLOCAL\r
+  #define XMLTOOL_DLLPUBLIC\r
+#else\r
+  #define XMLTOOL_IMPORT\r
+  #ifdef GCC_HASCLASSVISIBILITY\r
+    #define XMLTOOL_EXPORT __attribute__ ((visibility("default")))\r
+    #define XMLTOOL_DLLLOCAL __attribute__ ((visibility("hidden")))\r
+    #define XMLTOOL_DLLPUBLIC __attribute__ ((visibility("default")))\r
+  #else\r
+    #define XMLTOOL_EXPORT\r
+    #define XMLTOOL_DLLLOCAL\r
+    #define XMLTOOL_DLLPUBLIC\r
+  #endif\r
+#endif\r
+\r
+// Define XMLTOOL_API for DLL builds\r
+#ifdef XMLTOOLING_EXPORTS\r
+  #define XMLTOOL_API XMLTOOL_EXPORT\r
+#else\r
+  #define XMLTOOL_API XMLTOOL_IMPORT\r
+#endif\r
+\r
+// Throwable classes must always be visible on GCC in all binaries\r
+#ifdef WIN32\r
+  #define XMLTOOL_EXCEPTIONAPI(api) api\r
+#elif defined(GCC_HASCLASSVISIBILITY)\r
+  #define XMLTOOL_EXCEPTIONAPI(api) XMLTOOL_EXPORT\r
+#else\r
+  #define XMLTOOL_EXCEPTIONAPI(api)\r
+#endif\r
+\r
+#ifdef _MSC_VER\r
+    #define XMLTOOLING_DOXYGEN(desc) /##** desc */\r
+#else\r
+    #define XMLTOOLING_DOXYGEN(desc)\r
+#endif\r
+\r
+/**\r
+ * Blocks copy c'tor and assignment operator for a class.\r
+ */\r
+#define MAKE_NONCOPYABLE(type) \\r
+    private: \\r
+        type(const type&); \\r
+        type& operator=(const type&)\r
+\r
+#ifndef DOXYGEN_SKIP\r
+#ifndef NULL\r
+#define NULL    0\r
+#endif\r
+#define UNICODE_LITERAL_1(a) {xercesc::chLatin_##a, xercesc::chNull}\r
+#define UNICODE_LITERAL_2(a,b) {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chNull}\r
+#define UNICODE_LITERAL_3(a,b,c) {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chNull}\r
+#define UNICODE_LITERAL_4(a,b,c,d) {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chNull}\r
+#define UNICODE_LITERAL_5(a,b,c,d,e) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chNull}\r
+#define UNICODE_LITERAL_6(a,b,c,d,e,f) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chNull}\r
+#define UNICODE_LITERAL_7(a,b,c,d,e,f,g) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chNull}\r
+#define UNICODE_LITERAL_8(a,b,c,d,e,f,g,h) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chNull}\r
+#define UNICODE_LITERAL_9(a,b,c,d,e,f,g,h,i) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, xercesc::chNull}\r
+#define UNICODE_LITERAL_10(a,b,c,d,e,f,g,h,i,j) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chNull}\r
+#define UNICODE_LITERAL_11(a,b,c,d,e,f,g,h,i,j,k) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chNull}\r
+#define UNICODE_LITERAL_12(a,b,c,d,e,f,g,h,i,j,k,l) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chNull}\r
+#define UNICODE_LITERAL_13(a,b,c,d,e,f,g,h,i,j,k,l,m) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chNull}\r
+#define UNICODE_LITERAL_14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chNull}\r
+#define UNICODE_LITERAL_15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chNull}\r
+#define UNICODE_LITERAL_16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chNull}\r
+#define UNICODE_LITERAL_17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chNull}\r
+#define UNICODE_LITERAL_18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, xercesc::chNull}\r
+#define UNICODE_LITERAL_19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chNull}\r
+#define UNICODE_LITERAL_20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chNull}\r
+#define UNICODE_LITERAL_21(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chNull}\r
+#define UNICODE_LITERAL_22(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chNull}\r
+#define UNICODE_LITERAL_23(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chNull}\r
+#define UNICODE_LITERAL_24(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chNull}\r
+#define UNICODE_LITERAL_25(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chNull}\r
+#define UNICODE_LITERAL_26(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, xercesc::chNull}\r
+#define UNICODE_LITERAL_27(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \\r
+        xercesc::chLatin_##aa, xercesc::chNull}\r
+#define UNICODE_LITERAL_28(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \\r
+        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chNull}\r
+#define UNICODE_LITERAL_29(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \\r
+        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chLatin_##cc, xercesc::chNull}\r
+#define UNICODE_LITERAL_30(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \\r
+        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chLatin_##cc, xercesc::chLatin_##dd, xercesc::chNull}\r
+#define UNICODE_LITERAL_31(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd,ee) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \\r
+        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chLatin_##cc, xercesc::chLatin_##dd, xercesc::chLatin_##ee, xercesc::chNull}\r
+#define UNICODE_LITERAL_32(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd,ee,ff) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \\r
+        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chLatin_##cc, xercesc::chLatin_##dd, xercesc::chLatin_##ee, xercesc::chLatin_##ff, xercesc::chNull}\r
+#define UNICODE_LITERAL_33(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd,ee,ff,gg) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \\r
+        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chLatin_##cc, xercesc::chLatin_##dd, xercesc::chLatin_##ee, xercesc::chLatin_##ff, xercesc::chLatin_##gg, xercesc::chNull}\r
+#define UNICODE_LITERAL_34(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd,ee,ff,gg,hh) \\r
+    {xercesc::chLatin_##a, xercesc::chLatin_##b, xercesc::chLatin_##c, xercesc::chLatin_##d, xercesc::chLatin_##e, xercesc::chLatin_##f, xercesc::chLatin_##g, xercesc::chLatin_##h, xercesc::chLatin_##i, \\r
+        xercesc::chLatin_##j, xercesc::chLatin_##k, xercesc::chLatin_##l, xercesc::chLatin_##m, xercesc::chLatin_##n, xercesc::chLatin_##o, xercesc::chLatin_##p, xercesc::chLatin_##q, xercesc::chLatin_##r, \\r
+        xercesc::chLatin_##s, xercesc::chLatin_##t, xercesc::chLatin_##u, xercesc::chLatin_##v, xercesc::chLatin_##w, xercesc::chLatin_##x, xercesc::chLatin_##y, xercesc::chLatin_##z, \\r
+        xercesc::chLatin_##aa, xercesc::chLatin_##bb, xercesc::chLatin_##cc, xercesc::chLatin_##dd, xercesc::chLatin_##ee, xercesc::chLatin_##ff, xercesc::chLatin_##gg, xercesc::chLatin_##hh, xercesc::chNull}\r
+#endif /* DOXYGEN_SKIP */\r
+\r
+/**\r
+ * Begins the declaration of an XMLObject specialization for an abstract element/type.\r
+ * Basic boilerplate includes a protected constructor, empty virtual destructor,\r
+ * and Unicode constants for the default associated element's name and prefix.\r
+ * \r
+ * @param linkage   linkage specifier for the class\r
+ * @param cname     the name of the class to declare\r
+ * @param base      the base class to derive from using public virtual inheritance\r
+ * @param desc      documentation comment for class\r
+ */\r
+#define DECL_XMLOBJECT_ABSTRACT(linkage,cname,base,desc) \\r
+    XMLTOOLING_DOXYGEN(desc) \\r
+    class linkage cname : public virtual base { \\r
+    protected: \\r
+        cname() {} \\r
+    public: \\r
+        virtual ~cname() {} \\r
+        XMLTOOLING_DOXYGEN(Element local name) \\r
+        static const XMLCh LOCAL_NAME[]; \\r
+    }\r
+\r
+/**\r
+ * Begins the declaration of an XMLObject specialization.\r
+ * Basic boilerplate includes a protected constructor, empty virtual destructor,\r
+ * and Unicode constants for the default associated element's name and prefix.\r
+ * \r
+ * @param linkage   linkage specifier for the class\r
+ * @param cname     the name of the class to declare\r
+ * @param base      the base class to derive from using public virtual inheritance\r
+ * @param desc      documentation comment for class\r
+ */\r
+#define BEGIN_XMLOBJECT(linkage,cname,base,desc) \\r
+    XMLTOOLING_DOXYGEN(desc) \\r
+    class linkage cname : public virtual base { \\r
+    protected: \\r
+        cname() {} \\r
+    public: \\r
+        virtual ~cname() {} \\r
+        XMLTOOLING_DOXYGEN(Type-specific clone method.) \\r
+        virtual cname* clone##cname() const=0; \\r
+        XMLTOOLING_DOXYGEN(Element local name) \\r
+        static const XMLCh LOCAL_NAME[]\r
+\r
+/**\r
+ * Begins the declaration of an XMLObject specialization with two base classes.\r
+ * Basic boilerplate includes a protected constructor, empty virtual destructor,\r
+ * and Unicode constants for the default associated element's name and prefix.\r
+ * \r
+ * @param linkage   linkage specifier for the class\r
+ * @param cname     the name of the class to declare\r
+ * @param base      the first base class to derive from using public virtual inheritance\r
+ * @param base2     the second base class to derive from using public virtual inheritance\r
+ * @param desc      documentation comment for class\r
+ */\r
+#define BEGIN_XMLOBJECT2(linkage,cname,base,base2,desc) \\r
+    XMLTOOLING_DOXYGEN(desc) \\r
+    class linkage cname : public virtual base, public virtual base2 { \\r
+    protected: \\r
+        cname() {} \\r
+    public: \\r
+        virtual ~cname() {} \\r
+        XMLTOOLING_DOXYGEN(Type-specific clone method.) \\r
+        virtual cname* clone##cname() const=0; \\r
+        XMLTOOLING_DOXYGEN(Element local name) \\r
+        static const XMLCh LOCAL_NAME[]\r
+\r
+/**\r
+ * Begins the declaration of an XMLObject specialization with three base classes.\r
+ * Basic boilerplate includes a protected constructor, empty virtual destructor,\r
+ * and Unicode constants for the default associated element's name and prefix.\r
+ * \r
+ * @param linkage   linkage specifier for the class\r
+ * @param cname     the name of the class to declare\r
+ * @param base      the first base class to derive from using public virtual inheritance\r
+ * @param base2     the second base class to derive from using public virtual inheritance\r
+ * @param base3     the third base class to derive from using public virtual inheritance\r
+ * @param desc      documentation comment for class\r
+ */\r
+#define BEGIN_XMLOBJECT3(linkage,cname,base,base2,base3,desc) \\r
+    XMLTOOLING_DOXYGEN(desc) \\r
+    class linkage cname : public virtual base, public virtual base2, public virtual base3 { \\r
+    protected: \\r
+        cname() {} \\r
+    public: \\r
+        virtual ~cname() {} \\r
+        XMLTOOLING_DOXYGEN(Type-specific clone method.) \\r
+        virtual cname* clone##cname() const=0; \\r
+        XMLTOOLING_DOXYGEN(Element local name) \\r
+        static const XMLCh LOCAL_NAME[]\r
+\r
+/**\r
+ * Begins the declaration of an XMLObject specialization with four base classes.\r
+ * Basic boilerplate includes a protected constructor, empty virtual destructor,\r
+ * and Unicode constants for the default associated element's name and prefix.\r
+ * \r
+ * @param linkage   linkage specifier for the class\r
+ * @param cname     the name of the class to declare\r
+ * @param base      the first base class to derive from using public virtual inheritance\r
+ * @param base2     the second base class to derive from using public virtual inheritance\r
+ * @param base3     the third base class to derive from using public virtual inheritance\r
+ * @param base4     the fourth base class to derive from using public virtual inheritance\r
+ * @param desc      documentation comment for class\r
+ */\r
+#define BEGIN_XMLOBJECT4(linkage,cname,base,base2,base3,base4,desc) \\r
+    XMLTOOLING_DOXYGEN(desc) \\r
+    class linkage cname : public virtual base, public virtual base2, public virtual base3, public virtual base4 { \\r
+    protected: \\r
+        cname() {} \\r
+    public: \\r
+        virtual ~cname() {} \\r
+        XMLTOOLING_DOXYGEN(Type-specific clone method.) \\r
+        virtual cname* clone##cname() const=0; \\r
+        XMLTOOLING_DOXYGEN(Element local name) \\r
+        static const XMLCh LOCAL_NAME[]\r
+\r
+/**\r
+ * Begins the declaration of an XMLObject specialization with five base classes.\r
+ * Basic boilerplate includes a protected constructor, empty virtual destructor,\r
+ * and Unicode constants for the default associated element's name and prefix.\r
+ * \r
+ * @param linkage   linkage specifier for the class\r
+ * @param cname     the name of the class to declare\r
+ * @param base      the first base class to derive from using public virtual inheritance\r
+ * @param base2     the second base class to derive from using public virtual inheritance\r
+ * @param base3     the third base class to derive from using public virtual inheritance\r
+ * @param base4     the fourth base class to derive from using public virtual inheritance\r
+ * @param base5     the fifth base class to derive from using public virtual inheritance\r
+ * @param desc      documentation comment for class\r
+ */\r
+#define BEGIN_XMLOBJECT5(linkage,cname,base,base2,base3,base4,base5,desc) \\r
+    XMLTOOLING_DOXYGEN(desc) \\r
+    class linkage cname : public virtual base, public virtual base2, public virtual base3, public virtual base4, public virtual base5 { \\r
+    protected: \\r
+        cname() {} \\r
+    public: \\r
+        virtual ~cname() {} \\r
+        XMLTOOLING_DOXYGEN(Type-specific clone method.) \\r
+        virtual cname* clone##cname() const=0; \\r
+        XMLTOOLING_DOXYGEN(Element local name) \\r
+        static const XMLCh LOCAL_NAME[]\r
+\r
+/**\r
+ * Ends the declaration of an XMLObject specialization.\r
+ */\r
+#define END_XMLOBJECT }\r
+\r
+/**\r
+ * Declares a static variable holding the XMLObject's element QName.\r
+ */\r
+#define DECL_ELEMENT_QNAME \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(Element QName) \\r
+        static xmltooling::QName ELEMENT_QNAME\r
+\r
+/**\r
+ * Declares a static variable holding the XMLObject's schema type QName.\r
+ */\r
+#define DECL_TYPE_QNAME \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(Type QName) \\r
+        static xmltooling::QName TYPE_QNAME\r
+\r
+/**\r
+ * Implements a static variable holding an XMLObject's element QName.\r
+ * \r
+ * @param cname             the name of the XMLObject specialization\r
+ * @param namespaceURI      the XML namespace of the default associated element\r
+ * @param namespacePrefix   the XML namespace prefix of the default associated element\r
+ */\r
+#define IMPL_ELEMENT_QNAME(cname,namespaceURI,namespacePrefix) \\r
+    xmltooling::QName cname::ELEMENT_QNAME(namespaceURI,cname::LOCAL_NAME,namespacePrefix)\r
+\r
+/**\r
+ * Implements a static variable holding an XMLObject's schema type QName.\r
+ * \r
+ * @param cname             the name of the XMLObject specialization\r
+ * @param namespaceURI      the XML namespace of the default associated element\r
+ * @param namespacePrefix   the XML namespace prefix of the default associated element\r
+ */\r
+#define IMPL_TYPE_QNAME(cname,namespaceURI,namespacePrefix) \\r
+    xmltooling::QName cname::TYPE_QNAME(namespaceURI,cname::TYPE_NAME,namespacePrefix)\r
+\r
+/**\r
+ * Declares abstract set method for a typed XML attribute.\r
+ * The get method is omitted.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ * @param upcased   the upcased name of the attribute\r
+ * @param type      the attribute's data type\r
+ */\r
+#define DECL_INHERITED_XMLOBJECT_ATTRIB(proper,upcased,type) \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(proper attribute name) \\r
+        static const XMLCh upcased##_ATTRIB_NAME[]; \\r
+        XMLTOOLING_DOXYGEN(Sets the proper attribute.) \\r
+        virtual void set##proper(const type* proper)=0\r
+\r
+/**\r
+ * Declares abstract get/set methods for a typed XML attribute.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ * @param upcased   the upcased name of the attribute\r
+ * @param type      the attribute's data type\r
+ */\r
+#define DECL_XMLOBJECT_ATTRIB(proper,upcased,type) \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(proper attribute name) \\r
+        static const XMLCh upcased##_ATTRIB_NAME[]; \\r
+        XMLTOOLING_DOXYGEN(Returns the proper attribute.) \\r
+        virtual const type* get##proper() const=0; \\r
+        XMLTOOLING_DOXYGEN(Sets the proper attribute.) \\r
+        virtual void set##proper(const type* proper)=0\r
+\r
+/**\r
+ * Declares abstract set method for a string XML attribute.\r
+ * The get method is omitted.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ * @param upcased   the upcased name of the attribute\r
+ */\r
+#define DECL_INHERITED_STRING_ATTRIB(proper,upcased) \\r
+    DECL_INHERITED_XMLOBJECT_ATTRIB(proper,upcased,XMLCh)\r
+\r
+/**\r
+ * Declares abstract get/set methods for a string XML attribute.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ * @param upcased   the upcased name of the attribute\r
+ */\r
+#define DECL_STRING_ATTRIB(proper,upcased) \\r
+    DECL_XMLOBJECT_ATTRIB(proper,upcased,XMLCh)\r
+\r
+/**\r
+ * Declares abstract set method for a DateTime XML attribute.\r
+ * The get method is omitted.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ * @param upcased   the upcased name of the attribute\r
+ */\r
+#define DECL_INHERITED_DATETIME_ATTRIB(proper,upcased) \\r
+    DECL_INHERITED_XMLOBJECT_ATTRIB(proper,upcased,xmltooling::DateTime); \\r
+    XMLTOOLING_DOXYGEN(Sets the proper attribute.) \\r
+    virtual void set##proper(time_t proper)=0; \\r
+    XMLTOOLING_DOXYGEN(Sets the proper attribute.) \\r
+    virtual void set##proper(const XMLCh* proper)=0\r
+\r
+/**\r
+ * Declares abstract get/set methods for a DateTime XML attribute.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ * @param upcased   the upcased name of the attribute\r
+ */\r
+#define DECL_DATETIME_ATTRIB(proper,upcased) \\r
+    DECL_XMLOBJECT_ATTRIB(proper,upcased,xmltooling::DateTime); \\r
+    XMLTOOLING_DOXYGEN(Returns the proper attribute in epoch form.) \\r
+    virtual time_t get##proper##Epoch() const=0; \\r
+    XMLTOOLING_DOXYGEN(Sets the proper attribute.) \\r
+    virtual void set##proper(time_t proper)=0; \\r
+    XMLTOOLING_DOXYGEN(Sets the proper attribute.) \\r
+    virtual void set##proper(const XMLCh* proper)=0\r
+\r
+/**\r
+ * Declares abstract set method for an integer XML attribute.\r
+ * The get method is omitted.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ * @param upcased   the upcased name of the attribute\r
+ */\r
+#define DECL_INHERITED_INTEGER_ATTRIB(proper,upcased) \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(proper attribute name) \\r
+        static const XMLCh upcased##_ATTRIB_NAME[]; \\r
+        XMLTOOLING_DOXYGEN(Sets the proper attribute using a string value.) \\r
+        virtual void set##proper(const XMLCh* proper)=0; \\r
+        XMLTOOLING_DOXYGEN(Sets the proper attribute.) \\r
+        virtual void set##proper(int proper)=0\r
+\r
+/**\r
+ * Declares abstract get/set methods for an integer XML attribute.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ * @param upcased   the upcased name of the attribute\r
+ */\r
+#define DECL_INTEGER_ATTRIB(proper,upcased) \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(proper attribute name) \\r
+        static const XMLCh upcased##_ATTRIB_NAME[]; \\r
+        XMLTOOLING_DOXYGEN(Returns the proper attribute after a NULL indicator.) \\r
+        virtual std::pair<bool,int> get##proper() const=0; \\r
+        XMLTOOLING_DOXYGEN(Sets the proper attribute using a string value.) \\r
+        virtual void set##proper(const XMLCh* proper)=0; \\r
+        XMLTOOLING_DOXYGEN(Sets the proper attribute.) \\r
+        virtual void set##proper(int proper)=0\r
+\r
+/**\r
+ * Declares abstract get/set methods for a boolean XML attribute.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ * @param upcased   the upcased name of the attribute\r
+ * @param def       the default/presumed value, if no explicit value has been set\r
+ */\r
+#define DECL_BOOLEAN_ATTRIB(proper,upcased,def) \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(proper attribute name) \\r
+        static const XMLCh upcased##_ATTRIB_NAME[]; \\r
+        XMLTOOLING_DOXYGEN(Returns the proper attribute or def if not set.) \\r
+        bool proper() const { \\r
+            switch (get##proper()) { \\r
+                case xmlconstants::XML_BOOL_TRUE: \\r
+                case xmlconstants::XML_BOOL_ONE: \\r
+                    return true; \\r
+                case xmlconstants::XML_BOOL_FALSE: \\r
+                case xmlconstants::XML_BOOL_ZERO: \\r
+                    return false; \\r
+                default: \\r
+                    return def; \\r
+            } \\r
+        } \\r
+        XMLTOOLING_DOXYGEN(Returns the proper attribute as an explicit enumerated value.) \\r
+        virtual xmlconstants::xmltooling_bool_t get##proper() const=0; \\r
+        XMLTOOLING_DOXYGEN(Sets the proper attribute using an enumerated value.) \\r
+        virtual void proper(xmlconstants::xmltooling_bool_t value)=0; \\r
+        XMLTOOLING_DOXYGEN(Sets the proper attribute.) \\r
+        void proper(bool value) { \\r
+            proper(value ? xmlconstants::XML_BOOL_ONE : xmlconstants::XML_BOOL_ZERO); \\r
+        } \\r
+        XMLTOOLING_DOXYGEN(Sets the proper attribute using a string constant.) \\r
+        void set##proper(const XMLCh* value) { \\r
+            if (value) { \\r
+                switch (*value) { \\r
+                    case xercesc::chLatin_t: \\r
+                        proper(xmlconstants::XML_BOOL_TRUE); \\r
+                        break; \\r
+                    case xercesc::chLatin_f: \\r
+                        proper(xmlconstants::XML_BOOL_FALSE); \\r
+                        break; \\r
+                    case xercesc::chDigit_1: \\r
+                        proper(xmlconstants::XML_BOOL_ONE); \\r
+                        break; \\r
+                    case xercesc::chDigit_0: \\r
+                        proper(xmlconstants::XML_BOOL_ZERO); \\r
+                        break; \\r
+                    default: \\r
+                        proper(xmlconstants::XML_BOOL_NULL); \\r
+                } \\r
+            } \\r
+            else \\r
+                proper(xmlconstants::XML_BOOL_NULL); \\r
+        }\r
+\r
+/**\r
+ * Implements get/set methods and a private member for a typed XML attribute.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ * @param type      the attribute's data type\r
+ */\r
+#define IMPL_XMLOBJECT_ATTRIB(proper,type) \\r
+    protected: \\r
+        type* m_##proper; \\r
+    public: \\r
+        const type* get##proper() const { \\r
+            return m_##proper; \\r
+        } \\r
+        void set##proper(const type* proper) { \\r
+            m_##proper = prepareForAssignment(m_##proper,proper); \\r
+        }\r
+\r
+/**\r
+ * Implements get/set methods and a private member for a string XML attribute.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ */\r
+#define IMPL_STRING_ATTRIB(proper) \\r
+    IMPL_XMLOBJECT_ATTRIB(proper,XMLCh)\r
+\r
+/**\r
+ * Implements get/set methods and a private member for a string XML attribute,\r
+ * plus a getXMLID override.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ */\r
+#define IMPL_ID_ATTRIB(proper) \\r
+    IMPL_XMLOBJECT_ATTRIB(proper,XMLCh) \\r
+    const XMLCh* getXMLID() const { \\r
+        return m_##proper; \\r
+    }\r
+\r
+/**\r
+ * Implements get/set methods and a private member for a DateTime XML attribute.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ * @param fallback  epoch to return when attribute is NULL\r
+ */\r
+#define IMPL_DATETIME_ATTRIB(proper,fallback) \\r
+    protected: \\r
+        DateTime* m_##proper; \\r
+        time_t m_##proper##Epoch; \\r
+    public: \\r
+        const DateTime* get##proper() const { \\r
+            return m_##proper; \\r
+        } \\r
+        time_t get##proper##Epoch() const { \\r
+            return m_##proper ? m_##proper##Epoch : fallback; \\r
+        } \\r
+        void set##proper(const DateTime* proper) { \\r
+            m_##proper = prepareForAssignment(m_##proper,proper); \\r
+            if (m_##proper) \\r
+                m_##proper##Epoch=m_##proper->getEpoch(); \\r
+        } \\r
+        void set##proper(time_t proper) { \\r
+            m_##proper = prepareForAssignment(m_##proper,proper); \\r
+            m_##proper##Epoch = proper; \\r
+        } \\r
+        void set##proper(const XMLCh* proper) { \\r
+            m_##proper = prepareForAssignment(m_##proper,proper); \\r
+            if (m_##proper) \\r
+                m_##proper##Epoch=m_##proper->getEpoch(); \\r
+        }\r
+\r
+/**\r
+ * Implements get/set methods and a private member for an integer XML attribute.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ */\r
+#define IMPL_INTEGER_ATTRIB(proper) \\r
+    protected: \\r
+        XMLCh* m_##proper; \\r
+    public: \\r
+        pair<bool,int> get##proper() const { \\r
+            return make_pair((m_##proper!=NULL),(m_##proper!=NULL ? xercesc::XMLString::parseInt(m_##proper): 0)); \\r
+        } \\r
+        void set##proper(const XMLCh* proper) { \\r
+            m_##proper = prepareForAssignment(m_##proper,proper); \\r
+        } \\r
+        void set##proper(int proper) { \\r
+            char buf##proper[64]; \\r
+            sprintf(buf##proper,"%d",proper); \\r
+            auto_ptr_XMLCh wide##proper(buf##proper); \\r
+            set##proper(wide##proper.get()); \\r
+        }\r
+\r
+/**\r
+ * Implements get/set methods and a private member for a boolean XML attribute.\r
+ * \r
+ * @param proper    the proper name of the attribute\r
+ */\r
+#define IMPL_BOOLEAN_ATTRIB(proper) \\r
+    protected: \\r
+        xmlconstants::xmltooling_bool_t m_##proper; \\r
+    public: \\r
+        xmlconstants::xmltooling_bool_t get##proper() const { \\r
+            return m_##proper; \\r
+        } \\r
+        void proper(xmlconstants::xmltooling_bool_t value) { \\r
+            if (m_##proper != value) { \\r
+                releaseThisandParentDOM(); \\r
+                m_##proper = value; \\r
+            } \\r
+        }\r
+\r
+/**\r
+ * Declares abstract set method for a typed XML child object in a foreign namespace.\r
+ * The get method is omitted.\r
+ * \r
+ * @param proper    the proper name of the child type\r
+ * @param ns        the C++ namespace for the type\r
+ */\r
+#define DECL_INHERITED_TYPED_FOREIGN_CHILD(proper,ns) \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(Sets the proper child.) \\r
+        virtual void set##proper(ns::proper* child)=0\r
+\r
+/**\r
+ * Declares abstract get/set methods for a typed XML child object in a foreign namespace.\r
+ * \r
+ * @param proper    the proper name of the child type\r
+ * @param ns        the C++ namespace for the type\r
+ */\r
+#define DECL_TYPED_FOREIGN_CHILD(proper,ns) \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(Returns the proper child.) \\r
+        virtual ns::proper* get##proper() const=0; \\r
+        XMLTOOLING_DOXYGEN(Sets the proper child.) \\r
+        virtual void set##proper(ns::proper* child)=0\r
+\r
+/**\r
+ * Declares abstract set method for a typed XML child object.\r
+ * The get method is omitted.\r
+ * \r
+ * @param proper    the proper name of the child type\r
+ */\r
+#define DECL_INHERITED_TYPED_CHILD(proper) \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(Sets the proper child.) \\r
+        virtual void set##proper(proper* child)=0\r
+\r
+/**\r
+ * Declares abstract get/set methods for a typed XML child object.\r
+ * \r
+ * @param proper    the proper name of the child type\r
+ */\r
+#define DECL_TYPED_CHILD(proper) \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(Returns the proper child.) \\r
+        virtual proper* get##proper() const=0; \\r
+        XMLTOOLING_DOXYGEN(Sets the proper child.) \\r
+        virtual void set##proper(proper* child)=0\r
+\r
+/**\r
+ * Declares abstract get/set methods for a generic XML child object.\r
+ * \r
+ * @param proper    the proper name of the child\r
+ */\r
+#define DECL_XMLOBJECT_CHILD(proper) \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(Returns the proper child.) \\r
+        virtual xmltooling::XMLObject* get##proper() const=0; \\r
+        XMLTOOLING_DOXYGEN(Sets the proper child.) \\r
+        virtual void set##proper(xmltooling::XMLObject* child)=0\r
+\r
+\r
+/**\r
+ * Implements get/set methods and a private list iterator member for a typed XML child object.\r
+ * \r
+ * @param proper    the proper name of the child type\r
+ */\r
+#define IMPL_TYPED_CHILD(proper) \\r
+    protected: \\r
+        proper* m_##proper; \\r
+        std::list<xmltooling::XMLObject*>::iterator m_pos_##proper; \\r
+    public: \\r
+        proper* get##proper() const { \\r
+            return m_##proper; \\r
+        } \\r
+        void set##proper(proper* child) { \\r
+            prepareForAssignment(m_##proper,child); \\r
+            *m_pos_##proper = m_##proper = child; \\r
+        }\r
+\r
+/**\r
+ * Implements get/set methods and a private list iterator member for\r
+ * a typed XML child object in a foreign namespace\r
+ * \r
+ * @param proper    the proper name of the child type\r
+ * @param ns        the C++ namespace for the type\r
+ */\r
+#define IMPL_TYPED_FOREIGN_CHILD(proper,ns) \\r
+    protected: \\r
+        ns::proper* m_##proper; \\r
+        std::list<xmltooling::XMLObject*>::iterator m_pos_##proper; \\r
+    public: \\r
+        ns::proper* get##proper() const { \\r
+            return m_##proper; \\r
+        } \\r
+        void set##proper(ns::proper* child) { \\r
+            prepareForAssignment(m_##proper,child); \\r
+            *m_pos_##proper = m_##proper = child; \\r
+        }\r
+\r
+/**\r
+ * Implements get/set methods and a private list iterator member for a generic XML child object.\r
+ * \r
+ * @param proper    the proper name of the child\r
+ */\r
+#define IMPL_XMLOBJECT_CHILD(proper) \\r
+    protected: \\r
+        xmltooling::XMLObject* m_##proper; \\r
+        std::list<xmltooling::XMLObject*>::iterator m_pos_##proper; \\r
+    public: \\r
+        xmltooling::XMLObject* get##proper() const { \\r
+            return m_##proper; \\r
+        } \\r
+        void set##proper(xmltooling::XMLObject* child) { \\r
+            prepareForAssignment(m_##proper,child); \\r
+            *m_pos_##proper = m_##proper = child; \\r
+        }\r
+\r
+/**\r
+ * Declares abstract get/set methods for a typed XML child collection.\r
+ * \r
+ * @param proper    the proper name of the child type\r
+ */\r
+#define DECL_TYPED_CHILDREN(proper) \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(Returns modifiable proper collection.) \\r
+        virtual VectorOf(proper) get##proper##s()=0; \\r
+        XMLTOOLING_DOXYGEN(Returns reference to immutable proper collection.) \\r
+        virtual const std::vector<proper*>& get##proper##s() const=0\r
+\r
+/**\r
+ * Declares abstract get/set methods for a typed XML child collection in a foreign namespace.\r
+ * \r
+ * @param proper    the proper name of the child type\r
+ * @param ns        the C++ namespace for the type\r
+ */\r
+#define DECL_TYPED_FOREIGN_CHILDREN(proper,ns) \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(Returns modifiable proper collection.) \\r
+        virtual VectorOf(ns::proper) get##proper##s()=0; \\r
+        XMLTOOLING_DOXYGEN(Returns reference to immutable proper collection.) \\r
+        virtual const std::vector<ns::proper*>& get##proper##s() const=0\r
+\r
+/**\r
+ * Declares abstract get/set methods for a generic XML child collection.\r
+ * \r
+ * @param proper    the proper name of the child\r
+ */\r
+#define DECL_XMLOBJECT_CHILDREN(proper) \\r
+    public: \\r
+        XMLTOOLING_DOXYGEN(Returns modifiable proper collection.) \\r
+        virtual VectorOf(xmltooling::XMLObject) get##proper##s()=0; \\r
+        XMLTOOLING_DOXYGEN(Returns reference to immutable proper collection.) \\r
+        virtual const std::vector<xmltooling::XMLObject*>& get##proper##s() const=0\r
+\r
+/**\r
+ * Implements get method and a private vector member for a typed XML child collection.\r
+ * \r
+ * @param proper    the proper name of the child type\r
+ * @param fence     insertion fence for new objects of the child collection in backing list\r
+ */\r
+#define IMPL_TYPED_CHILDREN(proper,fence) \\r
+    protected: \\r
+        std::vector<proper*> m_##proper##s; \\r
+    public: \\r
+        VectorOf(proper) get##proper##s() { \\r
+            return VectorOf(proper)(this, m_##proper##s, &m_children, fence); \\r
+        } \\r
+        const std::vector<proper*>& get##proper##s() const { \\r
+            return m_##proper##s; \\r
+        } \r
+\r
+/**\r
+ * Implements get method and a private vector member for a typed XML child collection\r
+ * in a foreign namespace.\r
+ * \r
+ * @param proper    the proper name of the child type\r
+ * @param ns        the C++ namespace for the type\r
+ * @param fence     insertion fence for new objects of the child collection in backing list\r
+ */\r
+#define IMPL_TYPED_FOREIGN_CHILDREN(proper,ns,fence) \\r
+    protected: \\r
+        std::vector<ns::proper*> m_##proper##s; \\r
+    public: \\r
+        VectorOf(ns::proper) get##proper##s() { \\r
+            return VectorOf(ns::proper)(this, m_##proper##s, &m_children, fence); \\r
+        } \\r
+        const std::vector<ns::proper*>& get##proper##s() const { \\r
+            return m_##proper##s; \\r
+        } \r
+\r
+/**\r
+ * Implements get method and a private vector member for a generic XML child collection.\r
+ * \r
+ * @param proper    the proper name of the child\r
+ * @param fence     insertion fence for new objects of the child collection in backing list\r
+ */\r
+#define IMPL_XMLOBJECT_CHILDREN(proper,fence) \\r
+    protected: \\r
+        std::vector<xmltooling::XMLObject*> m_##proper##s; \\r
+    public: \\r
+        VectorOf(xmltooling::XMLObject) get##proper##s() { \\r
+            return VectorOf(xmltooling::XMLObject)(this, m_##proper##s, &m_children, fence); \\r
+        } \\r
+        const std::vector<xmltooling::XMLObject*>& get##proper##s() const { \\r
+            return m_##proper##s; \\r
+        } \r
+\r
+/**\r
+ * Implements marshalling for a string attribute\r
+ * \r
+ * @param proper        the proper name of the attribute\r
+ * @param ucase         the upcased name of the attribute\r
+ * @param namespaceURI  the XML namespace of the attribute\r
+ */\r
+#define MARSHALL_STRING_ATTRIB(proper,ucase,namespaceURI) \\r
+    if (m_##proper && *m_##proper) { \\r
+        domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, m_##proper); \\r
+    }\r
+\r
+/**\r
+ * Implements marshalling for a DateTime attribute\r
+ * \r
+ * @param proper        the proper name of the attribute\r
+ * @param ucase         the upcased name of the attribute\r
+ * @param namespaceURI  the XML namespace of the attribute\r
+ */\r
+#define MARSHALL_DATETIME_ATTRIB(proper,ucase,namespaceURI) \\r
+    if (m_##proper) { \\r
+        domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, m_##proper->getRawData()); \\r
+    }\r
+\r
+/**\r
+ * Implements marshalling for an integer attribute\r
+ * \r
+ * @param proper        the proper name of the attribute\r
+ * @param ucase         the upcased name of the attribute\r
+ * @param namespaceURI  the XML namespace of the attribute\r
+ */\r
+#define MARSHALL_INTEGER_ATTRIB(proper,ucase,namespaceURI) \\r
+    if (m_##proper && *m_##proper) { \\r
+        domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, m_##proper); \\r
+    }\r
+\r
+/**\r
+ * Implements marshalling for a boolean attribute\r
+ * \r
+ * @param proper        the proper name of the attribute\r
+ * @param ucase         the upcased name of the attribute\r
+ * @param namespaceURI  the XML namespace of the attribute\r
+ */\r
+#define MARSHALL_BOOLEAN_ATTRIB(proper,ucase,namespaceURI) \\r
+    switch (m_##proper) { \\r
+        case xmlconstants::XML_BOOL_TRUE: \\r
+            domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, xmlconstants::XML_TRUE); \\r
+            break; \\r
+        case xmlconstants::XML_BOOL_ONE: \\r
+            domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, xmlconstants::XML_ONE); \\r
+            break; \\r
+        case xmlconstants::XML_BOOL_FALSE: \\r
+            domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, xmlconstants::XML_FALSE); \\r
+            break; \\r
+        case xmlconstants::XML_BOOL_ZERO: \\r
+            domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, xmlconstants::XML_ZERO); \\r
+            break; \\r
+        case xmlconstants::XML_BOOL_NULL: \\r
+            break; \\r
+    }\r
+\r
+/**\r
+ * Implements marshalling for a QName attribute\r
+ * \r
+ * @param proper        the proper name of the attribute\r
+ * @param ucase         the upcased name of the attribute\r
+ * @param namespaceURI  the XML namespace of the attribute\r
+ */\r
+#define MARSHALL_QNAME_ATTRIB(proper,ucase,namespaceURI) \\r
+    if (m_##proper) { \\r
+        auto_ptr_XMLCh qstr(m_##proper->toString().c_str()); \\r
+        domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, qstr.get()); \\r
+    }\r
+\r
+/**\r
+ * Implements marshalling for an ID attribute\r
+ * \r
+ * @param proper        the proper name of the attribute\r
+ * @param ucase         the upcased name of the attribute\r
+ * @param namespaceURI  the XML namespace of the attribute\r
+ */\r
+#define MARSHALL_ID_ATTRIB(proper,ucase,namespaceURI) \\r
+    if (m_##proper && *m_##proper) { \\r
+        domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, m_##proper); \\r
+        domElement->setIdAttributeNS(namespaceURI, ucase##_ATTRIB_NAME); \\r
+    }\r
+\r
+/**\r
+ * Implements unmarshalling process branch for a string attribute\r
+ * \r
+ * @param proper        the proper name of the attribute\r
+ * @param ucase         the upcased name of the attribute\r
+ * @param namespaceURI  the XML namespace of the attribute\r
+ */\r
+#define PROC_STRING_ATTRIB(proper,ucase,namespaceURI) \\r
+    if (xmltooling::XMLHelper::isNodeNamed(attribute, namespaceURI, ucase##_ATTRIB_NAME)) { \\r
+        set##proper(attribute->getValue()); \\r
+        return; \\r
+    }\r
+\r
+/**\r
+ * Implements unmarshalling process branch for an ID attribute\r
+ * \r
+ * @param proper        the proper name of the attribute\r
+ * @param ucase         the upcased name of the attribute\r
+ * @param namespaceURI  the XML namespace of the attribute\r
+ */\r
+#define PROC_ID_ATTRIB(proper,ucase,namespaceURI) \\r
+    if (xmltooling::XMLHelper::isNodeNamed(attribute, namespaceURI, ucase##_ATTRIB_NAME)) { \\r
+        set##proper(attribute->getValue()); \\r
+        attribute->getOwnerElement()->setIdAttributeNode(attribute); \\r
+        return; \\r
+    }\r
+\r
+/**\r
+ * Implements unmarshalling process branch for a DateTime attribute\r
+ * \r
+ * @param proper        the proper name of the attribute\r
+ * @param ucase         the upcased name of the attribute\r
+ * @param namespaceURI  the XML namespace of the attribute\r
+ */\r
+#define PROC_DATETIME_ATTRIB(proper,ucase,namespaceURI) \\r
+    PROC_STRING_ATTRIB(proper,ucase,namespaceURI)\r
+\r
+/**\r
+ * Implements unmarshalling process branch for a DateTime attribute\r
+ * \r
+ * @param proper        the proper name of the attribute\r
+ * @param ucase         the upcased name of the attribute\r
+ * @param namespaceURI  the XML namespace of the attribute\r
+ */\r
+#define PROC_QNAME_ATTRIB(proper,ucase,namespaceURI) \\r
+    if (xmltooling::XMLHelper::isNodeNamed(attribute, namespaceURI, ucase##_ATTRIB_NAME)) { \\r
+        set##proper(XMLHelper::getAttributeValueAsQName(attribute)); \\r
+        return; \\r
+    }\r
+\r
+/**\r
+ * Implements unmarshalling process branch for an integer attribute\r
+ * \r
+ * @param proper        the proper name of the attribute\r
+ * @param ucase         the upcased name of the attribute\r
+ * @param namespaceURI  the XML namespace of the attribute\r
+ */\r
+#define PROC_INTEGER_ATTRIB(proper,ucase,namespaceURI) \\r
+    PROC_STRING_ATTRIB(proper,ucase,namespaceURI)\r
+\r
+/**\r
+ * Implements unmarshalling process branch for a boolean attribute\r
+ * \r
+ * @param proper        the proper name of the attribute\r
+ * @param ucase         the upcased name of the attribute\r
+ * @param namespaceURI  the XML namespace of the attribute\r
+ */\r
+#define PROC_BOOLEAN_ATTRIB(proper,ucase,namespaceURI) \\r
+    PROC_STRING_ATTRIB(proper,ucase,namespaceURI)\r
+\r
+/**\r
+ * Implements unmarshalling process branch for typed child collection element\r
+ * \r
+ * @param proper        the proper name of the child type\r
+ * @param namespaceURI  the XML namespace of the child element\r
+ * @param force         bypass use of hint and just cast down to check child\r
+ */\r
+#define PROC_TYPED_CHILDREN(proper,namespaceURI,force) \\r
+    if (force || xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,proper::LOCAL_NAME)) { \\r
+        proper* typesafe=dynamic_cast<proper*>(childXMLObject); \\r
+        if (typesafe) { \\r
+            get##proper##s().push_back(typesafe); \\r
+            return; \\r
+        } \\r
+    }\r
+\r
+/**\r
+ * Implements unmarshalling process branch for typed child collection element\r
+ * in a foreign namespace.\r
+ * \r
+ * @param proper        the proper name of the child type\r
+ * @param ns            the C++ namespace for the type\r
+ * @param namespaceURI  the XML namespace of the child element\r
+ * @param force         bypass use of hint and just cast down to check child\r
+ */\r
+#define PROC_TYPED_FOREIGN_CHILDREN(proper,ns,namespaceURI,force) \\r
+    if (force || xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,ns::proper::LOCAL_NAME)) { \\r
+        ns::proper* typesafe=dynamic_cast<ns::proper*>(childXMLObject); \\r
+        if (typesafe) { \\r
+            get##proper##s().push_back(typesafe); \\r
+            return; \\r
+        } \\r
+    }\r
+\r
+/**\r
+ * Implements unmarshalling process branch for typed child singleton element\r
+ * \r
+ * @param proper        the proper name of the child type\r
+ * @param namespaceURI  the XML namespace of the child element\r
+ * @param force         bypass use of hint and just cast down to check child\r
+ */\r
+#define PROC_TYPED_CHILD(proper,namespaceURI,force) \\r
+    if (force || xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,proper::LOCAL_NAME)) { \\r
+        proper* typesafe=dynamic_cast<proper*>(childXMLObject); \\r
+        if (typesafe && !m_##proper) { \\r
+            typesafe->setParent(this); \\r
+            *m_pos_##proper = m_##proper = typesafe; \\r
+            return; \\r
+        } \\r
+    }\r
+\r
+/**\r
+ * Implements unmarshalling process branch for typed child singleton element\r
+ * in a foreign namespace.\r
+ * \r
+ * @param proper        the proper name of the child type\r
+ * @param ns            the C++ namespace for the type\r
+ * @param namespaceURI  the XML namespace of the child element\r
+ * @param force         bypass use of hint and just cast down to check child\r
+ */\r
+#define PROC_TYPED_FOREIGN_CHILD(proper,ns,namespaceURI,force) \\r
+    if (force || xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,ns::proper::LOCAL_NAME)) { \\r
+        ns::proper* typesafe=dynamic_cast<ns::proper*>(childXMLObject); \\r
+        if (typesafe && !m_##proper) { \\r
+            typesafe->setParent(this); \\r
+            *m_pos_##proper = m_##proper = typesafe; \\r
+            return; \\r
+        } \\r
+    }\r
+\r
+/**\r
+ * Implements unmarshalling process branch for a generic child singleton element\r
+ * \r
+ * @param proper        the proper name of the child type\r
+ * @param namespaceURI  the XML namespace of the child element\r
+ */\r
+#define PROC_XMLOBJECT_CHILD(proper,namespaceURI) \\r
+    if (xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,proper::LOCAL_NAME)) { \\r
+        if (!m_##proper) { \\r
+            childXMLObject->setParent(this); \\r
+            *m_pos_##proper = m_##proper = childXMLObject; \\r
+            return; \\r
+        } \\r
+    }\r
+\r
+/**\r
+ * Declares aliased get/set methods for named XML element simple content.\r
+ * \r
+ * @param proper    the proper name to label the element's content\r
+ */\r
+#define DECL_SIMPLE_CONTENT(proper) \\r
+    XMLTOOLING_DOXYGEN(Returns proper.) \\r
+    const XMLCh* get##proper() const { \\r
+        return getTextContent(); \\r
+    } \\r
+    XMLTOOLING_DOXYGEN(Sets or clears proper.) \\r
+    void set##proper(const XMLCh* proper) { \\r
+        setTextContent(proper); \\r
+    }\r
+\r
+/**\r
+ * Declares aliased get/set methods for named integer XML element content.\r
+ * \r
+ * @param proper    the proper name to label the element's content\r
+ */\r
+#define DECL_INTEGER_CONTENT(proper) \\r
+    XMLTOOLING_DOXYGEN(Returns proper in integer form after a NULL indicator.) \\r
+    std::pair<bool,int> get##proper() const { \\r
+        return std::make_pair((getTextContent()!=NULL), (getTextContent()!=NULL ? xercesc::XMLString::parseInt(getTextContent()) : 0)); \\r
+    } \\r
+    XMLTOOLING_DOXYGEN(Sets proper.) \\r
+    void set##proper(int proper) { \\r
+        char buf[64]; \\r
+        sprintf(buf,"%d",proper); \\r
+        xmltooling::auto_ptr_XMLCh widebuf(buf); \\r
+        setTextContent(widebuf.get()); \\r
+    } \\r
+    XMLTOOLING_DOXYGEN(Sets or clears proper.) \\r
+    void set##proper(const XMLCh* proper) { \\r
+        setTextContent(proper); \\r
+    }\r
+\r
+/**\r
+ * Implements cloning methods for an XMLObject specialization implementation class.\r
+ * \r
+ * @param cname    the name of the XMLObject specialization\r
+ */\r
+#define IMPL_XMLOBJECT_CLONE(cname) \\r
+    cname* clone##cname() const { \\r
+        return dynamic_cast<cname*>(clone()); \\r
+    } \\r
+    xmltooling::XMLObject* clone() const { \\r
+        std::auto_ptr<xmltooling::XMLObject> domClone(xmltooling::AbstractDOMCachingXMLObject::clone()); \\r
+        cname##Impl* ret=dynamic_cast<cname##Impl*>(domClone.get()); \\r
+        if (ret) { \\r
+            domClone.release(); \\r
+            return ret; \\r
+        } \\r
+        return new cname##Impl(*this); \\r
+    }\r
+\r
+/**\r
+ * Declares an XMLObject specialization with a simple content model and type,\r
+ * handling it as string data.\r
+ * \r
+ * @param linkage   linkage specifier for the class\r
+ * @param cname     the name of the XMLObject specialization\r
+ * @param proper    the proper name to label the element's content\r
+ * @param desc      documentation for class\r
+ */\r
+#define DECL_XMLOBJECT_SIMPLE(linkage,cname,proper,desc) \\r
+    BEGIN_XMLOBJECT(linkage,cname,xmltooling::XMLObject,desc); \\r
+        DECL_SIMPLE_CONTENT(proper); \\r
+    END_XMLOBJECT\r
+\r
+/**\r
+ * Declares and defines an implementation class for an XMLObject with\r
+ * a simple content model and type, handling it as string data.\r
+ * \r
+ * @param linkage   linkage specifier for the class\r
+ * @param cname     the name of the XMLObject specialization\r
+ */\r
+#define DECL_XMLOBJECTIMPL_SIMPLE(linkage,cname) \\r
+    class linkage cname##Impl \\r
+        : public virtual cname, \\r
+            public xmltooling::AbstractSimpleElement, \\r
+            public xmltooling::AbstractDOMCachingXMLObject, \\r
+            public xmltooling::AbstractXMLObjectMarshaller, \\r
+            public xmltooling::AbstractXMLObjectUnmarshaller \\r
+    { \\r
+    public: \\r
+        virtual ~cname##Impl() {} \\r
+        cname##Impl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) \\r
+            : xmltooling::AbstractXMLObject(nsURI, localName, prefix, schemaType) { \\r
+        } \\r
+        cname##Impl(const cname##Impl& src) \\r
+            : xmltooling::AbstractXMLObject(src), \\r
+                xmltooling::AbstractSimpleElement(src), \\r
+                xmltooling::AbstractDOMCachingXMLObject(src) {} \\r
+        IMPL_XMLOBJECT_CLONE(cname) \\r
+    }\r
+\r
+#ifdef HAVE_COVARIANT_RETURNS\r
+\r
+/**\r
+ * Begins the declaration of an XMLObjectBuilder specialization.\r
+ * Basic boilerplate includes an empty virtual destructor, and\r
+ * a default builder that defaults the element name.\r
+ * \r
+ * @param linkage           linkage specifier for the class\r
+ * @param cname             the name of the XMLObject specialization\r
+ * @param namespaceURI      the XML namespace of the default associated element\r
+ * @param namespacePrefix   the XML namespace prefix of the default associated element\r
+ */\r
+#define BEGIN_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix) \\r
+    XMLTOOLING_DOXYGEN(Builder for cname objects.) \\r
+    class linkage cname##Builder : public xmltooling::ConcreteXMLObjectBuilder { \\r
+    public: \\r
+        virtual ~cname##Builder() {} \\r
+        XMLTOOLING_DOXYGEN(Default builder.) \\r
+        virtual cname* buildObject() const { \\r
+            return buildObject(namespaceURI,cname::LOCAL_NAME,namespacePrefix); \\r
+        } \\r
+        XMLTOOLING_DOXYGEN(Builder that allows element/type override.) \\r
+        virtual cname* buildObject( \\r
+            const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const xmltooling::QName* schemaType=NULL \\r
+            ) const\r
+\r
+/**\r
+ * Ends the declaration of an XMLObjectBuilder specialization.\r
+ */\r
+#define END_XMLOBJECTBUILDER }\r
+\r
+/**\r
+ * Declares a generic XMLObjectBuilder specialization.\r
+ * \r
+ * @param linkage           linkage specifier for the class\r
+ * @param cname             the name of the XMLObject specialization\r
+ * @param namespaceURI      the XML namespace of the default associated element\r
+ * @param namespacePrefix   the XML namespace prefix of the default associated element\r
+ */\r
+ #define DECL_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix) \\r
+    BEGIN_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix); \\r
+    XMLTOOLING_DOXYGEN(Singleton builder.) \\r
+    static cname* build##cname() { \\r
+        const cname##Builder* b = dynamic_cast<const cname##Builder*>( \\r
+            XMLObjectBuilder::getBuilder(xmltooling::QName(namespaceURI,cname::LOCAL_NAME)) \\r
+            ); \\r
+        if (b) \\r
+            return b->buildObject(); \\r
+        throw xmltooling::XMLObjectException("Unable to obtain typed builder for "#cname"."); \\r
+    } \\r
+    END_XMLOBJECTBUILDER\r
+\r
+/**\r
+ * Implements the standard XMLObjectBuilder specialization function. \r
+ * \r
+ * @param cname the name of the XMLObject specialization\r
+ */\r
+#define IMPL_XMLOBJECTBUILDER(cname) \\r
+    cname* cname##Builder::buildObject( \\r
+        const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType \\r
+        ) const \\r
+    { \\r
+        return new cname##Impl(nsURI,localName,prefix,schemaType); \\r
+    }\r
+\r
+#else   /* !HAVE_COVARIANT_RETURNS */\r
+\r
+/**\r
+ * Begins the declaration of an XMLObjectBuilder specialization.\r
+ * Basic boilerplate includes an empty virtual destructor, and\r
+ * a default builder that defaults the element name.\r
+ * \r
+ * @param linkage           linkage specifier for the class\r
+ * @param cname             the name of the XMLObject specialization\r
+ * @param namespaceURI      the XML namespace of the default associated element\r
+ * @param namespacePrefix   the XML namespace prefix of the default associated element\r
+ */\r
+#define BEGIN_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix) \\r
+    XMLTOOLING_DOXYGEN(Builder for cname objects.) \\r
+    class linkage cname##Builder : public xmltooling::ConcreteXMLObjectBuilder { \\r
+    public: \\r
+        virtual ~cname##Builder() {} \\r
+        XMLTOOLING_DOXYGEN(Default builder.) \\r
+        virtual xmltooling::XMLObject* buildObject() const { \\r
+            return buildObject(namespaceURI,cname::LOCAL_NAME,namespacePrefix); \\r
+        } \\r
+        XMLTOOLING_DOXYGEN(Builder that allows element/type override.) \\r
+        virtual xmltooling::XMLObject* buildObject( \\r
+            const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const xmltooling::QName* schemaType=NULL \\r
+            ) const\r
+\r
+/**\r
+ * Ends the declaration of an XMLObjectBuilder specialization.\r
+ */\r
+#define END_XMLOBJECTBUILDER }\r
+\r
+/**\r
+ * Declares a generic XMLObjectBuilder specialization.\r
+ * \r
+ * @param linkage           linkage specifier for the class\r
+ * @param cname             the name of the XMLObject specialization\r
+ * @param namespaceURI      the XML namespace of the default associated element\r
+ * @param namespacePrefix   the XML namespace prefix of the default associated element\r
+ */\r
+ #define DECL_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix) \\r
+    BEGIN_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix); \\r
+    XMLTOOLING_DOXYGEN(Singleton builder.) \\r
+    static cname* build##cname() { \\r
+        const cname##Builder* b = dynamic_cast<const cname##Builder*>( \\r
+            XMLObjectBuilder::getBuilder(xmltooling::QName(namespaceURI,cname::LOCAL_NAME)) \\r
+            ); \\r
+        if (b) \\r
+            return dynamic_cast<cname*>(b->buildObject()); \\r
+        throw xmltooling::XMLObjectException("Unable to obtain typed builder for "#cname"."); \\r
+    } \\r
+    END_XMLOBJECTBUILDER\r
+\r
+/**\r
+ * Implements the standard XMLObjectBuilder specialization function. \r
+ * \r
+ * @param cname the name of the XMLObject specialization\r
+ */\r
+#define IMPL_XMLOBJECTBUILDER(cname) \\r
+    xmltooling::XMLObject* cname##Builder::buildObject( \\r
+        const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType \\r
+        ) const \\r
+    { \\r
+        return new cname##Impl(nsURI,localName,prefix,schemaType); \\r
+    }\r
+\r
+#endif  /* HAVE_COVARIANT_RETURNS */\r
+\r
+/**\r
+ * Begins the declaration of a Schema Validator specialization.\r
+ * \r
+ * @param linkage           linkage specifier for the class\r
+ * @param cname the base name of the Validator specialization\r
+ */\r
+ #define BEGIN_XMLOBJECTVALIDATOR(linkage,cname) \\r
+    class linkage cname##SchemaValidator : public xmltooling::Validator \\r
+    { \\r
+    public: \\r
+        virtual ~cname##SchemaValidator() {} \\r
+        virtual void validate(const xmltooling::XMLObject* xmlObject) const { \\r
+            const cname* ptr=dynamic_cast<const cname*>(xmlObject); \\r
+            if (!ptr) \\r
+                throw xmltooling::ValidationException(#cname"SchemaValidator: unsupported object type ($1).",xmltooling::params(1,typeid(xmlObject).name())); \\r
+            if (ptr->nil() && (ptr->hasChildren() || ptr->getTextContent())) \\r
+               throw xmltooling::ValidationException("Object has nil property but with children or content.")\r
+\r
+/**\r
+ * Begins the declaration of a Schema Validator specialization subclass.\r
+ * \r
+ * @param linkage   linkage specifier for the class\r
+ * @param cname     the base name of the Validator specialization\r
+ * @param base      base class for the validator\r
+ */\r
+ #define BEGIN_XMLOBJECTVALIDATOR_SUB(linkage,cname,base) \\r
+    class linkage cname##SchemaValidator : public base##SchemaValidator \\r
+    { \\r
+    public: \\r
+        virtual ~cname##SchemaValidator() {} \\r
+        virtual void validate(const xmltooling::XMLObject* xmlObject) const { \\r
+            const cname* ptr=dynamic_cast<const cname*>(xmlObject); \\r
+            if (!ptr) \\r
+                throw xmltooling::ValidationException(#cname"SchemaValidator: unsupported object type ($1).",xmltooling::params(1,typeid(xmlObject).name()));\r
+\r
+/**\r
+ * Ends the declaration of a Validator specialization.\r
+ */\r
+#define END_XMLOBJECTVALIDATOR } }\r
+\r
+/**\r
+ * Validator code that checks the object type.\r
+ * \r
+ * @param cname     the name of the XMLObject specialization\r
+ */\r
+#define XMLOBJECTVALIDATOR_CHECKTYPE(cname) \\r
+    const cname* ptr=dynamic_cast<const cname*>(xmlObject); \\r
+    if (!ptr) \\r
+        throw xmltooling::ValidationException(#cname"SchemaValidator: unsupported object type ($1).",xmltooling::params(1,typeid(xmlObject).name()))\r
+\r
+/**\r
+ * Validator code that checks for a required attribute, content, or singleton.\r
+ * \r
+ * @param cname     the name of the XMLObject specialization\r
+ * @param proper    the proper name of the attribute, content, or singleton member \r
+ */\r
+#define XMLOBJECTVALIDATOR_REQUIRE(cname,proper) \\r
+    if (!ptr->get##proper()) \\r
+        throw xmltooling::ValidationException(#cname" must have "#proper".")\r
+\r
+/**\r
+ * Validator code that checks for a required integer attribute\r
+ * \r
+ * @param cname     the name of the XMLObject specialization\r
+ * @param proper    the proper name of the attribute, content, or singleton member \r
+ */\r
+#define XMLOBJECTVALIDATOR_REQUIRE_INTEGER(cname,proper) \\r
+    if (!ptr->get##proper().first) \\r
+        throw xmltooling::ValidationException(#cname" must have "#proper".")\r
+\r
+/**\r
+ * Validator code that checks for one of a pair of\r
+ * required attributes, content, or singletons.\r
+ * \r
+ * @param cname     the name of the XMLObject specialization\r
+ * @param proper1   the proper name of the first attribute, content, or singleton member \r
+ * @param proper2   the proper name of the second attribute, content, or singleton member \r
+ */\r
+#define XMLOBJECTVALIDATOR_ONEOF(cname,proper1,proper2) \\r
+    if (!ptr->get##proper1() && !ptr->get##proper2()) \\r
+        throw xmltooling::ValidationException(#cname" must have "#proper1" or "#proper2".")\r
+\r
+/**\r
+ * Validator code that checks for one of a pair of\r
+ * required attributes, content, or singletons, but disallows both.\r
+ * \r
+ * @param cname     the name of the XMLObject specialization\r
+ * @param proper1   the proper name of the first attribute, content, or singleton member \r
+ * @param proper2   the proper name of the second attribute, content, or singleton member \r
+ */\r
+#define XMLOBJECTVALIDATOR_ONLYONEOF(cname,proper1,proper2) \\r
+    if ((!ptr->get##proper1() && !ptr->get##proper2()) || (ptr->get##proper1() && ptr->get##proper2())) \\r
+        throw xmltooling::ValidationException(#cname" must have "#proper1" or "#proper2" but not both.")\r
+\r
+/**\r
+ * Validator code that checks for one of a set of three\r
+ * required attributes, content, or singletons.\r
+ * \r
+ * @param cname     the name of the XMLObject specialization\r
+ * @param proper1   the proper name of the first attribute, content, or singleton member\r
+ * @param proper2   the proper name of the second attribute, content, or singleton member\r
+ * @param proper3   the proper name of the third attribute, content, or singleton member\r
+ */\r
+#define XMLOBJECTVALIDATOR_ONEOF3(cname,proper1,proper2,proper3) \\r
+    if (!ptr->get##proper1() && !ptr->get##proper2() && !ptr->get##proper3()) \\r
+        throw xmltooling::ValidationException(#cname" must have "#proper1", "#proper2", or "#proper3".")\r
+\r
+/**\r
+ * Validator code that checks for one of a set of three\r
+ * required attributes, content, or singletons but disallows more than one.\r
+ * \r
+ * @param cname     the name of the XMLObject specialization\r
+ * @param proper1   the proper name of the first attribute, content, or singleton member\r
+ * @param proper2   the proper name of the second attribute, content, or singleton member\r
+ * @param proper3   the proper name of the third attribute, content, or singleton member\r
+ */\r
+#define XMLOBJECTVALIDATOR_ONLYONEOF3(cname,proper1,proper2,proper3) \\r
+    int c##proper1##proper2##proper3=0; \\r
+    if (ptr->get##proper1()!=NULL) \\r
+        c##proper1##proper2##proper3++; \\r
+    if (ptr->get##proper2()!=NULL) \\r
+        c##proper1##proper2##proper3++; \\r
+    if (ptr->get##proper3()!=NULL) \\r
+        c##proper1##proper2##proper3++; \\r
+    if (c##proper1##proper2##proper3 != 1) \\r
+        throw xmltooling::ValidationException(#cname" must have only one of "#proper1", "#proper2", or "#proper3".")\r
+\r
+/**\r
+ * Validator code that checks a co-constraint (if one present, the other must be)\r
+ * between a pair of attributes, content, or singletons.\r
+ * \r
+ * @param cname     the name of the XMLObject specialization\r
+ * @param proper1   the proper name of the first attribute, content, or singleton member \r
+ * @param proper2   the proper name of the second attribute, content, or singleton member \r
+ */\r
+#define XMLOBJECTVALIDATOR_NONEORBOTH(cname,proper1,proper2) \\r
+    if ((ptr->get##proper1() && !ptr->get##proper2()) || (!ptr->get##proper1() && ptr->get##proper2())) \\r
+        throw xmltooling::ValidationException(#cname" cannot have "#proper1" without "#proper2".")\r
+\r
+/**\r
+ * Validator code that checks for a non-empty collection.\r
+ * \r
+ * @param cname     the name of the XMLObject specialization\r
+ * @param proper    the proper name of the collection item \r
+ */\r
+#define XMLOBJECTVALIDATOR_NONEMPTY(cname,proper) \\r
+    if (ptr->get##proper##s().empty()) \\r
+        throw xmltooling::ValidationException(#cname" must have at least one "#proper".")\r
+\r
+/**\r
+ * Declares/defines a Validator specialization that checks object type and\r
+ * a non-empty simple content model.\r
+ * \r
+ * @param linkage   linkage specifier for the class\r
+ * @param cname     the name of the XMLObject specialization\r
+ */\r
+#define XMLOBJECTVALIDATOR_SIMPLE(linkage,cname) \\r
+    BEGIN_XMLOBJECTVALIDATOR(linkage,cname); \\r
+        XMLOBJECTVALIDATOR_REQUIRE(cname,TextContent); \\r
+    END_XMLOBJECTVALIDATOR\r
+\r
+#include <utility>\r
+\r
+/**\r
+ * @namespace xmltooling\r
+ * Public namespace of XML Tooling library\r
+ */\r
+namespace xmltooling {\r
+\r
+    /**\r
+     * Template function for cloning a sequence of XMLObjects.\r
+     * Invokes the clone() member on each element of the input sequence and adds the copy to\r
+     * the output sequence. Order is preserved.\r
+     * \r
+     * @param in    input sequence to clone\r
+     * @param out   output sequence to copy cloned pointers into\r
+     */\r
+    template<class InputSequence,class OutputSequence> void clone(const InputSequence& in, OutputSequence& out) {\r
+        for (typename InputSequence::const_iterator i=in.begin(); i!=in.end(); i++) {\r
+            if (*i)\r
+                out.push_back((*i)->clone());\r
+            else\r
+                out.push_back(*i);\r
+        }\r
+    }\r
+\r
+    /**\r
+     * Functor for cleaning up heap objects in containers.\r
+     */\r
+    template<class T> struct cleanup\r
+    {\r
+        /**\r
+         * Function operator to delete an object.\r
+         * \r
+         * @param ptr   object to delete\r
+         */\r
+        void operator()(T* ptr) {delete ptr;}\r
+        \r
+        /**\r
+         * Function operator to delete an object stored as const.\r
+         * \r
+         * @param ptr   object to delete after casting away const\r
+         */\r
+        void operator()(const T* ptr) {delete const_cast<T*>(ptr);}\r
+    };\r
+\r
+    /**\r
+     * Functor for cleaning up heap objects in key/value containers.\r
+     */\r
+    template<class A,class B> struct cleanup_pair\r
+    {\r
+        /**\r
+         * Function operator to delete an object.\r
+         * \r
+         * @param p   a pair in which the second component is the object to delete\r
+         */\r
+        void operator()(const std::pair<const A,B*>& p) {delete p.second;}\r
+    };\r
+\r
+    /**\r
+     * Functor for cleaning up const heap objects in key/value containers.\r
+     */\r
+    template<class A,class B> struct cleanup_const_pair\r
+    {\r
+        /**\r
+         * Function operator to delete an object stored as const\r
+         * \r
+         * @param p   a pair in which the second component is the const object to delete\r
+         */\r
+        void operator()(const std::pair<const A,const B*>& p) {delete const_cast<B*>(p.second);}\r
+    };\r
+};\r
+\r
+#endif /* __xmltooling_base_h__ */\r

diff --git a/xmltooling/exceptions.cpp b/xmltooling/exceptions.cpp
index 4b15451..1d0e883 100644 (file)
--- a/xmltooling/exceptions.cpp
+++ b/xmltooling/exceptions.cpp
@@ -1,314 +1,315 @@
-/*
- *  Copyright 2001-2007 Internet2
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * exceptions.cpp
- * 
- * Exception classes
- */
- 
-#include "internal.h"
-#include "exceptions.h"
-#include "XMLToolingConfig.h"
-#include "util/URLEncoder.h"
-#include "util/XMLConstants.h"
-#include "util/XMLHelper.h"
-
-#include <stdarg.h>
-#include <sstream>
-#include <xercesc/util/XMLUniDefs.hpp>
-
-using namespace xmltooling;
-using namespace std;
-using xmlconstants::XMLTOOLING_NS;
-
-params::params(int count,...)
-{
-    va_list args;
-    va_start(args,count);
-    while (count--)
-        v.push_back(va_arg(args,char*));
-    va_end(args);
-}
-
-namedparams::namedparams(int count,...)
-{
-    count*=2;
-    va_list args;
-    va_start(args,count);
-    while (count--)
-        v.push_back(va_arg(args,char*));
-    va_end(args);
-}
-
-XMLToolingException::ExceptionFactoryMap XMLToolingException::m_factoryMap;
-
-XMLToolingException* XMLToolingException::getInstance(const char* exceptionClass)
-{
-    if (exceptionClass) {
-        ExceptionFactoryMap::const_iterator i=m_factoryMap.find(exceptionClass);
-        if (i!=m_factoryMap.end())
-            return (i->second)();
-    }
-    return new XMLToolingException();
-}
-
-XMLToolingException::XMLToolingException(const char* msg, const params& p)
-{
-    if (msg)
-        m_msg=msg;
-    addProperties(p);
-}
-
-XMLToolingException::XMLToolingException(const char* msg, const namedparams& p)
-{
-    if (msg)
-        m_msg=msg;
-    addProperties(p);
-}
-
-XMLToolingException::XMLToolingException(const std::string& msg, const params& p) : m_msg(msg)
-{
-    addProperties(p);
-}
-
-XMLToolingException::XMLToolingException(const std::string& msg, const namedparams& p) : m_msg(msg)
-{
-    addProperties(p);
-}
-
-void XMLToolingException::setMessage(const char* msg)
-{
-    if (msg)
-        m_msg=msg;
-    else
-        m_msg.erase();
-    m_processedmsg.erase();
-}
-
-inline const char* get_digit_character()
-{
-    static const char  s_characters[19] = 
-    {
-            '9'
-        ,   '8'
-        ,   '7'
-        ,   '6'
-        ,   '5'
-        ,   '4'
-        ,   '3'
-        ,   '2'
-        ,   '1'
-        ,   '0'
-        ,   '1'
-        ,   '2'
-        ,   '3'
-        ,   '4'
-        ,   '5'
-        ,   '6'
-        ,   '7'
-        ,   '8'
-        ,   '9'
-    };
-    static const char  *s_mid  =   s_characters + 9;
-
-    return s_mid;
-}
-
-inline const char* unsigned_integer_to_string(char* buf, size_t cchBuf, int i)
-{
-    char* psz=buf + cchBuf - 1;     // Set psz to last char
-    *psz = 0;                       // Set terminating null
-
-    do {
-        unsigned int lsd = i % 10;  // Get least significant
-                                    // digit
-
-        i /= 10;                    // Prepare for next most
-                                    // significant digit
-
-        --psz;                      // Move back
-
-        *psz = get_digit_character()[lsd]; // Place the digit
-
-    } while(i!=0 && psz>buf);
-
-    return psz;
-}
-
-void XMLToolingException::addProperties(const params& p)
-{
-    m_processedmsg.erase();
-    int i=m_params.size()+1;
-    char buf[20];
-    const vector<const char*>& v=p.get();
-    for (vector<const char*>::const_iterator ci=v.begin(); ci!=v.end(); ci++) {
-        m_params[unsigned_integer_to_string(buf,sizeof(buf),i++)] = *ci;
-    }
-}
-        
-void XMLToolingException::addProperties(const namedparams& p)
-{
-    m_processedmsg.erase();
-    const vector<const char*>& v=p.get();
-    for (vector<const char*>::const_iterator ci=v.begin(); ci!=v.end(); ci++) {
-        m_params.erase(*ci);
-        m_params[*ci] = *(ci+1);
-        ci++;   // advance past name to value, then loop will advance it again
-    }
-}
-
-const char* XMLToolingException::getProperty(unsigned int index) const
-{
-    char buf[20];
-    map<string,string>::const_iterator i=m_params.find(unsigned_integer_to_string(buf,sizeof(buf),index));
-    return (i==m_params.end()) ? NULL : i->second.c_str();
-}
-
-const char* XMLToolingException::getProperty(const char* name) const
-{
-    map<string,string>::const_iterator i=m_params.find(name);
-    return (i==m_params.end()) ? NULL : i->second.c_str();
-}
-
-const char* XMLToolingException::getMessage() const
-{
-    if (!m_processedmsg.empty())
-        return m_processedmsg.c_str();
-    else if (m_params.empty())
-        return m_msg.c_str();
-
-    static const char* legal="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890_";
-
-    // Replace any parameters in the message.
-    string::size_type i=0,start=0;
-    while (start!=string::npos && start<m_msg.length() && (i=m_msg.find("$",start))!=string::npos) {
-        if (i>start)
-            m_processedmsg += m_msg.substr(start,i-start);  // append everything in between
-        start=i+1;                                  // move start to the beginning of the token name
-        i=m_msg.find_first_not_of(legal,start);     // find token delimiter
-        if (i==start) {                             // append a non legal character
-           m_processedmsg+=m_msg[start++];
-           continue;
-        }
-        
-        // search for token in map
-        map<string,string>::const_iterator param=m_params.find(m_msg.substr(start,(i==string::npos) ? i : i-start));
-        if (param!=m_params.end()) {
-            m_processedmsg+=param->second;
-            start=i;
-        }
-    }
-    if (start!=string::npos && start<m_msg.length())
-        m_processedmsg += m_msg.substr(start,i);    // append rest of string
-    return m_processedmsg.c_str();
-}
-
-void xml_encode(string& s, const char* pre, const char* start, const char* post)
-{
-    s += pre;
-    size_t pos;
-    while (start && *start) {
-        pos = strcspn(start, "\"<>&");
-        if (pos > 0) {
-            s.append(start, pos);
-            start += pos;
-        }
-        else {
-            switch (*start) {
-                case '\'':  s += "&apos;";     break;
-                case '<':   s += "&lt;";       break;
-                case '>':   s += "&gt;";       break;
-                case '&':   s += "&amp;";      break;
-                default:    s += *start;
-            }
-            start++;
-        }
-    }
-    s += post;
-}
-
-string XMLToolingException::toString() const
-{
-    string xml=string("<exception xmlns='http://www.opensaml.org/xmltooling' type='") + getClassName() + "'>";
-    const char* msg=getMessage();
-    if (msg)
-        xml_encode(xml, "<message>", msg, "</message>");
-    for (map<string,string>::const_iterator i=m_params.begin(); i!=m_params.end(); i++) {
-        xml_encode(xml, "<param name='", i->first.c_str(), "'");
-        xml_encode(xml, ">", i->second.c_str(), "</param>");
-    }
-    xml+="</exception>";
-    return xml;
-}
-
-string XMLToolingException::toQueryString() const
-{
-    string q;
-    const URLEncoder* enc = XMLToolingConfig::getConfig().getURLEncoder();
-    for (map<string,string>::const_iterator i=m_params.begin(); i!=m_params.end(); i++) {
-        if (!q.empty())
-            q += '&';
-        q = q + i->first + '=' + enc->encode(i->second.c_str());
-    }
-    return q;
-}
-
-XMLToolingException* XMLToolingException::fromStream(std::istream& in)
-{
-    static const XMLCh exception[] =    UNICODE_LITERAL_9(e,x,c,e,p,t,i,o,n);
-    static const XMLCh message[] =      UNICODE_LITERAL_7(m,e,s,s,a,g,e);
-    static const XMLCh name[] =         UNICODE_LITERAL_4(n,a,m,e);
-    static const XMLCh param[] =        UNICODE_LITERAL_5(p,a,r,a,m);
-    static const XMLCh type[] =         UNICODE_LITERAL_4(t,y,p,e);
-
-    DOMDocument* doc=XMLToolingConfig::getConfig().getParser().parse(in);
-    
-    // Check root element.
-    const DOMElement* root=doc->getDocumentElement();
-    if (!XMLHelper::isNodeNamed(root,XMLTOOLING_NS,exception)) {
-        doc->release();
-        throw XMLToolingException("Invalid root element on serialized exception.");
-    }
-    
-    auto_ptr_char classname(root->getAttributeNS(NULL,type));
-    auto_ptr<XMLToolingException> excep(XMLToolingException::getInstance(classname.get()));
-    
-    DOMElement* child=XMLHelper::getFirstChildElement(root,XMLTOOLING_NS,message);
-    if (child && child->hasChildNodes()) {
-        auto_ptr_char m(child->getFirstChild()->getNodeValue());
-        excep->setMessage(m.get());
-    }
-    
-    child=XMLHelper::getFirstChildElement(root,XMLTOOLING_NS,param);
-    while (child && child->hasChildNodes()) {
-        auto_ptr_char n(child->getAttributeNS(NULL,name));
-        char* v=toUTF8(child->getFirstChild()->getNodeValue());
-        if (n.get() && v)
-            excep->addProperty(n.get(), v);
-        delete[] v;
-        child=XMLHelper::getNextSiblingElement(child,XMLTOOLING_NS,param);
-    }
-
-    doc->release();
-    return excep.release();
-}
-        
-XMLToolingException* XMLToolingException::fromString(const char* s)
-{
-    istringstream in(s);
-    return fromStream(in);
-}
+/*\r
+ *  Copyright 2001-2007 Internet2\r
+ * \r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ *     http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ */\r
+\r
+/**\r
+ * exceptions.cpp\r
+ * \r
+ * Exception classes\r
+ */\r
+ \r
+#include "internal.h"\r
+#include "exceptions.h"\r
+#include "XMLToolingConfig.h"\r
+#include "util/URLEncoder.h"\r
+#include "util/XMLConstants.h"\r
+#include "util/XMLHelper.h"\r
+\r
+#include <stdarg.h>\r
+#include <memory>\r
+#include <sstream>\r
+#include <xercesc/util/XMLUniDefs.hpp>\r
+\r
+using namespace xmltooling;\r
+using namespace std;\r
+using xmlconstants::XMLTOOLING_NS;\r
+\r
+params::params(int count,...)\r
+{\r
+    va_list args;\r
+    va_start(args,count);\r
+    while (count--)\r
+        v.push_back(va_arg(args,char*));\r
+    va_end(args);\r
+}\r
+\r
+namedparams::namedparams(int count,...)\r
+{\r
+    count*=2;\r
+    va_list args;\r
+    va_start(args,count);\r
+    while (count--)\r
+        v.push_back(va_arg(args,char*));\r
+    va_end(args);\r
+}\r
+\r
+XMLToolingException::ExceptionFactoryMap XMLToolingException::m_factoryMap;\r
+\r
+XMLToolingException* XMLToolingException::getInstance(const char* exceptionClass)\r
+{\r
+    if (exceptionClass) {\r
+        ExceptionFactoryMap::const_iterator i=m_factoryMap.find(exceptionClass);\r
+        if (i!=m_factoryMap.end())\r
+            return (i->second)();\r
+    }\r
+    return new XMLToolingException();\r
+}\r
+\r
+XMLToolingException::XMLToolingException(const char* msg, const params& p)\r
+{\r
+    if (msg)\r
+        m_msg=msg;\r
+    addProperties(p);\r
+}\r
+\r
+XMLToolingException::XMLToolingException(const char* msg, const namedparams& p)\r
+{\r
+    if (msg)\r
+        m_msg=msg;\r
+    addProperties(p);\r
+}\r
+\r
+XMLToolingException::XMLToolingException(const std::string& msg, const params& p) : m_msg(msg)\r
+{\r
+    addProperties(p);\r
+}\r
+\r
+XMLToolingException::XMLToolingException(const std::string& msg, const namedparams& p) : m_msg(msg)\r
+{\r
+    addProperties(p);\r
+}\r
+\r
+void XMLToolingException::setMessage(const char* msg)\r
+{\r
+    if (msg)\r
+        m_msg=msg;\r
+    else\r
+        m_msg.erase();\r
+    m_processedmsg.erase();\r
+}\r
+\r
+inline const char* get_digit_character()\r
+{\r
+    static const char  s_characters[19] = \r
+    {\r
+            '9'\r
+        ,   '8'\r
+        ,   '7'\r
+        ,   '6'\r
+        ,   '5'\r
+        ,   '4'\r
+        ,   '3'\r
+        ,   '2'\r
+        ,   '1'\r
+        ,   '0'\r
+        ,   '1'\r
+        ,   '2'\r
+        ,   '3'\r
+        ,   '4'\r
+        ,   '5'\r
+        ,   '6'\r
+        ,   '7'\r
+        ,   '8'\r
+        ,   '9'\r
+    };\r
+    static const char  *s_mid  =   s_characters + 9;\r
+\r
+    return s_mid;\r
+}\r
+\r
+inline const char* unsigned_integer_to_string(char* buf, size_t cchBuf, int i)\r
+{\r
+    char* psz=buf + cchBuf - 1;     // Set psz to last char\r
+    *psz = 0;                       // Set terminating null\r
+\r
+    do {\r
+        unsigned int lsd = i % 10;  // Get least significant\r
+                                    // digit\r
+\r
+        i /= 10;                    // Prepare for next most\r
+                                    // significant digit\r
+\r
+        --psz;                      // Move back\r
+\r
+        *psz = get_digit_character()[lsd]; // Place the digit\r
+\r
+    } while(i!=0 && psz>buf);\r
+\r
+    return psz;\r
+}\r
+\r
+void XMLToolingException::addProperties(const params& p)\r
+{\r
+    m_processedmsg.erase();\r
+    int i=m_params.size()+1;\r
+    char buf[20];\r
+    const vector<const char*>& v=p.get();\r
+    for (vector<const char*>::const_iterator ci=v.begin(); ci!=v.end(); ci++) {\r
+        m_params[unsigned_integer_to_string(buf,sizeof(buf),i++)] = *ci;\r
+    }\r
+}\r
+        \r
+void XMLToolingException::addProperties(const namedparams& p)\r
+{\r
+    m_processedmsg.erase();\r
+    const vector<const char*>& v=p.get();\r
+    for (vector<const char*>::const_iterator ci=v.begin(); ci!=v.end(); ci++) {\r
+        m_params.erase(*ci);\r
+        m_params[*ci] = *(ci+1);\r
+        ci++;   // advance past name to value, then loop will advance it again\r
+    }\r
+}\r
+\r
+const char* XMLToolingException::getProperty(unsigned int index) const\r
+{\r
+    char buf[20];\r
+    map<string,string>::const_iterator i=m_params.find(unsigned_integer_to_string(buf,sizeof(buf),index));\r
+    return (i==m_params.end()) ? NULL : i->second.c_str();\r
+}\r
+\r
+const char* XMLToolingException::getProperty(const char* name) const\r
+{\r
+    map<string,string>::const_iterator i=m_params.find(name);\r
+    return (i==m_params.end()) ? NULL : i->second.c_str();\r
+}\r
+\r
+const char* XMLToolingException::getMessage() const\r
+{\r
+    if (!m_processedmsg.empty())\r
+        return m_processedmsg.c_str();\r
+    else if (m_params.empty())\r
+        return m_msg.c_str();\r
+\r
+    static const char* legal="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890_";\r
+\r
+    // Replace any parameters in the message.\r
+    string::size_type i=0,start=0;\r
+    while (start!=string::npos && start<m_msg.length() && (i=m_msg.find("$",start))!=string::npos) {\r
+        if (i>start)\r
+            m_processedmsg += m_msg.substr(start,i-start);  // append everything in between\r
+        start=i+1;                                  // move start to the beginning of the token name\r
+        i=m_msg.find_first_not_of(legal,start);     // find token delimiter\r
+        if (i==start) {                             // append a non legal character\r
+           m_processedmsg+=m_msg[start++];\r
+           continue;\r
+        }\r
+        \r
+        // search for token in map\r
+        map<string,string>::const_iterator param=m_params.find(m_msg.substr(start,(i==string::npos) ? i : i-start));\r
+        if (param!=m_params.end()) {\r
+            m_processedmsg+=param->second;\r
+            start=i;\r
+        }\r
+    }\r
+    if (start!=string::npos && start<m_msg.length())\r
+        m_processedmsg += m_msg.substr(start,i);    // append rest of string\r
+    return m_processedmsg.c_str();\r
+}\r
+\r
+void xml_encode(string& s, const char* pre, const char* start, const char* post)\r
+{\r
+    s += pre;\r
+    size_t pos;\r
+    while (start && *start) {\r
+        pos = strcspn(start, "\"<>&");\r
+        if (pos > 0) {\r
+            s.append(start, pos);\r
+            start += pos;\r
+        }\r
+        else {\r
+            switch (*start) {\r
+                case '\'':  s += "&apos;";     break;\r
+                case '<':   s += "&lt;";       break;\r
+                case '>':   s += "&gt;";       break;\r
+                case '&':   s += "&amp;";      break;\r
+                default:    s += *start;\r
+            }\r
+            start++;\r
+        }\r
+    }\r
+    s += post;\r
+}\r
+\r
+string XMLToolingException::toString() const\r
+{\r
+    string xml=string("<exception xmlns='http://www.opensaml.org/xmltooling' type='") + getClassName() + "'>";\r
+    const char* msg=getMessage();\r
+    if (msg)\r
+        xml_encode(xml, "<message>", msg, "</message>");\r
+    for (map<string,string>::const_iterator i=m_params.begin(); i!=m_params.end(); i++) {\r
+        xml_encode(xml, "<param name='", i->first.c_str(), "'");\r
+        xml_encode(xml, ">", i->second.c_str(), "</param>");\r
+    }\r
+    xml+="</exception>";\r
+    return xml;\r
+}\r
+\r
+string XMLToolingException::toQueryString() const\r
+{\r
+    string q;\r
+    const URLEncoder* enc = XMLToolingConfig::getConfig().getURLEncoder();\r
+    for (map<string,string>::const_iterator i=m_params.begin(); i!=m_params.end(); i++) {\r
+        if (!q.empty())\r
+            q += '&';\r
+        q = q + i->first + '=' + enc->encode(i->second.c_str());\r
+    }\r
+    return q;\r
+}\r
+\r
+XMLToolingException* XMLToolingException::fromStream(std::istream& in)\r
+{\r
+    static const XMLCh exception[] =    UNICODE_LITERAL_9(e,x,c,e,p,t,i,o,n);\r
+    static const XMLCh message[] =      UNICODE_LITERAL_7(m,e,s,s,a,g,e);\r
+    static const XMLCh name[] =         UNICODE_LITERAL_4(n,a,m,e);\r
+    static const XMLCh param[] =        UNICODE_LITERAL_5(p,a,r,a,m);\r
+    static const XMLCh type[] =         UNICODE_LITERAL_4(t,y,p,e);\r
+\r
+    DOMDocument* doc=XMLToolingConfig::getConfig().getParser().parse(in);\r
+    \r
+    // Check root element.\r
+    const DOMElement* root=doc->getDocumentElement();\r
+    if (!XMLHelper::isNodeNamed(root,XMLTOOLING_NS,exception)) {\r
+        doc->release();\r
+        throw XMLToolingException("Invalid root element on serialized exception.");\r
+    }\r
+    \r
+    auto_ptr_char classname(root->getAttributeNS(NULL,type));\r
+    auto_ptr<XMLToolingException> excep(XMLToolingException::getInstance(classname.get()));\r
+    \r
+    DOMElement* child=XMLHelper::getFirstChildElement(root,XMLTOOLING_NS,message);\r
+    if (child && child->hasChildNodes()) {\r
+        auto_ptr_char m(child->getFirstChild()->getNodeValue());\r
+        excep->setMessage(m.get());\r
+    }\r
+    \r
+    child=XMLHelper::getFirstChildElement(root,XMLTOOLING_NS,param);\r
+    while (child && child->hasChildNodes()) {\r
+        auto_ptr_char n(child->getAttributeNS(NULL,name));\r
+        char* v=toUTF8(child->getFirstChild()->getNodeValue());\r
+        if (n.get() && v)\r
+            excep->addProperty(n.get(), v);\r
+        delete[] v;\r
+        child=XMLHelper::getNextSiblingElement(child,XMLTOOLING_NS,param);\r
+    }\r
+\r
+    doc->release();\r
+    return excep.release();\r
+}\r
+        \r
+XMLToolingException* XMLToolingException::fromString(const char* s)\r
+{\r
+    istringstream in(s);\r
+    return fromStream(in);\r
+}\r

diff --git a/xmltooling/impl/MemoryStorageService.cpp b/xmltooling/impl/MemoryStorageService.cpp
index af0fd71..b297d65 100644 (file)
--- a/xmltooling/impl/MemoryStorageService.cpp
+++ b/xmltooling/impl/MemoryStorageService.cpp
@@ -1,318 +1,319 @@
-/*
- *  Copyright 2001-2007 Internet2
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * MemoryStorageService.cpp
- * 
- * In-memory "persistent" storage, suitable for simple applications.
- */
-
-#include "internal.h"
-#include "logging.h"
-#include "util/NDC.h"
-#include "util/StorageService.h"
-#include "util/Threads.h"
-#include "util/XMLHelper.h"
-
-#include <xercesc/util/XMLUniDefs.hpp>
-
-using namespace xmltooling::logging;
-using namespace xmltooling;
-using namespace std;
-
-namespace xmltooling {
-    class XMLTOOL_DLLLOCAL MemoryStorageService : public StorageService
-    {
-    public:
-        MemoryStorageService(const DOMElement* e);
-        virtual ~MemoryStorageService();
-        
-        bool createString(const char* context, const char* key, const char* value, time_t expiration);
-        int readString(const char* context, const char* key, string* pvalue=NULL, time_t* pexpiration=NULL, int version=0);
-        int updateString(const char* context, const char* key, const char* value=NULL, time_t expiration=0, int version=0);
-        bool deleteString(const char* context, const char* key);
-        
-        bool createText(const char* context, const char* key, const char* value, time_t expiration) {
-            return createString(context, key, value, expiration);
-        }
-        int readText(const char* context, const char* key, string* pvalue=NULL, time_t* pexpiration=NULL, int version=0) {
-            return readString(context, key, pvalue, pexpiration, version);
-        }
-        int updateText(const char* context, const char* key, const char* value=NULL, time_t expiration=0, int version=0) {
-            return updateString(context, key, value, expiration, version);
-        }
-        bool deleteText(const char* context, const char* key) {
-            return deleteString(context, key);
-        }
-        
-        void reap(const char* context);
-        void updateContext(const char* context, time_t expiration);
-        void deleteContext(const char* context) {
-            m_lock->wrlock();
-            m_contextMap.erase(context);
-            m_lock->unlock();
-        }
-
-    private:
-        void cleanup();
-    
-        struct XMLTOOL_DLLLOCAL Record {
-            Record() : expiration(0), version(1) {}
-            Record(const string& s, time_t t) : data(s), expiration(t), version(1) {}
-            string data;
-            time_t expiration;
-            int version;
-        };
-        
-        struct XMLTOOL_DLLLOCAL Context {
-            Context() {}
-            Context(const Context& src) {
-                m_dataMap = src.m_dataMap;
-            }
-            map<string,Record> m_dataMap;
-            unsigned long reap(time_t exp);
-        };
-
-        Context& readContext(const char* context) {
-            m_lock->rdlock();
-            map<string,Context>::iterator i = m_contextMap.find(context);
-            if (i != m_contextMap.end())
-                return i->second;
-            m_lock->unlock();
-            m_lock->wrlock();
-            return m_contextMap[context];
-        }
-
-        Context& writeContext(const char* context) {
-            m_lock->wrlock();
-            return m_contextMap[context];
-        }
-
-        map<string,Context> m_contextMap;
-        RWLock* m_lock;
-        CondWait* shutdown_wait;
-        Thread* cleanup_thread;
-        static void* cleanup_fn(void*);
-        bool shutdown;
-        int m_cleanupInterval;
-        Category& m_log;
-    };
-
-    StorageService* XMLTOOL_DLLLOCAL MemoryStorageServiceFactory(const DOMElement* const & e)
-    {
-        return new MemoryStorageService(e);
-    }
-};
-
-static const XMLCh cleanupInterval[] = UNICODE_LITERAL_15(c,l,e,a,n,u,p,I,n,t,e,r,v,a,l);
-
-MemoryStorageService::MemoryStorageService(const DOMElement* e)
-    : m_lock(NULL), shutdown_wait(NULL), cleanup_thread(NULL), shutdown(false), m_cleanupInterval(0),
-        m_log(Category::getInstance(XMLTOOLING_LOGCAT".StorageService"))
-{
-    const XMLCh* tag=e ? e->getAttributeNS(NULL,cleanupInterval) : NULL;
-    if (tag && *tag) {
-        m_cleanupInterval = XMLString::parseInt(tag);
-    }
-    if (!m_cleanupInterval)
-        m_cleanupInterval=900;
-
-    m_lock = RWLock::create();
-    shutdown_wait = CondWait::create();
-    cleanup_thread = Thread::create(&cleanup_fn, (void*)this);
-}
-
-MemoryStorageService::~MemoryStorageService()
-{
-    // Shut down the cleanup thread and let it know...
-    shutdown = true;
-    shutdown_wait->signal();
-    cleanup_thread->join(NULL);
-
-    delete shutdown_wait;
-    delete m_lock;
-}
-
-void* MemoryStorageService::cleanup_fn(void* cache_p)
-{
-    MemoryStorageService* cache = reinterpret_cast<MemoryStorageService*>(cache_p);
-
-#ifndef WIN32
-    // First, let's block all signals 
-    Thread::mask_all_signals();
-#endif
-
-    // Now run the cleanup process.
-    cache->cleanup();
-    return NULL;
-}
-
-void MemoryStorageService::cleanup()
-{
-#ifdef _DEBUG
-    NDC ndc("cleanup");
-#endif
-
-    auto_ptr<Mutex> mutex(Mutex::create());
-    mutex->lock();
-
-    m_log.info("cleanup thread started...running every %d seconds", m_cleanupInterval);
-
-    while (!shutdown) {
-        shutdown_wait->timedwait(mutex.get(), m_cleanupInterval);
-        if (shutdown)
-            break;
-        
-        unsigned long count=0;
-        time_t now = time(NULL);
-        m_lock->wrlock();
-        SharedLock locker(m_lock, false);
-        for (map<string,Context>::iterator i=m_contextMap.begin(); i!=m_contextMap.end(); ++i)
-            count += i->second.reap(now);
-        
-        if (count)
-            m_log.info("purged %d expired record(s) from storage", count);
-    }
-
-    m_log.info("cleanup thread finished");
-
-    mutex->unlock();
-    Thread::exit(NULL);
-}
-
-void MemoryStorageService::reap(const char* context)
-{
-    Context& ctx = writeContext(context);
-    SharedLock locker(m_lock, false);
-    ctx.reap(time(NULL));
-}
-
-unsigned long MemoryStorageService::Context::reap(time_t exp)
-{
-    // Garbage collect any expired entries.
-    unsigned long count=0;
-    map<string,Record>::iterator cur = m_dataMap.begin();
-    map<string,Record>::iterator stop = m_dataMap.end();
-    while (cur != stop) {
-        if (cur->second.expiration <= exp) {
-            map<string,Record>::iterator tmp = cur++;
-            m_dataMap.erase(tmp);
-            ++count;
-        }
-        else {
-            cur++;
-        }
-    }
-    return count;
-}
-
-bool MemoryStorageService::createString(const char* context, const char* key, const char* value, time_t expiration)
-{
-    Context& ctx = writeContext(context);
-    SharedLock locker(m_lock, false);
-
-    // Check for a duplicate.
-    map<string,Record>::iterator i=ctx.m_dataMap.find(key);
-    if (i!=ctx.m_dataMap.end()) {
-        // Not yet expired?
-        if (time(NULL) < i->second.expiration)
-            return false;
-        // It's dead, so we can just remove it now and create the new record.
-        ctx.m_dataMap.erase(i);
-    }
-    
-    ctx.m_dataMap[key]=Record(value,expiration);
-    
-    m_log.debug("inserted record (%s) in context (%s)", key, context);
-    return true;
-}
-
-int MemoryStorageService::readString(const char* context, const char* key, string* pvalue, time_t* pexpiration, int version)
-{
-    Context& ctx = readContext(context);
-    SharedLock locker(m_lock, false);
-
-    map<string,Record>::iterator i=ctx.m_dataMap.find(key);
-    if (i==ctx.m_dataMap.end())
-        return 0;
-    else if (time(NULL) >= i->second.expiration)
-        return 0;
-    if (pexpiration)
-        *pexpiration = i->second.expiration;
-    if (i->second.version == version)
-        return version; // nothing's changed, so just echo back the version
-    if (pvalue)
-        *pvalue = i->second.data;
-    return i->second.version;
-}
-
-int MemoryStorageService::updateString(const char* context, const char* key, const char* value, time_t expiration, int version)
-{
-    Context& ctx = writeContext(context);
-    SharedLock locker(m_lock, false);
-
-    map<string,Record>::iterator i=ctx.m_dataMap.find(key);
-    if (i==ctx.m_dataMap.end())
-        return 0;
-    else if (time(NULL) >= i->second.expiration)
-        return 0;
-    
-    if (version > 0 && version != i->second.version)
-        return -1;  // caller's out of sync
-
-    if (value) {
-        i->second.data = value;
-        ++(i->second.version);
-    }
-        
-    if (expiration && expiration != i->second.expiration)
-        i->second.expiration = expiration;
-
-    m_log.debug("updated record (%s) in context (%s)", key, context);
-    return i->second.version;
-}
-
-bool MemoryStorageService::deleteString(const char* context, const char* key)
-{
-    Context& ctx = writeContext(context);
-    SharedLock locker(m_lock, false);
-    
-    // Find the record.
-    map<string,Record>::iterator i=ctx.m_dataMap.find(key);
-    if (i!=ctx.m_dataMap.end()) {
-        ctx.m_dataMap.erase(i);
-        m_log.debug("deleted record (%s) in context (%s)", key, context);
-        return true;
-    }
-
-    m_log.debug("deleting record (%s) in context (%s)....not found", key, context);
-    return false;
-}
-
-void MemoryStorageService::updateContext(const char* context, time_t expiration)
-{
-    Context& ctx = writeContext(context);
-    SharedLock locker(m_lock, false);
-
-    time_t now = time(NULL);
-    map<string,Record>::iterator stop=ctx.m_dataMap.end();
-    for (map<string,Record>::iterator i = ctx.m_dataMap.begin(); i!=stop; ++i) {
-        if (now < i->second.expiration)
-            i->second.expiration = expiration;
-    }
-
-    m_log.debug("updated expiration of valid records in context (%s)", context);
-}
+/*\r
+ *  Copyright 2001-2007 Internet2\r
+ * \r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ *     http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ */\r
+\r
+/**\r
+ * MemoryStorageService.cpp\r
+ * \r
+ * In-memory "persistent" storage, suitable for simple applications.\r
+ */\r
+\r
+#include "internal.h"\r
+#include "logging.h"\r
+#include "util/NDC.h"\r
+#include "util/StorageService.h"\r
+#include "util/Threads.h"\r
+#include "util/XMLHelper.h"\r
+\r
+#include <memory>\r
+#include <xercesc/util/XMLUniDefs.hpp>\r
+\r
+using namespace xmltooling::logging;\r
+using namespace xmltooling;\r
+using namespace std;\r
+\r
+namespace xmltooling {\r
+    class XMLTOOL_DLLLOCAL MemoryStorageService : public StorageService\r
+    {\r
+    public:\r
+        MemoryStorageService(const DOMElement* e);\r
+        virtual ~MemoryStorageService();\r
+        \r
+        bool createString(const char* context, const char* key, const char* value, time_t expiration);\r
+        int readString(const char* context, const char* key, string* pvalue=NULL, time_t* pexpiration=NULL, int version=0);\r
+        int updateString(const char* context, const char* key, const char* value=NULL, time_t expiration=0, int version=0);\r
+        bool deleteString(const char* context, const char* key);\r
+        \r
+        bool createText(const char* context, const char* key, const char* value, time_t expiration) {\r
+            return createString(context, key, value, expiration);\r
+        }\r
+        int readText(const char* context, const char* key, string* pvalue=NULL, time_t* pexpiration=NULL, int version=0) {\r
+            return readString(context, key, pvalue, pexpiration, version);\r
+        }\r
+        int updateText(const char* context, const char* key, const char* value=NULL, time_t expiration=0, int version=0) {\r
+            return updateString(context, key, value, expiration, version);\r
+        }\r
+        bool deleteText(const char* context, const char* key) {\r
+            return deleteString(context, key);\r
+        }\r
+        \r
+        void reap(const char* context);\r
+        void updateContext(const char* context, time_t expiration);\r
+        void deleteContext(const char* context) {\r
+            m_lock->wrlock();\r
+            m_contextMap.erase(context);\r
+            m_lock->unlock();\r
+        }\r
+\r
+    private:\r
+        void cleanup();\r
+    \r
+        struct XMLTOOL_DLLLOCAL Record {\r
+            Record() : expiration(0), version(1) {}\r
+            Record(const string& s, time_t t) : data(s), expiration(t), version(1) {}\r
+            string data;\r
+            time_t expiration;\r
+            int version;\r
+        };\r
+        \r
+        struct XMLTOOL_DLLLOCAL Context {\r
+            Context() {}\r
+            Context(const Context& src) {\r
+                m_dataMap = src.m_dataMap;\r
+            }\r
+            map<string,Record> m_dataMap;\r
+            unsigned long reap(time_t exp);\r
+        };\r
+\r
+        Context& readContext(const char* context) {\r
+            m_lock->rdlock();\r
+            map<string,Context>::iterator i = m_contextMap.find(context);\r
+            if (i != m_contextMap.end())\r
+                return i->second;\r
+            m_lock->unlock();\r
+            m_lock->wrlock();\r
+            return m_contextMap[context];\r
+        }\r
+\r
+        Context& writeContext(const char* context) {\r
+            m_lock->wrlock();\r
+            return m_contextMap[context];\r
+        }\r
+\r
+        map<string,Context> m_contextMap;\r
+        RWLock* m_lock;\r
+        CondWait* shutdown_wait;\r
+        Thread* cleanup_thread;\r
+        static void* cleanup_fn(void*);\r
+        bool shutdown;\r
+        int m_cleanupInterval;\r
+        Category& m_log;\r
+    };\r
+\r
+    StorageService* XMLTOOL_DLLLOCAL MemoryStorageServiceFactory(const DOMElement* const & e)\r
+    {\r
+        return new MemoryStorageService(e);\r
+    }\r
+};\r
+\r
+static const XMLCh cleanupInterval[] = UNICODE_LITERAL_15(c,l,e,a,n,u,p,I,n,t,e,r,v,a,l);\r
+\r
+MemoryStorageService::MemoryStorageService(const DOMElement* e)\r
+    : m_lock(NULL), shutdown_wait(NULL), cleanup_thread(NULL), shutdown(false), m_cleanupInterval(0),\r
+        m_log(Category::getInstance(XMLTOOLING_LOGCAT".StorageService"))\r
+{\r
+    const XMLCh* tag=e ? e->getAttributeNS(NULL,cleanupInterval) : NULL;\r
+    if (tag && *tag) {\r
+        m_cleanupInterval = XMLString::parseInt(tag);\r
+    }\r
+    if (!m_cleanupInterval)\r
+        m_cleanupInterval=900;\r
+\r
+    m_lock = RWLock::create();\r
+    shutdown_wait = CondWait::create();\r
+    cleanup_thread = Thread::create(&cleanup_fn, (void*)this);\r
+}\r
+\r
+MemoryStorageService::~MemoryStorageService()\r
+{\r
+    // Shut down the cleanup thread and let it know...\r
+    shutdown = true;\r
+    shutdown_wait->signal();\r
+    cleanup_thread->join(NULL);\r
+\r
+    delete shutdown_wait;\r
+    delete m_lock;\r
+}\r
+\r
+void* MemoryStorageService::cleanup_fn(void* cache_p)\r
+{\r
+    MemoryStorageService* cache = reinterpret_cast<MemoryStorageService*>(cache_p);\r
+\r
+#ifndef WIN32\r
+    // First, let's block all signals \r
+    Thread::mask_all_signals();\r
+#endif\r
+\r
+    // Now run the cleanup process.\r
+    cache->cleanup();\r
+    return NULL;\r
+}\r
+\r
+void MemoryStorageService::cleanup()\r
+{\r
+#ifdef _DEBUG\r
+    NDC ndc("cleanup");\r
+#endif\r
+\r
+    auto_ptr<Mutex> mutex(Mutex::create());\r
+    mutex->lock();\r
+\r
+    m_log.info("cleanup thread started...running every %d seconds", m_cleanupInterval);\r
+\r
+    while (!shutdown) {\r
+        shutdown_wait->timedwait(mutex.get(), m_cleanupInterval);\r
+        if (shutdown)\r
+            break;\r
+        \r
+        unsigned long count=0;\r
+        time_t now = time(NULL);\r
+        m_lock->wrlock();\r
+        SharedLock locker(m_lock, false);\r
+        for (map<string,Context>::iterator i=m_contextMap.begin(); i!=m_contextMap.end(); ++i)\r
+            count += i->second.reap(now);\r
+        \r
+        if (count)\r
+            m_log.info("purged %d expired record(s) from storage", count);\r
+    }\r
+\r
+    m_log.info("cleanup thread finished");\r
+\r
+    mutex->unlock();\r
+    Thread::exit(NULL);\r
+}\r
+\r
+void MemoryStorageService::reap(const char* context)\r
+{\r
+    Context& ctx = writeContext(context);\r
+    SharedLock locker(m_lock, false);\r
+    ctx.reap(time(NULL));\r
+}\r
+\r
+unsigned long MemoryStorageService::Context::reap(time_t exp)\r
+{\r
+    // Garbage collect any expired entries.\r
+    unsigned long count=0;\r
+    map<string,Record>::iterator cur = m_dataMap.begin();\r
+    map<string,Record>::iterator stop = m_dataMap.end();\r
+    while (cur != stop) {\r
+        if (cur->second.expiration <= exp) {\r
+            map<string,Record>::iterator tmp = cur++;\r
+            m_dataMap.erase(tmp);\r
+            ++count;\r
+        }\r
+        else {\r
+            cur++;\r
+        }\r
+    }\r
+    return count;\r
+}\r
+\r
+bool MemoryStorageService::createString(const char* context, const char* key, const char* value, time_t expiration)\r
+{\r
+    Context& ctx = writeContext(context);\r
+    SharedLock locker(m_lock, false);\r
+\r
+    // Check for a duplicate.\r
+    map<string,Record>::iterator i=ctx.m_dataMap.find(key);\r
+    if (i!=ctx.m_dataMap.end()) {\r
+        // Not yet expired?\r
+        if (time(NULL) < i->second.expiration)\r
+            return false;\r
+        // It's dead, so we can just remove it now and create the new record.\r
+        ctx.m_dataMap.erase(i);\r
+    }\r
+    \r
+    ctx.m_dataMap[key]=Record(value,expiration);\r
+    \r
+    m_log.debug("inserted record (%s) in context (%s)", key, context);\r
+    return true;\r
+}\r
+\r
+int MemoryStorageService::readString(const char* context, const char* key, string* pvalue, time_t* pexpiration, int version)\r
+{\r
+    Context& ctx = readContext(context);\r
+    SharedLock locker(m_lock, false);\r
+\r
+    map<string,Record>::iterator i=ctx.m_dataMap.find(key);\r
+    if (i==ctx.m_dataMap.end())\r
+        return 0;\r
+    else if (time(NULL) >= i->second.expiration)\r
+        return 0;\r
+    if (pexpiration)\r
+        *pexpiration = i->second.expiration;\r
+    if (i->second.version == version)\r
+        return version; // nothing's changed, so just echo back the version\r
+    if (pvalue)\r
+        *pvalue = i->second.data;\r
+    return i->second.version;\r
+}\r
+\r
+int MemoryStorageService::updateString(const char* context, const char* key, const char* value, time_t expiration, int version)\r
+{\r
+    Context& ctx = writeContext(context);\r
+    SharedLock locker(m_lock, false);\r
+\r
+    map<string,Record>::iterator i=ctx.m_dataMap.find(key);\r
+    if (i==ctx.m_dataMap.end())\r
+        return 0;\r
+    else if (time(NULL) >= i->second.expiration)\r
+        return 0;\r
+    \r
+    if (version > 0 && version != i->second.version)\r
+        return -1;  // caller's out of sync\r
+\r
+    if (value) {\r
+        i->second.data = value;\r
+        ++(i->second.version);\r
+    }\r
+        \r
+    if (expiration && expiration != i->second.expiration)\r
+        i->second.expiration = expiration;\r
+\r
+    m_log.debug("updated record (%s) in context (%s)", key, context);\r
+    return i->second.version;\r
+}\r
+\r
+bool MemoryStorageService::deleteString(const char* context, const char* key)\r
+{\r
+    Context& ctx = writeContext(context);\r
+    SharedLock locker(m_lock, false);\r
+    \r
+    // Find the record.\r
+    map<string,Record>::iterator i=ctx.m_dataMap.find(key);\r
+    if (i!=ctx.m_dataMap.end()) {\r
+        ctx.m_dataMap.erase(i);\r
+        m_log.debug("deleted record (%s) in context (%s)", key, context);\r
+        return true;\r
+    }\r
+\r
+    m_log.debug("deleting record (%s) in context (%s)....not found", key, context);\r
+    return false;\r
+}\r
+\r
+void MemoryStorageService::updateContext(const char* context, time_t expiration)\r
+{\r
+    Context& ctx = writeContext(context);\r
+    SharedLock locker(m_lock, false);\r
+\r
+    time_t now = time(NULL);\r
+    map<string,Record>::iterator stop=ctx.m_dataMap.end();\r
+    for (map<string,Record>::iterator i = ctx.m_dataMap.begin(); i!=stop; ++i) {\r
+        if (now < i->second.expiration)\r
+            i->second.expiration = expiration;\r
+    }\r
+\r
+    m_log.debug("updated expiration of valid records in context (%s)", context);\r
+}\r