#define __xmltooling_abstractxmlobj_h__\r
\r
#include <xmltooling/XMLObject.h>\r
+#include <xmltooling/util/DateTime.h>\r
\r
#if defined (_MSC_VER)\r
#pragma warning( push )\r
\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
- /**\r
- * @see XMLObject::getElementQName()\r
- */\r
const QName& getElementQName() const {\r
return m_elementQname;\r
}\r
\r
- /**\r
- * @see XMLObject::setElementNamespacePrefix()\r
- */\r
- void setElementNamespacePrefix(const XMLCh* prefix) {\r
- m_elementQname.setPrefix(prefix);\r
- }\r
-\r
- /**\r
- * @see XMLObject::getNamespaces()\r
- */\r
const std::set<Namespace>& getNamespaces() const {\r
return m_namespaces;\r
}\r
\r
- /**\r
- * @see XMLObject::addNamespace()\r
- */\r
void addNamespace(const Namespace& ns) const {\r
if (ns.alwaysDeclare() || m_namespaces.find(ns)==m_namespaces.end()) {\r
m_namespaces.insert(ns);\r
}\r
}\r
\r
- /**\r
- * @see XMLObject::removeNamespace()\r
- */\r
void removeNamespace(const Namespace& ns) {\r
m_namespaces.erase(ns);\r
}\r
\r
- /**\r
- * @see XMLObject::getSchemaType()\r
- */\r
const QName* getSchemaType() const {\r
return m_typeQname;\r
}\r
\r
- /**\r
- * @see XMLObject::setSchemaType()\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
- /**\r
- * @see XMLObject::hasParent()\r
- */\r
bool hasParent() const {\r
return m_parent != NULL;\r
}\r
\r
- /**\r
- * @see XMLObject::getParent()\r
- */\r
XMLObject* getParent() const {\r
return m_parent;\r
}\r
\r
- /**\r
- * @see XMLObject::setParent()\r
- */\r
void setParent(XMLObject* parent) {\r
m_parent = parent;\r
}\r
\r
+ protected:\r
/**\r
- * @see XMLObject::hasChildren()\r
+ * Constructor\r
+ * \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
- bool hasChildren() const {\r
- return !m_children.empty();\r
- }\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
+ \r
/**\r
- * @see XMLObject::getOrderedChildren()\r
+ * A helper function for derived classes, for assignment of strings.\r
+ *\r
+ * This 'normalizes' newString, and then if it is different from oldString,\r
+ * it invalidates the DOM, frees the old string, and returns the new.\r
+ * If not different, it frees the new string and just returns the old value.\r
+ * \r
+ * @param oldValue - the current value\r
+ * @param newValue - the new value\r
+ * \r
+ * @return the value that should be assigned\r
*/\r
- const std::list<XMLObject*>& getOrderedChildren() const {\r
- return m_children;\r
- }\r
+ XMLCh* prepareForAssignment(XMLCh* oldValue, const XMLCh* newValue);\r
\r
- protected:\r
/**\r
- * Constructor\r
+ * A helper function for derived classes, for assignment of date/time data.\r
+ *\r
+ * It invalidates the DOM, frees the old object, and returns the new.\r
+ * \r
+ * @param oldValue - the current value\r
+ * @param newValue - the new value\r
+ * \r
+ * @return the value that should be assigned\r
+ */\r
+ DateTime* prepareForAssignment(DateTime* oldValue, const DateTime* newValue);\r
+\r
+ /**\r
+ * A helper function for derived classes, for assignment of date/time data.\r
+ *\r
+ * It invalidates the DOM, frees the old object, and returns the new.\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 oldValue - the current value\r
+ * @param newValue - the epoch to assign as the new value\r
+ * \r
+ * @return the value that should be assigned\r
+ */\r
+ DateTime* prepareForAssignment(DateTime* oldValue, time_t newValue);\r
+\r
+ /**\r
+ * A helper function for derived classes, for assignment of date/time data.\r
+ *\r
+ * It invalidates the DOM, frees the old object, and returns the new.\r
+ * \r
+ * @param oldValue - the current value\r
+ * @param newValue - the new value in string form\r
+ * \r
+ * @return the value that should be assigned\r
+ */\r
+ DateTime* prepareForAssignment(DateTime* oldValue, const XMLCh* newValue);\r
+\r
+ /**\r
+ * A helper function for derived classes, for assignment of QName data.\r
+ *\r
+ * It invalidates the DOM, frees the old object, and returns the new.\r
+ * \r
+ * @param oldValue - the current value\r
+ * @param newValue - the new value\r
+ * \r
+ * @return the value that should be assigned\r
*/\r
- AbstractXMLObject(const XMLCh* namespaceURI=NULL, const XMLCh* elementLocalName=NULL, const XMLCh* namespacePrefix=NULL);\r
+ QName* prepareForAssignment(QName* oldValue, const QName* newValue);\r
\r
/**\r
- * Underlying list of child objects.\r
- * Manages the lifetime of the children.\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
+ * 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 new value \r
+ * \r
+ * @throws XMLObjectException if the new child already has a parent.\r
*/\r
- std::list<XMLObject*> m_children;\r
+ XMLObject* prepareForAssignment(XMLObject* oldValue, XMLObject* newValue);\r
\r
/**\r
* Set of namespaces associated with the object.\r