Refactored simple content and child-handling into mixin classes.

[shibboleth/xmltooling.git] / xmltooling / AbstractXMLObject.h

diff --git a/xmltooling/AbstractXMLObject.h b/xmltooling/AbstractXMLObject.h
index 6beecfd..5ead42f 100644 (file)
--- a/xmltooling/AbstractXMLObject.h
+++ b/xmltooling/AbstractXMLObject.h
@@ -34,11 +34,17 @@ namespace xmltooling {
 \r
     /**\r
      * An abstract implementation of XMLObject.\r
+     * This is the primary concrete base class, and supplies basic namespace,\r
+     * type, and parent handling. Most implementation classes should not\r
+     * directly inherit from this class, but rather from the various mixins\r
+     * that supply the rest of the XMLObject interface, as required.\r
      */\r
     class XMLTOOL_API AbstractXMLObject : public virtual XMLObject\r
     {\r
     public:\r
-        virtual ~AbstractXMLObject();\r
+        virtual ~AbstractXMLObject() {\r
+            delete m_typeQname;\r
+        }\r
 \r
         const QName& getElementQName() const {\r
             return m_elementQname;\r
@@ -62,15 +68,6 @@ namespace xmltooling {
             return m_typeQname;\r
         }\r
     \r
-        void setSchemaType(const QName* type) {\r
-            delete m_typeQname;\r
-            m_typeQname = NULL;\r
-            if (type) {\r
-                m_typeQname = new QName(*type);\r
-                addNamespace(Namespace(type->getNamespaceURI(), type->getPrefix()));\r
-            }\r
-        }\r
-    \r
         bool hasParent() const {\r
             return m_parent != NULL;\r
         }\r
@@ -83,23 +80,18 @@ namespace xmltooling {
             m_parent = parent;\r
         }\r
 \r
-        bool hasChildren() const {\r
-            return !m_children.empty();\r
-        }\r
-\r
-        const std::list<XMLObject*>& getOrderedChildren() const {\r
-            return m_children;\r
-        }\r
-\r
      protected:\r
         /**\r
          * Constructor\r
          * \r
-         * @param namespaceURI the namespace the element is in\r
-         * @param elementLocalName the local name of the XML element this Object represents\r
-         * @param namespacePrefix the namespace prefix to use\r
+         * @param nsURI         the namespace of the element\r
+         * @param localName     the local name of the XML element this Object represents\r
+         * @param prefix        the namespace prefix to use\r
+         * @param schemaType    the xsi:type to use\r
          */\r
-        AbstractXMLObject(const XMLCh* namespaceURI=NULL, const XMLCh* elementLocalName=NULL, const XMLCh* namespacePrefix=NULL);\r
+        AbstractXMLObject(\r
+            const XMLCh* nsURI=NULL, const XMLCh* localName=NULL, const XMLCh* prefix=NULL, const QName* schemaType=NULL\r
+            );\r
 \r
         /** Copy constructor. */\r
         AbstractXMLObject(const AbstractXMLObject& src);\r
@@ -115,39 +107,25 @@ namespace xmltooling {
          * \r
          * @return the value that should be assigned\r
          */\r
-        XMLCh* prepareForAssignment(XMLCh* oldValue, const XMLCh* newValue) {\r
-            XMLCh* newString = XMLString::replicate(newValue);\r
-            XMLString::trim(newString);\r
-            if (!XMLString::equals(oldValue,newValue)) {\r
-                releaseThisandParentDOM();\r
-                XMLString::release(&oldValue);\r
-                return newString;\r
-            }\r
-            XMLString::release(&newString);\r
-            return oldValue;            \r
-        }\r
+        XMLCh* prepareForAssignment(XMLCh* oldValue, const XMLCh* newValue);\r
 \r
         /**\r
          * A helper function for derived classes, for assignment of (singleton) XML objects.\r
          * \r
          * It is indifferent to whether either the old or the new version of the value is null. \r
-         * This method will do a safe compare of the objects and will also invalidate the DOM if appropriate\r
+         * This method will do a safe compare of the objects and will also invalidate the DOM if appropriate.\r
+         * Note that since the new value (even if NULL) is always returned, it may be more efficient\r
+         * to discard the return value and just assign independently if a dynamic cast would be involved.\r
          * \r
          * @param oldValue - current value\r
          * @param newValue - proposed new value\r
-         * @return the value to assign \r
+         * @return the new value \r
          * \r
          * @throws XMLObjectException if the new child already has a parent.\r
          */\r
         XMLObject* prepareForAssignment(XMLObject* oldValue, XMLObject* newValue);\r
 \r
         /**\r
-         * Underlying list of child objects.\r
-         * Manages the lifetime of the children.\r
-         */\r
-        std::list<XMLObject*> m_children;\r
-\r
-        /**\r
          * Set of namespaces associated with the object.\r
          */\r
         mutable std::set<Namespace> m_namespaces;\r