1 files changed, 403 insertions, 0 deletions
diff --git a/src/old/xmlnode.cpp b/src/old/xmlnode.cpp
new file mode 100644
index 0000000..96d5850
--- /dev/null
+++ b/src/old/xmlnode.cpp
@@ -0,0 +1,403 @@
+#include "xmlnode.h"
+XmlNode::XmlNode( const Bu::FString &sName, XmlNode *pParent ) :
+        sName( sName ),
+        pParent( pParent )
+{
+}
+XmlNode::~XmlNode()
+{
+}
+/*
+void XmlNode::setName( const char *sName )
+{
+        if( pParent )
+        {
+                if( this->sName.size() == 0 )
+                {
+                        // We're not in the hash yet, so add us
+                        this->sName = sName;
+                        pParent->hChildren.insert( this->sName.c_str(), this );
+                }
+                else
+                {
+                        // Slightly more tricky, delete us, then add us...
+                        pParent->hChildren.del( this->sName.c_str() );
+                        this->sName = sName;
+                        pParent->hChildren.insert( this->sName.c_str(), this );
+                }
+        }
+        else
+        {
+                // If we have no parent, then just set the name string, we don't need
+                // to worry about hashing.
+                this->sName = sName;
+        }
+}
+void XmlNode::setContent( const char *sContent, int nIndex )
+{
+        if( nIndex == -1 )
+        {
+                nIndex = nCurContent;
+        }
+        if( nIndex == 0 )
+        {
+                if( this->sPreContent )
+                {
+                        delete this->sPreContent;
+                }
+        
+                this->sPreContent = new std::string( sContent );
+        }
+        else
+        {
+                nIndex--;
+                if( lPostContent[nIndex] )
+                {
+                        delete (std::string *)lPostContent[nIndex];
+                }
+                lPostContent.setAt( nIndex, new std::string( sContent ) );
+        }
+}
+const char *XmlNode::getContent( int nIndex )
+{
+        if( nIndex == 0 )
+        {
+                if( sPreContent )
+                {
+                        return sPreContent->c_str();
+                }
+        }
+        else
+        {
+                nIndex--;
+                if( lPostContent[nIndex] )
+                {
+                        return ((std::string *)lPostContent[nIndex])->c_str();
+                }
+        }
+        return NULL;
+}*/
+XmlNode *XmlNode::addChild( const Bu::FString &sName )
+{
+        return addChild( new XmlNode( sName, this ) );
+}
+XmlNode *XmlNode::addChild( XmlNode *pNode )
+{
+        Child c = { typeNode };
+        c.pNode = pNode;
+        lChildren.append( c );
+        pNode->pParent = this;
+        return pNode;
+}
+XmlNode *XmlNode::getParent()
+{
+        return pParent;
+}
+void XmlNode::addProperty( const Bu::FString &sName, const Bu::FString &sValue )
+{
+        hProperties.insert( sName, sValue );
+}
+int XmlNode::getNumProperties()
+{
+        return hProperties.size();
+}
+/*
+const char *XmlNode::getPropertyName( int nIndex )
+{
+        std::string *tmp = ((std::string *)lPropNames[nIndex]);
+        if( tmp == NULL )
+                return NULL;
+        return tmp->c_str();
+}
+const char *XmlNode::getProperty( int nIndex )
+{
+        std::string *tmp = ((std::string *)lPropValues[nIndex]);
+        if( tmp == NULL )
+                return NULL;
+        return tmp->c_str();
+}
+*/
+Bu::FString XmlNode::getProperty( const Bu::FString &sName )
+{
+        return hProperties[sName];
+}
+/*
+void XmlNode::deleteProperty( int nIndex )
+{
+        hProperties.del( ((std::string *)lPropNames[nIndex])->c_str() );
+        delete (std::string *)lPropNames[nIndex];
+        delete (std::string *)lPropValues[nIndex];
+        lPropNames.deleteAt( nIndex );
+        lPropValues.deleteAt( nIndex );
+}
+bool XmlNode::hasChildren()
+{
+        return hChildren.getSize()>0;
+}*/
+int XmlNode::getNumChildren()
+{
+        return lChildren.getSize();
+}
+/*
+XmlNode *XmlNode::getChild( int nIndex )
+{
+        return (XmlNode *)lChildren[nIndex];
+}
+*/
+XmlNode *XmlNode::getChild( const Bu::FString &sName, int nSkip )
+{
+        if( !hChildren.has( sName ) )
+                return NULL;
+        Bu::List<XmlNode *>::iterator i = hChildren[sName]->begin();
+        return *i;
+}
+Bu::FString XmlNode::getName()
+{
+        return sName;
+}
+/*
+void XmlNode::deleteNode( int nIndex, const char *sReplacementText )
+{
+        XmlNode *xRet = detatchNode( nIndex, sReplacementText );
+        if( xRet != NULL )
+        {
+                delete xRet;
+        }
+}
+XmlNode *XmlNode::detatchNode( int nIndex, const char *sReplacementText )
+{
+        if( nIndex < 0 || nIndex >= lChildren.getSize() )
+                return NULL;
+        
+        // The real trick when deleteing a node isn't actually deleting it, it's
+        // reforming the content around the node that's now missing...hmmm...
+        
+        if( nIndex == 0 )
+        {
+                // If the index is zero we have to deal with the pre-content
+                if( sReplacementText )
+                {
+                        if( sPreContent == NULL )
+                        {
+                                sPreContent = new std::string( sReplacementText );
+                        }
+                        else
+                        {
+                                *sPreContent += sReplacementText;
+                        }
+                }
+                if( lPostContent.getSize() > 0 )
+                {
+                        if( lPostContent[0] != NULL )
+                        {
+                                if( sPreContent == NULL )
+                                {
+                                        sPreContent = new std::string(
+                                                ((std::string *)lPostContent[0])->c_str()
+                                                );
+                                }
+                                else
+                                {
+                                        *sPreContent +=
+                                                ((std::string *)lPostContent[0])->c_str();
+                                }
+                        }
+                        delete (std::string *)lPostContent[0];
+                        lPostContent.deleteAt( 0 );
+                }
+        }
+        else
+        {
+                int nCont = nIndex-1;
+                // If it's above zero we deal with the post-content only
+                if( sReplacementText )
+                {
+                        if( lPostContent[nCont] == NULL )
+                        {
+                                lPostContent.setAt( nCont, new std::string( sReplacementText ) );
+                        }
+                        else
+                        {
+                                *((std::string *)lPostContent[nCont]) += sReplacementText;
+                        }
+                }
+                if( lPostContent.getSize() > nIndex )
+                {
+                        if( lPostContent[nIndex] != NULL )
+                        {
+                                if( lPostContent[nCont] == NULL )
+                                {
+                                        lPostContent.setAt( nCont, new std::string(
+                                                ((std::string *)lPostContent[nIndex])->c_str()
+                                                ) );
+                                }
+                                else
+                                {
+                                        *((std::string *)lPostContent[nCont]) +=
+                                                ((std::string *)lPostContent[nIndex])->c_str();
+                                }
+                        }
+                        delete (std::string *)lPostContent[nIndex];
+                        lPostContent.deleteAt( nIndex );
+                }
+        }
+        XmlNode *xRet = (XmlNode *)lChildren[nIndex];
+        hChildren.del( ((XmlNode *)lChildren[nIndex])->getName() );
+        lChildren.deleteAt( nIndex );
+        
+        return xRet;
+}
+void XmlNode::replaceNode( int nIndex, XmlNode *pNewNode )
+{
+        if( nIndex < 0 || nIndex >= lChildren.getSize() )
+                return; //TODO: throw an exception
+        
+        delete (XmlNode *)lChildren[nIndex];
+        lChildren.setAt( nIndex, pNewNode );
+        pNewNode->pParent = this;
+}
+XmlNode *XmlNode::getCopy()
+{
+        XmlNode *pNew = new XmlNode();
+        pNew->sName = sName;
+        if( sPreContent )
+        {
+                pNew->sPreContent = new std::string( sPreContent->c_str() );
+        }
+        else
+        {
+                pNew->sPreContent = NULL;
+        }
+        pNew->nCurContent = 0;
+        
+        int nSize = lPostContent.getSize();
+        pNew->lPostContent.setSize( nSize );
+        for( int j = 0; j < nSize; j++ )
+        {
+                if( lPostContent[j] )
+                {
+                        pNew->lPostContent.setAt(
+                                j, new std::string(
+                                        ((std::string *)lPostContent[j])->c_str()
+                                        )
+                                );
+                }
+                else
+                {
+                        pNew->lPostContent.setAt( j, NULL );
+                }
+        }
+        nSize = lChildren.getSize();
+        pNew->lChildren.setSize( nSize );
+        for( int j = 0; j < nSize; j++ )
+        {
+                XmlNode *pChild = ((XmlNode *)lChildren[j])->getCopy();
+                pNew->lChildren.setAt( j, pChild );
+                pChild->pParent = pNew;
+                pNew->hChildren.insert( pChild->getName(), pChild );
+        }
+        nSize = lPropNames.getSize();
+        pNew->lPropNames.setSize( nSize );
+        pNew->lPropValues.setSize( nSize );
+        for( int j = 0; j < nSize; j++ )
+        {
+                std::string *pProp = new std::string( ((std::string *)lPropNames[j])->c_str() );
+                std::string *pVal = new std::string( ((std::string *)lPropValues[j])->c_str() );
+                pNew->lPropNames.setAt( j, pProp );
+                pNew->lPropValues.setAt( j, pVal );
+                pNew->hProperties.insert( pProp->c_str(), pVal->c_str() );
+                pNew->nCurContent++;
+        }
+        return pNew;
+}
+void XmlNode::deleteNodeKeepChildren( int nIndex )
+{
+        // This is a tricky one...we need to do some patching to keep things all
+        // even...
+        XmlNode *xRet = (XmlNode *)lChildren[nIndex];
+        if( xRet == NULL )
+        {
+                return;
+        }
+        else
+        {
+                if( getContent( nIndex ) )
+                {
+                        std::string sBuf( getContent( nIndex ) );
+                        sBuf += xRet->getContent( 0 );
+                        setContent( sBuf.c_str(), nIndex );
+                }
+                else
+                {
+                        setContent( xRet->getContent( 0 ), nIndex );
+                }
+                
+                int nSize = xRet->lChildren.getSize();
+                for( int j = 0; j < nSize; j++ )
+                {
+                        XmlNode *pCopy = ((XmlNode *)xRet->lChildren[j])->getCopy();
+                        pCopy->pParent = this;
+                        lChildren.insertBefore( pCopy, nIndex+j );
+                
+                        if( xRet->lPostContent[j] )
+                        {
+                                lPostContent.insertBefore(
+                                        new std::string( ((std::string *)xRet->lPostContent[j])->c_str() ),
+                                        nIndex+j
+                                        );
+                        }
+                        else
+                        {
+                                lPostContent.insertBefore( NULL, nIndex+j );
+                        }
+                }
+                
+                if( getContent( nIndex+nSize ) )
+                {
+                        //SString sBuf( getContent( nIndex+nSize ) );
+                        //sBuf.catfrom( xRet->getContent( nSize ) );
+                        //setContent( sBuf, nIndex+nSize );
+                }
+                else
+                {
+                        setContent( xRet->getContent( nSize ), nIndex+nSize );
+                }
+                deleteNode( nIndex+nSize );
+        }
+}
+void XmlNode::replaceNodeWithChildren( int nIndex, XmlNode *pNewNode )
+{
+}
+*/

