Added a list template class, seems to work pretty well for now, I may have

forgotten proper cleanup in the deconstructor, but besides that you can do
almost everything you need.  I'll make a slist/stack next, probably with the
same basic code, just a different structure (not doubley-linked).

The xml system from old-libbu++ is almost completely converted, I was going to
re-write it, but this seemed easier at first, it may not have been, we'll see.
It almost parses everything again, and almost outputs again, and it does use
streams now.

The FString is partway to doing minimum chunk allocations, so that adding
single-characters will be really fast up to the minimum chunk size.  I also
figured out how to add this optimization without any extra variables taking
up space, and it's optional in the template, which is cool.  You can specify
the size of the blocks (default 256 bytes), if it's 0 then they'll be like the
old FString, 1 chunk per operation.

The next FString update should be allowing efficient removal from the begining
of the string by faking it, and simply moving a secondary base pointer ahead,
and then optimizing appends after that fact to simply move the existing data
around if you shouldn't have to re-allocate (alla FlexBuf).  The final fun
addition that I'm planning is a simple switch in the template (boolean) that
will switch an FString into a thread-safe mode without changing the interface
or anything that you can do with them at all.  It may increasing memory usage,
but they should still be better than std::strings, and totally thread-safe.

The best part of that is that if it's done with a boolean template parameter and
if statements that only test that parameter controlling flow, the code that you
don't want (threadsafe/non-threadsafe) won't be included at all
post-optimization.

1 files changed, 32 insertions, 74 deletions

diff --git a/src/xmlnode.cpp b/src/xmlnode.cpp
index b1ed9a9..96d5850 100644
--- a/src/xmlnode.cpp
+++ b/src/xmlnode.cpp
@@ -1,53 +1,15 @@
 #include "xmlnode.h"
-#include "hashfunctionstring.h"
 
-XmlNode::XmlNode( const char *sName, XmlNode *pParent, const char *sContent ) :
-        hProperties( new HashFunctionString(), 53, false ),
-        hChildren( new HashFunctionString(), 53, true )
+XmlNode::XmlNode( const Bu::FString &sName, XmlNode *pParent ) :
+        sName( sName ),
+        pParent( pParent )
 {
-        this->pParent = pParent;
-        if( sName != NULL )
-        {
-                setName( sName );
-        }
-        if( sContent != NULL )
-        {
-                this->sPreContent = new std::string( sContent );
-        }
-        else
-        {
-                this->sPreContent = NULL;
-        }
-        nCurContent = 0;
 }
 
 XmlNode::~XmlNode()
 {
-        for( int j = 0; j < lChildren.getSize(); j++ )
-        {
-                delete (XmlNode *)lChildren[j];
-        }
-        for( int j = 0; j < lPropNames.getSize(); j++ )
-        {
-                delete (std::string *)lPropNames[j];
-        }
-        for( int j = 0; j < lPropValues.getSize(); j++ )
-        {
-                delete (std::string *)lPropValues[j];
-        }
-        for( int j = 0; j < lPostContent.getSize(); j++ )
-        {
-                if( lPostContent[j] != NULL )
-                {
-                        delete (std::string *)lPostContent[j];
-                }
-        }
-        if( sPreContent )
-        {
-                delete sPreContent;
-        }
 }
-
+/*
 void XmlNode::setName( const char *sName )
 {
         if( pParent )
@@ -120,18 +82,18 @@ const char *XmlNode::getContent( int nIndex )
         }
 
         return NULL;
-}
+}*/
 
-XmlNode *XmlNode::addChild( const char *sName, const char *sContent )
+XmlNode *XmlNode::addChild( const Bu::FString &sName )
 {
-        return addChild( new XmlNode( sName, this, sContent ) );
+        return addChild( new XmlNode( sName, this ) );
 }
 
 XmlNode *XmlNode::addChild( XmlNode *pNode )
 {
-        lChildren.append( pNode );
-        lPostContent.append( NULL );
-        nCurContent++;
+        Child c = { typeNode };
+        c.pNode = pNode;
+        lChildren.append( c );
         pNode->pParent = this;
 
         return pNode;
@@ -142,21 +104,16 @@ XmlNode *XmlNode::getParent()
         return pParent;
 }
 
-void XmlNode::addProperty( const char *sName, const char *sValue )
+void XmlNode::addProperty( const Bu::FString &sName, const Bu::FString &sValue )
 {
-        std::string *pName = new std::string( sName );
-        std::string *pValue = new std::string( sValue );
-        
-        hProperties.insert( pName->c_str(), pValue->c_str() );
-        lPropNames.append( pName );
-        lPropValues.append( pValue );
+        hProperties.insert( sName, sValue );
 }
 
 int XmlNode::getNumProperties()
 {
-        return lPropNames.getSize();
+        return hProperties.size();
 }
-
+/*
 const char *XmlNode::getPropertyName( int nIndex )
 {
         std::string *tmp = ((std::string *)lPropNames[nIndex]);
@@ -172,15 +129,12 @@ const char *XmlNode::getProperty( int nIndex )
                 return NULL;
         return tmp->c_str();
 }
-
-const char *XmlNode::getProperty( const char *sName )
+*/
+Bu::FString XmlNode::getProperty( const Bu::FString &sName )
 {
-        const char *tmp = (const char *)hProperties[sName];
-        if( tmp == NULL )
-                return NULL;
-        return tmp;
+        return hProperties[sName];
 }
-
+/*
 void XmlNode::deleteProperty( int nIndex )
 {
         hProperties.del( ((std::string *)lPropNames[nIndex])->c_str() );
@@ -194,29 +148,33 @@ void XmlNode::deleteProperty( int nIndex )
 
 bool XmlNode::hasChildren()
 {
-        return lChildren.getSize()>0;
-}
+        return hChildren.getSize()>0;
+}*/
 
 int XmlNode::getNumChildren()
 {
         return lChildren.getSize();
 }
-
+/*
 XmlNode *XmlNode::getChild( int nIndex )
 {
         return (XmlNode *)lChildren[nIndex];
 }
-
-XmlNode *XmlNode::getChild( const char *sName, int nSkip )
+*/
+XmlNode *XmlNode::getChild( const Bu::FString &sName, int nSkip )
 {
-        return (XmlNode *)hChildren.get( sName, nSkip );
+        if( !hChildren.has( sName ) )
+                return NULL;
+
+        Bu::List<XmlNode *>::iterator i = hChildren[sName]->begin();
+        return *i;
 }
 
-const char *XmlNode::getName()
+Bu::FString XmlNode::getName()
 {
-        return sName.c_str();
+        return sName;
 }
-
+/*
 void XmlNode::deleteNode( int nIndex, const char *sReplacementText )
 {
         XmlNode *xRet = detatchNode( nIndex, sReplacementText );
@@ -442,4 +400,4 @@ void XmlNode::deleteNodeKeepChildren( int nIndex )
 void XmlNode::replaceNodeWithChildren( int nIndex, XmlNode *pNewNode )
 {
 }
-
+*/