1 files changed, 236 insertions, 0 deletions
diff --git a/src/xmlnode.h b/src/xmlnode.h
new file mode 100644
index 0000000..2b01226
--- /dev/null
+++ b/src/xmlnode.h
@@ -0,0 +1,236 @@
+#ifndef XMLNODE
+#define XMLNODE
+#include <iostream>
+#include "linkedlist.h"
+#include "hashtable.h"
+/**
+ * Maintains all data pertient to an XML node, including sub-nodes and content.
+ * All child nodes can be accessed through index and through name via a hash
+ * table.  This makes it very easy to gain simple and fast access to all of
+ * your data.  For most applications, the memory footprint is also rather
+ * small.  While XmlNode objects can be used directly to create XML structures
+ * it is highly reccomended that all operations be performed through the
+ * XmlDocument class.
+ *@author Mike Buland
+ */
+class XmlNode
+{
+public:
+        /**
+         * Construct a new XmlNode.
+         *@param sName The name of the node.
+         *@param pParent The parent node.
+         *@param sContent The initial content string.
+         */
+        XmlNode(
+                const char *sName=NULL,
+                XmlNode *pParent = NULL,
+                const char *sContent=NULL
+                );
+        
+        /**
+         * Delete the node and cleanup all memory.
+         */
+        ~XmlNode();
+        /**
+         * Change the name of the node.
+         *@param sName The new name of the node.
+         */
+        void setName( const char *sName );
+        /**
+         * Construct a new node and add it as a child to this node, also return a
+         * pointer to the newly constructed node.
+         *@param sName The name of the new node.
+         *@param sContent The initial content of the new node.
+         *@returns A pointer to the newly created child node.
+         */
+        XmlNode *addChild( const char *sName, const char *sContent=NULL );
+        /**
+         * Add an already created XmlNode as a child to this node.  The new child
+         * XmlNode's parent will be changed appropriately and the parent XmlNode
+         * will take ownership of the child.
+         *@param pChild The child XmlNode to add to this XmlNode.
+         *@returns A pointer to the child node that was just added.
+         */
+        XmlNode *addChild( XmlNode *pChild );
+        /**
+         * Add a new property to the XmlNode.  Properties are name/value pairs.
+         *@param sName The name of the property.  Specifying a name that's already
+         * in use will overwrite that property.
+         *@param sValue The textual value of the property.
+         */
+        void addProperty( const char *sName, const char *sValue );
+        /**
+         * Get a pointer to the parent node, if any.
+         *@returns A pointer to the node's parent, or NULL if there isn't one.
+         */
+        XmlNode *getParent();
+        /**
+         * Tells you if this node has children.
+         *@returns True if this node has at least one child, false otherwise.
+         */
+        bool hasChildren();
+        /**
+         * Tells you how many children this node has.
+         *@returns The number of children this node has.
+         */
+        int getNumChildren();
+        /**
+         * Get a child node at a specific index.
+         *@param nIndex The zero-based index of the child to retreive.
+         *@returns A pointer to the child, or NULL if you requested an invalid
+         * index.
+         */
+        XmlNode *getChild( int nIndex );
+        /**
+         * Get a child with the specified name, and possibly skip value.  For an
+         * explination of skip values see the HashTable.
+         *@param sName The name of the child to find.
+         *@param nSkip The number of nodes with that name to skip.
+         *@returns A pointer to the child, or NULL if no child with that name was
+         * found.
+         */
+        XmlNode *getChild( const char *sName, int nSkip=0 );
+        /**
+         * Get a pointer to the name of this node.  Do not change this, use setName
+         * instead.
+         *@returns A pointer to the name of this node.
+         */
+        const char *getName();
+        /**
+         * Set the content of this node, optionally at a specific index.  Using the
+         * default of -1 will set the content after the last added node.
+         *@param sContent The content string to use.
+         *@param nIndex The index of the content.
+         */
+        void setContent( const char *sContent, int nIndex=-1 );
+        /**
+         * Get the content string at a given index, or zero for initial content.
+         *@param nIndex The index of the content.
+         *@returns A pointer to the content at that location.
+         */
+        const char *getContent( int nIndex = 0 );
+        /**
+         * Get the number of properties in this node.
+         *@returns The number of properties in this node.
+         */
+        int getNumProperties();
+        /**
+         * Get a property's name by index.
+         *@param nIndex The index of the property to examine.
+         *@returns A pointer to the name of the property specified, or NULL if none
+         * found.
+         */
+        const char *getPropertyName( int nIndex );
+        /**
+         * Get a proprty's value by index.
+         *@param nIndex The index of the property to examine.
+         *@returns A pointer to the value of the property specified, or NULL if none
+         * found.
+         */
+        const char *getProperty( int nIndex );
+        /**
+         * Get a propery's value by name.
+         *@param sName The name of the property to examine.
+         *@returns A pointer to the value of the property specified, or NULL if none
+         * found.
+         */
+        const char *getProperty( const char *sName );
+        /**
+         * Delete a property by index.
+         *@param nIndex The index of the property to delete.
+         *@returns True if the property was found and deleted, false if it wasn't
+         * found.
+         */
+        bool deleteProperty( int nIndex );
+        /**
+         * Delete a child node, possibly replacing it with some text.  This actually
+         * fixes all content strings around the newly deleted child node.
+         *@param nIndex The index of the node to delete.
+         *@param sReplacementText The optional text to replace the node with.
+         *@returns True of the node was found, and deleted, false if it wasn't
+         * found.
+         */
+        bool deleteNode( int nIndex, const char *sReplacementText = NULL );
+        /**
+         * Delete a given node, but move all of it's children and content up to
+         * replace the deleted node.  All of the content of the child node is
+         * spliced seamlessly into place with the parent node's content.
+         *@param nIndex The node to delete.
+         *@returns True if the node was found and deleted, false if it wasn't.
+         */
+        bool deleteNodeKeepChildren( int nIndex );
+        /**
+         * Detatch a given child node from this node.  This effectively works just
+         * like a deleteNode, except that instead of deleting the node it is removed
+         * and returned, and all ownership is given up.
+         *@param nIndex The index of the node to detatch.
+         *@param sReplacementText The optional text to replace the detatched node
+         * with.
+         *@returns A pointer to the newly detatched node, which then passes
+         * ownership to the caller.
+         */
+        XmlNode *detatchNode( int nIndex, const char *sReplacementText = NULL );
+        /**
+         * Replace a given node with a different node that is not currently owned by
+         * this XmlNode or any ancestor.
+         *@param nIndex The index of the node to replace.
+         *@param pNewNode The new node to replace the old node with.
+         *@returns True if the node was found and replaced, false if it wasn't.
+         */
+        bool replaceNode( int nIndex, XmlNode *pNewNode );
+        /**
+         * Replace a given node with the children and content of a given node.
+         *@param nIndex The index of the node to replace.
+         *@param pNewNode The node that contains the children and content that will
+         * replace the node specified by nIndex.
+         *@returns True if the node was found and replaced, false if it wasn't.
+         */
+        bool replaceNodeWithChildren( int nIndex, XmlNode *pNewNode );
+        /**
+         * Get a copy of this node and all children.  getCopy is recursive, so
+         * beware copying large trees of xml.
+         *@returns A newly created copy of this node and all of it's children.
+         */
+        XmlNode *getCopy();
+private:
+        std::string sName;      /**< The name of the node. */
+        std::string *sPreContent;       /**< The content that goes before any node. */
+        LinkedList lChildren;   /**< The children. */
+        LinkedList lPostContent;        /**< The content that comes after children. */
+        HashTable hProperties;  /**< Property hashtable. */
+        HashTable hChildren;    /**< Children hashtable. */
+        LinkedList lPropNames;  /**< List of property names. */
+        LinkedList lPropValues; /**< List of property values. */
+        XmlNode *pParent;       /**< A pointer to the parent of this node. */
+        int nCurContent;        /**< The current content we're on, for using the -1 on
+                                                         setContent. */
+};
+#endif

