- Moved to DOMC

1 files changed, 1659 insertions, 0 deletions

diff --git a/src/domcxx.h b/src/domcxx.h
new file mode 100644
index 0000000..bd96078
--- /dev/null
+++ b/src/domcxx.h
@@ -0,0 +1,1659 @@
+/*
+ * Copyright (c) 2004, Nate Nielsen
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions of source code must retain the above
+ *       copyright notice, this list of conditions and the
+ *       following disclaimer.
+ *     * Redistributions in binary form must reproduce the
+ *       above copyright notice, this list of conditions and
+ *       the following disclaimer in the documentation and/or
+ *       other materials provided with the distribution.
+ *     * The names of contributors to this software may not be
+ *       used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ *
+ * CONTRIBUTORS
+ *  Nate Nielsen <nielsen@memberwebs.com>
+ *
+ */
+
+// TODO: UPDATE these comments once done
+// DOMC C++ WRAPPER
+//
+//   Everything is in the DOM namespace.
+//
+
+#ifndef __DOMCXX_H__
+#define __DOMCXX_H__
+
+#include <stdio.h>
+#include <exception>
+#include <string>
+
+namespace DOM
+{
+	extern "C"
+	{
+        #define this _this
+        #include <domc.h>
+        #include <dom.h>
+        #undef this
+	}
+
+#ifdef ASSERT
+	#define DOM_ASSERT ASSERT
+#else
+	#include <assert.h>
+	#define ASSERT assert
+#endif
+
+    typedef std::basic_string<char> data_str;
+    typedef std::basic_string<char> dom_str;
+
+	#define ASSERT_VALID() \
+		ASSERT(isValid());
+	#define ASSERT_VALID_NODE(node) \
+		ASSERT(node.isValid());
+	#define ASSERT_TYPE(t) \
+		ASSERT(getNodeType() == t)
+	#define ASSERT_NODE_TYPE(n, t) \
+		ASSERT(n.getNodeType() == t)
+    #define RESET_ERR() \
+        DOM_Exception = 0;
+    #define CHECK_ERR() \
+        if(DOM_Exception != 0) throw DOMException(DOM_Exception);
+    #define NO_REFCNT   0xFFFFFFFF
+    #define FROM_D(s) \
+        ((DOM_String*)((s).c_str()))
+    #define FROM_V(s) \
+        ((DOM_String*)((s).c_str()))
+
+	class DOMException
+	{
+	public:
+        DOMException(int e)
+        {
+            ASSERT(e != 0);
+          code = (short)e;
+        }
+
+		typedef enum
+		{
+			INDEX_SIZE_ERR = 1,
+			DOMSTRING_SIZE_ERR = 2,
+			HIERARCHY_REQUEST_ERR = 3,
+			WRONG_DOCUMENT_ERR = 4,
+			INVALID_CHARACTER_ERR = 5,
+			NO_DATA_ALLOWED_ERR = 6,
+			NO_MODIFICATION_ALLOWED_ERR = 7,
+			NOT_FOUND_ERR = 8,
+			NOT_SUPPORTED_ERR = 9,
+			INUSE_ATTRIBUTE_ERR = 10
+		} CODES;
+
+		int getCode()
+			{ return code; }
+		char* getMessage()
+			{ /* TODO: Get from the domc library */ return NULL; }
+		void getDetails(int* cde, char** message,
+			            char** documentUri, int* fileLine)
+	    {
+            *cde = code;
+            *message = NULL;        // TODO: Get from domc library
+            *documentUri = NULL;
+            *fileLine = 0;
+        }
+
+		short code;
+	};
+
+    class NodeList;
+    class NamedNodeMap;
+	class Element;
+	class Document;
+	class DOMImplementation;
+
+    /* We only perform ref counting on nodes outside the tree */
+    #define INC_NODE_REF(n) \
+        if((n).m_node != NULL && ((n).m_node)->parentNode == NULL) incref((n).m_node)
+    #define DEC_NODE_REF(n) \
+        if((n).m_node != NULL && ((n).m_node)->parentNode == NULL) decref((n).m_node)
+
+	/**
+	 * Thin wrapper class for a DOM Node
+	 */
+	class Node
+    {
+	public:
+		enum TYPES
+		{
+			 ELEMENT_NODE = DOM_ELEMENT_NODE,
+			 ATTRIBUTE_NODE = DOM_ATTRIBUTE_NODE,
+			 TEXT_NODE = DOM_TEXT_NODE,
+			 CDATA_SECTION_NODE = DOM_CDATA_SECTION_NODE,
+			 ENTITY_REFERENCE_NODE = DOM_ENTITY_REFERENCE_NODE,
+			 ENTITY_NODE = DOM_ENTITY_NODE,
+			 PROCESSING_INSTRUCTION_NODE = DOM_PROCESSING_INSTRUCTION_NODE,
+			 COMMENT_NODE = DOM_COMMENT_NODE,
+			 DOCUMENT_NODE = DOM_DOCUMENT_NODE,
+			 DOCUMENT_TYPE_NODE = DOM_DOCUMENT_TYPE_NODE,
+			 DOCUMENT_FRAGMENT_NODE = DOM_DOCUMENT_FRAGMENT_NODE,
+			 NOTATION_NODE = DOM_NOTATION_NODE
+		};
+
+		Node()
+    		{ m_node = NULL; }
+
+		Node(const Node& node)
+		{
+            INC_NODE_REF(node);
+			m_node = node.m_node;
+		}
+
+	    Node& operator=(const Node& other)
+		{
+            INC_NODE_REF(other);
+            DEC_NODE_REF(*this);
+			m_node = other.m_node;
+			return *this;
+		}
+
+		Node& operator=(const void* null)
+		{
+			ASSERT(null == NULL);
+            DEC_NODE_REF(*this);
+			m_node = NULL;
+			return *this;
+		}
+
+        ~Node()
+            { DEC_NODE_REF(*this); }
+
+		bool operator==(const Node& other) const
+    		{ return m_node == other.m_node; }
+		bool operator==(const void* null) const
+    		{ ASSERT(null == NULL); return m_node == NULL; }
+		bool operator!=(const Node& other) const
+			{ return !operator==(other); }
+		bool operator!=(const void* null) const
+			{ return !operator==(null); }
+
+		const Node* operator->() const
+			{ return (const Node*)this; }
+		Node* operator->()
+			{ return this; }
+
+		dom_str getNodeName() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			DOM_String* name = m_node->nodeName;
+			return dom_str(name);
+		}
+
+		data_str getNodeValue() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            // TODO: Check on memory management
+			DOM_String* value = DOM_Node_getNodeValue(m_node);
+			return data_str(value);
+		}
+
+		void setNodeValue(const data_str& value)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            RESET_ERR();
+			DOM_Node_setNodeValue(m_node, FROM_V(value));
+            CHECK_ERR();
+		}
+
+		short getNodeType() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            return (short)(m_node->nodeType);
+		}
+
+		Node getParentNode() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			return Node(m_node->parentNode);
+		}
+
+		NodeList getChildNodes() const
+			throw(DOMException);
+
+		Node getFirstChild() const
+			throw(DOMException)
+		{
+            ASSERT_VALID();
+            return Node(m_node->firstChild);
+		}
+
+		Node getLastChild() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            return Node(m_node->lastChild);
+		}
+
+		Node getPreviousSibling() const
+			throw(DOMException)
+		{
+            ASSERT_VALID();
+            return Node(m_node->previousSibling);
+		}
+
+		Node getNextSibling() const
+			throw(DOMException)
+		{
+            ASSERT_VALID();
+            return Node(m_node->nextSibling);
+		}
+
+		NamedNodeMap getAttributes() const
+			throw(DOMException);
+
+		Document getOwnerDocument() const
+			throw(DOMException);
+
+		Node insertBefore(const Node& newChild, const Node& refChild)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(newChild);
+			ASSERT_VALID_NODE(refChild);
+            RESET_ERR();
+            Node node(DOM_Node_insertBefore(m_node, newChild.m_node, refChild.m_node));
+            CHECK_ERR();
+            return node;
+		}
+
+		Node replaceChild(const Node& newChild, const Node& refChild)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(newChild);
+			ASSERT_VALID_NODE(refChild);
+            RESET_ERR();
+            Node node(DOM_Node_replaceChild(m_node, newChild.m_node, refChild.m_node));
+            CHECK_ERR();
+            return node;
+		}
+
+		Node removeChild(const Node& oldChild)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(oldChild);
+            RESET_ERR();
+            Node node(DOM_Node_removeChild(m_node, oldChild.m_node));
+            CHECK_ERR();
+            return node;
+		}
+
+		Node appendChild(const Node& newChild)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(newChild);
+            RESET_ERR();
+            Node node(DOM_Node_appendChild(m_node, newChild.m_node));
+            CHECK_ERR();
+            return node;
+		}
+
+		bool hasChildNodes() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            return DOM_Node_hasChildNodes(m_node) ? true : false;
+		}
+
+		Node cloneNode(bool deep) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            RESET_ERR();
+			Node node(DOM_Node_cloneNode(m_node, deep ? 1 : 0));
+            CHECK_ERR();
+			return node;
+		}
+
+		void normalize()
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            if(m_node->nodeType == DOM_ELEMENT_NODE)
+            {
+                RESET_ERR();
+                DOM_Element_normalize(m_node);
+                CHECK_ERR();
+            }
+		}
+
+		bool isSupported(const dom_str& feature,
+						 const dom_str& version) const
+		{
+			ASSERT_VALID();
+			return false;
+		}
+
+#if INCOMPLETE
+		dom_str getNamespaceURI() const
+			throw(DOMException)
+		{
+		}
+
+		dom_str getPrefix() const
+			throw(DOMException)
+		{
+		}
+
+		void setPrefix(const dom_str& prefix)
+			throw(DOMException)
+		{
+		}
+
+		dom_str getLocalName() const
+			throw(DOMException)
+		{
+		}
+#endif
+
+		bool hasAttributes() const
+			throw (DOMException)
+		{
+			ASSERT_VALID();
+
+			if(getNodeType() != ELEMENT_NODE)
+				return false;
+
+            return m_node->attributes != NULL &&
+                   m_node->attributes->length > 0;
+		}
+
+		void* setUserData(void* data)
+			throw(DOMException)
+		{
+            ASSERT_VALID();
+            m_node->userData = data;
+		}
+
+		void* getUserData() const
+			throw(DOMException)
+		{
+            ASSERT_VALID();
+            return m_node->userData;
+		}
+
+		bool isValid() const
+    		{ return m_node != NULL; }
+
+	protected:
+		Node(DOM_Node* node)
+        {
+            m_node = node;
+            INC_NODE_REF(*this);
+        }
+
+	protected:
+		DOM_Node* m_node;
+
+		friend class Document;
+        friend class NodeList;
+        friend class NamedNodeMap;
+
+    private:
+        inline void incref(DOM_Node* node)
+            { ASSERT(node); ++(node->rtfxRefCount); }
+
+        inline void decref(DOM_Node* node)
+        {
+            ASSERT(node);
+            ASSERT(node->parentNode == NULL);
+            --(node->rtfxRefCount);
+            if(node->rtfxRefCount <= 0)
+            {
+                ASSERT(node->ownerDocument);
+                DOM_Document_destroyNode(node->ownerDocument, node);
+            }
+        }
+	};
+
+	class Attr :
+		public Node
+	{
+	public:
+		Attr() { }
+		Attr(const Attr& node) :
+			Node(node) { }
+
+	    Attr& operator=(const Attr& other)
+			{ Node::operator=(other); return *this; }
+		Attr& operator=(const void* null)
+			{ Node::operator=(null); return *this; }
+		const Attr* operator->() const
+			{ return (const Attr*)this; }
+		Attr* operator->()
+			{ return this; }
+
+		dom_str getName() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ATTRIBUTE_NODE);
+			return getNodeName();
+		}
+
+		Element getOwnerElement() const
+			throw(DOMException);
+
+		bool getSpecified() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ATTRIBUTE_NODE);
+			return true;
+		}
+
+		data_str getValue() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ATTRIBUTE_NODE);
+			return getNodeValue();
+		}
+
+		void setValue(const data_str& value)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ATTRIBUTE_NODE);
+			setNodeValue(value);
+		}
+
+	protected:
+		Attr(DOM_Node* node) :
+			 Node(node) { }
+
+		friend class Element;
+		friend class Document;
+	};
+
+	/**
+	 * This wrapper class for an element
+	 */
+	class Element :
+		public Node
+	{
+	public:
+		Element() { }
+		Element(const Element& node) :
+			Node(node) {}
+
+        Element& operator=(const Node& other)
+            { Node::operator=(other); return *this; }
+	    Element& operator=(const Element& other)
+			{ Node::operator=(other); return *this; }
+		Element& operator=(const void* null)
+			{ Node::operator=(null); return *this; }
+		const Element* operator->() const
+			{ return (const Element*)this; }
+		Element* operator->()
+			{ return this; }
+
+		dom_str getTagName() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+			return getNodeName();
+		}
+
+		data_str getAttribute(const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+            RESET_ERR();
+            // TODO: Check on memory management
+			DOM_String* value = DOM_Element_getAttribute(m_node, FROM_D(name));
+            CHECK_ERR();
+			return data_str(value);
+		}
+
+		void setAttribute(const dom_str& name, const data_str& value)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+            RESET_ERR();
+            DOM_Element_setAttribute(m_node, FROM_D(name), FROM_V(value));
+            CHECK_ERR();
+		}
+
+		void removeAttribute(const dom_str& name)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+            RESET_ERR();
+            DOM_Element_removeAttribute(m_node, FROM_D(name));
+            CHECK_ERR();
+		}
+
+		Attr getAttributeNode(const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+            RESET_ERR();
+            Attr attr(DOM_Element_getAttributeNode(m_node, FROM_D(name)));
+            CHECK_ERR();
+			return attr;
+		}
+
+		Attr setAttributeNode(const Attr& attr)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(attr);
+			ASSERT_TYPE(ELEMENT_NODE);
+            RESET_ERR();
+            Attr att(DOM_Element_setAttributeNode(m_node, attr.m_node));
+            CHECK_ERR();
+			return att;
+		}
+
+		Attr removeAttributeNode(const Attr& attr)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(attr);
+			ASSERT_TYPE(ELEMENT_NODE);
+            RESET_ERR();
+            Attr att(DOM_Element_removeAttributeNode(m_node, attr.m_node));
+            CHECK_ERR();
+            return att;
+		}
+
+		NodeList getElementsByTagName(const dom_str& name) const
+			throw(DOMException);
+
+#ifdef INCOMPLETE
+		data_str getAttributeNS(const dom_str& uri, const dom_str& name) const
+			throw(DOMException)
+		{
+		}
+
+		void setAttributeNS(const dom_str& uri, const dom_str& name,
+							const data_str& value)
+			throw(DOMException)
+		{
+		}
+
+		void removeAttributeNS(const dom_str& uri, const dom_str& name)
+			throw(DOMException)
+		{
+		}
+
+		Attr getAttributeNodeNS(const dom_str& uri, const dom_str& name) const
+			throw(DOMException)
+		{
+		}
+
+		Attr setAttributeNodeNS(const Attr& attr)
+			throw(DOMException)
+		{
+		}
+
+		NodeList getElementsByTagNameNS(const dom_str& uri,
+										const dom_str& name) const
+			throw(DOMException);
+#endif
+
+		bool hasAttribute(const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+            RESET_ERR();
+            bool ret = (DOM_Element_getAttributeNode(m_node, FROM_D(name)) != NULL);
+            CHECK_ERR();
+            return ret;
+		}
+
+#ifdef INCOMPLETE
+		bool hasAttributeNS(const dom_str& uri, const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+			return getAttributeNodeNS(uri, name) != NULL;
+		}
+#endif
+
+	protected:
+		Element(DOM_Node* node) :
+			 Node(node) { }
+
+		friend class Attr;
+		friend class Document;
+	};
+
+
+	class CharacterData :
+		public Node
+	{
+	public:
+		CharacterData() { }
+		CharacterData(const Node& node) :
+			Node(node) { }
+
+        CharacterData& operator=(const Node& other)
+            { Node::operator=(other); return *this; }
+	    CharacterData& operator=(const CharacterData& other)
+			{ Node::operator=(other); return *this; }
+		CharacterData& operator=(const void* null)
+			{ Node::operator=(null); return *this; }
+		const CharacterData* operator->() const
+			{ return (const CharacterData*)this; }
+		CharacterData* operator->()
+			{ return this; }
+
+		void appendData(const data_str& data)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+            RESET_ERR();
+            DOM_CharacterData_appendData(m_node, FROM_D(data));
+            CHECK_ERR();
+		}
+
+		void deleteData(int offset, int count)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+            RESET_ERR();
+            DOM_CharacterData_deleteData(m_node, offset, count);
+            CHECK_ERR();
+		}
+
+		data_str getData() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+			return getNodeValue();
+		}
+
+		int getLength() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+            RESET_ERR();
+            int len = DOM_CharacterData_getLength(m_node);
+            CHECK_ERR();
+            return len;
+		}
+
+		void insertData(int offset, const data_str& data)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+            RESET_ERR();
+            DOM_CharacterData_insertData(m_node, offset, FROM_V(data));
+            CHECK_ERR();
+		}
+
+		void replaceData(int offset, int count, const data_str& data)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+            RESET_ERR();
+            DOM_CharacterData_replaceData(m_node, offset, count, FROM_V(data));
+            CHECK_ERR();
+		}
+
+		void setData(const data_str& data)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+			setNodeValue(data);
+		}
+
+		data_str substringData(int offset, int count) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+            RESET_ERR();
+            DOM_String* value = DOM_CharacterData_substringData(m_node, offset, count);
+            CHECK_ERR();
+            return data_str(value);
+		}
+
+	protected:
+		CharacterData(DOM_Node* node) :
+			 Node(node) { }
+	};
+
+	class Text :
+		public CharacterData
+	{
+	public:
+		Text() { }
+		Text(const Node& node) :
+			CharacterData(node) { }
+
+		Text& operator=(const Text& other)
+			{ CharacterData::operator=(other); return *this; }
+		Text& operator=(const void* null)
+			{ CharacterData::operator=(null); return *this; }
+		const Text* operator->() const
+			{ return (const Text*)this; }
+		Text* operator->()
+			{ return this; }
+
+		Text splitText(int offset)
+			throw(DOMException)
+        {
+            ASSERT_VALID();
+            ASSERT_TYPE(TEXT_NODE);
+            RESET_ERR();
+            Text text(DOM_Text_splitText(m_node, offset));
+            CHECK_ERR();
+            return text;
+        }
+
+	protected:
+		Text(DOM_Node* node) :
+			 CharacterData(node) { }
+
+		friend class Document;
+	};
+
+	class CDATASection :
+		public Text
+	{
+	public:
+		CDATASection() { }
+		CDATASection(const CDATASection& node) :
+			Text(node) { }
+
+		CDATASection& operator=(const CDATASection& other)
+			{ Text::operator=(other); return *this; }
+		CDATASection& operator=(void* null)
+			{ Text::operator=(null); return *this; }
+		const CDATASection* operator->() const
+			{ return (const CDATASection*)this; }
+		CDATASection* operator->()
+			{ return this; }
+
+	protected:
+		CDATASection(DOM_Node* node) :
+			 Text(node) { }
+
+		friend class Document;
+	};
+
+	class Comment :
+		public CharacterData
+	{
+	public:
+		Comment() { }
+		Comment(const Comment& node) :
+			CharacterData(node) { }
+
+        Comment& operator=(const Node& other)
+            { Node::operator=(other); return *this; }
+		Comment& operator=(const Comment& other)
+			{ CharacterData::operator=(other); return *this; }
+		Comment& operator=(void* null)
+			{ CharacterData::operator=(null); return *this; }
+		const Comment* operator->() const
+			{ return (const Comment*)this; }
+		Comment* operator->()
+			{ return this; }
+
+	protected:
+		Comment(DOM_Node* node) :
+			 CharacterData(node) { }
+
+		friend class Document;
+	};
+
+	class ProcessingInstruction :
+		public Node
+	{
+	public:
+		ProcessingInstruction() { }
+		ProcessingInstruction(const ProcessingInstruction& node) :
+			Node(node) { }
+
+        ProcessingInstruction& operator=(const Node& other)
+            { Node::operator=(other); return *this; }
+		ProcessingInstruction& operator=(const ProcessingInstruction& other)
+			{ Node::operator=(other); return *this; }
+		ProcessingInstruction& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const ProcessingInstruction* operator->() const
+			{ return (const ProcessingInstruction*)this; }
+		ProcessingInstruction* operator->()
+			{ return this; }
+
+		data_str getData() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(PROCESSING_INSTRUCTION_NODE);
+			return getNodeValue();
+		}
+
+		dom_str getTarget() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(PROCESSING_INSTRUCTION_NODE);
+			return getNodeName();
+		}
+
+		void setData(const data_str& data)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(PROCESSING_INSTRUCTION_NODE);
+			setNodeValue(data);
+		}
+
+	protected:
+		ProcessingInstruction(DOM_Node* node) :
+			 Node(node) { }
+
+		friend class Document;
+	};
+
+	class DocumentFragment :
+		public Node
+	{
+	public:
+		DocumentFragment() { }
+		DocumentFragment(const DocumentFragment& node) :
+			Node(node) { }
+
+        DocumentFragment& operator=(const Node& other)
+            { Node::operator=(other); return *this; }
+		DocumentFragment& operator=(const DocumentFragment& other)
+			{ Node::operator=(other); return *this; }
+		DocumentFragment& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const DocumentFragment* operator->() const
+			{ return (const DocumentFragment*)this; }
+		DocumentFragment* operator->()
+			{ return this; }
+
+    protected:
+        DocumentFragment(DOM_Node* node) :
+            Node(node) { }
+
+        friend class Document;
+	};
+
+	class Entity :
+		public Node
+	{
+	public:
+		Entity() { }
+		Entity(const Entity& node) :
+			Node(node) { }
+
+        Entity& operator=(const Node& other)
+            { Node::operator=(other); return *this; }
+		Entity& operator=(const Entity& other)
+			{ Node::operator=(other); return *this; }
+		Entity& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const Entity* operator->() const
+			{ return (const Entity*)this; }
+		Entity* operator->()
+			{ return this; }
+
+		dom_str getNotationName() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ENTITY_NODE);
+            return getNodeName();
+		}
+
+		dom_str getPublicId() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ENTITY_NODE);
+            return dom_str(m_node->u.Entity.publicId);
+		}
+
+		dom_str getSystemId() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ENTITY_NODE);
+            return dom_str(m_node->u.Entity.systemId);
+		}
+
+    protected:
+        Entity(DOM_Node* node) :
+            Node(node) { }
+
+        friend class DocumentType;
+	};
+
+	class EntityReference :
+		public Node
+	{
+	public:
+		EntityReference() { }
+		EntityReference(const EntityReference& node) :
+			Node(node) { }
+
+        EntityReference& operator=(const Node& other)
+            { Node::operator=(other); return *this; }
+		EntityReference& operator=(const EntityReference& other)
+			{ Node::operator=(other); return *this; }
+		EntityReference& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const EntityReference* operator->() const
+			{ return (const EntityReference*)this; }
+		EntityReference* operator->()
+			{ return this; }
+
+    protected:
+        EntityReference(DOM_Node* node) :
+            Node(node) { }
+
+        friend class DocumentType;
+        friend class Document;
+	};
+
+	class Notation :
+		public Node
+	{
+	public:
+		Notation() { }
+		Notation(const Notation& node) :
+			Node(node) { }
+
+        Notation& operator=(const Node& other)
+            { Node::operator=(other); return *this; }
+		Notation& operator=(const Notation& other)
+			{ Node::operator=(other); return *this; }
+		Notation& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const Notation* operator->() const
+			{ return (const Notation*)this; }
+		Notation* operator->()
+			{ return this; }
+
+		dom_str getPublicId() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(NOTATION_NODE);
+            return dom_str(m_node->u.Notation.publicId);
+		}
+
+		dom_str getSystemId() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(NOTATION_NODE);
+            return dom_str(m_node->u.Notation.systemId);
+		}
+
+    protected:
+        Notation(DOM_Node* node) :
+            Node(node) { }
+
+        friend class DocumentType;
+	};
+
+	class DocumentType :
+		public Node
+	{
+	public:
+		DocumentType() { }
+		DocumentType(const DocumentType& node) :
+			Node(node) { }
+
+        DocumentType& operator=(const Node& other)
+            { Node::operator=(other); return *this; }
+		DocumentType& operator=(const DocumentType& other)
+			{ Node::operator=(other); return *this; }
+		DocumentType& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const DocumentType* operator->() const
+			{ return (const DocumentType*)this; }
+		DocumentType* operator->()
+			{ return this; }
+
+		NamedNodeMap getEntities() const
+			throw(DOMException);
+
+        NamedNodeMap getNotations() const
+            throw(DOMException);
+
+		dom_str getInternalSubset() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            ASSERT_TYPE(DOCUMENT_TYPE_NODE);
+            return dom_str(m_node->u.DocumentType.internalSubset);
+		}
+
+		dom_str getName() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            ASSERT_TYPE(DOCUMENT_TYPE_NODE);
+            return getNodeName();
+		}
+
+    protected:
+        DocumentType(DOM_Node* node) :
+            Node(node) { }
+
+        friend class Document;
+        friend class DOMImplementation;
+	};
+
+
+	class Document :
+		public Node
+	{
+	public:
+		Document() { }
+		Document(const Document& doc) :
+			Node(doc) { }
+
+		Document& operator=(const Document& other)
+			{ Node::operator=(other); return *this; }
+		Document& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const Document* operator->() const
+			{ return (const Document*)this; }
+		Document* operator->()
+			{ return this; }
+
+		DocumentType getDocType() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+            RESET_ERR();
+            DocumentType dt(DOM_Document_getDoctype(m_node));
+            CHECK_ERR();
+            return dt;
+		}
+
+		DOMImplementation getImplementation() const
+			throw(DOMException);
+
+		Element getDocumentElement() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+            RESET_ERR();
+            Element el(DOM_Document_getDocumentElement(m_node));
+            CHECK_ERR();
+            return el;
+		}
+
+		Element createElement(const dom_str& tag) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+            RESET_ERR();
+            Element el(DOM_Document_createElement(m_node, FROM_D(tag)));
+            CHECK_ERR();
+            return el;
+		}
+
+		DocumentFragment createDocumentFragment() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+            RESET_ERR();
+            DocumentFragment df(DOM_Document_createDocumentFragment(m_node));
+            CHECK_ERR();
+            return df;
+		}
+
+		Text createTextNode(const data_str& data) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+            RESET_ERR();
+            Text text(DOM_Document_createTextNode(m_node, FROM_V(data)));
+            CHECK_ERR();
+            return text;
+		}
+
+		Comment createComment(const data_str& data) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+            RESET_ERR();
+            Comment comment(DOM_Document_createComment(m_node, FROM_V(data)));
+            CHECK_ERR();
+            return comment;
+		}
+
+		CDATASection createCDATASection(const data_str& data) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+            RESET_ERR();
+            CDATASection cdata(DOM_Document_createCDATASection(m_node, FROM_V(data)));
+            CHECK_ERR();
+            return cdata;
+		}
+
+		ProcessingInstruction createProcessingInstruction(const dom_str& targ,
+														  const data_str& data) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+            RESET_ERR();
+            ProcessingInstruction pi(DOM_Document_createProcessingInstruction
+                            (m_node, FROM_D(targ), FROM_V(data)));
+            CHECK_ERR();
+            return pi;
+		}
+
+		Attr createAttribute(const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+            RESET_ERR();
+            Attr attr(DOM_Document_createAttribute(m_node, FROM_D(name)));
+            CHECK_ERR();
+            return attr;
+		}
+
+		EntityReference createEntityReference(const dom_str& name)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+            RESET_ERR();
+            EntityReference er(DOM_Document_createEntityReference(m_node, FROM_D(name)));
+            CHECK_ERR();
+            return er;
+		}
+
+		NodeList getElementsByTagName(const dom_str& name) const
+			throw(DOMException);
+
+#ifdef INCOMPLETE
+		Node importNode(const Node& import, bool deep) const
+			throw(DOMException)
+		{
+		}
+
+		Element createElementNS(const dom_str& uri, const dom_str& tag) const
+			throw(DOMException)
+		{
+		}
+
+		Attr createAttributeNS(const dom_str& uri, const dom_str& name) const
+			throw(DOMException)
+		{
+		}
+
+		NodeList getElementsByTagNameNS(const dom_str& uri,
+										const dom_str& name) const
+			throw(DOMException);
+
+		Element getElementById(const dom_str& id) const
+			throw(DOMException)
+		{
+		}
+#endif
+        void serialize(FILE* f)
+            throw(DOMException)
+        {
+            ASSERT_VALID();
+            RESET_ERR();
+            DOM_DocumentLS_fwrite(m_node, f);
+            CHECK_ERR();
+        }
+
+	protected:
+        Document(DOM_Document* doc) :
+            Node(doc) { }
+
+		friend class Node;
+		friend class DOMImplementation;
+	};
+
+	class DOMImplementation
+	{
+	public:
+		DOMImplementation()  { }
+		DOMImplementation(const DOMImplementation& impl) { }
+
+		DOMImplementation& operator=(const DOMImplementation& other)
+			{ return *this; }
+		DOMImplementation& operator=(void* null)
+			{ return *this; }
+		const DOMImplementation* operator->() const
+			{ return (const DOMImplementation*)this; }
+		DOMImplementation* operator->()
+			{ return this; }
+
+		Document createDocument(const dom_str& uri, const dom_str& qname,
+								const DocumentType& type) const
+			throw(DOMException)
+		{
+            RESET_ERR();
+            Document doc(DOM_Implementation_createDocument
+                    (FROM_D(uri), FROM_D(qname), type.m_node));
+            CHECK_ERR();
+            return doc;
+		}
+
+		DocumentType createDocumentType(const dom_str& qname,
+									    const dom_str& publicId,
+										const dom_str& systemId) const
+			throw(DOMException)
+		{
+            RESET_ERR();
+            DocumentType doctype(DOM_Implementation_createDocumentType
+                    (FROM_D(qname), FROM_D(publicId), FROM_D(systemId)));
+            CHECK_ERR();
+            return doctype;
+		}
+
+		bool hasFeature(const dom_str& feature, const dom_str& version) const
+			throw(DOMException)
+		{
+            RESET_ERR();
+            int ret = DOM_Implementation_hasFeature(FROM_D(feature), FROM_D(version));
+            CHECK_ERR();
+            return ret == 0 ? false : true;
+		}
+	};
+
+    /* We only perform ref counting on lists marked that way */
+    #define INC_NODELIST_REF(l) \
+        if((l).m_list != NULL && ((l).m_list->rtfxRefCount) != NO_REFCNT) incref((l).m_list)
+    #define DEC_NODELIST_REF(l) \
+        if((l).m_list != NULL && ((l).m_list->rtfxRefCount) != NO_REFCNT) decref((l).m_list)
+
+    class NodeList
+    {
+	public:
+        NodeList()
+            { m_list = NULL; }
+
+        NodeList(const NodeList& list)
+        {
+            INC_NODELIST_REF(list);
+            m_list = list.m_list;
+        }
+
+        NodeList& operator=(const NodeList& other)
+        {
+            INC_NODELIST_REF(other);
+            DEC_NODELIST_REF(*this);
+            m_list = other.m_list;
+            return *this;
+        }
+
+        NodeList& operator=(const void* null)
+        {
+            ASSERT(null == NULL);
+            DEC_NODELIST_REF(*this);
+            m_list = NULL;
+            return *this;
+        }
+
+        ~NodeList()
+            { DEC_NODELIST_REF(*this); }
+
+        bool operator==(const NodeList& other) const
+            { return m_list == other.m_list; }
+        bool operator==(const void* null) const
+            { ASSERT(null == NULL); return m_list == NULL; }
+        bool operator!=(const NodeList& other) const
+            { return !operator==(other); }
+        bool operator!=(const void* null) const
+            { return !operator==(null); }
+
+        const NodeList* operator->() const
+            { return (const NodeList*)this; }
+        NodeList* operator->()
+            { return this; }
+
+#ifdef COMPARE_REF
+		bool operator==(const NodeList& other) const
+			{ return m_list == ((NodeList&)other).m_list; }
+#endif
+
+		virtual int getLength() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            return m_list->length;
+		}
+
+		virtual Node item(int index) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            RESET_ERR();
+            Node node(DOM_NodeList_item(m_list, index));
+            CHECK_ERR();
+            return node;
+		}
+
+	protected:
+		NodeList(DOM_NodeList* list, bool refcnt)
+		{
+			m_list = list;
+
+            if(m_list != NULL)
+            {
+                if(refcnt)
+                    INC_NODELIST_REF(*this);
+                else
+                    m_list->rtfxRefCount = NO_REFCNT;
+            }
+		}
+
+		bool isValid() const
+		{
+			return m_list != NULL;
+		}
+
+	protected:
+		DOM_NodeList* m_list;
+
+		friend class Element;
+		friend class Document;
+
+    private:
+        inline void incref(DOM_NodeList* list)
+            { ASSERT(list && (list->rtfxRefCount) != NO_REFCNT); ++(list->rtfxRefCount); }
+
+        inline void decref(DOM_NodeList* list)
+        {
+            ASSERT(list->rtfxRefCount != NO_REFCNT);
+            --(list->rtfxRefCount);
+            if(list->rtfxRefCount <= 0)
+            {
+                ASSERT(list->_ownerDocument != NULL);
+                DOM_Document_destroyNodeList(list->_ownerDocument, list, 0);
+            }
+        }
+
+        friend class Node;
+	};
+
+
+	class NamedNodeMap :
+        public NodeList
+    {
+	public:
+        NamedNodeMap()
+            { }
+
+        NamedNodeMap(const NamedNodeMap& list) :
+            NodeList(list) { }
+
+        NamedNodeMap& operator=(const NamedNodeMap& other)
+            { NodeList::operator=(other); return *this; }
+        NamedNodeMap& operator=(void* null)
+            { NodeList::operator=(null); return *this; }
+       const NamedNodeMap* operator->() const
+            { return (const NamedNodeMap*)this; }
+       NamedNodeMap* operator->()
+            { return this; }
+
+		virtual int getLength() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            return NodeList::getLength();
+		}
+
+		virtual Node getNamedItem(const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            RESET_ERR();
+            Node node(DOM_NamedNodeMap_getNamedItem(m_list, FROM_D(name)));
+            CHECK_ERR();
+            return node;
+		}
+
+#ifdef INCOMPLETE
+		virtual Node getNamedItemNS(const dom_str& uri, const dom_str& name) const
+			throw(DOMException)
+		{
+		}
+#endif
+
+		virtual Node item(int index) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            RESET_ERR();
+            Node node(DOM_NodeList_item(m_list, index));
+            CHECK_ERR();
+            return node;
+		}
+
+		virtual Node removeNamedItem(const dom_str& name)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+            RESET_ERR();
+            Node node(DOM_NamedNodeMap_removeNamedItem(m_list, FROM_D(name)));
+            CHECK_ERR();
+            return node;
+		}
+
+#ifdef INCOMPLETE
+		virtual Node removeNamedItemNS(const dom_str& uri, const dom_str& name)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+			return Node();
+		}
+#endif
+
+		virtual Node setNamedItem(const Node& arg)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(arg);
+            RESET_ERR();
+            Node node(DOM_NamedNodeMap_setNamedItem(m_list, arg.m_node));
+            CHECK_ERR();
+            return node;
+		}
+
+#ifdef INCOMPLETE
+		virtual Node setNamedItemNS(const Node& arg)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(arg);
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+			return Node();
+		}
+#endif
+
+	protected:
+        NamedNodeMap(DOM_NodeList* list, bool refcnt) :
+            NodeList(list, refcnt) { }
+
+        friend class Node;
+        friend class DocumentType;
+	};
+
+
+	inline NodeList Node::getChildNodes() const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		return NodeList(m_node->childNodes, false);
+	}
+
+	inline NamedNodeMap Node::getAttributes() const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		if(getNodeType() != ELEMENT_NODE)
+			return NamedNodeMap();
+
+		return NamedNodeMap(m_node->attributes, false);
+	}
+
+	inline Document Node::getOwnerDocument() const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		return Document(m_node->ownerDocument);
+	}
+
+	inline Element Attr::getOwnerElement() const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		ASSERT_TYPE(ATTRIBUTE_NODE);
+        return Element(m_node->u.Attr.ownerElement);
+	}
+
+	inline NodeList Element::getElementsByTagName(const dom_str& name) const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		ASSERT_TYPE(ELEMENT_NODE);
+        RESET_ERR();
+        NodeList list(DOM_Element_getElementsByTagName(m_node, FROM_D(name)), true);
+        CHECK_ERR();
+        return list;
+	}
+
+#ifdef INCOMPLETE
+	inline NodeList Element::getElementsByTagNameNS(const dom_str& uri,
+										     const dom_str& name) const
+		throw(DOMException)
+	{
+	}
+#endif
+
+	inline NodeList Document::getElementsByTagName(const dom_str& name) const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		ASSERT_TYPE(DOCUMENT_NODE);
+        RESET_ERR();
+        NodeList list(DOM_Document_getElementsByTagName(m_node, FROM_D(name)), true);
+        CHECK_ERR();
+        return list;
+	}
+
+#ifdef INCOMPLETE
+	inline NodeList Document::getElementsByTagNameNS(const dom_str& uri,
+											  const dom_str& name) const
+		throw(DOMException)
+	{
+	}
+#endif
+
+	inline DOMImplementation Document::getImplementation() const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		ASSERT_TYPE(DOCUMENT_NODE);
+		return DOMImplementation();
+	}
+
+    inline NamedNodeMap DocumentType::getEntities() const
+       throw(DOMException)
+    {
+        ASSERT_VALID();
+        ASSERT_TYPE(DOCUMENT_TYPE_NODE);
+        return NamedNodeMap(m_node->u.DocumentType.entities, false);
+    }
+
+    inline NamedNodeMap DocumentType::getNotations() const
+        throw(DOMException)
+    {
+        ASSERT_VALID();
+        ASSERT_TYPE(DOCUMENT_TYPE_NODE);
+        return NamedNodeMap(m_node->u.DocumentType.notations, false);
+    }
+
+}; // namespace DOM
+
+
+#endif //__DOMCXX_H__