+/**
+ * Implements get/set methods and a private member for a typed, qualified XML attribute.
+ *
+ * @param proper the proper name of the attribute
+ * @param type the attribute's data type
+ */
+#define IMPL_XMLOBJECT_FOREIGN_ATTRIB(proper,type) \
+ protected: \
+ XMLCh* m_##proper##Prefix; \
+ type* m_##proper; \
+ public: \
+ const type* get##proper() const { \
+ return m_##proper; \
+ } \
+ void set##proper(const type* proper) { \
+ m_##proper = prepareForAssignment(m_##proper,proper); \
+ xercesc::XMLString::release(&m_##proper##Prefix); \
+ m_##proper##Prefix = nullptr; \
+ }
+
+/**
+ * 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) { \
+ xmltooling::auto_ptr_XMLCh qstr(m_##proper->toString().c_str()); \
+ domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, qstr.get()); \
+ }
+
+#ifdef XMLTOOLING_XERCESC_BOOLSETIDATTRIBUTE
+/**
+ * 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, true); \
+ }
+#else
+/**
+ * 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); \
+ }
+#endif
+
+/**
+ * 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; \
+ }
+
+#ifdef XMLTOOLING_XERCESC_BOOLSETIDATTRIBUTE
+/**
+ * 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, true); \
+ return; \
+ }
+#else
+/**
+ * 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; \
+ }
+#endif
+
+/**
+ * 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)) { \
+ std::auto_ptr<xmltooling::QName> q(xmltooling::XMLHelper::getAttributeValueAsQName(attribute)); \
+ set##proper(q.get()); \
+ 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()!=nullptr), (getTextContent()!=nullptr ? xercesc::XMLString::parseInt(getTextContent()) : 0)); \
+ } \
+ XMLTOOLING_DOXYGEN(Sets proper.) \
+ void set##proper(int proper) { \
+ try { \
+ xmltooling::xstring buf = boost::lexical_cast<xmltooling::xstring>(proper); \
+ setTextContent(buf.c_str()); \
+ } \
+ catch (boost::bad_lexical_cast&) { \
+ } \
+ } \
+ 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); \
+ }
+
+/**
+ * Implements cloning methods for an XMLObject specialization implementation class
+ * that must override a base class clone method.
+ *
+ * @param cname the name of the XMLObject specialization
+ * @param base name of base type.
+ */
+#define IMPL_XMLOBJECT_CLONE2(cname,base) \
+ cname* clone##cname() const { \
+ return dynamic_cast<cname*>(clone()); \
+ } \
+ base* clone##base() const { \
+ return dynamic_cast<base*>(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); \
+ }
+
+/**
+ * Implements cloning methods for an XMLObject specialization implementation class that
+ * needs two stage duplication to avoid invoking virtual methods during construction.
+ *
+ * @param cname the name of the XMLObject specialization
+ */
+#define IMPL_XMLOBJECT_CLONE_EX(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; \
+ } \
+ std::auto_ptr<cname##Impl> ret2(new cname##Impl(*this)); \
+ ret2->_clone(*this); \
+ return ret2.release(); \
+ }
+
+/**
+ * Implements cloning methods for an XMLObject specialization implementation class that
+ * needs two stage duplication to avoid invoking virtual methods during construction,
+ * and must override a base class clone method.
+ *
+ * @param cname the name of the XMLObject specialization
+ * @param base name of base type
+ */
+#define IMPL_XMLOBJECT_CLONE_EX2(cname,base) \
+ cname* clone##cname() const { \
+ return dynamic_cast<cname*>(clone()); \
+ } \
+ base* clone##base() const { \
+ return dynamic_cast<base*>(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; \
+ } \
+ std::auto_ptr<cname##Impl> ret2(new cname##Impl(*this)); \
+ ret2->_clone(*this); \
+ return ret2.release(); \
+ }
+
+/**
+ * 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 xmltooling::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=nullptr, const xmltooling::QName* schemaType=nullptr \
+ ) 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 xmltooling::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=nullptr, const xmltooling::QName* schemaType=nullptr \
+ ) 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 xmltooling::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()!=nullptr) \
+ c##proper1##proper2##proper3++; \
+ if (ptr->get##proper2()!=nullptr) \
+ c##proper1##proper2##proper3++; \
+ if (ptr->get##proper3()!=nullptr) \
+ 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.