diff --git a/src/xmlnode.h b/src/xmlnode.h new file mode 100644 index 0000000..2b01226 --- /dev/null +++ b/src/xmlnode.h
@@ -0,0 +1,236 @@
	1	#ifndef XMLNODE
	2	#define XMLNODE
	3
	4	#include <iostream>
	5	#include "linkedlist.h"
	6	#include "hashtable.h"
	7
	8	/**
	9	* Maintains all data pertient to an XML node, including sub-nodes and content.
	10	* All child nodes can be accessed through index and through name via a hash
	11	* table. This makes it very easy to gain simple and fast access to all of
	12	* your data. For most applications, the memory footprint is also rather
	13	* small. While XmlNode objects can be used directly to create XML structures
	14	* it is highly reccomended that all operations be performed through the
	15	* XmlDocument class.
	16	*@author Mike Buland
	17	*/
	18	class XmlNode
	19	{
	20	public:
	21	/**
	22	* Construct a new XmlNode.
	23	*@param sName The name of the node.
	24	*@param pParent The parent node.
	25	*@param sContent The initial content string.
	26	*/
	27	XmlNode(
	28	const char *sName=NULL,
	29	XmlNode *pParent = NULL,
	30	const char *sContent=NULL
	31	);
	32
	33	/**
	34	* Delete the node and cleanup all memory.
	35	*/
	36	~XmlNode();
	37
	38	/**
	39	* Change the name of the node.
	40	*@param sName The new name of the node.
	41	*/
	42	void setName( const char *sName );
	43
	44	/**
	45	* Construct a new node and add it as a child to this node, also return a
	46	* pointer to the newly constructed node.
	47	*@param sName The name of the new node.
	48	*@param sContent The initial content of the new node.
	49	*@returns A pointer to the newly created child node.
	50	*/
	51	XmlNode addChild( const char sName, const char *sContent=NULL );
	52
	53	/**
	54	* Add an already created XmlNode as a child to this node. The new child
	55	* XmlNode's parent will be changed appropriately and the parent XmlNode
	56	* will take ownership of the child.
	57	*@param pChild The child XmlNode to add to this XmlNode.
	58	*@returns A pointer to the child node that was just added.
	59	*/
	60	XmlNode addChild( XmlNode pChild );
	61
	62	/**
	63	* Add a new property to the XmlNode. Properties are name/value pairs.
	64	*@param sName The name of the property. Specifying a name that's already
	65	* in use will overwrite that property.
	66	*@param sValue The textual value of the property.
	67	*/
	68	void addProperty( const char sName, const char sValue );
	69
	70	/**
	71	* Get a pointer to the parent node, if any.
	72	*@returns A pointer to the node's parent, or NULL if there isn't one.
	73	*/
	74	XmlNode *getParent();
	75
	76	/**
	77	* Tells you if this node has children.
	78	*@returns True if this node has at least one child, false otherwise.
	79	*/
	80	bool hasChildren();
	81
	82	/**
	83	* Tells you how many children this node has.
	84	*@returns The number of children this node has.
	85	*/
	86	int getNumChildren();
	87
	88	/**
	89	* Get a child node at a specific index.
	90	*@param nIndex The zero-based index of the child to retreive.
	91	*@returns A pointer to the child, or NULL if you requested an invalid
	92	* index.
	93	*/
	94	XmlNode *getChild( int nIndex );
	95
	96	/**
	97	* Get a child with the specified name, and possibly skip value. For an
	98	* explination of skip values see the HashTable.
	99	*@param sName The name of the child to find.
	100	*@param nSkip The number of nodes with that name to skip.
	101	*@returns A pointer to the child, or NULL if no child with that name was
	102	* found.
	103	*/
	104	XmlNode getChild( const char sName, int nSkip=0 );
	105
	106	/**
	107	* Get a pointer to the name of this node. Do not change this, use setName
	108	* instead.
	109	*@returns A pointer to the name of this node.
	110	*/
	111	const char *getName();
	112
	113	/**
	114	* Set the content of this node, optionally at a specific index. Using the
	115	* default of -1 will set the content after the last added node.
	116	*@param sContent The content string to use.
	117	*@param nIndex The index of the content.
	118	*/
	119	void setContent( const char *sContent, int nIndex=-1 );
	120
	121	/**
	122	* Get the content string at a given index, or zero for initial content.
	123	*@param nIndex The index of the content.
	124	*@returns A pointer to the content at that location.
	125	*/
	126	const char *getContent( int nIndex = 0 );
	127
	128	/**
	129	* Get the number of properties in this node.
	130	*@returns The number of properties in this node.
	131	*/
	132	int getNumProperties();
	133
	134	/**
	135	* Get a property's name by index.
	136	*@param nIndex The index of the property to examine.
	137	*@returns A pointer to the name of the property specified, or NULL if none
	138	* found.
	139	*/
	140	const char *getPropertyName( int nIndex );
	141
	142	/**
	143	* Get a proprty's value by index.
	144	*@param nIndex The index of the property to examine.
	145	*@returns A pointer to the value of the property specified, or NULL if none
	146	* found.
	147	*/
	148	const char *getProperty( int nIndex );
	149
	150	/**
	151	* Get a propery's value by name.
	152	*@param sName The name of the property to examine.
	153	*@returns A pointer to the value of the property specified, or NULL if none
	154	* found.
	155	*/
	156	const char getProperty( const char sName );
	157
	158	/**
	159	* Delete a property by index.
	160	*@param nIndex The index of the property to delete.
	161	*@returns True if the property was found and deleted, false if it wasn't
	162	* found.
	163	*/
	164	bool deleteProperty( int nIndex );
	165
	166	/**
	167	* Delete a child node, possibly replacing it with some text. This actually
	168	* fixes all content strings around the newly deleted child node.
	169	*@param nIndex The index of the node to delete.
	170	*@param sReplacementText The optional text to replace the node with.
	171	*@returns True of the node was found, and deleted, false if it wasn't
	172	* found.
	173	*/
	174	bool deleteNode( int nIndex, const char *sReplacementText = NULL );
	175
	176	/**
	177	* Delete a given node, but move all of it's children and content up to
	178	* replace the deleted node. All of the content of the child node is
	179	* spliced seamlessly into place with the parent node's content.
	180	*@param nIndex The node to delete.
	181	*@returns True if the node was found and deleted, false if it wasn't.
	182	*/
	183	bool deleteNodeKeepChildren( int nIndex );
	184
	185	/**
	186	* Detatch a given child node from this node. This effectively works just
	187	* like a deleteNode, except that instead of deleting the node it is removed
	188	* and returned, and all ownership is given up.
	189	*@param nIndex The index of the node to detatch.
	190	*@param sReplacementText The optional text to replace the detatched node
	191	* with.
	192	*@returns A pointer to the newly detatched node, which then passes
	193	* ownership to the caller.
	194	*/
	195	XmlNode detatchNode( int nIndex, const char sReplacementText = NULL );
	196
	197	/**
	198	* Replace a given node with a different node that is not currently owned by
	199	* this XmlNode or any ancestor.
	200	*@param nIndex The index of the node to replace.
	201	*@param pNewNode The new node to replace the old node with.
	202	*@returns True if the node was found and replaced, false if it wasn't.
	203	*/
	204	bool replaceNode( int nIndex, XmlNode *pNewNode );
	205
	206	/**
	207	* Replace a given node with the children and content of a given node.
	208	*@param nIndex The index of the node to replace.
	209	*@param pNewNode The node that contains the children and content that will
	210	* replace the node specified by nIndex.
	211	*@returns True if the node was found and replaced, false if it wasn't.
	212	*/
	213	bool replaceNodeWithChildren( int nIndex, XmlNode *pNewNode );
	214
	215	/**
	216	* Get a copy of this node and all children. getCopy is recursive, so
	217	* beware copying large trees of xml.
	218	*@returns A newly created copy of this node and all of it's children.
	219	*/
	220	XmlNode *getCopy();
	221
	222	private:
	223	std::string sName; /*< The name of the node. /
	224	std::string sPreContent; /< The content that goes before any node. /
	225	LinkedList lChildren; /*< The children. /
	226	LinkedList lPostContent; /*< The content that comes after children. /
	227	HashTable hProperties; /*< Property hashtable. /
	228	HashTable hChildren; /*< Children hashtable. /
	229	LinkedList lPropNames; /*< List of property names. /
	230	LinkedList lPropValues; /*< List of property values. /
	231	XmlNode pParent; /< A pointer to the parent of this node. /
	232	int nCurContent; /**< The current content we're on, for using the -1 on
	233	setContent. */
	234	};
	235
	236	#endif