diff --git a/src/old/xmlnode.cpp b/src/old/xmlnode.cpp new file mode 100644 index 0000000..96d5850 --- /dev/null +++ b/src/old/xmlnode.cpp
@@ -0,0 +1,403 @@
	1	#include "xmlnode.h"
	2
	3	XmlNode::XmlNode( const Bu::FString &sName, XmlNode *pParent ) :
	4	sName( sName ),
	5	pParent( pParent )
	6	{
	7	}
	8
	9	XmlNode::~XmlNode()
	10	{
	11	}
	12	/*
	13	void XmlNode::setName( const char *sName )
	14	{
	15	if( pParent )
	16	{
	17	if( this->sName.size() == 0 )
	18	{
	19	// We're not in the hash yet, so add us
	20	this->sName = sName;
	21	pParent->hChildren.insert( this->sName.c_str(), this );
	22	}
	23	else
	24	{
	25	// Slightly more tricky, delete us, then add us...
	26	pParent->hChildren.del( this->sName.c_str() );
	27	this->sName = sName;
	28	pParent->hChildren.insert( this->sName.c_str(), this );
	29	}
	30	}
	31	else
	32	{
	33	// If we have no parent, then just set the name string, we don't need
	34	// to worry about hashing.
	35	this->sName = sName;
	36	}
	37	}
	38
	39	void XmlNode::setContent( const char *sContent, int nIndex )
	40	{
	41	if( nIndex == -1 )
	42	{
	43	nIndex = nCurContent;
	44	}
	45	if( nIndex == 0 )
	46	{
	47	if( this->sPreContent )
	48	{
	49	delete this->sPreContent;
	50	}
	51
	52	this->sPreContent = new std::string( sContent );
	53	}
	54	else
	55	{
	56	nIndex--;
	57	if( lPostContent[nIndex] )
	58	{
	59	delete (std::string *)lPostContent[nIndex];
	60	}
	61
	62	lPostContent.setAt( nIndex, new std::string( sContent ) );
	63	}
	64	}
	65
	66	const char *XmlNode::getContent( int nIndex )
	67	{
	68	if( nIndex == 0 )
	69	{
	70	if( sPreContent )
	71	{
	72	return sPreContent->c_str();
	73	}
	74	}
	75	else
	76	{
	77	nIndex--;
	78	if( lPostContent[nIndex] )
	79	{
	80	return ((std::string *)lPostContent[nIndex])->c_str();
	81	}
	82	}
	83
	84	return NULL;
	85	}*/
	86
	87	XmlNode *XmlNode::addChild( const Bu::FString &sName )
	88	{
	89	return addChild( new XmlNode( sName, this ) );
	90	}
	91
	92	XmlNode XmlNode::addChild( XmlNode pNode )
	93	{
	94	Child c = { typeNode };
	95	c.pNode = pNode;
	96	lChildren.append( c );
	97	pNode->pParent = this;
	98
	99	return pNode;
	100	}
	101
	102	XmlNode *XmlNode::getParent()
	103	{
	104	return pParent;
	105	}
	106
	107	void XmlNode::addProperty( const Bu::FString &sName, const Bu::FString &sValue )
	108	{
	109	hProperties.insert( sName, sValue );
	110	}
	111
	112	int XmlNode::getNumProperties()
	113	{
	114	return hProperties.size();
	115	}
	116	/*
	117	const char *XmlNode::getPropertyName( int nIndex )
	118	{
	119	std::string tmp = ((std::string )lPropNames[nIndex]);
	120	if( tmp == NULL )
	121	return NULL;
	122	return tmp->c_str();
	123	}
	124
	125	const char *XmlNode::getProperty( int nIndex )
	126	{
	127	std::string tmp = ((std::string )lPropValues[nIndex]);
	128	if( tmp == NULL )
	129	return NULL;
	130	return tmp->c_str();
	131	}
	132	*/
	133	Bu::FString XmlNode::getProperty( const Bu::FString &sName )
	134	{
	135	return hProperties[sName];
	136	}
	137	/*
	138	void XmlNode::deleteProperty( int nIndex )
	139	{
	140	hProperties.del( ((std::string *)lPropNames[nIndex])->c_str() );
	141
	142	delete (std::string *)lPropNames[nIndex];
	143	delete (std::string *)lPropValues[nIndex];
	144
	145	lPropNames.deleteAt( nIndex );
	146	lPropValues.deleteAt( nIndex );
	147	}
	148
	149	bool XmlNode::hasChildren()
	150	{
	151	return hChildren.getSize()>0;
	152	}*/
	153
	154	int XmlNode::getNumChildren()
	155	{
	156	return lChildren.getSize();
	157	}
	158	/*
	159	XmlNode *XmlNode::getChild( int nIndex )
	160	{
	161	return (XmlNode *)lChildren[nIndex];
	162	}
	163	*/
	164	XmlNode *XmlNode::getChild( const Bu::FString &sName, int nSkip )
	165	{
	166	if( !hChildren.has( sName ) )
	167	return NULL;
	168
	169	Bu::List<XmlNode *>::iterator i = hChildren[sName]->begin();
	170	return *i;
	171	}
	172
	173	Bu::FString XmlNode::getName()
	174	{
	175	return sName;
	176	}
	177	/*
	178	void XmlNode::deleteNode( int nIndex, const char *sReplacementText )
	179	{
	180	XmlNode *xRet = detatchNode( nIndex, sReplacementText );
	181
	182	if( xRet != NULL )
	183	{
	184	delete xRet;
	185	}
	186	}
	187
	188	XmlNode XmlNode::detatchNode( int nIndex, const char sReplacementText )
	189	{
	190	if( nIndex < 0 \|\| nIndex >= lChildren.getSize() )
	191	return NULL;
	192
	193	// The real trick when deleteing a node isn't actually deleting it, it's
	194	// reforming the content around the node that's now missing...hmmm...
	195
	196	if( nIndex == 0 )
	197	{
	198	// If the index is zero we have to deal with the pre-content
	199	if( sReplacementText )
	200	{
	201	if( sPreContent == NULL )
	202	{
	203	sPreContent = new std::string( sReplacementText );
	204	}
	205	else
	206	{
	207	*sPreContent += sReplacementText;
	208	}
	209	}
	210	if( lPostContent.getSize() > 0 )
	211	{
	212	if( lPostContent[0] != NULL )
	213	{
	214	if( sPreContent == NULL )
	215	{
	216	sPreContent = new std::string(
	217	((std::string *)lPostContent[0])->c_str()
	218	);
	219	}
	220	else
	221	{
	222	*sPreContent +=
	223	((std::string *)lPostContent[0])->c_str();
	224	}
	225	}
	226	delete (std::string *)lPostContent[0];
	227	lPostContent.deleteAt( 0 );
	228	}
	229	}
	230	else
	231	{
	232	int nCont = nIndex-1;
	233	// If it's above zero we deal with the post-content only
	234	if( sReplacementText )
	235	{
	236	if( lPostContent[nCont] == NULL )
	237	{
	238	lPostContent.setAt( nCont, new std::string( sReplacementText ) );
	239	}
	240	else
	241	{
	242	((std::string )lPostContent[nCont]) += sReplacementText;
	243	}
	244	}
	245	if( lPostContent.getSize() > nIndex )
	246	{
	247	if( lPostContent[nIndex] != NULL )
	248	{
	249	if( lPostContent[nCont] == NULL )
	250	{
	251	lPostContent.setAt( nCont, new std::string(
	252	((std::string *)lPostContent[nIndex])->c_str()
	253	) );
	254	}
	255	else
	256	{
	257	((std::string )lPostContent[nCont]) +=
	258	((std::string *)lPostContent[nIndex])->c_str();
	259	}
	260	}
	261	delete (std::string *)lPostContent[nIndex];
	262	lPostContent.deleteAt( nIndex );
	263	}
	264	}
	265
	266	XmlNode xRet = (XmlNode )lChildren[nIndex];
	267	hChildren.del( ((XmlNode *)lChildren[nIndex])->getName() );
	268	lChildren.deleteAt( nIndex );
	269
	270	return xRet;
	271	}
	272
	273	void XmlNode::replaceNode( int nIndex, XmlNode *pNewNode )
	274	{
	275	if( nIndex < 0 \|\| nIndex >= lChildren.getSize() )
	276	return; //TODO: throw an exception
	277
	278	delete (XmlNode *)lChildren[nIndex];
	279	lChildren.setAt( nIndex, pNewNode );
	280	pNewNode->pParent = this;
	281	}
	282
	283	XmlNode *XmlNode::getCopy()
	284	{
	285	XmlNode *pNew = new XmlNode();
	286
	287	pNew->sName = sName;
	288	if( sPreContent )
	289	{
	290	pNew->sPreContent = new std::string( sPreContent->c_str() );
	291	}
	292	else
	293	{
	294	pNew->sPreContent = NULL;
	295	}
	296	pNew->nCurContent = 0;
	297
	298	int nSize = lPostContent.getSize();
	299	pNew->lPostContent.setSize( nSize );
	300	for( int j = 0; j < nSize; j++ )
	301	{
	302	if( lPostContent[j] )
	303	{
	304	pNew->lPostContent.setAt(
	305	j, new std::string(
	306	((std::string *)lPostContent[j])->c_str()
	307	)
	308	);
	309	}
	310	else
	311	{
	312	pNew->lPostContent.setAt( j, NULL );
	313	}
	314	}
	315
	316	nSize = lChildren.getSize();
	317	pNew->lChildren.setSize( nSize );
	318	for( int j = 0; j < nSize; j++ )
	319	{
	320	XmlNode pChild = ((XmlNode )lChildren[j])->getCopy();
	321	pNew->lChildren.setAt( j, pChild );
	322	pChild->pParent = pNew;
	323	pNew->hChildren.insert( pChild->getName(), pChild );
	324	}
	325
	326	nSize = lPropNames.getSize();
	327	pNew->lPropNames.setSize( nSize );
	328	pNew->lPropValues.setSize( nSize );
	329	for( int j = 0; j < nSize; j++ )
	330	{
	331	std::string pProp = new std::string( ((std::string )lPropNames[j])->c_str() );
	332	std::string pVal = new std::string( ((std::string )lPropValues[j])->c_str() );
	333	pNew->lPropNames.setAt( j, pProp );
	334	pNew->lPropValues.setAt( j, pVal );
	335	pNew->hProperties.insert( pProp->c_str(), pVal->c_str() );
	336	pNew->nCurContent++;
	337	}
	338
	339	return pNew;
	340	}
	341
	342	void XmlNode::deleteNodeKeepChildren( int nIndex )
	343	{
	344	// This is a tricky one...we need to do some patching to keep things all
	345	// even...
	346	XmlNode xRet = (XmlNode )lChildren[nIndex];
	347
	348	if( xRet == NULL )
	349	{
	350	return;
	351	}
	352	else
	353	{
	354	if( getContent( nIndex ) )
	355	{
	356	std::string sBuf( getContent( nIndex ) );
	357	sBuf += xRet->getContent( 0 );
	358	setContent( sBuf.c_str(), nIndex );
	359	}
	360	else
	361	{
	362	setContent( xRet->getContent( 0 ), nIndex );
	363	}
	364
	365	int nSize = xRet->lChildren.getSize();
	366	for( int j = 0; j < nSize; j++ )
	367	{
	368	XmlNode pCopy = ((XmlNode )xRet->lChildren[j])->getCopy();
	369	pCopy->pParent = this;
	370	lChildren.insertBefore( pCopy, nIndex+j );
	371
	372	if( xRet->lPostContent[j] )
	373	{
	374	lPostContent.insertBefore(
	375	new std::string( ((std::string *)xRet->lPostContent[j])->c_str() ),
	376	nIndex+j
	377	);
	378	}
	379	else
	380	{
	381	lPostContent.insertBefore( NULL, nIndex+j );
	382	}
	383	}
	384
	385	if( getContent( nIndex+nSize ) )
	386	{
	387	//SString sBuf( getContent( nIndex+nSize ) );
	388	//sBuf.catfrom( xRet->getContent( nSize ) );
	389	//setContent( sBuf, nIndex+nSize );
	390	}
	391	else
	392	{
	393	setContent( xRet->getContent( nSize ), nIndex+nSize );
	394	}
	395
	396	deleteNode( nIndex+nSize );
	397	}
	398	}
	399
	400	void XmlNode::replaceNodeWithChildren( int nIndex, XmlNode *pNewNode )
	401	{
	402	}
	403	*/