X-Git-Url: http://www.project-moonshot.org/gitweb/?p=shibboleth%2Fcpp-xmltooling.git;a=blobdiff_plain;f=xmltooling%2FAbstractXMLObject.cpp;h=64488562b9cf827d5afccd1f944087db53d84829;hp=780304a8c9ed7296422afc7d0db2d2e6944909b1;hb=f6221acce6ee490b9189dd2f5efabda3b9e64fb1;hpb=7c2636878325d3c99889f626a93dc876b5a77d65

diff --git a/xmltooling/AbstractXMLObject.cpp b/xmltooling/AbstractXMLObject.cpp
index 780304a..6448856 100644
--- a/xmltooling/AbstractXMLObject.cpp
+++ b/xmltooling/AbstractXMLObject.cpp
@@ -1,5 +1,5 @@
 /*
-*  Copyright 2001-2006 Internet2
+*  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.
@@ -25,17 +25,12 @@
 #include "exceptions.h"
 
 #include <algorithm>
-#include <log4cpp/Category.hh>
 
 using namespace xmltooling;
 
-AbstractXMLObject::~AbstractXMLObject() {
-    delete m_typeQname;
-    std::for_each(m_children.begin(), m_children.end(), cleanup<XMLObject>());
-}
-
 AbstractXMLObject::AbstractXMLObject(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
-    : m_log(&log4cpp::Category::getInstance(XMLTOOLING_LOGCAT".XMLObject")),
+    : m_log(logging::Category::getInstance(XMLTOOLING_LOGCAT".XMLObject")),
+    	m_schemaLocation(NULL), m_noNamespaceSchemaLocation(NULL), m_nil(xmlconstants::XML_BOOL_NULL),
         m_parent(NULL), m_elementQname(nsURI, localName, prefix), m_typeQname(NULL)
 {
     addNamespace(Namespace(nsURI, prefix));
@@ -46,14 +41,106 @@ AbstractXMLObject::AbstractXMLObject(const XMLCh* nsURI, const XMLCh* localName,
 }
 
 AbstractXMLObject::AbstractXMLObject(const AbstractXMLObject& src)
-    : m_namespaces(src.m_namespaces), m_log(src.m_log), m_parent(NULL), m_elementQname(src.m_elementQname), m_typeQname(NULL)
+    : m_namespaces(src.m_namespaces), m_log(src.m_log), m_schemaLocation(XMLString::replicate(src.m_schemaLocation)),
+        m_noNamespaceSchemaLocation(XMLString::replicate(src.m_noNamespaceSchemaLocation)), m_nil(src.m_nil),
+        m_parent(NULL), m_elementQname(src.m_elementQname), m_typeQname(NULL)
 {
     if (src.m_typeQname)
         m_typeQname=new QName(*src.m_typeQname);
 }
 
-XMLObject* AbstractXMLObject::prepareForAssignment(XMLObject* oldValue, XMLObject* newValue) {
+void XMLObject::setNil(const XMLCh* value) {
+    if (value) {
+        switch (*value) {
+            case xercesc::chLatin_t:
+                nil(xmlconstants::XML_BOOL_TRUE);
+                break;
+            case xercesc::chLatin_f:
+                nil(xmlconstants::XML_BOOL_FALSE);
+                break;
+            case xercesc::chDigit_1:
+                nil(xmlconstants::XML_BOOL_ONE);
+                break;
+            case xercesc::chDigit_0:
+                nil(xmlconstants::XML_BOOL_ZERO);
+                break;
+            default:
+                nil(xmlconstants::XML_BOOL_NULL);
+        }
+    }
+    else {
+        nil(xmlconstants::XML_BOOL_NULL);
+    }
+}
+
+XMLCh* AbstractXMLObject::prepareForAssignment(XMLCh* oldValue, const XMLCh* newValue)
+{
+    if (!XMLString::equals(oldValue,newValue)) {
+        releaseThisandParentDOM();
+        XMLCh* newString = XMLString::replicate(newValue);
+        XMLString::release(&oldValue);
+        return newString;
+    }
+    return oldValue;
+}
+
+QName* AbstractXMLObject::prepareForAssignment(QName* oldValue, const QName* newValue)
+{
+    if (!oldValue) {
+        if (newValue) {
+            releaseThisandParentDOM();
+            Namespace newNamespace(newValue->getNamespaceURI(), newValue->getPrefix());
+            addNamespace(newNamespace);
+            return new QName(*newValue);
+        }
+        return NULL;
+    }
+
+    delete oldValue;
+    releaseThisandParentDOM();
+    if (newValue) {
+        Namespace newNamespace(newValue->getNamespaceURI(), newValue->getPrefix());
+        addNamespace(newNamespace);
+        return new QName(*newValue);
+    }
+    return NULL;
+}
 
+DateTime* AbstractXMLObject::prepareForAssignment(DateTime* oldValue, const DateTime* newValue)
+{
+    if (!oldValue) {
+        if (newValue) {
+            releaseThisandParentDOM();
+            return new DateTime(*newValue);
+        }
+        return NULL;
+    }
+
+    delete oldValue;
+    releaseThisandParentDOM();
+    return newValue ? new DateTime(*newValue) : NULL;
+}
+
+DateTime* AbstractXMLObject::prepareForAssignment(DateTime* oldValue, time_t newValue)
+{
+    delete oldValue;
+    releaseThisandParentDOM();
+    DateTime* ret = new DateTime(newValue);
+    ret->parseDateTime();
+    return ret;
+}
+
+DateTime* AbstractXMLObject::prepareForAssignment(DateTime* oldValue, const XMLCh* newValue)
+{
+    delete oldValue;
+    releaseThisandParentDOM();
+    DateTime* ret = new DateTime(newValue);
+    ret->parseDateTime();
+    return ret;
+}
+
+XMLObject* AbstractXMLObject::prepareForAssignment(XMLObject* oldValue, XMLObject* newValue)
+{
     if (newValue && newValue->hasParent())
         throw XMLObjectException("child XMLObject cannot be added - it is already the child of another XMLObject");
 
@@ -74,3 +161,16 @@ XMLObject* AbstractXMLObject::prepareForAssignment(XMLObject* oldValue, XMLObjec
 
     return newValue;
 }
+
+void AbstractXMLObject::detach()
+{
+    if (!getParent())
+        return;
+    else if (getParent()->hasParent())
+        throw XMLObjectException("Cannot detach an object whose parent is itself a child.");
+
+    // Pull ourselves out of the parent and then blast him.
+    getParent()->removeChild(this);
+    delete m_parent;
+    m_parent = NULL;
+}