239 files changed, 9329 insertions, 4429 deletions

diff --git a/src/archival.cpp b/src/archival.cpp
new file mode 100644
index 0000000..79c28f1
--- /dev/null
+++ b/src/archival.cpp
@@ -0,0 +1,10 @@
+#include "archival.h"
+
+Bu::Archival::Archival()
+{
+}
+
+Bu::Archival::~Archival()
+{
+}
+
diff --git a/src/archival.h b/src/archival.h
new file mode 100644
index 0000000..8be3308
--- /dev/null
+++ b/src/archival.h
@@ -0,0 +1,38 @@
+#ifndef BU_ARCHIVAL_H
+#define BU_ARCHIVAL_H
+
+namespace Bu
+{
+        /**
+         * The base class for any class you want to archive.  Simply include this as
+         * a base class, implement the purely virtual archive function and you've
+         * got an easily archiveable class.
+         *
+         * Archival: "of or pertaining to archives or valuable records; contained
+         * in or comprising such archives or records."
+         */
+        class Archival
+        {
+        public:
+                /**
+                 * Does nothing, here for completeness.
+                 */
+                Archival();
+
+                /**
+                 * Here to ensure the deconstructor is virtual.
+                 */
+                virtual ~Archival();
+
+                /**
+                 * This is the main workhorse of the archive system, just override and
+                 * you've got a archiveable class.  A reference to the Archive
+                 * used is passed in as your only parameter, query it to discover if
+                 * you are loading or saving.
+                 * @param ar A reference to the Archive object to use.
+                 */
+                virtual void archive( class Archive &ar )=0;
+        };
+}
+
+#endif
diff --git a/src/archive.cpp b/src/archive.cpp
new file mode 100644
index 0000000..7208bae
--- /dev/null
+++ b/src/archive.cpp
@@ -0,0 +1,386 @@
+#include "archive.h"
+
+Bu::Archive::Archive( Stream &rStream, bool bLoading ) :
+        bLoading( bLoading ),
+        rStream( rStream ),
+        nNextID( 1 )
+{
+}
+
+Bu::Archive::~Archive()
+{
+}
+
+void Bu::Archive::write( const void *pData, int32_t nSize )
+{
+        if( nSize == 0 || pData == NULL )
+                return;
+        
+        rStream.write( (const char *)pData, nSize );
+}
+
+void Bu::Archive::read( void *pData, int32_t nSize )
+{
+        if( nSize == 0 || pData == NULL )
+                return;
+
+        rStream.read( (char *)pData, nSize );
+}
+
+void Bu::Archive::close()
+{
+        rStream.close();
+}
+
+bool Bu::Archive::isLoading()
+{
+        return bLoading;
+}
+Bu::Archive &Bu::Archive::operator<<(bool p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(int8_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(int16_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(int32_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(int64_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(uint8_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(uint16_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(uint32_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(uint64_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(long p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(float p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(double p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(long double p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+
+Bu::Archive &Bu::Archive::operator>>(bool &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(int8_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(int16_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(int32_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(int64_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(uint8_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(uint16_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(uint32_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(uint64_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(long &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(float &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(double &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(long double &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+
+Bu::Archive &Bu::Archive::operator&&(bool &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+
+Bu::Archive &Bu::Archive::operator&&(int8_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+
+Bu::Archive &Bu::Archive::operator&&(int16_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+
+Bu::Archive &Bu::Archive::operator&&(int32_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+
+Bu::Archive &Bu::Archive::operator&&(int64_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+
+Bu::Archive &Bu::Archive::operator&&(uint8_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+
+Bu::Archive &Bu::Archive::operator&&(uint16_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+
+Bu::Archive &Bu::Archive::operator&&(uint32_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+
+Bu::Archive &Bu::Archive::operator&&(uint64_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+
+Bu::Archive &Bu::Archive::operator&&(float &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+
+Bu::Archive &Bu::Archive::operator&&(double &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+
+Bu::Archive &Bu::Archive::operator&&(long double &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+
+
+Bu::Archive &Bu::operator<<(Bu::Archive &s, Bu::Archival &p)
+{
+        p.archive( s );
+        return s;
+}
+
+Bu::Archive &Bu::operator>>(Bu::Archive &s, Bu::Archival &p)
+{
+        p.archive( s );
+        return s;
+}
+
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, std::string &s )
+{
+        ar << (uint32_t)s.length();
+        ar.write( s.c_str(), s.length() );
+
+        return ar;
+}
+
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, std::string &s )
+{
+        uint32_t l;
+        ar >> l;
+        char *tmp = new char[l+1];
+        tmp[l] = '\0';
+        ar.read( tmp, l );
+        s = tmp;
+        delete[] tmp;
+
+        return ar;
+}
+
+uint32_t Bu::Archive::getID( const void *ptr )
+{
+        if( hPtrID.has( (int)ptr ) )
+                return hPtrID.get( (int)ptr );
+        hPtrID.insert( (int)ptr, nNextID );
+        return nNextID++;
+}
+
+void Bu::Archive::assocPtrID( void **ptr, uint32_t id )
+{
+        if( hPtrID.has( id ) )
+        {
+                *ptr = (void *)hPtrID.get( id );
+                return;
+        }
+
+        if( !hPtrDest.has( id ) )
+                hPtrDest.insert( id, List<void **>() );
+                        
+        hPtrDest[id].value().append( ptr );
+}
+
+void Bu::Archive::readID( const void *ptr, uint32_t id )
+{
+        hPtrID.insert( id, (int)ptr );
+
+        if( hPtrDest.has( id ) )
+        {
+                Bu::List<void **> &l = hPtrDest.get( id );
+                for( Bu::List<void **>::iterator i = l.begin(); i != l.end(); i++ )
+                {
+                        *(*i) = (void *)ptr;
+                }
+
+                hPtrDest.erase( id );
+        }
+}
+
diff --git a/src/archive.h b/src/archive.h
new file mode 100644
index 0000000..a2d4c8f
--- /dev/null
+++ b/src/archive.h
@@ -0,0 +1,212 @@
+#ifndef BU_ARCHIVE_H
+#define BU_ARCHIVE_H
+
+#include <stdint.h>
+#include <string>
+#include "bu/archival.h"
+#include "bu/stream.h"
+#include <list>
+#include "bu/hash.h"
+#include "bu/list.h"
+
+namespace Bu
+{
+        /**
+         * Provides a framework for serialization of objects and primitives.  The
+         * archive will handle any basic primitive, a few special types, like char *
+         * strings, as well as STL classes and anything that inherits from the
+         * Archival class.  Each Archive operates on a Stream, so you can send the
+         * data using an Archive almost anywhere.
+         *
+         * In order to use an Archive to store something to a file, try something
+         * like:
+         *@code
+     * File sOut("output", "wb"); // This is a stream subclass
+         * Archive ar( sOut, Archive::save );
+         * ar << myClass;
+         @endcode
+         * In this example myClass is any class that inherits from Archival.  When
+         * the storage operator is called, the Archival::archive() function in the
+         * myClass object is called with a reference to the Archive.  This can be
+         * handled in one of two ways:
+         *@code
+         * void MyClass::archive( Archive &ar )
+         * {
+         *      ar && sName && nAge && sJob;
+         * }
+         @endcode
+         * Here we don't worry about weather we're loading or saving by using the
+         * smart && operator.  This allows us to write very consistent, very simple
+         * archive functions that really do a lot of work.  If we wanted to do
+         * something different in the case of loading or saving we would do:
+         *@code
+         * void MyClass::archive( Archive &ar )
+         * {
+         *      if( ar.isLoading() )
+         *      {
+         *              ar >> sName >> nAge >> sJob;
+         *      } else
+         *      {
+         *              ar << sName << nAge << sJob;
+         *      }
+         * }
+         @endcode
+         * Archive currently does not provide facility to make fully portable
+         * archives.  For example, it will not convert between endianness for you,
+         * nor will it take into account differences between primitive sizes on
+         * different platforms.  This, at the moment, is up to the user to ensure.
+         * One way of dealing with the latter problem is to make sure and use
+         * explicit primitive types from the stdint.h header, i.e. int32_t.
+         */
+        class Archive
+        {
+        private:
+                bool bLoading;
+        public:
+                bool isLoading();
+
+                enum
+                {
+                        load    =       true,
+                        save    =       false
+                };
+                
+                Archive( Stream &rStream, bool bLoading );
+                virtual ~Archive();
+                virtual void close();
+
+                virtual void write(const void *, int32_t);
+                virtual void read(void *, int32_t);
+                
+                virtual Archive &operator<<(bool);
+                virtual Archive &operator<<(int8_t);
+                virtual Archive &operator<<(int16_t);
+                virtual Archive &operator<<(int32_t);
+                virtual Archive &operator<<(int64_t);
+                virtual Archive &operator<<(uint8_t);
+                virtual Archive &operator<<(uint16_t);
+                virtual Archive &operator<<(uint32_t);
+                virtual Archive &operator<<(uint64_t);
+                virtual Archive &operator<<(long);
+                virtual Archive &operator<<(float);
+                virtual Archive &operator<<(double);
+                virtual Archive &operator<<(long double);
+
+                virtual Archive &operator>>(bool &);
+                virtual Archive &operator>>(int8_t &);
+                virtual Archive &operator>>(int16_t &);
+                virtual Archive &operator>>(int32_t &);
+                virtual Archive &operator>>(int64_t &);
+                virtual Archive &operator>>(uint8_t &);
+                virtual Archive &operator>>(uint16_t &);
+                virtual Archive &operator>>(uint32_t &);
+                virtual Archive &operator>>(uint64_t &);
+                virtual Archive &operator>>(long &);
+                virtual Archive &operator>>(float &);
+                virtual Archive &operator>>(double &);
+                virtual Archive &operator>>(long double &);
+                
+                virtual Archive &operator&&(bool &);
+                virtual Archive &operator&&(int8_t &);
+                virtual Archive &operator&&(int16_t &);
+                virtual Archive &operator&&(int32_t &);
+                virtual Archive &operator&&(int64_t &);
+                virtual Archive &operator&&(uint8_t &);
+                virtual Archive &operator&&(uint16_t &);
+                virtual Archive &operator&&(uint32_t &);
+                virtual Archive &operator&&(uint64_t &);
+                virtual Archive &operator&&(float &);
+                virtual Archive &operator&&(double &);
+                virtual Archive &operator&&(long double &);
+
+                uint32_t getID( const void *ptr );
+                void assocPtrID( void **ptr, uint32_t id );
+                void readID( const void *ptr, uint32_t id );
+
+        private:
+                Stream &rStream;
+                uint32_t nNextID;
+                Hash<uint32_t,uint32_t> hPtrID;
+                Hash<uint32_t,List<void **> > hPtrDest;
+        };
+
+        Archive &operator<<(Archive &, class Bu::Archival &);
+        Archive &operator>>(Archive &, class Bu::Archival &);
+        //Archive &operator&&(Archive &s, class Bu::Archival &p);
+
+        Archive &operator<<(Archive &, std::string &);
+        Archive &operator>>(Archive &, std::string &);
+        //Archive &operator&&(Archive &, std::string &);
+        
+        template<typename T> Archive &operator&&( Archive &ar, T &dat )
+        {
+                if( ar.isLoading() )
+                {
+                        return ar >> dat;
+                }
+                else
+                {
+                        return ar << dat;
+                }
+        }
+
+        template<typename T> Archive &operator<<( Archive &ar, std::list<T> &l )
+        {
+                typename std::list<T>::size_type num = l.size();
+                ar << num;
+                for( typename std::list<T>::const_iterator i = l.begin(); i != l.end();
+                         i++ )
+                {
+                        ar << *i;
+                }
+
+                return ar;
+        }
+
+        template<typename T> Archive &operator>>( Archive &ar, std::list<T> &l )
+        {
+                typename std::list<T>::size_type num;
+                ar >> num;
+
+                l.resize( num );
+                for( typename std::list<T>::const_iterator i = l.begin();
+                         i != l.end(); i++ )
+                {
+                        ar >> *i;
+                }
+
+                return ar;
+        }
+
+        template<typename key, typename value>
+        Archive &operator<<( Archive &ar, Hash<key,value> &h )
+        {
+                ar << h.size();
+                for( typename Hash<key,value>::iterator i = h.begin(); i != h.end(); i++ )
+                {
+                        //std::pair<key,value> p = *i;
+                        ar << (i.getKey()) << (i.getValue());
+                }
+
+                return ar;
+        }
+
+        template<typename key, typename value>
+        Archive &operator>>( Archive &ar, Hash<key,value> &h )
+        {
+                h.clear();
+                uint32_t nSize;
+                ar >> nSize;
+
+                for( uint32_t j = 0; j < nSize; j++ )
+                {
+                        key k; value v;
+                        ar >> k >> v;
+                        h.insert( k, v );
+                }
+
+                return ar;
+        }
+}
+
+#endif
diff --git a/src/arraylist.cpp b/src/arraylist.cpp
deleted file mode 100644
index ef21426..0000000
--- a/src/arraylist.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#include "arraylist.h"
-#include <stdlib.h>
-#include <string.h>
-
-ArrayList::ArrayList( int initSize, int growByFactor )
-{
-        apData = new void *[initSize];
-        nSize = 0;
-        nCapacity = initSize;
-        nGrowByFactor = growByFactor;
-}
-
-ArrayList::~ArrayList(  )
-{
-        delete[] apData;
-}
-
-void *ArrayList::getAt( int index )
-{
-        if( index < 0 || index > nSize )
-                return NULL;
-
-        return apData[index];
-}
-
-void ArrayList::append( void *data )
-{
-        insertBefore( data, nSize );
-}
-
-void ArrayList::insertBefore( void *data, int pos )
-{
-        if( pos < 0 || pos > nSize )
-                return;
-
-        checkResize();
-        memmove( &apData[pos+1], &apData[pos], (nSize-pos)*sizeof(void*) );
-        apData[pos] = data;
-        nSize++;
-}
-
-int ArrayList::getSize(  )
-{
-        return nSize;
-}
-
-bool ArrayList::isEmpty(  )
-{
-        return nSize==0;
-}
-
-void ArrayList::deleteAt( int index )
-{
-        if( index < 0 || index >= nSize )
-                return;
-
-        memmove( &apData[index], &apData[index+1], (nSize-index-1)*sizeof(void *) );
-        nSize--;
-}
-
-void ArrayList::empty()
-{
-        // Probably the easiest as far as things go.
-        nSize = 0;
-}
-
-void ArrayList::resizeTo( int newSize )
-{
-        void **apNew = new void *[newSize];
-        memmove( apNew, apData, nSize*sizeof(void *) );
-        nCapacity = newSize;
-        delete[] apData;
-        apData = apNew;
-}
-
-void ArrayList::checkResize()
-{
-        if( nSize >= nCapacity )
-        {
-                resizeTo( nCapacity + nGrowByFactor );
-        }
-}
-
-void ArrayList::setSize( int newSize )
-{
-        if( newSize < 0 )
-                return;
-
-        nSize = newSize;
-        checkResize();
-}
-
-void ArrayList::setAt( int index, void *data )
-{
-        if( index < 0 || index >= nSize )
-                return;
-
-        apData[index] = data;
-}
-
diff --git a/src/arraylist.h b/src/arraylist.h
deleted file mode 100644
index 0fda34a..0000000
--- a/src/arraylist.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/** \file arraylist.h
- * Describes the ArrayList class.
- *@author Mike Buland
- */
-#ifndef ARRAY_LIST_H
-#define ARRAY_LIST_H
-
-#include "list.h"
-
-/** A simple list which uses an array.  This is a great choice if you won't do
-  * a lot of adding and deleting and need a fast random access list.  Otherwise
-  * use the LinkedList.
-  *@author Mike Buland
-  */
-class ArrayList : public List
-{
-public:
-        /** Creates an arraylist with some pre-defined specs spelled out.
-          *@param initSize the inital number of elements to allocate.
-          *@param growByFactor How much to increase the size of the array by
-          * each time we run out of room.
-          */
-        ArrayList( int initSize=100, int growByFactor=10 );
-        /**
-         * Destroy the ArrayList
-         */
-        virtual ~ArrayList();
-
-        void *getAt( int nIndex );
-        void append( void *pData );
-        void insertBefore( void *pData, int nPos = 0 );
-        int getSize(  );
-        bool isEmpty(  );
-        void deleteAt( int nIndex );
-        void empty();
-        void setSize( int nNewSize );
-        void setAt( int nIndex, void *pData );
-
-private:
-        /**
-         * Checks to see if the system needs to be resized, if it does, this will
-         * automatically resize based on your parameters.
-         */
-        void checkResize();
-
-        /**
-         * Resize the system to a specified size.  If it is larger, then all data
-         * will be retained, if smaller the elements at the end will be cut off.
-         *@param newSize The number of elements to include after resizing.
-         */
-        void resizeTo( int newSize );
-
-        /**
-         * Actual master array of pointers.  This is done to follow the List specs.
-         * All data transactions are performed with pointers or compatable
-         * primitive data-types.
-         */
-        void **apData;
-
-        /**
-         * The number of filled in elements in the array.  This is the practical
-         * real size of the ArrayList for all userspace applications.
-         */
-        int nSize;
-
-        /**
-         * The number of elements allocated in memory.  Not all of these have to be
-         * filled in, and it is usually larger than nSize so that adding and
-         * deleting elements is fast and easy.
-         */
-        int nCapacity;
-
-        /**
-         * The amount to grow by whenever the array needs resizing.
-         */
-        int nGrowByFactor;
-};
-
-#endif
-
diff --git a/src/atom.cpp b/src/atom.cpp
new file mode 100644
index 0000000..f966bfc
--- /dev/null
+++ b/src/atom.cpp
@@ -0,0 +1 @@
+#include "bu/atom.h"
diff --git a/src/atom.h b/src/atom.h
new file mode 100644
index 0000000..fad47eb
--- /dev/null
+++ b/src/atom.h
@@ -0,0 +1,107 @@
+#ifndef BU_ATOM_H
+#define BU_ATOM_H
+
+#include <stdint.h>
+#include <memory>
+#include "bu/exceptions.h"
+
+namespace Bu
+{
+        /**
+         *
+         */
+        template <typename t, typename talloc=std::allocator<t> >
+        class Atom
+        {
+        private:
+                typedef struct Atom<t, talloc> MyType;
+
+        public:
+                Atom() :
+                        pData( NULL )
+                {
+                }
+
+                virtual ~Atom()
+                {
+                        clear();
+                }
+
+                bool has() const
+                {
+                        return (pData != NULL);
+                }
+
+                void set( const t &val )
+                {
+                        clear();
+                        pData = ta.allocate( 1 );
+                        ta.construct( pData, val );
+                }
+
+                t &get()
+                {
+                        if( !pData )
+                                throw Bu::ExceptionBase("Not set");
+                        return *pData;
+                }
+
+                const t &get() const
+                {
+                        if( !pData )
+                                throw Bu::ExceptionBase("Not set");
+                        return *pData;
+                }
+
+                void clear()
+                {
+                        if( pData )
+                        {
+                                ta.destroy( pData );
+                                ta.deallocate( pData, 1 );
+                                pData = NULL;
+                        }
+                }
+
+                operator const t &() const
+                {
+                        if( !pData )
+                                throw Bu::ExceptionBase("Not set");
+                        return *pData;
+                }
+                
+                operator t &()
+                {
+                        if( !pData )
+                                throw Bu::ExceptionBase("Not set");
+                        return *pData;
+                }
+
+                MyType &operator =( const t &oth )
+                {
+                        set( oth );
+
+                        return *this;
+                }
+
+                t *operator ->()
+                {
+                        if( !pData )
+                                throw Bu::ExceptionBase("Not set");
+                        return pData;
+                }
+
+                t &operator *()
+                {
+                        if( !pData )
+                                throw Bu::ExceptionBase("Not set");
+                        return *pData;
+                }
+
+        private:
+                t *pData;
+                talloc ta;
+        };
+}
+
+#endif
diff --git a/src/bzip2.cpp b/src/bzip2.cpp
new file mode 100644
index 0000000..fbe5712
--- /dev/null
+++ b/src/bzip2.cpp
@@ -0,0 +1,196 @@
+#include "bu/bzip2.h"
+#include "bu/exceptions.h"
+
+using namespace Bu;
+
+Bu::BZip2::BZip2( Bu::Stream &rNext, int nCompression ) :
+        Bu::Filter( rNext ),
+        nCompression( nCompression )
+{
+        start();
+}
+
+Bu::BZip2::~BZip2()
+{
+        stop();
+}
+
+void Bu::BZip2::start()
+{
+        bzState.state = NULL;
+        bzState.bzalloc = NULL;
+        bzState.bzfree = NULL;
+        bzState.opaque = NULL;
+
+        nBufSize = 50000;
+        pBuf = new char[nBufSize];
+}
+
+size_t Bu::BZip2::stop()
+{
+        if( bzState.state )
+        {
+                if( bReading )
+                {
+                        BZ2_bzDecompressEnd( &bzState );
+                        delete[] pBuf;
+                        pBuf = NULL;
+                        return 0;
+                }
+                else
+                {
+                        size_t sTotal = 0;
+                        for(;;)
+                        {
+                                bzState.next_in = NULL;
+                                bzState.avail_in = 0;
+                                bzState.avail_out = nBufSize;
+                                bzState.next_out = pBuf;
+                                int res = BZ2_bzCompress( &bzState, BZ_FINISH );
+                                if( bzState.avail_out < nBufSize )
+                                {
+                                        sTotal += rNext.write( pBuf, nBufSize-bzState.avail_out );
+                                }
+                                if( res == BZ_STREAM_END )
+                                        break;
+                        }
+                        BZ2_bzCompressEnd( &bzState );
+                        delete[] pBuf;
+                        pBuf = NULL;
+                        return sTotal;
+                }
+        }
+        return 0;
+}
+
+void Bu::BZip2::bzError( int code )
+{
+        switch( code )
+        {
+                case BZ_OK:
+                case BZ_RUN_OK:
+                case BZ_FLUSH_OK:
+                case BZ_FINISH_OK:
+                        return;
+
+                case BZ_CONFIG_ERROR:
+                        throw ExceptionBase("BZip2: Library configured improperly, reinstall.");
+
+                case BZ_SEQUENCE_ERROR:
+                        throw ExceptionBase("BZip2: Functions were called in an invalid sequence.");
+
+                case BZ_PARAM_ERROR:
+                        throw ExceptionBase("BZip2: Invalid parameter was passed into a function.");
+
+                case BZ_MEM_ERROR:
+                        throw ExceptionBase("BZip2: Couldn't allocate sufficient memory.");
+
+                case BZ_DATA_ERROR:
+                        throw ExceptionBase("BZip2: Data was corrupted before decompression.");
+
+                case BZ_DATA_ERROR_MAGIC:
+                        throw ExceptionBase("BZip2: Stream does not appear to be bzip2 data.");
+
+                case BZ_IO_ERROR:
+                        throw ExceptionBase("BZip2: File couldn't be read from / written to.");
+
+                case BZ_UNEXPECTED_EOF:
+                        throw ExceptionBase("BZip2: End of file encountered before end of stream.");
+
+                case BZ_OUTBUFF_FULL:
+                        throw ExceptionBase("BZip2: Buffer not large enough to accomidate data.");
+
+                default:
+                        throw ExceptionBase("BZip2: Unknown error encountered.");
+        
+        }
+}
+
+size_t Bu::BZip2::read( void *pData, size_t nBytes )
+{
+        if( !bzState.state )
+        {
+                bReading = true;
+                BZ2_bzDecompressInit( &bzState, 0, 0 );
+                bzState.next_in = pBuf;
+                bzState.avail_in = 0;
+        }
+        if( bReading == false )
+                throw ExceptionBase("This bzip2 filter is in writing mode, you can't read.");
+
+        int nRead = 0;
+        int nReadTotal = bzState.total_out_lo32;
+        bzState.next_out = (char *)pData;
+        bzState.avail_out = nBytes;
+        for(;;)
+        {
+                int ret = BZ2_bzDecompress( &bzState );
+        
+                nReadTotal += nRead-bzState.avail_out;
+
+                if( ret == BZ_STREAM_END )
+                {
+                        if( bzState.avail_in > 0 )
+                        {
+                                if( rNext.isSeekable() )
+                                {
+                                        rNext.seek( -bzState.avail_in );
+                                }
+                        }
+                        return nBytes-bzState.avail_out;
+                }
+                bzError( ret );
+
+                if( bzState.avail_out )
+                {
+                        if( bzState.avail_in == 0 )
+                        {
+                                nRead = rNext.read( pBuf, nBufSize );
+                                bzState.next_in = pBuf;
+                                bzState.avail_in = nRead;
+                        }
+                }
+                else
+                {
+                        return nBytes-bzState.avail_out;
+                }
+        }
+        return 0;
+}
+
+size_t Bu::BZip2::write( const void *pData, size_t nBytes )
+{
+        if( !bzState.state )
+        {
+                bReading = false;
+                BZ2_bzCompressInit( &bzState, nCompression, 0, 30 );
+        }
+        if( bReading == true )
+                throw ExceptionBase("This bzip2 filter is in reading mode, you can't write.");
+
+        size_t sTotalOut = 0;
+        bzState.next_in = (char *)pData;
+        bzState.avail_in = nBytes;
+        for(;;)
+        {
+                bzState.avail_out = nBufSize;
+                bzState.next_out = pBuf;
+
+                bzError( BZ2_bzCompress( &bzState, BZ_RUN ) );
+
+                if( bzState.avail_out < nBufSize )
+                {
+                        sTotalOut += rNext.write( pBuf, nBufSize-bzState.avail_out );
+                }
+                if( bzState.avail_in == 0 )
+                        break;
+        }
+
+        return sTotalOut;
+}
+
+bool Bu::BZip2::isOpen()
+{
+        return (bzState.state != NULL);
+}
+
diff --git a/src/bzip2.h b/src/bzip2.h
new file mode 100644
index 0000000..0a111e8
--- /dev/null
+++ b/src/bzip2.h
@@ -0,0 +1,37 @@
+#ifndef BU_BZIP2_H
+#define BU_BZIP2_H
+
+#include <stdint.h>
+#include <bzlib.h>
+
+#include "bu/filter.h"
+
+namespace Bu
+{
+        /**
+         *
+         */
+        class BZip2 : public Bu::Filter
+        {
+        public:
+                BZip2( Bu::Stream &rNext, int nCompression=9 );
+                virtual ~BZip2();
+
+                virtual void start();
+                virtual size_t stop();
+                virtual size_t read( void *pBuf, size_t nBytes );
+                virtual size_t write( const void *pBuf, size_t nBytes );
+
+                virtual bool isOpen();
+
+        private:
+                void bzError( int code );
+                bz_stream bzState;
+                bool bReading;
+                int nCompression;
+                char *pBuf;
+                uint32_t nBufSize;
+        };
+}
+
+#endif
diff --git a/src/client.cpp b/src/client.cpp
new file mode 100644
index 0000000..8077b3d
--- /dev/null
+++ b/src/client.cpp
@@ -0,0 +1,206 @@
+#include "bu/client.h"
+#include "bu/socket.h"
+#include <stdlib.h>
+#include <errno.h>
+#include "bu/exceptions.h"
+#include "bu/protocol.h"
+
+/** Read buffer size. */
+#define RBS             (1024*2)
+
+Bu::Client::Client( Bu::Socket *pSocket ) :
+        pSocket( pSocket ),
+        pProto( NULL ),
+        nRBOffset( 0 )
+{
+}
+
+Bu::Client::~Client()
+{
+}
+
+void Bu::Client::processInput()
+{
+        char buf[RBS];
+        size_t nRead, nTotal=0;
+
+        for(;;)
+        {
+                nRead = pSocket->read( buf, nRead );
+                if( nRead < 0  )
+                {
+                        throw Bu::ConnectionException(
+                                excodeReadError,
+                                "Read error: %s",
+                                strerror( errno )
+                                );
+                }
+                else if( nRead == 0 )
+                {
+                        break;
+                }
+                else
+                {
+                        nTotal += nRead;
+                        sReadBuf.append( buf, nRead );
+                        if( !pSocket->canRead() )
+                                break;
+                }
+        }
+
+        if( nTotal == 0 )
+        {
+                pSocket->close();
+        }
+
+        if( pProto && nTotal )
+        {
+                pProto->onNewData( this );
+        }
+}
+
+void Bu::Client::processOutput()
+{
+        if( sWriteBuf.getSize() > 0 )
+        {
+                pSocket->write( sWriteBuf.getStr(), sWriteBuf.getSize() );
+                sWriteBuf.clear();
+        }
+}
+
+void Bu::Client::setProtocol( Protocol *pProto )
+{
+        this->pProto = pProto;
+}
+
+Bu::Protocol *Bu::Client::getProtocol()
+{
+        return pProto;
+}
+
+void Bu::Client::clearProtocol()
+{
+        pProto = NULL;
+}
+
+Bu::FString &Bu::Client::getInput()
+{
+        return sReadBuf;
+}
+
+Bu::FString &Bu::Client::getOutput()
+{
+        return sWriteBuf;
+}
+
+bool Bu::Client::isOpen()
+{
+        if( !pSocket ) return false;
+        return pSocket->isOpen();
+}
+
+void Bu::Client::write( const void *pData, int nBytes )
+{
+        sWriteBuf.append( (const char *)pData, nBytes );
+}
+
+void Bu::Client::write( int8_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+
+void Bu::Client::write( int16_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+
+void Bu::Client::write( int32_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+
+void Bu::Client::write( int64_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+
+void Bu::Client::write( uint8_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+
+void Bu::Client::write( uint16_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+
+void Bu::Client::write( uint32_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+
+void Bu::Client::write( uint64_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+
+void Bu::Client::read( void *pData, int nBytes )
+{
+        memcpy( pData, sReadBuf.getStr()+nRBOffset, nBytes );
+        nRBOffset += nBytes;
+        if( sReadBuf.getSize()-nRBOffset == 0 )
+        {
+                sReadBuf.clear();
+                nRBOffset = 0;
+        }
+        // This is an experimental threshold, maybe I'll make this configurable
+        // later on.
+        else if(
+                (sReadBuf.getSize() >= 1024 && nRBOffset >= sReadBuf.getSize()/2) ||
+                (nRBOffset >= sReadBuf.getSize()/4)
+                )
+        {
+                sReadBuf.trimFront( nRBOffset );
+                nRBOffset = 0;
+        }
+}
+
+void Bu::Client::peek( void *pData, int nBytes )
+{
+        memcpy( pData, sReadBuf.getStr()+nRBOffset, nBytes );
+}
+
+void Bu::Client::seek( int nBytes )
+{
+        nRBOffset += nBytes;
+        if( sReadBuf.getSize()-nRBOffset == 0 )
+        {
+                sReadBuf.clear();
+                nRBOffset = 0;
+        }
+        // This is an experimental threshold, maybe I'll make this configurable
+        // later on.
+        else if(
+                (sReadBuf.getSize() >= 1024 && nRBOffset >= sReadBuf.getSize()/2) ||
+                (nRBOffset >= sReadBuf.getSize()/4)
+                )
+        {
+                sReadBuf.trimFront( nRBOffset );
+                nRBOffset = 0;
+        }
+}
+
+long Bu::Client::getInputSize()
+{
+        return sReadBuf.getSize()-nRBOffset;
+}
+
+const Bu::Socket *Bu::Client::getSocket() const
+{
+        return pSocket;
+}
+
+void Bu::Client::disconnect()
+{
+}
+
diff --git a/src/client.h b/src/client.h
new file mode 100644
index 0000000..5947521
--- /dev/null
+++ b/src/client.h
@@ -0,0 +1,63 @@
+#ifndef BU_CLIENT_H
+#define BU_CLIENT_H
+
+#include <stdint.h>
+
+#include "bu/fstring.h"
+
+namespace Bu
+{
+        class Protocol;
+        class Socket;
+
+        /**
+         *
+         */
+        class Client
+        {
+        public:
+                Client( Bu::Socket *pSocket );
+                virtual ~Client();
+
+                void processInput();
+                void processOutput();
+
+                Bu::FString &getInput();
+                Bu::FString &getOutput();
+                void write( const void *pData, int nBytes );
+                void write( int8_t nData );
+                void write( int16_t nData );
+                void write( int32_t nData );
+                void write( int64_t nData );
+                void write( uint8_t nData );
+                void write( uint16_t nData );
+                void write( uint32_t nData );
+                void write( uint64_t nData );
+                void read( void *pData, int nBytes );
+                void peek( void *pData, int nBytes );
+                void seek( int nBytes );
+                long getInputSize();
+
+                void setProtocol( Protocol *pProto );
+                Bu::Protocol *getProtocol();
+                void clearProtocol();
+
+                bool isOpen();
+
+                const Bu::Socket *getSocket() const;
+
+                /**
+                 *@todo Make this not suck.
+                 */
+                void disconnect();
+
+        private:
+                Bu::Socket *pSocket;
+                Bu::Protocol *pProto;
+                Bu::FString sReadBuf;
+                int nRBOffset;
+                Bu::FString sWriteBuf;
+        };
+}
+
+#endif
diff --git a/src/entities/bu-class b/src/entities/bu-class
new file mode 100644
index 0000000..7b25291
--- /dev/null
+++ b/src/entities/bu-class
@@ -0,0 +1,48 @@
+<?xml version="1.1" ?>
+<entity desc="Basic cpp class, with optional parent class. (.cpp+.h)">
+        <param name="name" required="yes" desc="Name of the class"/>
+        <param name="parent" required="no" desc="Name of the parent class"/>
+        <file
+                name="header"
+                filename="{=name:%tolower}.h"
+>#ifndef {=name:%uccsplit:%toupper}_H
+#define {=name:%uccsplit:%toupper}_H
+
+#include &lt;stdint.h&gt;
+
+{?parent:"#include \"bu/{=parent:%tolower}.h\"
+
+"}namespace Bu
+{
+        /**
+         *
+         */
+        class {=name}{?parent:" : public {=parent}"}
+        {
+        public:
+                {=name}();
+                virtual ~{=name}();
+
+        private:
+
+        };
+}
+
+#endif
+</file>
+        <file
+                name="source"
+                filename="{=name:%tolower}.cpp"
+>#include "bu/{=name:%tolower}.h"
+
+using namespace Bu;
+
+Bu::{=name}::{=name}()
+{
+}
+
+Bu::{=name}::~{=name}()
+{
+}
+</file>
+</entity>
diff --git a/src/exceptionbase.cpp b/src/exceptionbase.cpp
index f3d22da..f6ec625 100644
--- a/src/exceptionbase.cpp
+++ b/src/exceptionbase.cpp
@@ -1,7 +1,7 @@
 #include "exceptionbase.h"
 #include <stdarg.h>
 
-ExceptionBase::ExceptionBase( const char *lpFormat, ... ) throw() :
+Bu::ExceptionBase::ExceptionBase( const char *lpFormat, ... ) throw() :
         nErrorCode( 0 ),
         sWhat( NULL )
 {
@@ -12,7 +12,7 @@ ExceptionBase::ExceptionBase( const char *lpFormat, ... ) throw() :
         va_end(ap);
 }
 
-ExceptionBase::ExceptionBase( int nCode, const char *lpFormat, ... ) throw() :
+Bu::ExceptionBase::ExceptionBase( int nCode, const char *lpFormat, ... ) throw() :
         nErrorCode( nCode ),
         sWhat( NULL )
 {
@@ -23,13 +23,13 @@ ExceptionBase::ExceptionBase( int nCode, const char *lpFormat, ... ) throw() :
         va_end(ap);
 }
 
-ExceptionBase::ExceptionBase( int nCode ) throw() :
+Bu::ExceptionBase::ExceptionBase( int nCode ) throw() :
         nErrorCode( nCode ),
         sWhat( NULL )
 {
 }
 
-ExceptionBase::~ExceptionBase() throw()
+Bu::ExceptionBase::~ExceptionBase() throw()
 {
         if( sWhat )
         {
@@ -38,7 +38,7 @@ ExceptionBase::~ExceptionBase() throw()
         }
 }
 
-void ExceptionBase::setWhat( const char *lpFormat, va_list &vargs )
+void Bu::ExceptionBase::setWhat( const char *lpFormat, va_list &vargs )
 {
         if( sWhat ) delete[] sWhat;
         int nSize;
@@ -48,7 +48,7 @@ void ExceptionBase::setWhat( const char *lpFormat, va_list &vargs )
         vsnprintf( sWhat, nSize+1, lpFormat, vargs );
 }
 
-void ExceptionBase::setWhat( const char *lpText )
+void Bu::ExceptionBase::setWhat( const char *lpText )
 {
         if( sWhat ) delete[] sWhat;
         int nSize;
@@ -58,12 +58,12 @@ void ExceptionBase::setWhat( const char *lpText )
         strcpy( sWhat, lpText );
 }
 
-const char *ExceptionBase::what() const throw()
+const char *Bu::ExceptionBase::what() const throw()
 {
         return sWhat;
 }
 
-int ExceptionBase::getErrorCode()
+int Bu::ExceptionBase::getErrorCode()
 {
         return nErrorCode;
 }
diff --git a/src/exceptionbase.h b/src/exceptionbase.h
index 6f1eca7..24e4bbf 100644
--- a/src/exceptionbase.h
+++ b/src/exceptionbase.h
@@ -1,75 +1,84 @@
-#ifndef EXCEPTION_BASE_H
-#define EXCEPTION_BASE_H
+#ifndef BU_EXCEPTION_BASE_H
+#define BU_EXCEPTION_BASE_H
 
 #include <string>
 #include <exception>
 #include <stdarg.h>
 
-/**
- * A generalized Exception base class.  This is nice for making general and
- * flexible child classes that can create new error code classes.
- */
-class ExceptionBase : public std::exception
+namespace Bu
 {
-public:
-        /**
-         * Construct an exception with an error code of zero, but with a
-         * description.  The use of this is not reccomended most of the time, it's
-         * generally best to include an error code with the exception so your
-         * program can handle the exception in a better way.
-         * @param sFormat The format of the text.  See printf for more info.
-         */
-        ExceptionBase( const char *sFormat, ... ) throw();
-        
         /**
+         * A generalized Exception base class.  This is nice for making general and
+         * flexible child classes that can create new error code classes.
+         *
+         * In order to create your own exception class use these two lines.
          * 
-         * @param nCode 
-         * @param sFormat
-         */
-        ExceptionBase( int nCode, const char *sFormat, ... ) throw();
-        
-        /**
+         * in your header:  subExceptionDecl( NewClassName );
          * 
-         * @param nCode 
-         * @return 
+         * in your source:  subExcpetienDef( NewClassName );
          */
-        ExceptionBase( int nCode=0 ) throw();
-        
-        /**
-         * 
-         * @return 
-         */
-        virtual ~ExceptionBase() throw();
+        class ExceptionBase : public std::exception
+        {
+        public:
+                /**
+                 * Construct an exception with an error code of zero, but with a
+                 * description.  The use of this is not reccomended most of the time,
+                 * it's generally best to include an error code with the exception so
+                 * your program can handle the exception in a better way.
+                 * @param sFormat The format of the text.  See printf for more info.
+                 */
+                ExceptionBase( const char *sFormat, ... ) throw();
+                
+                /**
+                 * 
+                 * @param nCode 
+                 * @param sFormat
+                 */
+                ExceptionBase( int nCode, const char *sFormat, ... ) throw();
+                
+                /**
+                 * 
+                 * @param nCode 
+                 * @return 
+                 */
+                ExceptionBase( int nCode=0 ) throw();
+                
+                /**
+                 * 
+                 * @return 
+                 */
+                virtual ~ExceptionBase() throw();
 
-        /**
-         * 
-         * @return 
-         */
-        virtual const char *what() const throw();
-        
-        /**
-         * 
-         * @return 
-         */
-        int getErrorCode();
-        
-        /**
-         * 
-         * @param lpFormat 
-         * @param vargs 
-         */
-        void setWhat( const char *lpFormat, va_list &vargs );
+                /**
+                 * 
+                 * @return 
+                 */
+                virtual const char *what() const throw();
+                
+                /**
+                 * 
+                 * @return 
+                 */
+                int getErrorCode();
+                
+                /**
+                 * 
+                 * @param lpFormat 
+                 * @param vargs 
+                 */
+                void setWhat( const char *lpFormat, va_list &vargs );
 
-        /**
-         *
-         * @param lpText
-         */
-        void setWhat( const char *lpText );
+                /**
+                 *
+                 * @param lpText
+                 */
+                void setWhat( const char *lpText );
 
-private:
-        int nErrorCode; /**< The code for the error that occured. */
-        char *sWhat;    /**< The text string telling people what went wrong. */
-};
+        private:
+                int nErrorCode; /**< The code for the error that occured. */
+                char *sWhat;    /**< The text string telling people what went wrong. */
+        };
+}
 
 #define subExceptionDecl( name )                                                                                        \
 class name : public ExceptionBase                                                                                       \
diff --git a/src/exceptions.cpp b/src/exceptions.cpp
index ce79a5e..50b95c3 100644
--- a/src/exceptions.cpp
+++ b/src/exceptions.cpp
@@ -1,8 +1,13 @@
 #include "exceptions.h"
 #include <stdarg.h>
 
-subExceptionDef( XmlException )
-subExceptionDef( FileException )
-subExceptionDef( ConnectionException )
-subExceptionDef( PluginException )
-
+namespace Bu
+{
+        subExceptionDef( XmlException )
+        subExceptionDef( TafException )
+        subExceptionDef( FileException )
+        subExceptionDef( SocketException )
+        subExceptionDef( ConnectionException )
+        subExceptionDef( PluginException )
+        subExceptionDef( UnsupportedException )
+}
diff --git a/src/exceptions.h b/src/exceptions.h
index 0ab2b15..b824b91 100644
--- a/src/exceptions.h
+++ b/src/exceptions.h
@@ -1,25 +1,32 @@
-#ifndef EXCEPTIONS_H
-#define EXCEPTIONS_H
+#ifndef BU_EXCEPTIONS_H
+#define BU_EXCEPTIONS_H
 
 #include "exceptionbase.h"
 #include <stdarg.h>
 
-subExceptionDecl( XmlException )
-subExceptionDecl( FileException )
-subExceptionDecl( ConnectionException )
-subExceptionDecl( PluginException )
-
-enum eFileException
-{
-        excodeEOF
-};
-        
-enum eConnectionException
+namespace Bu
 {
-        excodeReadError,
-        excodeBadReadError,
-        excodeConnectionClosed,
-        excodeSocketTimeout
-};
+        subExceptionDecl( XmlException )
+        subExceptionDecl( TafException )
+        subExceptionDecl( FileException )
+        subExceptionDecl( SocketException )
+        subExceptionDecl( ConnectionException )
+        subExceptionDecl( PluginException )
+        subExceptionDecl( UnsupportedException )
+
+        enum eFileException
+        {
+                excodeEOF
+        };
+                
+        enum eConnectionException
+        {
+                excodeReadError,
+                excodeWriteError,
+                excodeBadReadError,
+                excodeConnectionClosed,
+                excodeSocketTimeout
+        };
+}
 
 #endif
diff --git a/src/file.cpp b/src/file.cpp
new file mode 100644
index 0000000..1a8bd08
--- /dev/null
+++ b/src/file.cpp
@@ -0,0 +1,158 @@
+#include "file.h"
+#include "exceptions.h"
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+Bu::File::File( const char *sName, const char *sFlags )
+{
+        fh = fopen( sName, sFlags );
+        if( fh == NULL )
+        {
+                throw Bu::FileException( errno, strerror(errno) );
+        }
+}
+
+Bu::File::File( const Bu::FString &sName, const char *sFlags )
+{
+        fh = fopen( sName.getStr(), sFlags );
+        if( fh == NULL )
+        {
+                throw Bu::FileException( errno, strerror(errno) );
+        }
+}
+
+Bu::File::File( int fd, const char *sFlags )
+{
+        fh = fdopen( fd, sFlags );
+}
+
+Bu::File::~File()
+{
+        close();
+}
+
+void Bu::File::close()
+{
+        if( fh )
+        {
+                fclose( fh );
+                fh = NULL;
+        }
+}
+
+size_t Bu::File::read( void *pBuf, size_t nBytes )
+{
+        if( !fh )
+                throw FileException("File not open.");
+
+        int nAmnt = fread( pBuf, 1, nBytes, fh );
+
+        //if( nAmnt == 0 )
+        //      throw FileException("End of file.");
+
+        return nAmnt;
+}
+
+size_t Bu::File::write( const void *pBuf, size_t nBytes )
+{
+        if( !fh )
+                throw FileException("File not open.");
+
+        return fwrite( pBuf, 1, nBytes, fh );
+}
+
+long Bu::File::tell()
+{
+        if( !fh )
+                throw FileException("File not open.");
+
+        return ftell( fh );
+}
+
+void Bu::File::seek( long offset )
+{
+        if( !fh )
+                throw FileException("File not open.");
+
+        fseek( fh, offset, SEEK_CUR );
+}
+
+void Bu::File::setPos( long pos )
+{
+        if( !fh )
+                throw FileException("File not open.");
+
+        fseek( fh, pos, SEEK_SET );
+}
+
+void Bu::File::setPosEnd( long pos )
+{
+        if( !fh )
+                throw FileException("File not open.");
+        
+        fseek( fh, pos, SEEK_END );
+}
+
+bool Bu::File::isEOS()
+{
+        return feof( fh );
+}
+
+bool Bu::File::canRead()
+{
+        return true;
+}
+
+bool Bu::File::canWrite()
+{
+        return true;
+}
+
+bool Bu::File::isReadable()
+{
+        return true;
+}
+
+bool Bu::File::isWritable()
+{
+        return true;
+}
+
+bool Bu::File::isSeekable()
+{
+        return true;
+}
+
+bool Bu::File::isBlocking()
+{
+        return true;
+}
+
+void Bu::File::setBlocking( bool bBlocking )
+{
+        return;
+}
+
+#ifndef WIN32
+void Bu::File::truncate( long nSize )
+{
+        ftruncate( fileno( fh ), nSize );
+}
+
+void Bu::File::chmod( mode_t t )
+{
+        fchmod( fileno( fh ), t );
+}
+#endif
+
+void Bu::File::flush()
+{
+        fflush( fh );
+}
+
+bool Bu::File::isOpen()
+{
+        return (fh != NULL);
+}
+
diff --git a/src/file.h b/src/file.h
new file mode 100644
index 0000000..d4e43eb
--- /dev/null
+++ b/src/file.h
@@ -0,0 +1,78 @@
+#ifndef BU_FILE_H
+#define BU_FILE_H
+
+#include <stdint.h>
+
+#include "bu/stream.h"
+#include "bu/fstring.h"
+
+namespace Bu
+{
+        class File : public Bu::Stream
+        {
+        public:
+                File( const char *sName, const char *sFlags );
+                File( const Bu::FString &sName, const char *sFlags );
+                File( int fd, const char *sFlags );
+                virtual ~File();
+
+                virtual void close();
+                virtual size_t read( void *pBuf, size_t nBytes );
+                virtual size_t write( const void *pBuf, size_t nBytes );
+
+                virtual long tell();
+                virtual void seek( long offset );
+                virtual void setPos( long pos );
+                virtual void setPosEnd( long pos );
+                virtual bool isEOS();
+                virtual bool isOpen();
+
+                virtual void flush();
+
+                virtual bool canRead();
+                virtual bool canWrite();
+
+                virtual bool isReadable();
+                virtual bool isWritable();
+                virtual bool isSeekable();
+
+                virtual bool isBlocking();
+                virtual void setBlocking( bool bBlocking=true );
+
+                /**
+                 * Create a temp file and return its handle
+                 *@param sName (Bu::FString) Give in the form: "/tmp/tmpfileXXXXXXXX"
+                 *              It will alter your (sName) setting the 'X's to random
+                 *              characters.
+                 *@param sFlags (const char *) Standard file flags 'rb'... etc..
+                 *@returns (Bu::File) A file object representing your temp file.
+                 */
+#ifndef WIN32
+                inline static Bu::File tempFile( Bu::FString &sName, const char *sFlags )
+                {
+                        int afh_d = mkstemp( sName.getStr() );
+
+                        return Bu::File( afh_d, sFlags );
+                }
+
+                /**
+                 * Set the size of the file to (nSize). You can either grow or shrink
+                 *              the file.
+                 *@param nSize (long) The new size of the file.
+                 */
+                void truncate( long nSize );
+
+                /**
+                 * Change the file access permissions.
+                 *@param t (mode_t) The new file access permissions.
+                 */
+                void chmod( mode_t t );
+#endif
+
+        private:
+                FILE *fh;
+
+        };
+}
+
+#endif
diff --git a/src/filter.cpp b/src/filter.cpp
new file mode 100644
index 0000000..96a8694
--- /dev/null
+++ b/src/filter.cpp
@@ -0,0 +1,97 @@
+#include "bu/filter.h"
+
+Bu::Filter::Filter( Bu::Stream &rNext ) :
+        rNext( rNext )
+{
+}
+
+Bu::Filter::~Filter()
+{
+        //printf("-> Bu::Filter::~Filter()\n");         
+}
+/*
+void Bu::Filter::start()
+{
+        printf("-> Bu::Filter::start()\n");
+}
+
+void Bu::Filter::stop()
+{
+}*/
+
+void Bu::Filter::close()
+{
+        stop();
+        rNext.close();
+}
+
+long Bu::Filter::tell()
+{
+        return rNext.tell();
+}
+
+void Bu::Filter::seek( long offset )
+{
+        rNext.seek( offset );
+}
+
+void Bu::Filter::setPos( long pos )
+{
+        rNext.setPos( pos );
+}
+
+void Bu::Filter::setPosEnd( long pos )
+{
+        rNext.setPosEnd( pos );
+}
+
+bool Bu::Filter::isEOS()
+{
+        return rNext.isEOS();
+}
+
+bool Bu::Filter::isOpen()
+{
+        return rNext.isOpen();
+}
+
+bool Bu::Filter::canRead()
+{
+        return rNext.canRead();
+}
+
+bool Bu::Filter::canWrite()
+{
+        return rNext.canWrite();
+}
+
+bool Bu::Filter::isReadable()
+{
+        return rNext.isReadable();
+}
+
+bool Bu::Filter::isWritable()
+{
+        return rNext.isWritable();
+}
+
+bool Bu::Filter::isSeekable()
+{
+        return rNext.isSeekable();
+}
+
+bool Bu::Filter::isBlocking()
+{
+        return rNext.isBlocking();
+}
+
+void Bu::Filter::setBlocking( bool bBlocking )
+{
+        rNext.setBlocking( bBlocking );
+}
+
+void Bu::Filter::flush()
+{
+        rNext.flush();
+}
+
diff --git a/src/filter.h b/src/filter.h
new file mode 100644
index 0000000..bd557b2
--- /dev/null
+++ b/src/filter.h
@@ -0,0 +1,65 @@
+#ifndef BU_FILTER_H
+#define BU_FILTER_H
+
+#include <stdint.h>
+
+#include "bu/stream.h"
+
+namespace Bu
+{
+        /**
+         * Data filter base class.  Each data filter should contain a read and write
+         * section.  Effectively, the write applies the filter, the read un-applies
+         * the filter, if possible.  For example, BZip2 is a filter that compresses
+         * on write and decompresses on read.  All bi-directional filters should
+         * follow:  x == read( write( x ) ) (byte-for-byte comparison)
+         *
+         * Also, all returned buffers should be owned by the filter, and deleted
+         * when the filter is deleted.  This means that the output of a read or
+         * write operation must be used before the next call to read or write or the
+         * data will be destroyed.  Also, the internal buffer may be changed or
+         * recreated between calls, so always get a new pointer from a call to
+         * read or write.
+         *
+         * The close function can also return data, so make sure to check for it,
+         * many filters such as compression filters will buffer data until they have
+         * enough to create a compression block, in these cases the leftover data
+         * will be returned by close.
+         */
+        class Filter : public Bu::Stream
+        {
+        public:
+                Filter( Bu::Stream &rNext );
+                virtual ~Filter();
+
+                virtual void start()=0;
+                virtual size_t stop()=0;
+                virtual void close();
+                virtual long tell();
+                virtual void seek( long offset );
+                virtual void setPos( long pos );
+                virtual void setPosEnd( long pos );
+                virtual bool isEOS();
+                virtual bool isOpen();
+
+                virtual void flush();
+
+                virtual bool canRead();
+                virtual bool canWrite();
+
+                virtual bool isReadable();
+                virtual bool isWritable();
+                virtual bool isSeekable();
+
+                virtual bool isBlocking();
+                virtual void setBlocking( bool bBlocking=true );
+
+        protected:
+                Bu::Stream &rNext;
+
+        private:
+
+        };
+}
+
+#endif
diff --git a/src/fstring.cpp b/src/fstring.cpp
index 82d024d..f71d6c1 100644
--- a/src/fstring.cpp
+++ b/src/fstring.cpp
@@ -1,13 +1,20 @@
 #include "fstring.h"
 #include "hash.h"
 
-template<> uint32_t __calcHashCode<FString>( const FString &k )
+template<> uint32_t Bu::__calcHashCode<Bu::FString>( const Bu::FString &k )
 {
         return __calcHashCode( k.c_str() );
 }
 
-template<> bool __cmpHashKeys<FString>( const FString &a, const FString &b )
+template<> bool Bu::__cmpHashKeys<Bu::FString>(
+                const Bu::FString &a, const Bu::FString &b )
 {
         return a == b;
 }
 
+std::basic_ostream<char>& operator<< (std::basic_ostream<char> &os, const Bu::FString &val )
+{
+        os.write( val.getStr(), val.getSize() );
+        return os;
+}
+
diff --git a/src/fstring.h b/src/fstring.h
index c5397cc..1e1fc02 100644
--- a/src/fstring.h
+++ b/src/fstring.h
@@ -1,651 +1,903 @@
-#ifndef F_STRING_H
-#define F_STRING_H
+#ifndef BU_F_STRING_H
+#define BU_F_STRING_H
 
 #include <stdint.h>
 #include <memory>
-#include "serializable.h"
-#include "serializer.h"
+#include "bu/archival.h"
+#include "bu/archive.h"
+#include "bu/hash.h"
 
-template< typename chr >
-struct FStringChunk
-{
-        long nLength;
-        chr *pData;
-        FStringChunk *pNext;
-};
-
-/**
- * Flexible String class.  This class was designed with string passing and
- * generation in mind.  Like the standard string class you can specify what
- * datatype to use for each character.  Unlike the standard string class,
- * collection of appended and prepended terms is done lazily, making long
- * operations that involve many appends very inexpensive.  In addition internal
- * ref-counting means that if you pass strings around between functions there's
- * almost no overhead in time or memory since a reference is created and no
- * data is actually copied.  This also means that you never need to put any
- * FBasicString into a ref-counting container class.
- */
-template< typename chr, typename chralloc=std::allocator<chr>, typename chunkalloc=std::allocator<struct FStringChunk<chr> > >
-class FBasicString : public Serializable
+#define min( a, b )  ((a<b)?(a):(b))
+
+namespace Bu
 {
+        template< typename chr >
+        struct FStringChunk
+        {
+                long nLength;
+                chr *pData;
+                FStringChunk *pNext;
+        };
+
+        /**
+         * Flexible String class.  This class was designed with string passing and
+         * generation in mind.  Like the standard string class you can specify what
+         * datatype to use for each character.  Unlike the standard string class,
+         * collection of appended and prepended terms is done lazily, making long
+         * operations that involve many appends very inexpensive.  In addition internal
+         * ref-counting means that if you pass strings around between functions there's
+         * almost no overhead in time or memory since a reference is created and no
+         * data is actually copied.  This also means that you never need to put any
+         * FBasicString into a ref-counting container class.
+         *
+         *@param chr (typename) Type of character (i.e. char)
+         *@param nMinSize (int) Chunk size (default: 256)
+         *@param chralloc (typename) Memory Allocator for chr
+         *@param chunkalloc (typename) Memory Allocator for chr chunks
+         */
+        template< typename chr, int nMinSize=256, typename chralloc=std::allocator<chr>, typename chunkalloc=std::allocator<struct FStringChunk<chr> > >
+        class FBasicString : public Archival
+        {
 #ifndef VALTEST
 #define cpy( dest, src, size ) memcpy( dest, src, size*sizeof(chr) )
 #endif
-private:
-        typedef struct FStringChunk<chr> Chunk;
-        typedef struct FBasicString<chr, chralloc, chunkalloc> MyType;
-
-public:
-        FBasicString() :
-                nLength( 0 ),
-                pnRefs( NULL ),
-                pFirst( NULL ),
-                pLast( NULL )
-        {
-        }
+        private:
+                typedef struct FStringChunk<chr> Chunk;
+                typedef struct FBasicString<chr, nMinSize, chralloc, chunkalloc> MyType;
+
+        public:
+                FBasicString() :
+                        nLength( 0 ),
+                        pnRefs( NULL ),
+                        pFirst( NULL ),
+                        pLast( NULL )
+                {
+                }
 
-        FBasicString( const chr *pData ) :
-                nLength( 0 ),
-                pnRefs( NULL ),
-                pFirst( NULL ),
-                pLast( NULL )
-        {
-                append( pData );
-        }
-
-        FBasicString( const chr *pData, long nLength ) :
-                nLength( 0 ),
-                pnRefs( NULL ),
-                pFirst( NULL ),
-                pLast( NULL )
-        {
-                append( pData, nLength );
-        }
-
-        FBasicString( const MyType &rSrc ) :
-                nLength( 0 ),
-                pnRefs( NULL ),
-                pFirst( NULL ),
-                pLast( NULL )
-        {
-                // Here we have no choice but to copy, since the other guy is a const.
-                // In the case that the source were flat, we could get a reference, it
-                // would make some things faster, but not matter in many other cases.
-
-                joinShare( rSrc );
-                //copyFrom( rSrc );
-        }
-
-        FBasicString( const MyType &rSrc, long nLength ) :
-                nLength( 0 ),
-                pnRefs( NULL ),
-                pFirst( NULL ),
-                pLast( NULL )
-        {
-                append( rSrc.pFirst->pData, nLength );
-        }
-        
-        FBasicString( const MyType &rSrc, long nStart, long nLength ) :
-                nLength( 0 ),
-                pnRefs( NULL ),
-                pFirst( NULL ),
-                pLast( NULL )
-        {
-                append( rSrc.pFirst->pData+nStart, nLength );
-        }
-
-        FBasicString( long nSize ) :
-                nLength( nSize ),
-                pnRefs( NULL ),
-                pFirst( NULL ),
-                pLast( NULL )
-        {
-                pFirst = pLast = newChunk( nSize );
-        }
+                FBasicString( const chr *pData ) :
+                        nLength( 0 ),
+                        pnRefs( NULL ),
+                        pFirst( NULL ),
+                        pLast( NULL )
+                {
+                        append( pData );
+                }
 
-        virtual ~FBasicString()
-        {
-                clear();
-        }
+                FBasicString( const chr *pData, long nLength ) :
+                        nLength( 0 ),
+                        pnRefs( NULL ),
+                        pFirst( NULL ),
+                        pLast( NULL )
+                {
+                        append( pData, nLength );
+                }
 
-        void append( const chr *pData )
-        {
-                long nLen;
-                for( nLen = 0; pData[nLen] != (chr)0; nLen++ );
-                
-                Chunk *pNew = newChunk( nLen );
-                cpy( pNew->pData, pData, nLen );
+                FBasicString( const MyType &rSrc ) :
+                        nLength( 0 ),
+                        pnRefs( NULL ),
+                        pFirst( NULL ),
+                        pLast( NULL )
+                {
+                        // Here we have no choice but to copy, since the other guy is a const.
+                        // In the case that the source were flat, we could get a reference, it
+                        // would make some things faster, but not matter in many other cases.
 
-                appendChunk( pNew );
-        }
+                        joinShare( rSrc );
+                        //copyFrom( rSrc );
+                }
 
-        void append( const chr *pData, long nLen )
-        {
-                Chunk *pNew = newChunk( nLen );
+                FBasicString( const MyType &rSrc, long nLength ) :
+                        nLength( 0 ),
+                        pnRefs( NULL ),
+                        pFirst( NULL ),
+                        pLast( NULL )
+                {
+                        append( rSrc.pFirst->pData, nLength );
+                }
                 
-                cpy( pNew->pData, pData, nLen );
+                FBasicString( const MyType &rSrc, long nStart, long nLength ) :
+                        nLength( 0 ),
+                        pnRefs( NULL ),
+                        pFirst( NULL ),
+                        pLast( NULL )
+                {
+                        append( rSrc.pFirst->pData+nStart, nLength );
+                }
 
-                appendChunk( pNew );
-        }
+                FBasicString( long nSize ) :
+                        nLength( nSize ),
+                        pnRefs( NULL ),
+                        pFirst( NULL ),
+                        pLast( NULL )
+                {
+                        pFirst = pLast = newChunk( nSize );
+                }
 
-        void prepend( const chr *pData )
-        {
-                long nLen;
-                for( nLen = 0; pData[nLen] != (chr)0; nLen++ );
-                
-                Chunk *pNew = newChunk( nLen );
-                cpy( pNew->pData, pData, nLen );
+                virtual ~FBasicString()
+                {
+                        clear();
+                }
 
-                prependChunk( pNew );
-        }
+                /**
+                 *@todo void append( const MyType & sData )
+                 */
 
-        void prepend( const chr *pData, long nLen )
-        {
-                Chunk *pNew = newChunk( nLen );
-                
-                cpy( pNew->pData, pData, nLen );
+                /**
+                 * Append data to your string.
+                 *@param pData (const chr *) The data to append.
+                 */
+                void append( const chr *pData )
+                {
+                        if( !pData ) return;
+                        long nLen;
+                        for( nLen = 0; pData[nLen] != (chr)0; nLen++ );
+                        if( nLen == 0 )
+                                return;
+                        
+                        Chunk *pNew = newChunk( nLen );
+                        cpy( pNew->pData, pData, nLen );
 
-                prependChunk( pNew );
-        }
+                        appendChunk( pNew );
+                }
 
-        void clear()
-        {
-                realClear();
-        }
+                /**
+                 * Append data to your string.
+                 *@param pData (const chr *) The data to append.
+                 *@param nLen (long) The length of the data to append.
+                 */
+                void append( const chr *pData, long nLen )
+                {
+                        if( nLen == 0 )
+                                return;
 
-        void resize( long nNewSize )
-        {
-                if( nLength == nNewSize )
-                        return;
-
-                flatten();
-
-                Chunk *pNew = newChunk( nNewSize );
-                long nNewLen = (nNewSize<nLength)?(nNewSize):(nLength);
-                cpy( pNew->pData, pFirst->pData, nNewLen );
-                pNew->pData[nNewLen] = (chr)0;
-                aChr.deallocate( pFirst->pData, pFirst->nLength+1 );
-                aChunk.deallocate( pFirst, 1 );
-                pFirst = pLast = pNew;
-                nLength = nNewSize;
-        }
-
-        long getSize() const
-        {
-                return nLength;
-        }
-        
-        chr *getStr()
-        {
-                if( pFirst == NULL )
-                        return NULL;
-
-                flatten();
-                return pFirst->pData;
-        }
-        
-        const chr *getStr() const
-        {
-                if( pFirst == NULL )
-                        return NULL;
+                        Chunk *pNew = newChunk( nLen );
+                        
+                        cpy( pNew->pData, pData, nLen );
 
-                flatten();
-                return pFirst->pData;
-        }
+                        appendChunk( pNew );
+                }
 
-        chr *c_str()
-        {
-                if( pFirst == NULL )
-                        return NULL;
-
-                flatten();
-                return pFirst->pData;
-        }
-        
-        const chr *c_str() const
-        {
-                if( pFirst == NULL )
-                        return NULL;
+                /**
+                 * Append a single chr to your string.
+                 *@param cData (const chr &) The character to append.
+                 */
+                void append( const chr &cData )
+                {
+                        append( &cData, 1 );
+                }
 
-                flatten();
-                return pFirst->pData;
-        }
+                /**
+                 * Prepend another FString to this one.
+                 *@param sData (MyType &) The FString to prepend.
+                 */
+                void prepend( const MyType & sData )
+                {
+                        prepend( sData.getStr(), sData.getSize() );
+                }
 
-        MyType &operator +=( const chr *pData )
-        {
-                append( pData );
+                /**
+                 * Prepend data to your string.
+                 *@param pData (const chr *) The data to prepend.
+                 */
+                void prepend( const chr *pData )
+                {
+                        long nLen;
+                        for( nLen = 0; pData[nLen] != (chr)0; nLen++ );
+                        
+                        Chunk *pNew = newChunk( nLen );
+                        cpy( pNew->pData, pData, nLen );
 
-                return (*this);
-        }
-        
-        MyType &operator +=( const MyType &rSrc )
-        {
-                rSrc.flatten();
-                append( rSrc.pFirst->pData, rSrc.nLength );
+                        prependChunk( pNew );
+                }
 
-                return (*this);
-        }
+                /**
+                 * Prepend data to your string.
+                 *@param pData (const chr *) The data to prepend.
+                 *@param nLen (long) The length of the data to prepend.
+                 */
+                void prepend( const chr *pData, long nLen )
+                {
+                        Chunk *pNew = newChunk( nLen );
+                        
+                        cpy( pNew->pData, pData, nLen );
 
-        MyType &operator +=( const chr pData )
-        {
-                chr tmp[2] = { pData, (chr)0 };
-                append( tmp );
+                        prependChunk( pNew );
+                }
 
-                return (*this);
-        }
+                /**
+                 *@todo void prepend( const chr &cData )
+                 */
 
-        MyType &operator =( const chr *pData )
-        {
-                clear();
-                append( pData );
+                /**
+                 * Clear all data from the string.
+                 */
+                void clear()
+                {
+                        realClear();
+                }
 
-                return (*this);
-        }
+                /**
+                 * Force the string to resize
+                 *@param nNewSize (long) The new size of the string.
+                 */
+                void resize( long nNewSize )
+                {
+                        if( nLength == nNewSize )
+                                return;
 
-        MyType &operator =( const MyType &rSrc )
-        {
-                //if( rSrc.isFlat() )
-                //{
-                        joinShare( rSrc );
-                //}
-                //else
-                //{
-                //      copyFrom( rSrc );
-                //}
-                //
-
-                return (*this);
-        }
-        
-        bool operator ==( const chr *pData ) const
-        {
-                if( pFirst == NULL ) {
-                        if( pData == NULL )
-                                return true;
-                        return false;
+                        flatten();
+
+                        Chunk *pNew = newChunk( nNewSize );
+                        long nNewLen = (nNewSize<nLength)?(nNewSize):(nLength);
+                        cpy( pNew->pData, pFirst->pData, nNewLen );
+                        pNew->pData[nNewLen] = (chr)0;
+                        aChr.deallocate( pFirst->pData, pFirst->nLength+1 );
+                        aChunk.deallocate( pFirst, 1 );
+                        pFirst = pLast = pNew;
+                        nLength = nNewSize;
                 }
 
-                flatten();
-                const chr *a = pData;
-                chr *b = pFirst->pData;
-                for( ; *a!=(chr)0; a++, b++ )
+                /**
+                 * Get the current size of the string.
+                 *@returns (long) The current size of the string.
+                 */
+                long getSize() const
                 {
-                        if( *a != *b )
-                                return false;
+                        return nLength;
                 }
+                
+                /**
+                 * Get a pointer to the string array.
+                 *@returns (chr *) The string data.
+                 */
+                chr *getStr()
+                {
+                        if( pFirst == NULL )
+                                return NULL;
 
-                return true;
-        }
-        
-        bool operator ==( const MyType &pData ) const
-        {
-                if( pFirst == pData.pFirst )
-                        return true;
-                if( pFirst == NULL ) 
-                        return false;
+                        flatten();
+                        return pFirst->pData;
+                }
+                
+                /**
+                 * Get a const pointer to the string array.
+                 *@returns (const chr *) The string data.
+                 */
+                const chr *getStr() const
+                {
+                        if( pFirst == NULL )
+                                return NULL;
+
+                        flatten();
+                        return pFirst->pData;
+                }
 
-                flatten();
-                pData.flatten();
-                const chr *a = pData.pFirst->pData;
-                chr *b = pFirst->pData;
-                for( ; *a!=(chr)0; a++, b++ )
+                /**
+                 * (std::string compatability) Get a pointer to the string array.
+                 *@returns (chr *) The string data.
+                 */
+                chr *c_str()
                 {
-                        if( *a != *b )
-                                return false;
+                        if( pFirst == NULL )
+                                return NULL;
+
+                        flatten();
+                        return pFirst->pData;
                 }
+                
+                /**
+                 * (std::string compatability) Get a const pointer to the string array.
+                 *@returns (const chr *) The string data.
+                 */
+                const chr *c_str() const
+                {
+                        if( pFirst == NULL )
+                                return NULL;
 
-                return true;
-        }
+                        flatten();
+                        return pFirst->pData;
+                }
 
-        bool operator !=(const chr *pData ) const
-        {
-                return !(*this == pData);
-        }
-        
-        bool operator !=(const MyType &pData ) const
-        {
-                return !(*this == pData);
-        }
+                /**
+                 * Plus equals operator for FString.
+                 *@param pData (const chr *) The data to append to your FString.
+                 */
+                MyType &operator +=( const chr *pData )
+                {
+                        append( pData );
 
-        chr &operator[]( long nIndex )
-        {
-                flatten();
+                        return (*this);
+                }
+                
+                /**
+                 * Plus equals operator for FString.
+                 *@param pData (const MyType &) The FString to append to your FString.
+                 */
+                MyType &operator +=( const MyType &rSrc )
+                {
+                        if( rSrc.nLength == 0 )
+                                return (*this);
+                        rSrc.flatten();
+                        append( rSrc.pFirst->pData, rSrc.nLength );
 
-                return pFirst->pData[nIndex];
-        }
-        
-        const chr &operator[]( long nIndex ) const
-        {
-                flatten();
+                        return (*this);
+                }
 
-                return pFirst->pData[nIndex];
-        }
+                /**
+                 * Plus equals operator for FString.
+                 *@param pData (const chr) The character to append to your FString.
+                 */
+                MyType &operator +=( const chr pData )
+                {
+                        append( &pData, 1 );
 
-        bool isWS( long nIndex ) const
-        {
-                flatten();
+                        return (*this);
+                }
 
-                return pFirst->pData[nIndex]==' ' || pFirst->pData[nIndex]=='\t'
-                        || pFirst->pData[nIndex]=='\r' || pFirst->pData[nIndex]=='\n';
-        }
+                /**
+                 * Assignment operator.
+                 *@param pData (const chr *) The character array to append to your
+                 *              FString.
+                 */
+                MyType &operator =( const chr *pData )
+                {
+                        clear();
+                        append( pData );
 
-        bool isAlpha( long nIndex ) const
-        {
-                flatten();
+                        return (*this);
+                }
 
-                return (pFirst->pData[nIndex] >= 'a' && pFirst->pData[nIndex] <= 'z')
-                        || (pFirst->pData[nIndex] >= 'A' && pFirst->pData[nIndex] <= 'Z');
-        }
+                /**
+                 * Reset your FString to this character array.
+                 *@param pData (const chr *) The character array to set your FString to.
+                 */
+                void set( const chr *pData )
+                {
+                        clear();
+                        append( pData );
+                }
 
-        void toLower()
-        {
-                flatten();
-                unShare();
+                /**
+                 * Reset your FString to this character array.
+                 *@param pData (const chr *) The character array to set your FString to.
+                 *@param nSize (long) The length of the inputted character array.
+                 */
+                void set( const chr *pData, long nSize )
+                {
+                        clear();
+                        append( pData, nSize );
+                }
 
-                for( long j = 0; j < nLength; j++ )
+                /**
+                 * Assignment operator.
+                 *@param rSrc (const MyType &) The FString to set your FString to.
+                 */
+                MyType &operator =( const MyType &rSrc )
                 {
-                        if( pFirst->pData[j] >= 'A' && pFirst->pData[j] <= 'Z' )
-                                pFirst->pData[j] -= 'A'-'a';
+                        //if( rSrc.isFlat() )
+                        //{
+                                joinShare( rSrc );
+                        //}
+                        //else
+                        //{
+                        //      copyFrom( rSrc );
+                        //}
+                        //
+
+                        return (*this);
                 }
-        }
+                
+                /**
+                 * Equals comparison operator.
+                 *@param pData (const chr *) The character array to compare your FString
+                 *              to.
+                 */
+                bool operator ==( const chr *pData ) const
+                {
+                        if( pFirst == NULL ) {
+                                if( pData == NULL )
+                                        return true;
+                                return false;
+                        }
 
-        void toUpper()
-        {
-                flatten();
-                unShare();
+                        flatten();
+                        const chr *a = pData;
+                        chr *b = pFirst->pData;
+                        for( ; *a!=(chr)0; a++, b++ )
+                        {
+                                if( *a != *b )
+                                        return false;
+                        }
 
-                for( long j = 0; j < nLength; j++ )
+                        return true;
+                }
+                
+                /**
+                 * Equals comparison operator.
+                 *@param pData (const MyType &) The FString to compare your FString to.
+                 */
+                bool operator ==( const MyType &pData ) const
                 {
-                        if( pFirst->pData[j] >= 'a' && pFirst->pData[j] <= 'z' )
-                                pFirst->pData[j] += 'A'-'a';
+                        if( pFirst == pData.pFirst )
+                                return true;
+                        if( pFirst == NULL ) 
+                                return false;
+
+                        flatten();
+                        pData.flatten();
+                        const chr *a = pData.pFirst->pData;
+                        chr *b = pFirst->pData;
+                        for( ; *a!=(chr)0; a++, b++ )
+                        {
+                                if( *a != *b )
+                                        return false;
+                        }
+
+                        return true;
                 }
-        }
 
-        void serialize( class Serializer &ar )
-        {
-                if( ar.isLoading() )
+                /**
+                 * Not equals comparison operator.
+                 *@param pData (const chr *) The character array to compare your FString
+                 *              to.
+                 */
+                bool operator !=(const chr *pData ) const
                 {
-                        clear();
-                        long nLen;
-                        ar >> nLen;
+                        return !(*this == pData);
+                }
                 
-                        Chunk *pNew = newChunk( nLen );
-                        ar.read( pNew->pData, nLen*sizeof(chr) );
-                        appendChunk( pNew );
+                /**
+                 * Not equals comparison operator.
+                 *@param pData (const MyType &) The FString to compare your FString to.
+                 */
+                bool operator !=(const MyType &pData ) const
+                {
+                        return !(*this == pData);
                 }
-                else
+
+                /**
+                 * Indexing operator
+                 *@param nIndex (long) The index of the character you want.
+                 *@returns (chr &) The character at position (nIndex).
+                 */
+                chr &operator[]( long nIndex )
                 {
                         flatten();
-                        
-                        ar << nLength;
-                        ar.write( pFirst->pData, nLength*sizeof(chr) );
+
+                        return pFirst->pData[nIndex];
                 }
-        }
+                
+                /**
+                 * Const indexing operator
+                 *@param nIndex (long) The index of the character you want.
+                 *@returns (const chr &) The character at position (nIndex).
+                 */
+                const chr &operator[]( long nIndex ) const
+                {
+                        flatten();
 
-private:
-        void flatten() const
-        {
-                if( isFlat() )
-                        return;
+                        return pFirst->pData[nIndex];
+                }
+/*
+                operator const chr *() const
+                {
+                        if( !pFirst ) return NULL;
+                        flatten();
+                        return pFirst->pData;
+                }
+                */
 
-                if( pFirst == NULL )
-                        return;
+                operator bool() const
+                {
+                        return (pFirst != NULL);
+                }
 
-                unShare();
+                bool isSet() const
+                {
+                        return (pFirst != NULL);
+                }
 
-                Chunk *pNew = newChunk( nLength );
-                chr *pos = pNew->pData;
-                Chunk *i = pFirst;
-                for(;;)
+                /**
+                 * Is the character at index (nIndex) white space?
+                 *@param nIndex (long) The index of the character you want to check.
+                 *@returns (bool) Is it white space?
+                 */
+                bool isWS( long nIndex ) const
                 {
-                        cpy( pos, i->pData, i->nLength );
-                        pos += i->nLength;
-                        i = i->pNext;
-                        if( i == NULL )
-                                break;
+                        flatten();
+
+                        return pFirst->pData[nIndex]==' ' || pFirst->pData[nIndex]=='\t'
+                                || pFirst->pData[nIndex]=='\r' || pFirst->pData[nIndex]=='\n';
                 }
-                realClear();
 
-                pLast = pFirst = pNew;
-                nLength = pNew->nLength;
-        }
-        
-        void realClear() const
-        {
-                if( pFirst == NULL )
-                        return;
+                /**
+                 * Is the character at index (nIndex) a letter?
+                 *@param nIndex (long) The index of the character you want to check.
+                 *@returns (bool) Is it a letter?
+                 */
+                bool isAlpha( long nIndex ) const
+                {
+                        flatten();
 
-                if( isShared() )
+                        return (pFirst->pData[nIndex] >= 'a' && pFirst->pData[nIndex] <= 'z')
+                                || (pFirst->pData[nIndex] >= 'A' && pFirst->pData[nIndex] <= 'Z');
+                }
+
+                /**
+                 * Convert your alpha characters to lower case.
+                 */
+                void toLower()
                 {
-                        decRefs();
+                        flatten();
+                        unShare();
+
+                        for( long j = 0; j < nLength; j++ )
+                        {
+                                if( pFirst->pData[j] >= 'A' && pFirst->pData[j] <= 'Z' )
+                                        pFirst->pData[j] -= 'A'-'a';
+                        }
+                }
+
+                /**
+                 * Convert your alpha characters to upper case.
+                 */
+                void toUpper()
+                {
+                        flatten();
+                        unShare();
+
+                        for( long j = 0; j < nLength; j++ )
+                        {
+                                if( pFirst->pData[j] >= 'a' && pFirst->pData[j] <= 'z' )
+                                        pFirst->pData[j] += 'A'-'a';
+                        }
+                }
+
+                /**
+                 * Find the index of the first occurrance of (sText)
+                 *@param sText (const char *) The string to search for.
+                 *@returns (long) The index of the first occurrance. -1 for not found.
+                 */
+                long find( const char *sText )
+                {
+                        long nTLen = strlen( sText );
+                        flatten();
+                        for( long j = 0; j < pFirst->nLength-nTLen; j++ )
+                        {
+                                if( !strncmp( sText, pFirst->pData+j, nTLen ) )
+                                        return j;
+                        }
+                        return -1;
+                }
+
+                /**
+                 * Do a reverse search for (sText)
+                 *@param sText (const char *) The string to search for.
+                 *@returns (long) The index of the last occurrance. -1 for not found.
+                 */
+                long rfind( const char *sText )
+                {
+                        long nTLen = strlen( sText );
+                        flatten();
+                        for( long j = pFirst->nLength-nTLen-1; j >= 0; j-- )
+                        {
+                                if( !strncmp( sText, pFirst->pData+j, nTLen ) )
+                                        return j;
+                        }
+                        return -1;
+                }
+
+                /**
+                 * Remove nAmnt bytes from the front of the string.  This function
+                 * operates in O(n) time and should be used sparingly.
+                 */
+                void trimFront( long nAmnt )
+                {
+                        long nNewLen = nLength - nAmnt;
+                        flatten();
+                        Chunk *pNew = newChunk( nNewLen );
+                        cpy( pNew->pData, pFirst->pData, nNewLen );
+                        clear();
+                        appendChunk( pNew );
+                }
+
+                /**
+                 * Function the archiver calls to archive your FString.
+                 *@param ar (Archive) The archive which is archiving your FString.
+                 */
+                void archive( class Archive &ar )
+                {
+                        if( ar.isLoading() )
+                        {
+                                clear();
+                                long nLen;
+                                ar >> nLen;
+
+                                if( nLen > 0 )
+                                {
+                                        Chunk *pNew = newChunk( nLen );
+                                        ar.read( pNew->pData, nLen*sizeof(chr) );
+                                        appendChunk( pNew );
+                                }
+                        }
+                        else
+                        {
+                                flatten();
+                                
+                                ar << nLength;
+                                if( nLength )
+                                        ar.write( pFirst->pData, nLength*sizeof(chr) );
+                        }
                 }
-                else
+
+        private:
+                void flatten() const
                 {
+                        if( isFlat() )
+                                return;
+
+                        if( pFirst == NULL )
+                                return;
+
+                        unShare();
+
+                        Chunk *pNew = newChunk( nLength );
+                        chr *pos = pNew->pData;
                         Chunk *i = pFirst;
                         for(;;)
                         {
-                                Chunk *n = i->pNext;
-                                aChr.deallocate( i->pData, i->nLength+1 );
-                                aChunk.deallocate( i, 1 );
-                                if( n == NULL )
+                                cpy( pos, i->pData, i->nLength );
+                                pos += i->nLength;
+                                i = i->pNext;
+                                if( i == NULL )
                                         break;
-                                i = n;
                         }
-                        pFirst = pLast = NULL;
-                        nLength = 0;
+                        realClear();
+
+                        pLast = pFirst = pNew;
+                        nLength = pNew->nLength;
                 }
-        }
-        
-        void copyFrom( const FBasicString<chr, chralloc, chunkalloc> &rSrc )
-        {
-                if( rSrc.pFirst == NULL )
-                        return;
                 
-                decRefs();
-
-                Chunk *pNew = newChunk( rSrc.nLength );
-                chr *pos = pNew->pData;
-                Chunk *i = rSrc.pFirst;
-                for(;;)
+                void realClear() const
                 {
-                        cpy( pos, i->pData, i->nLength );
-                        pos += i->nLength;
-                        i = i->pNext;
-                        if( i == NULL )
-                                break;
-                }
-                clear();
+                        if( pFirst == NULL )
+                                return;
 
-                appendChunk( pNew );
-        }
-        
-        bool isFlat() const
-        {
-                return (pFirst == pLast);
-        }
-
-        bool isShared() const
-        {
-                return (pnRefs != NULL);
-        }
+                        if( isShared() )
+                        {
+                                decRefs();
+                        }
+                        else
+                        {
+                                Chunk *i = pFirst;
+                                for(;;)
+                                {
+                                        Chunk *n = i->pNext;
+                                        aChr.deallocate( i->pData, i->nLength+1 );
+                                        aChunk.deallocate( i, 1 );
+                                        if( n == NULL )
+                                                break;
+                                        i = n;
+                                }
+                                pFirst = pLast = NULL;
+                                nLength = 0;
+                        }
+                }
+                
+                void copyFrom( const FBasicString<chr, nMinSize, chralloc, chunkalloc> &rSrc )
+                {
+                        if( rSrc.pFirst == NULL )
+                                return;
+                        
+                        decRefs();
 
-        Chunk *newChunk() const
-        {
-                Chunk *pNew = aChunk.allocate( 1 );
-                pNew->pNext = NULL;
-                return pNew;
-        }
-        
-        Chunk *newChunk( long nLen ) const
-        {
-                Chunk *pNew = aChunk.allocate( 1 );
-                pNew->pNext = NULL;
-                pNew->nLength = nLen;
-                pNew->pData = aChr.allocate( nLen+1 );
-                pNew->pData[nLen] = (chr)0;
-                return pNew;
-        }
-
-        void appendChunk( Chunk *pNewChunk )
-        {
-                unShare();
+                        Chunk *pNew = newChunk( rSrc.nLength );
+                        chr *pos = pNew->pData;
+                        Chunk *i = rSrc.pFirst;
+                        for(;;)
+                        {
+                                cpy( pos, i->pData, i->nLength );
+                                pos += i->nLength;
+                                i = i->pNext;
+                                if( i == NULL )
+                                        break;
+                        }
+                        clear();
 
-                if( pFirst == NULL )
-                        pLast = pFirst = pNewChunk;
-                else
+                        appendChunk( pNew );
+                }
+                
+                bool isFlat() const
                 {
-                        pLast->pNext = pNewChunk;
-                        pLast = pNewChunk;
+                        return (pFirst == pLast);
                 }
 
-                nLength += pNewChunk->nLength;
-        }
-        
-        void prependChunk( Chunk *pNewChunk )
-        {
-                unShare();
+                bool isShared() const
+                {
+                        return (pnRefs != NULL);
+                }
 
-                if( pFirst == NULL )
-                        pLast = pFirst = pNewChunk;
-                else
+                Chunk *newChunk() const
+                {
+                        Chunk *pNew = aChunk.allocate( 1 );
+                        pNew->pNext = NULL;
+                        return pNew;
+                }
+                
+                Chunk *newChunk( long nLen ) const
                 {
-                        pNewChunk->pNext = pFirst;
-                        pFirst = pNewChunk;
+                        Chunk *pNew = aChunk.allocate( 1 );
+                        pNew->pNext = NULL;
+                        pNew->nLength = nLen;
+                        pNew->pData = aChr.allocate( nLen+1 );
+                        pNew->pData[nLen] = (chr)0;
+                        return pNew;
                 }
 
-                nLength += pNewChunk->nLength;
-        }
+                void appendChunk( Chunk *pNewChunk )
+                {
+                        unShare();
 
-        void joinShare( MyType &rSrc )
-        {
-                clear();
+                        if( pFirst == NULL )
+                                pLast = pFirst = pNewChunk;
+                        else
+                        {
+                                pLast->pNext = pNewChunk;
+                                pLast = pNewChunk;
+                        }
 
-                if( !rSrc.isFlat() )
-                        rSrc.flatten();
+                        nLength += pNewChunk->nLength;
+                }
+                
+                void prependChunk( Chunk *pNewChunk )
+                {
+                        unShare();
 
-                rSrc.initCount();
-                pnRefs = rSrc.pnRefs;
-                (*pnRefs)++;
-                nLength = rSrc.nLength;
-                pFirst = rSrc.pFirst;
-                pLast = rSrc.pLast;
-        }
-        
-        void joinShare( const MyType &rSrc )
-        {
-                clear();
+                        if( pFirst == NULL )
+                                pLast = pFirst = pNewChunk;
+                        else
+                        {
+                                pNewChunk->pNext = pFirst;
+                                pFirst = pNewChunk;
+                        }
 
-                rSrc.flatten();
+                        nLength += pNewChunk->nLength;
+                }
 
-                if( !rSrc.isShared() )
+                void joinShare( MyType &rSrc )
                 {
-                        rSrc.pnRefs = new uint32_t;
-                        (*rSrc.pnRefs) = 1;
+                        clear();
+
+                        if( !rSrc.isFlat() )
+                                rSrc.flatten();
+
+                        rSrc.initCount();
+                        pnRefs = rSrc.pnRefs;
+                        (*pnRefs)++;
+                        nLength = rSrc.nLength;
+                        pFirst = rSrc.pFirst;
+                        pLast = rSrc.pLast;
                 }
-                pnRefs = rSrc.pnRefs;
-                (*pnRefs)++;
-                nLength = rSrc.nLength;
-                pFirst = rSrc.pFirst;
-                pLast = rSrc.pLast;
-        }
+                
+                void joinShare( const MyType &rSrc )
+                {
+                        clear();
 
-        /**
-         * This takes an object that was shared and makes a copy of the base data
-         * that was being shared so that this copy can be changed.  This should be
-         * added before any call that will change this object;
-         */
-        void unShare() const
-        {
-                if( isShared() == false )
-                        return;
+                        rSrc.flatten();
 
-                Chunk *pNew = newChunk( nLength );
-                chr *pos = pNew->pData;
-                Chunk *i = pFirst;
-                for(;;)
+                        if( !rSrc.isShared() )
+                        {
+                                rSrc.pnRefs = new uint32_t;
+                                (*rSrc.pnRefs) = 1;
+                        }
+                        pnRefs = rSrc.pnRefs;
+                        (*pnRefs)++;
+                        nLength = rSrc.nLength;
+                        pFirst = rSrc.pFirst;
+                        pLast = rSrc.pLast;
+                }
+
+                /**
+                 * This takes an object that was shared and makes a copy of the base data
+                 * that was being shared so that this copy can be changed.  This should be
+                 * added before any call that will change this object;
+                 */
+                void unShare() const
                 {
-                        cpy( pos, i->pData, i->nLength );
-                        pos += i->nLength;
-                        i = i->pNext;
-                        if( i == NULL )
-                                break;
+                        if( isShared() == false )
+                                return;
+                        if( pFirst == NULL )
+                                return;
+
+                        Chunk *pNew = newChunk( nLength );
+                        chr *pos = pNew->pData;
+                        Chunk *i = pFirst;
+                        for(;;)
+                        {
+                                cpy( pos, i->pData, i->nLength );
+                                pos += i->nLength;
+                                i = i->pNext;
+                                if( i == NULL )
+                                        break;
+                        }
+                        decRefs();
+                        pLast = pFirst = pNew;
+                        nLength = pNew->nLength;
                 }
-                decRefs();
-                pLast = pFirst = pNew;
-                nLength = pNew->nLength;
-        }
 
-        /**
-         * This decrements our ref count and pulls us out of the share.  If the ref
-         * count hits zero because of this, it destroys the share.  This is not
-         * safe to call on it's own, it's much better to call unShare.
-         */
-        void decRefs() const
-        {
-                if( isShared() )
+                /**
+                 * This decrements our ref count and pulls us out of the share.  If the ref
+                 * count hits zero because of this, it destroys the share.  This is not
+                 * safe to call on it's own, it's much better to call unShare.
+                 */
+                void decRefs() const
                 {
-                        (*pnRefs)--;
-                        if( (*pnRefs) == 0 )
-                                destroyShare();
-                        else
+                        if( isShared() )
                         {
-                                pnRefs = NULL;
-                                pFirst = NULL;
-                                pLast = NULL;
-                                nLength = 0;
+                                (*pnRefs)--;
+                                if( (*pnRefs) == 0 )
+                                        destroyShare();
+                                else
+                                {
+                                        pnRefs = NULL;
+                                        pFirst = NULL;
+                                        pLast = NULL;
+                                        nLength = 0;
+                                }
                         }
                 }
-        }
 
-        /**
-         * While the unShare function removes an instance from a share, this
-         * function destroys the data that was in the share, removing the share
-         * itself.  This should only be called when the refcount for the share has
-         * or is about to reach zero.
-         */
-        void destroyShare() const
-        {
-                delete pnRefs;
-                pnRefs = NULL;
-                realClear();
-        }
+                /**
+                 * While the unShare function removes an instance from a share, this
+                 * function destroys the data that was in the share, removing the share
+                 * itself.  This should only be called when the refcount for the share has
+                 * or is about to reach zero.
+                 */
+                void destroyShare() const
+                {
+                        delete pnRefs;
+                        pnRefs = NULL;
+                        realClear();
+                }
 
 #ifdef VALTEST
-        void cpy( chr *dest, const chr *src, long count ) const
-        {
-                for( int j = 0; j < count; j++ )
+                void cpy( chr *dest, const chr *src, long count ) const
                 {
-                        *dest = *src;
-                        dest++;
-                        src++;
+                        for( int j = 0; j < count; j++ )
+                        {
+                                *dest = *src;
+                                dest++;
+                                src++;
+                        }
                 }
-        }
 #endif
 
-        void initCount() const
-        {
-                if( !isShared() )
+                void initCount() const
                 {
-                        pnRefs = new uint32_t;
-                        (*pnRefs) = 1;
+                        if( !isShared() )
+                        {
+                                pnRefs = new uint32_t;
+                                (*pnRefs) = 1;
+                        }
                 }
-        }
 
-private:
-        mutable long nLength;
-        mutable uint32_t *pnRefs;
-        mutable Chunk *pFirst;
-        mutable Chunk *pLast;
+        private:
+                mutable long nLength;
+                mutable uint32_t *pnRefs;
+                mutable Chunk *pFirst;
+                mutable Chunk *pLast;
 
-        mutable chralloc aChr;
-        mutable chunkalloc aChunk;
-};
+                mutable chralloc aChr;
+                mutable chunkalloc aChunk;
+        };
 
-typedef FBasicString<char> FString;
+        typedef FBasicString<char> FString;
 
-#include "hash.h"
-template<> uint32_t __calcHashCode<FString>( const FString &k );
-template<> bool __cmpHashKeys<FString>( const FString &a, const FString &b );
+        template<> uint32_t __calcHashCode<FString>( const FString &k );
+        template<> bool __cmpHashKeys<FString>( const FString &a, const FString &b );
+}
 
+#include <ostream>
+std::basic_ostream<char>& operator<< (std::basic_ostream<char> &os, const Bu::FString &val );
 
 #endif
diff --git a/src/hash.cpp b/src/hash.cpp
index c52e6b1..a207c29 100644
--- a/src/hash.cpp
+++ b/src/hash.cpp
@@ -1,29 +1,29 @@
 #include "hash.h"
 
-subExceptionDef( HashException )
+namespace Bu { subExceptionDef( HashException ) }
 
-template<> uint32_t __calcHashCode<int>( const int &k )
+template<> uint32_t Bu::__calcHashCode<int>( const int &k )
 {
         return k;
 }
 
-template<> bool __cmpHashKeys<int>( const int &a, const int &b )
+template<> bool Bu::__cmpHashKeys<int>( const int &a, const int &b )
 {
         return a == b;
 }
 
-template<> uint32_t __calcHashCode<unsigned int>( const unsigned int &k )
+template<> uint32_t Bu::__calcHashCode<unsigned int>( const unsigned int &k )
 {
         return k;
 }
 
-template<> bool __cmpHashKeys<unsigned int>( const unsigned int &a, const unsigned int &b )
+template<> bool Bu::__cmpHashKeys<unsigned int>( const unsigned int &a, const unsigned int &b )
 {
         return a == b;
 }
 
 template<>
-uint32_t __calcHashCode<const char *>( const char * const &k )
+uint32_t Bu::__calcHashCode<const char *>( const char * const &k )
 {
         if (k == NULL)
         {
@@ -39,7 +39,7 @@ uint32_t __calcHashCode<const char *>( const char * const &k )
         return nPos;
 }
 
-template<> bool __cmpHashKeys<const char *>( const char * const &a, const char * const &b )
+template<> bool Bu::__cmpHashKeys<const char *>( const char * const &a, const char * const &b )
 {
         if( a == b )
                 return true;
@@ -52,7 +52,7 @@ template<> bool __cmpHashKeys<const char *>( const char * const &a, const char *
 }
 
 template<>
-uint32_t __calcHashCode<char *>( char * const &k )
+uint32_t Bu::__calcHashCode<char *>( char * const &k )
 {
         if (k == NULL)
         {
@@ -68,7 +68,7 @@ uint32_t __calcHashCode<char *>( char * const &k )
         return nPos;
 }
 
-template<> bool __cmpHashKeys<char *>( char * const &a, char * const &b )
+template<> bool Bu::__cmpHashKeys<char *>( char * const &a, char * const &b )
 {
         if( a == b )
                 return true;
@@ -80,7 +80,7 @@ template<> bool __cmpHashKeys<char *>( char * const &a, char * const &b )
         return false;
 }
 
-template<> uint32_t __calcHashCode<std::string>( const std::string &k )
+template<> uint32_t Bu::__calcHashCode<std::string>( const std::string &k )
 {
         std::string::size_type j, sz = k.size();
         const char *s = k.c_str();
@@ -94,20 +94,8 @@ template<> uint32_t __calcHashCode<std::string>( const std::string &k )
         return nPos;
 }
 
-template<> bool __cmpHashKeys<std::string>( const std::string &a, const std::string &b )
+template<> bool Bu::__cmpHashKeys<std::string>( const std::string &a, const std::string &b )
 {
         return a == b;
 }
 
-template<> uint32_t __calcHashCode<Hashable>( const Hashable &k )
-{
-        return 0;
-        //return k.getHashCode();
-}
-
-template<> bool __cmpHashKeys<Hashable>( const Hashable &a, const Hashable &b )
-{
-        return false;
-        //return a.compareForHash( b );
-}
-
diff --git a/src/hash.h b/src/hash.h
index a21d651..f183823 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -1,745 +1,1071 @@
-#ifndef HASH_H
-#define HASH_H
+#ifndef BU_HASH_H
+#define BU_HASH_H
 
 #include <stddef.h>
 #include <string.h>
 #include <memory>
 #include <iostream>
 #include <list>
-#include "exceptionbase.h"
-#include "hashable.h"
-#include "serializable.h"
-#include "serializer.h"
+#include <utility>
+#include "bu/exceptionbase.h"
+#include "bu/list.h"
+///#include "archival.h"
+///#include "archive.h"
 
 #define bitsToBytes( n ) (n/32+(n%32>0 ? 1 : 0))
 
-subExceptionDecl( HashException )
-
-enum eHashException
+namespace Bu
 {
-        excodeNotFilled
-};
-
-template<typename T>
-uint32_t __calcHashCode( const T &k );
-
-template<typename T>
-bool __cmpHashKeys( const T &a, const T &b );
+        subExceptionDecl( HashException )
 
-struct __calcNextTSize_fast
-{
-        uint32_t operator()( uint32_t nCapacity, uint32_t nFill, uint32_t nDeleted ) const
+        enum eHashException
         {
-                if( nDeleted >= nCapacity/2 )
-                        return nCapacity;
-                return nCapacity*2+1;
-        }
-};
+                excodeNotFilled
+        };
 
-template<typename key, typename value, typename sizecalc = __calcNextTSize_fast, typename keyalloc = std::allocator<key>, typename valuealloc = std::allocator<value>, typename challoc = std::allocator<uint32_t> >
-class Hash;
+        template<typename T>
+        uint32_t __calcHashCode( const T &k );
 
-template< typename key, typename _value, typename sizecalc = __calcNextTSize_fast, typename keyalloc = std::allocator<key>, typename valuealloc = std::allocator<_value>, typename challoc = std::allocator<uint32_t> >
-struct HashProxy
-{
-        friend class Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc>;
-private:
-        HashProxy( Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &h, key *k, uint32_t nPos, uint32_t hash ) :
-                hsh( h ),
-                pKey( k ),
-                nPos( nPos ),
-                hash( hash ),
-                bFilled( false )
-        {
-        }
+        template<typename T>
+        bool __cmpHashKeys( const T &a, const T &b );
 
-        HashProxy( Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &h, uint32_t nPos, _value *pValue ) :
-                hsh( h ),
-                nPos( nPos ),
-                pValue( pValue ),
-                bFilled( true )
+        struct __calcNextTSize_fast
         {
-        }
+                uint32_t operator()( uint32_t nCapacity, uint32_t nFill, uint32_t nDeleted ) const
+                {
+                        if( nDeleted >= nCapacity/2 )
+                                return nCapacity;
+                        return nCapacity*2+1;
+                }
+        };
 
-        Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &hsh;
-        key *pKey;
-        uint32_t nPos;
-        _value *pValue;
-        uint32_t hash;
-        bool bFilled;
+        template<typename key, typename value, typename sizecalc = __calcNextTSize_fast, typename keyalloc = std::allocator<key>, typename valuealloc = std::allocator<value>, typename challoc = std::allocator<uint32_t> >
+        class Hash;
 
-public:
-        operator _value &()
+        template< typename key, typename _value, typename sizecalc = __calcNextTSize_fast, typename keyalloc = std::allocator<key>, typename valuealloc = std::allocator<_value>, typename challoc = std::allocator<uint32_t> >
+        struct HashProxy
         {
-                if( bFilled == false )
-                        throw HashException(
-                                        excodeNotFilled,
-                                        "No data assosiated with that key."
-                                        );
-                return *pValue;
-        }
+                friend class Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc>;
+        private:
+                HashProxy( Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &h, key *k, uint32_t nPos, uint32_t hash ) :
+                        hsh( h ),
+                        pKey( k ),
+                        nPos( nPos ),
+                        hash( hash ),
+                        bFilled( false )
+                {
+                }
 
-        _value &value()
-        {
-                if( bFilled == false )
-                        throw HashException(
-                                        excodeNotFilled,
-                                        "No data assosiated with that key."
-                                        );
-                return *pValue;
-        }
+                HashProxy( Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &h, uint32_t nPos, _value *pValue ) :
+                        hsh( h ),
+                        nPos( nPos ),
+                        pValue( pValue ),
+                        bFilled( true )
+                {
+                }
 
-        bool isFilled()
-        {
-                return bFilled;
-        }
+                Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &hsh;
+                key *pKey;
+                uint32_t nPos;
+                _value *pValue;
+                uint32_t hash;
+                bool bFilled;
 
-        void erase()
-        {
-                if( bFilled )
+        public:
+                /**
+                 * Cast operator for HashProxy.
+                 *@returns (value_type &) The value the HashProxy is pointing to.
+                 */
+                operator _value &()
                 {
-                        hsh._erase( nPos );
-                        hsh.onDelete();
+                        if( bFilled == false )
+                                throw HashException(
+                                                excodeNotFilled,
+                                                "No data assosiated with that key."
+                                                );
+                        return *pValue;
                 }
-        }
 
-        _value operator=( _value nval )
-        {
-                if( bFilled )
+                /**
+                 * Direct function for retrieving a value out of the HashProxy.
+                 *@returns (value_type &) The value pointed to by this HashProxy.
+                 */
+                _value &value()
                 {
-                        hsh.va.destroy( pValue );
-                        hsh.va.construct( pValue, nval );
-                        hsh.onUpdate();
+                        if( bFilled == false )
+                                throw HashException(
+                                                excodeNotFilled,
+                                                "No data assosiated with that key."
+                                                );
+                        return *pValue;
                 }
-                else
+
+                /**
+                 * Whether this HashProxy points to something real or not.
+                 */
+                bool isFilled()
                 {
-                        hsh.fill( nPos, *pKey, nval, hash ); 
-                        hsh.onInsert();
+                        return bFilled;
                 }
 
-                return nval;
-        }
+                /**
+                 * Erase the data pointed to by this HashProxy.
+                 */
+                void erase()
+                {
+                        if( bFilled )
+                        {
+                                hsh._erase( nPos );
+                                hsh.onDelete();
+                        }
+                }
 
-        _value *operator->()
-        {
-                if( bFilled == false )
-                        throw HashException(
-                                        excodeNotFilled,
-                                        "No data assosiated with that key."
-                                        );
-                return pValue;
-        }
-};
+                /**
+                 * Assign data to this point in the hash table.
+                 *@param nval (value_type) the data to assign.
+                 */
+                _value operator=( _value nval )
+                {
+                        if( bFilled )
+                        {
+                                hsh.va.destroy( pValue );
+                                hsh.va.construct( pValue, nval );
+                                hsh.onUpdate();
+                        }
+                        else
+                        {
+                                hsh.fill( nPos, *pKey, nval, hash ); 
+                                hsh.onInsert();
+                        }
 
-template<typename key, typename value, typename sizecalc, typename keyalloc, typename valuealloc, typename challoc >
-class Hash
-{
-        friend struct HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>;
-public:
-        Hash() :
-                nCapacity( 11 ),
-                nFilled( 0 ),
-                nDeleted( 0 ),
-                bFilled( NULL ),
-                bDeleted( NULL ),
-                aKeys( NULL ),
-                aValues( NULL ),
-                aHashCodes( NULL )
-        {
-                nKeysSize = bitsToBytes( nCapacity );
-                bFilled = ca.allocate( nKeysSize );
-                bDeleted = ca.allocate( nKeysSize );
-                clearBits();
-
-                aHashCodes = ca.allocate( nCapacity );
-                aKeys = ka.allocate( nCapacity );
-                aValues = va.allocate( nCapacity );
-        }
+                        return nval;
+                }
 
-        Hash( const Hash &src ) :
-                nCapacity( src.nCapacity ),
-                nFilled( 0 ),
-                nDeleted( 0 ),
-                bFilled( NULL ),
-                bDeleted( NULL ),
-                aKeys( NULL ),
-                aValues( NULL ),
-                aHashCodes( NULL )
-        {
-                nKeysSize = bitsToBytes( nCapacity );
-                bFilled = ca.allocate( nKeysSize );
-                bDeleted = ca.allocate( nKeysSize );
-                clearBits();
+                /**
+                 * Pointer extraction operator. Access to members of data pointed to
+                 *              by HashProxy.
+                 *@returns (value_type *)
+                 */
+                _value *operator->()
+                {
+                        if( bFilled == false )
+                                throw HashException(
+                                                excodeNotFilled,
+                                                "No data assosiated with that key."
+                                                );
+                        return pValue;
+                }
+        };
 
-                aHashCodes = ca.allocate( nCapacity );
-                aKeys = ka.allocate( nCapacity );
-                aValues = va.allocate( nCapacity );
+        /**
+         * Libbu Template Hash Table
+         *@param key (typename) The datatype of the hashtable keys
+         *@param value (typename) The datatype of the hashtable data
+         *@param sizecalc (typename) Functor to compute new table size on rehash
+         *@param keyalloc (typename) Memory allocator for hashtable keys
+         *@param valuealloc (typename) Memory allocator for hashtable values
+         *@param challoc (typename) Byte allocator for bitflags
+         */
+        template<typename key, typename value, typename sizecalc, typename keyalloc, typename valuealloc, typename challoc >
+        class Hash
+        {
+                friend struct HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+        public:
+                Hash() :
+                        nCapacity( 11 ),
+                        nFilled( 0 ),
+                        nDeleted( 0 ),
+                        bFilled( NULL ),
+                        bDeleted( NULL ),
+                        aKeys( NULL ),
+                        aValues( NULL ),
+                        aHashCodes( NULL )
+                {
+                        nKeysSize = bitsToBytes( nCapacity );
+                        bFilled = ca.allocate( nKeysSize );
+                        bDeleted = ca.allocate( nKeysSize );
+                        clearBits();
+
+                        aHashCodes = ca.allocate( nCapacity );
+                        aKeys = ka.allocate( nCapacity );
+                        aValues = va.allocate( nCapacity );
+                }
 
-                for( uint32_t j = 0; j < src.nCapacity; j++ )
+                Hash( const Hash &src ) :
+                        nCapacity( src.nCapacity ),
+                        nFilled( 0 ),
+                        nDeleted( 0 ),
+                        bFilled( NULL ),
+                        bDeleted( NULL ),
+                        aKeys( NULL ),
+                        aValues( NULL ),
+                        aHashCodes( NULL )
                 {
-                        if( src.isFilled( j ) )
+                        nKeysSize = bitsToBytes( nCapacity );
+                        bFilled = ca.allocate( nKeysSize );
+                        bDeleted = ca.allocate( nKeysSize );
+                        clearBits();
+
+                        aHashCodes = ca.allocate( nCapacity );
+                        aKeys = ka.allocate( nCapacity );
+                        aValues = va.allocate( nCapacity );
+
+                        for( uint32_t j = 0; j < src.nCapacity; j++ )
                         {
-                                insert( src.aKeys[j], src.aValues[j] );
+                                if( src.isFilled( j ) )
+                                {
+                                        insert( src.aKeys[j], src.aValues[j] );
+                                }
                         }
                 }
-        }
 
-        Hash &operator=( const Hash &src )
-        {
-                for( uint32_t j = 0; j < nCapacity; j++ )
+                /**
+                 * Hashtable assignment operator. Clears this hashtable and
+                 * copies RH into it.
+                 */
+                Hash &operator=( const Hash &src )
                 {
-                        if( isFilled( j ) )
-                                if( !isDeleted( j ) )
+                        for( uint32_t j = 0; j < nCapacity; j++ )
+                        {
+                                if( isFilled( j ) )
+                                        if( !isDeleted( j ) )
+                                        {
+                                                va.destroy( &aValues[j] );
+                                                ka.destroy( &aKeys[j] );
+                                        }
+                        }
+                        va.deallocate( aValues, nCapacity );
+                        ka.deallocate( aKeys, nCapacity );
+                        ca.deallocate( bFilled, nKeysSize );
+                        ca.deallocate( bDeleted, nKeysSize );
+                        ca.deallocate( aHashCodes, nCapacity );
+
+                        nFilled = 0;
+                        nDeleted = 0;
+                        nCapacity = src.nCapacity;
+                        nKeysSize = bitsToBytes( nCapacity );
+                        bFilled = ca.allocate( nKeysSize );
+                        bDeleted = ca.allocate( nKeysSize );
+                        clearBits();
+
+                        aHashCodes = ca.allocate( nCapacity );
+                        aKeys = ka.allocate( nCapacity );
+                        aValues = va.allocate( nCapacity );
+
+                        for( uint32_t j = 0; j < src.nCapacity; j++ )
+                        {
+                                if( src.isFilled( j ) )
                                 {
-                                        va.destroy( &aValues[j] );
-                                        ka.destroy( &aKeys[j] );
+                                        insert( src.aKeys[j], src.aValues[j] );
                                 }
-                }
-                va.deallocate( aValues, nCapacity );
-                ka.deallocate( aKeys, nCapacity );
-                ca.deallocate( bFilled, nKeysSize );
-                ca.deallocate( bDeleted, nKeysSize );
-                ca.deallocate( aHashCodes, nCapacity );
-
-                nFilled = 0;
-                nDeleted = 0;
-                nCapacity = src.nCapacity;
-                nKeysSize = bitsToBytes( nCapacity );
-                bFilled = ca.allocate( nKeysSize );
-                bDeleted = ca.allocate( nKeysSize );
-                clearBits();
+                        }
 
-                aHashCodes = ca.allocate( nCapacity );
-                aKeys = ka.allocate( nCapacity );
-                aValues = va.allocate( nCapacity );
+                        return *this;
+                }
 
-                for( uint32_t j = 0; j < src.nCapacity; j++ )
+                virtual ~Hash()
                 {
-                        if( src.isFilled( j ) )
+                        for( uint32_t j = 0; j < nCapacity; j++ )
                         {
-                                insert( src.aKeys[j], src.aValues[j] );
+                                if( isFilled( j ) )
+                                        if( !isDeleted( j ) )
+                                        {
+                                                va.destroy( &aValues[j] );
+                                                ka.destroy( &aKeys[j] );
+                                        }
                         }
+                        va.deallocate( aValues, nCapacity );
+                        ka.deallocate( aKeys, nCapacity );
+                        ca.deallocate( bFilled, nKeysSize );
+                        ca.deallocate( bDeleted, nKeysSize );
+                        ca.deallocate( aHashCodes, nCapacity );
                 }
 
-                return *this;
-        }
-
-        virtual ~Hash()
-        {
-                for( uint32_t j = 0; j < nCapacity; j++ )
+                /**
+                 * Get the current hash table capacity. (Changes at re-hash)
+                 *@returns (uint32_t) The current capacity.
+                 */
+                uint32_t getCapacity()
                 {
-                        if( isFilled( j ) )
-                                if( !isDeleted( j ) )
-                                {
-                                        va.destroy( &aValues[j] );
-                                        ka.destroy( &aKeys[j] );
-                                }
+                        return nCapacity;
                 }
-                va.deallocate( aValues, nCapacity );
-                ka.deallocate( aKeys, nCapacity );
-                ca.deallocate( bFilled, nKeysSize );
-                ca.deallocate( bDeleted, nKeysSize );
-                ca.deallocate( aHashCodes, nCapacity );
-        }
 
-        uint32_t getCapacity()
-        {
-                return nCapacity;
-        }
+                /**
+                 * Get the number of hash locations spoken for. (Including 
+                 * not-yet-cleaned-up deleted items.)
+                 *@returns (uint32_t) The current fill state.
+                 */
+                uint32_t getFill()
+                {
+                        return nFilled;
+                }
 
-        uint32_t getFill()
-        {
-                return nFilled;
-        }
+                /**
+                 * Get the number of items stored in the hash table.
+                 *@returns (uint32_t) The number of items stored in the hash table.
+                 */
+                uint32_t size()
+                {
+                        return nFilled-nDeleted;
+                }
 
-        uint32_t size()
-        {
-                return nFilled-nDeleted;
-        }
+                /**
+                 * Get the number of items which have been deleted, but not yet
+                 * cleaned up.
+                 *@returns (uint32_t) The number of deleted items.
+                 */
+                uint32_t getDeleted()
+                {
+                        return nDeleted;
+                }
 
-        uint32_t getDeleted()
-        {
-                return nDeleted;
-        }
+                /**
+                 * Hash table index operator
+                 *@param k (key_type) Key of data to be retrieved.
+                 *@returns (HashProxy) Proxy pointing to the data.
+                 */
+                virtual HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc> operator[]( key k )
+                {
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = probe( hash, k, bFill );
 
-        virtual HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc> operator[]( key k )
-        {
-                uint32_t hash = __calcHashCode( k );
-                bool bFill;
-                uint32_t nPos = probe( hash, k, bFill );
+                        if( bFill )
+                        {
+                                return HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>( *this, nPos, &aValues[nPos] );
+                        }
+                        else
+                        {
+                                return HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>( *this, &k, nPos, hash );
+                        }
+                }
 
-                if( bFill )
+                /**
+                 * Insert a value (v) under key (k) into the hash table
+                 *@param k (key_type) Key to list the value under.
+                 *@param v (value_type) Value to store in the hash table.
+                 */
+                virtual void insert( key k, value v )
                 {
-                        return HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>( *this, nPos, &aValues[nPos] );
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = probe( hash, k, bFill );
+
+                        if( bFill )
+                        {
+                                va.destroy( &aValues[nPos] );
+                                va.construct( &aValues[nPos], v );
+                                onUpdate();
+                        }
+                        else
+                        {
+                                fill( nPos, k, v, hash );
+                                onInsert();
+                        }
                 }
-                else
+
+                /**
+                 * Remove a value from the hash table.
+                 *@param k (key_type) The data under this key will be erased.
+                 */
+                virtual void erase( key k )
                 {
-                        return HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>( *this, &k, nPos, hash );
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = probe( hash, k, bFill );
+
+                        if( bFill )
+                        {
+                                _erase( nPos );
+                                onDelete();
+                        }
                 }
-        }
 
-        virtual void insert( key k, value v )
-        {
-                uint32_t hash = __calcHashCode( k );
-                bool bFill;
-                uint32_t nPos = probe( hash, k, bFill );
+                struct iterator;
 
-                if( bFill )
+                /**
+                 * Remove a value from the hash pointed to from an iterator.
+                 *@param i (iterator &) The data to be erased.
+                 */
+                virtual void erase( struct iterator &i )
                 {
-                        va.destroy( &aValues[nPos] );
-                        va.construct( &aValues[nPos], v );
-                        onUpdate();
+                        if( this != &i.hsh )
+                                throw HashException("This iterator didn't come from this Hash.");
+                        if( isFilled( i.nPos ) && !isDeleted( i.nPos ) )
+                        {
+                                _erase( i.nPos );
+                                onDelete();
+                        }
                 }
-                else
+
+                /**
+                 * Remove all data from the hash table.
+                 */
+                virtual void clear()
                 {
-                        fill( nPos, k, v, hash );
-                        onInsert();
+                        for( uint32_t j = 0; j < nCapacity; j++ )
+                        {
+                                if( isFilled( j ) )
+                                        if( !isDeleted( j ) )
+                                        {
+                                                va.destroy( &aValues[j] );
+                                                ka.destroy( &aKeys[j] );
+                                                onDelete();
+                                        }
+                        }
+                        
+                        clearBits();
                 }
-        }
 
-        virtual void erase( key k )
-        {
-                uint32_t hash = __calcHashCode( k );
-                bool bFill;
-                uint32_t nPos = probe( hash, k, bFill );
+                /**
+                 * Get an item of data from the hash table.
+                 *@param k (key_type) Key pointing to the data to be retrieved.
+                 *@returns (value_type &) The data pointed to by (k).
+                 */
+                virtual value &get( key k )
+                {
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = probe( hash, k, bFill );
 
-                if( bFill )
+                        if( bFill )
+                        {
+                                return aValues[nPos];
+                        }
+                        else
+                        {
+                                throw HashException(
+                                                excodeNotFilled,
+                                                "No data assosiated with that key."
+                                                );
+                        }
+                }
+                
+                /**
+                 * Get a const item of data from the hash table.
+                 *@param k (key_type) Key pointing to the data to be retrieved.
+                 *@returns (const value_type &) A const version of the data pointed
+                 *              to by (k).
+                 */
+                virtual const value &get( key k ) const
                 {
-                        _erase( nPos );
-                        onDelete();
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = probe( hash, k, bFill );
+
+                        if( bFill )
+                        {
+                                return aValues[nPos];
+                        }
+                        else
+                        {
+                                throw HashException(
+                                                excodeNotFilled,
+                                                "No data assosiated with that key."
+                                                );
+                        }
                 }
-        }
 
-        struct iterator;
-        virtual void erase( struct iterator &i )
-        {
-                if( this != &i.hsh )
-                        throw HashException("This iterator didn't come from this Hash.");
-                if( isFilled( i.nPos ) && !isDeleted( i.nPos ) )
+                /**
+                 * Does the hash table contain an item under key (k).
+                 *@param k (key_type) The key to check.
+                 *@returns (bool) Whether there was an item in the hash under key (k).
+                 */
+                virtual bool has( key k )
                 {
-                        _erase( i.nPos );
-                        onDelete();
+                        bool bFill;
+                        probe( __calcHashCode( k ), k, bFill, false );
+
+                        return bFill;
                 }
-        }
 
-        virtual void clear()
-        {
-                for( uint32_t j = 0; j < nCapacity; j++ )
+                /**
+                 * Iteration structure for iterating through the hash.
+                 */
+                typedef struct iterator
                 {
-                        if( isFilled( j ) )
-                                if( !isDeleted( j ) )
+                        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+                private:
+                        iterator( Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh ) :
+                                hsh( hsh ),
+                                nPos( 0 ),
+                                bFinished( false )
+                        {
+                                nPos = hsh.getFirstPos( bFinished );
+                        }
+                        
+                        iterator( Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh, bool bDone ) :
+                                hsh( hsh ),
+                                nPos( 0 ),
+                                bFinished( bDone )
+                        {
+                        }
+
+                        Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh;
+                        uint32_t nPos;
+                        bool bFinished;
+
+                public:
+                        /**
+                         * Iterator incrementation operator. Move the iterator forward.
+                         */
+                        iterator operator++( int )
+                        {
+                                if( bFinished == false )
+                                        nPos = hsh.getNextPos( nPos, bFinished );
+
+                                return *this;
+                        }
+                        
+                        /**
+                         * Iterator incrementation operator. Move the iterator forward.
+                         */
+                        iterator operator++()
+                        {
+                                if( bFinished == false )
+                                        nPos = hsh.getNextPos( nPos, bFinished );
+
+                                return *this;
+                        }
+
+                        /**
+                         * Iterator equality comparison operator. Iterators the same?
+                         */
+                        bool operator==( const iterator &oth )
+                        {
+                                if( bFinished != oth.bFinished )
+                                        return false;
+                                if( bFinished == true )
                                 {
-                                        va.destroy( &aValues[j] );
-                                        ka.destroy( &aKeys[j] );
-                                        onDelete();
+                                        return true;
                                 }
-                }
-                
-                clearBits();
-        }
+                                else
+                                {
+                                        if( oth.nPos == nPos )
+                                                return true;
+                                        return false;
+                                }
+                        }
+                        
+                        /**
+                         * Iterator not equality comparison operator. Not the same?
+                         */
+                        bool operator!=( const iterator &oth )
+                        {
+                                return !(*this == oth );
+                        }
 
-        virtual value &get( key k )
-        {
-                uint32_t hash = __calcHashCode( k );
-                bool bFill;
-                uint32_t nPos = probe( hash, k, bFill );
+                        /**
+                         * Iterator assignment operator.
+                         */
+                        iterator operator=( const iterator &oth )
+                        {
+                                if( &hsh != &oth.hsh )
+                                        throw HashException(
+                                                "Cannot mix iterators from different hash objects.");
+                                nPos = oth.nPos;
+                                bFinished = oth.bFinished;
+                        }
 
-                if( bFill )
-                {
-                        return aValues[nPos];
-                }
-                else
+                        /**
+                         * Iterator dereference operator... err.. get the value
+                         *@returns (value_type &) The value behind this iterator.
+                         */
+                        value &operator *()
+                        {
+                                return hsh.getValueAtPos( nPos );
+                        }
+                        
+                        /**
+                         * Get the key behind this iterator.
+                         *@returns (key_type &) The key behind this iterator.
+                         */
+                        key &getKey()
+                        {
+                                return hsh.getKeyAtPos( nPos );
+                        }
+
+                        /**
+                         * Get the value behind this iterator.
+                         *@returs (value_type &) The value behind this iterator.
+                         */
+                        value &getValue()
+                        {
+                                return hsh.getValueAtPos( nPos );
+                        }
+                };
+                
+                /**
+                 * Iteration structure for iterating through the hash (const).
+                 */
+                typedef struct const_iterator
                 {
-                        throw HashException(
-                                        excodeNotFilled,
-                                        "No data assosiated with that key."
-                                        );
-                }
-        }
+                        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+                private:
+                        const_iterator( const Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh ) :
+                                hsh( hsh ),
+                                nPos( 0 ),
+                                bFinished( false )
+                        {
+                                nPos = hsh.getFirstPos( bFinished );
+                        }
+                        
+                        const_iterator( const Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh, bool bDone ) :
+                                hsh( hsh ),
+                                nPos( 0 ),
+                                bFinished( bDone )
+                        {
+                        }
 
-        virtual bool has( key k )
-        {
-                bool bFill;
-                probe( __calcHashCode( k ), k, bFill, false );
+                        const Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh;
+                        uint32_t nPos;
+                        bool bFinished;
 
-                return bFill;
-        }
+                public:
+                        /**
+                         * Iterator incrementation operator. Move the iterator forward.
+                         */
+                        const_iterator operator++( int )
+                        {
+                                if( bFinished == false )
+                                        nPos = hsh.getNextPos( nPos, bFinished );
 
-        typedef struct iterator
-        {
-                friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
-        private:
-                iterator( Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh ) :
-                        hsh( hsh ),
-                        nPos( 0 ),
-                        bFinished( false )
+                                return *this;
+                        }
+                        
+                        /**
+                         * Iterator incrementation operator. Move the iterator forward.
+                         */
+                        const_iterator operator++()
+                        {
+                                if( bFinished == false )
+                                        nPos = hsh.getNextPos( nPos, bFinished );
+
+                                return *this;
+                        }
+
+                        /**
+                         * Iterator equality comparison operator. Iterators the same?
+                         */
+                        bool operator==( const const_iterator &oth )
+                        {
+                                if( bFinished != oth.bFinished )
+                                        return false;
+                                if( bFinished == true )
+                                {
+                                        return true;
+                                }
+                                else
+                                {
+                                        if( oth.nPos == nPos )
+                                                return true;
+                                        return false;
+                                }
+                        }
+                        
+                        /**
+                         * Iterator not equality comparison operator. Not the same?
+                         */
+                        bool operator!=( const const_iterator &oth )
+                        {
+                                return !(*this == oth );
+                        }
+
+                        /**
+                         * Iterator assignment operator.
+                         */
+                        const_iterator operator=( const const_iterator &oth )
+                        {
+                                if( &hsh != &oth.hsh )
+                                        throw HashException(
+                                                "Cannot mix iterators from different hash objects.");
+                                nPos = oth.nPos;
+                                bFinished = oth.bFinished;
+                        }
+
+                        /**
+                         * Iterator dereference operator... err.. get the value
+                         *@returns (value_type &) The value behind this iterator.
+                         */
+                        const value &operator *() const
+                        {
+                                return hsh.getValueAtPos( nPos );
+                        }
+                        
+                        /**
+                         * Get the key behind this iterator.
+                         *@returns (key_type &) The key behind this iterator.
+                         */
+                        const key &getKey() const
+                        {
+                                return hsh.getKeyAtPos( nPos );
+                        }
+
+                        /**
+                         * Get the value behind this iterator.
+                         *@returs (value_type &) The value behind this iterator.
+                         */
+                        const value &getValue() const
+                        {
+                                return hsh.getValueAtPos( nPos );
+                        }
+                };
+
+                /**
+                 * Get an iterator pointing to the first item in the hash table.
+                 *@returns (iterator) An iterator pointing to the first item in the
+                 *              hash table.
+                 */
+                iterator begin()
                 {
-                        nPos = hsh.getFirstPos( bFinished );
+                        return iterator( *this );
                 }
                 
-                iterator( Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh, bool bDone ) :
-                        hsh( hsh ),
-                        nPos( 0 ),
-                        bFinished( bDone )
+                const_iterator begin() const
                 {
+                        return const_iterator( *this );
                 }
-
-                Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh;
-                uint32_t nPos;
-                bool bFinished;
-
-        public:
-                iterator operator++( int )
+                
+                /**
+                 * Get an iterator pointing to a point just past the last item in the
+                 *              hash table.
+                 *@returns (iterator) An iterator pointing to a point just past the
+                 *              last item in the hash table.
+                 */
+                iterator end()
                 {
-                        if( bFinished == false )
-                                nPos = hsh.getNextPos( nPos, bFinished );
-
-                        return *this;
+                        return iterator( *this, true );
                 }
                 
-                iterator operator++()
+                const_iterator end() const
                 {
-                        if( bFinished == false )
-                                nPos = hsh.getNextPos( nPos, bFinished );
-
-                        return *this;
+                        return const_iterator( *this, true );
                 }
 
-                bool operator==( const iterator &oth )
+                /**
+                 * Get a list of all the keys in the hash table.
+                 *@returns (std::list<key_type>) The list of keys in the hash table.
+                 */
+                Bu::List<key> getKeys() const
                 {
-                        if( bFinished != oth.bFinished )
-                                return false;
-                        if( bFinished == true )
+                        Bu::List<key> lKeys;
+
+                        for( uint32_t j = 0; j < nCapacity; j++ )
                         {
-                                return true;
+                                if( isFilled( j ) )
+                                {
+                                        if( !isDeleted( j ) )
+                                        {
+                                                lKeys.append( aKeys[j] );
+                                        }
+                                }
                         }
-                        else
+
+                        return lKeys;
+                }
+
+        protected:
+                virtual void onInsert() {}
+                virtual void onUpdate() {}
+                virtual void onDelete() {}
+                virtual void onReHash() {}
+
+                virtual void clearBits()
+                {
+                        for( uint32_t j = 0; j < nKeysSize; j++ )
                         {
-                                if( oth.nPos == nPos )
-                                        return true;
-                                return false;
+                                bFilled[j] = bDeleted[j] = 0;
                         }
                 }
-                
-                bool operator!=( const iterator &oth )
+
+                virtual void fill( uint32_t loc, key &k, value &v, uint32_t hash )
                 {
-                        return !(*this == oth );
+                        bFilled[loc/32] |= (1<<(loc%32));
+                        va.construct( &aValues[loc], v );
+                        ka.construct( &aKeys[loc], k );
+                        aHashCodes[loc] = hash;
+                        nFilled++;
+                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
+                        //      nFilled, nDeleted, nCapacity );
                 }
 
-                iterator operator=( const iterator &oth )
+                virtual void _erase( uint32_t loc )
                 {
-                        if( &hsh != &oth.hsh )
-                                throw HashException(
-                                        "Cannot mix iterators from different hash objects.");
-                        nPos = oth.nPos;
-                        bFinished = oth.bFinished;
+                        bDeleted[loc/32] |= (1<<(loc%32));
+                        va.destroy( &aValues[loc] );
+                        ka.destroy( &aKeys[loc] );
+                        nDeleted++;
+                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
+                        //      nFilled, nDeleted, nCapacity );
                 }
 
-                std::pair<key,value> operator *()
+                virtual std::pair<key,value> getAtPos( uint32_t nPos )
+                {
+                        return std::pair<key,value>(aKeys[nPos],aValues[nPos]);
+                }
+                
+                virtual key &getKeyAtPos( uint32_t nPos )
                 {
-                        return hsh.getAtPos( nPos );
+                        return aKeys[nPos];
                 }
                 
-                key &getKey()
+                virtual const key &getKeyAtPos( uint32_t nPos ) const
                 {
-                        return hsh.getKeyAtPos( nPos );
+                        return aKeys[nPos];
+                }
+                
+                virtual value &getValueAtPos( uint32_t nPos )
+                {
+                        return aValues[nPos];
+                }
+                
+                virtual const value &getValueAtPos( uint32_t nPos ) const
+                {
+                        return aValues[nPos];
                 }
 
-                value &getValue()
+                virtual uint32_t getFirstPos( bool &bFinished ) const
                 {
-                        return hsh.getValueAtPos( nPos );
+                        for( uint32_t j = 0; j < nCapacity; j++ )
+                        {
+                                if( isFilled( j ) )
+                                        if( !isDeleted( j ) )
+                                                return j;
+                        }
+
+                        bFinished = true;
+                        return 0;
                 }
-        };
 
-        iterator begin()
-        {
-                return iterator( *this );
-        }
-        
-        iterator end()
-        {
-                return iterator( *this, true );
-        }
+                virtual uint32_t getNextPos( uint32_t nPos, bool &bFinished ) const
+                {
+                        for( uint32_t j = nPos+1; j < nCapacity; j++ )
+                        {
+                                if( isFilled( j ) )
+                                        if( !isDeleted( j ) )
+                                                return j;
+                        }
 
-        std::list<key> getKeys()
-        {
-                std::list<key> lKeys;
+                        bFinished = true;
+                        return 0;
+                }
 
-                for( uint32_t j = 0; j < nCapacity; j++ )
+                uint32_t probe( uint32_t hash, key k, bool &bFill, bool rehash=true )
                 {
-                        if( isFilled( j ) )
+                        uint32_t nCur = hash%nCapacity;
+
+                        // First we scan to see if the key is already there, abort if we
+                        // run out of probing room, or we find a non-filled entry
+                        for( int8_t j = 0;
+                                isFilled( nCur ) && j < 32;
+                                nCur = (nCur + (1<<j))%nCapacity, j++
+                                )
                         {
-                                if( !isDeleted( j ) )
+                                // Is this the same hash code we were looking for?
+                                if( hash == aHashCodes[nCur] )
                                 {
-                                        lKeys.push_back( aKeys[j] );
+                                        // Skip over deleted entries.  Deleted entries are also filled,
+                                        // so we only have to do this check here.
+                                        if( isDeleted( nCur ) )
+                                                continue;
+
+                                        // Is it really the same key? (for safety)
+                                        if( __cmpHashKeys( aKeys[nCur], k ) == true )
+                                        {
+                                                bFill = true;
+                                                return nCur;
+                                        }
                                 }
                         }
-                }
 
-                return lKeys;
-        }
+                        // This is our insurance, if the table is full, then go ahead and
+                        // rehash, then try again.
+                        if( isFilled( nCur ) && rehash == true )
+                        {
+                                reHash( szCalc(getCapacity(), getFill(), getDeleted()) );
 
-protected:
-        virtual void onInsert() {}
-        virtual void onUpdate() {}
-        virtual void onDelete() {}
-        virtual void onReHash() {}
+                                // This is potentially dangerous, and could cause an infinite loop.
+                                // Be careful writing probe, eh?
+                                return probe( hash, k, bFill );
+                        }
 
-        virtual void clearBits()
-        {
-                for( uint32_t j = 0; j < nKeysSize; j++ )
-                {
-                        bFilled[j] = bDeleted[j] = 0;
+                        bFill = false;
+                        return nCur;
                 }
-        }
-
-        virtual void fill( uint32_t loc, key &k, value &v, uint32_t hash )
-        {
-                bFilled[loc/32] |= (1<<(loc%32));
-                va.construct( &aValues[loc], v );
-                ka.construct( &aKeys[loc], k );
-                aHashCodes[loc] = hash;
-                nFilled++;
-                //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                //      nFilled, nDeleted, nCapacity );
-        }
-
-        virtual void _erase( uint32_t loc )
-        {
-                bDeleted[loc/32] |= (1<<(loc%32));
-                va.destroy( &aValues[loc] );
-                ka.destroy( &aKeys[loc] );
-                nDeleted++;
-                //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                //      nFilled, nDeleted, nCapacity );
-        }
-
-        virtual std::pair<key,value> getAtPos( uint32_t nPos )
-        {
-                return std::pair<key,value>(aKeys[nPos],aValues[nPos]);
-        }
-        
-        virtual key &getKeyAtPos( uint32_t nPos )
-        {
-                return aKeys[nPos];
-        }
-        
-        virtual value &getValueAtPos( uint32_t nPos )
-        {
-                return aValues[nPos];
-        }
-
-        virtual uint32_t getFirstPos( bool &bFinished )
-        {
-                for( uint32_t j = 0; j < nCapacity; j++ )
+                
+                uint32_t probe( uint32_t hash, key k, bool &bFill, bool rehash=true ) const
                 {
-                        if( isFilled( j ) )
-                                if( !isDeleted( j ) )
-                                        return j;
-                }
+                        uint32_t nCur = hash%nCapacity;
+
+                        // First we scan to see if the key is already there, abort if we
+                        // run out of probing room, or we find a non-filled entry
+                        for( int8_t j = 0;
+                                isFilled( nCur ) && j < 32;
+                                nCur = (nCur + (1<<j))%nCapacity, j++
+                                )
+                        {
+                                // Is this the same hash code we were looking for?
+                                if( hash == aHashCodes[nCur] )
+                                {
+                                        // Skip over deleted entries.  Deleted entries are also filled,
+                                        // so we only have to do this check here.
+                                        if( isDeleted( nCur ) )
+                                                continue;
+
+                                        // Is it really the same key? (for safety)
+                                        if( __cmpHashKeys( aKeys[nCur], k ) == true )
+                                        {
+                                                bFill = true;
+                                                return nCur;
+                                        }
+                                }
+                        }
 
-                bFinished = true;
-                return 0;
-        }
+                        bFill = false;
+                        return nCur;
+                }
 
-        virtual uint32_t getNextPos( uint32_t nPos, bool &bFinished )
-        {
-                for( uint32_t j = nPos+1; j < nCapacity; j++ )
+                void reHash( uint32_t nNewSize )
                 {
-                        if( isFilled( j ) )
-                                if( !isDeleted( j ) )
-                                        return j;
-                }
+                        //printf("---REHASH---");
+                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
+                        //      nFilled, nDeleted, nCapacity );
+                        
+                        // Save all the old data
+                        uint32_t nOldCapacity = nCapacity;
+                        uint32_t *bOldFilled = bFilled;
+                        uint32_t *aOldHashCodes = aHashCodes;
+                        uint32_t nOldKeysSize = nKeysSize;
+                        uint32_t *bOldDeleted = bDeleted;
+                        value *aOldValues = aValues;
+                        key *aOldKeys = aKeys;
+                        
+                        // Calculate new sizes
+                        nCapacity = nNewSize;
+                        nKeysSize = bitsToBytes( nCapacity );
+                
+                        // Allocate new memory + prep
+                        bFilled = ca.allocate( nKeysSize );
+                        bDeleted = ca.allocate( nKeysSize );
+                        clearBits();
 
-                bFinished = true;
-                return 0;
-        }
+                        aHashCodes = ca.allocate( nCapacity );
+                        aKeys = ka.allocate( nCapacity );
+                        aValues = va.allocate( nCapacity );
 
-        uint32_t probe( uint32_t hash, key k, bool &bFill, bool rehash=true )
-        {
-                uint32_t nCur = hash%nCapacity;
+                        nDeleted = nFilled = 0;
 
-                // First we scan to see if the key is already there, abort if we
-                // run out of probing room, or we find a non-filled entry
-                for( int8_t j = 0;
-                        isFilled( nCur ) && j < 32;
-                        nCur = (nCur + (1<<j))%nCapacity, j++
-                        )
-                {
-                        // Is this the same hash code we were looking for?
-                        if( hash == aHashCodes[nCur] )
+                        // Re-insert all of the old data (except deleted items)
+                        for( uint32_t j = 0; j < nOldCapacity; j++ )
                         {
-                                // Skip over deleted entries.  Deleted entries are also filled,
-                                // so we only have to do this check here.
-                                if( isDeleted( nCur ) )
-                                        continue;
+                                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
+                                        (bOldDeleted[j/32]&(1<<(j%32)))==0 )
+                                {
+                                        insert( aOldKeys[j], aOldValues[j] );
+                                }
+                        }
 
-                                // Is it really the same key? (for safety)
-                                if( __cmpHashKeys( aKeys[nCur], k ) == true )
+                        // Delete all of the old data
+                        for( uint32_t j = 0; j < nOldCapacity; j++ )
+                        {
+                                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 )
                                 {
-                                        bFill = true;
-                                        return nCur;
+                                        va.destroy( &aOldValues[j] );
+                                        ka.destroy( &aOldKeys[j] );
                                 }
                         }
+                        va.deallocate( aOldValues, nOldCapacity );
+                        ka.deallocate( aOldKeys, nOldCapacity );
+                        ca.deallocate( bOldFilled, nOldKeysSize );
+                        ca.deallocate( bOldDeleted, nOldKeysSize );
+                        ca.deallocate( aOldHashCodes, nOldCapacity );
                 }
 
-                // This is our insurance, if the table is full, then go ahead and
-                // rehash, then try again.
-                if( isFilled( nCur ) && rehash == true )
+                virtual bool isFilled( uint32_t loc ) const
                 {
-                        reHash( szCalc(getCapacity(), getFill(), getDeleted()) );
+                        return (bFilled[loc/32]&(1<<(loc%32)))!=0;
+                }
 
-                        // This is potentially dangerous, and could cause an infinite loop.
-                        // Be careful writing probe, eh?
-                        return probe( hash, k, bFill );
+                virtual bool isDeleted( uint32_t loc ) const
+                {
+                        return (bDeleted[loc/32]&(1<<(loc%32)))!=0;
                 }
 
-                bFill = false;
-                return nCur;
-        }
+        protected:
+                uint32_t nCapacity;
+                uint32_t nFilled;
+                uint32_t nDeleted;
+                uint32_t *bFilled;
+                uint32_t *bDeleted;
+                uint32_t nKeysSize;
+                key *aKeys;
+                value *aValues;
+                uint32_t *aHashCodes;
+                valuealloc va;
+                keyalloc ka;
+                challoc ca;
+                sizecalc szCalc;
+        };
 
-        void reHash( uint32_t nNewSize )
-        {
-                //printf("---REHASH---");
-                //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                //      nFilled, nDeleted, nCapacity );
-                
-                // Save all the old data
-                uint32_t nOldCapacity = nCapacity;
-                uint32_t *bOldFilled = bFilled;
-                uint32_t *aOldHashCodes = aHashCodes;
-                uint32_t nOldKeysSize = nKeysSize;
-                uint32_t *bOldDeleted = bDeleted;
-                value *aOldValues = aValues;
-                key *aOldKeys = aKeys;
-                
-                // Calculate new sizes
-                nCapacity = nNewSize;
-                nKeysSize = bitsToBytes( nCapacity );
-        
-                // Allocate new memory + prep
-                bFilled = ca.allocate( nKeysSize );
-                bDeleted = ca.allocate( nKeysSize );
-                clearBits();
+        template<> uint32_t __calcHashCode<int>( const int &k );
+        template<> bool __cmpHashKeys<int>( const int &a, const int &b );
 
-                aHashCodes = ca.allocate( nCapacity );
-                aKeys = ka.allocate( nCapacity );
-                aValues = va.allocate( nCapacity );
+        template<> uint32_t __calcHashCode<unsigned int>( const unsigned int &k );
+        template<> bool __cmpHashKeys<unsigned int>( const unsigned int &a, const unsigned int &b );
 
-                nDeleted = nFilled = 0;
+        template<> uint32_t __calcHashCode<const char *>( const char * const &k );
+        template<> bool __cmpHashKeys<const char *>( const char * const &a, const char * const &b );
 
-                // Re-insert all of the old data (except deleted items)
-                for( uint32_t j = 0; j < nOldCapacity; j++ )
-                {
-                        if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
-                                (bOldDeleted[j/32]&(1<<(j%32)))==0 )
-                        {
-                                insert( aOldKeys[j], aOldValues[j] );
-                        }
-                }
+        template<> uint32_t __calcHashCode<char *>( char * const &k );
+        template<> bool __cmpHashKeys<char *>( char * const &a, char * const &b );
 
-                // Delete all of the old data
-                for( uint32_t j = 0; j < nOldCapacity; j++ )
+        template<> uint32_t __calcHashCode<std::string>( const std::string &k );
+        template<> bool __cmpHashKeys<std::string>( const std::string &a, const std::string &b );
+
+        /*
+        template<typename key, typename value>
+        Archive &operator<<( Archive &ar, Hash<key,value> &h )
+        {
+                ar << h.size();
+                for( typename Hash<key,value>::iterator i = h.begin(); i != h.end(); i++ )
                 {
-                        if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
-                                (bOldDeleted[j/32]&(1<<(j%32)))==0 )
-                        {
-                                va.destroy( &aOldValues[j] );
-                                ka.destroy( &aOldKeys[j] );
-                        }
+                        std::pair<key,value> p = *i;
+                        ar << p.first << p.second;
                 }
-                va.deallocate( aOldValues, nOldCapacity );
-                ka.deallocate( aOldKeys, nOldCapacity );
-                ca.deallocate( bOldFilled, nOldKeysSize );
-                ca.deallocate( bOldDeleted, nOldKeysSize );
-                ca.deallocate( aOldHashCodes, nOldCapacity );
-        }
 
-        virtual bool isFilled( uint32_t loc ) const
-        {
-                return (bFilled[loc/32]&(1<<(loc%32)))!=0;
+                return ar;
         }
 
-        virtual bool isDeleted( uint32_t loc )
+        template<typename key, typename value>
+        Archive &operator>>( Archive &ar, Hash<key,value> &h )
         {
-                return (bDeleted[loc/32]&(1<<(loc%32)))!=0;
-        }
+                h.clear();
+                uint32_t nSize;
+                ar >> nSize;
 
-protected:
-        uint32_t nCapacity;
-        uint32_t nFilled;
-        uint32_t nDeleted;
-        uint32_t *bFilled;
-        uint32_t *bDeleted;
-        uint32_t nKeysSize;
-        key *aKeys;
-        value *aValues;
-        uint32_t *aHashCodes;
-        valuealloc va;
-        keyalloc ka;
-        challoc ca;
-        sizecalc szCalc;
-};
-
-template<> uint32_t __calcHashCode<int>( const int &k );
-template<> bool __cmpHashKeys<int>( const int &a, const int &b );
-
-template<> uint32_t __calcHashCode<unsigned int>( const unsigned int &k );
-template<> bool __cmpHashKeys<unsigned int>( const unsigned int &a, const unsigned int &b );
-
-template<> uint32_t __calcHashCode<const char *>( const char * const &k );
-template<> bool __cmpHashKeys<const char *>( const char * const &a, const char * const &b );
-
-template<> uint32_t __calcHashCode<char *>( char * const &k );
-template<> bool __cmpHashKeys<char *>( char * const &a, char * const &b );
-
-template<> uint32_t __calcHashCode<std::string>( const std::string &k );
-template<> bool __cmpHashKeys<std::string>( const std::string &a, const std::string &b );
-
-template<> uint32_t __calcHashCode<Hashable>( const Hashable &k );
-template<> bool __cmpHashKeys<Hashable>( const Hashable &a, const Hashable &b );
-
-template<typename key, typename value>
-Serializer &operator<<( Serializer &ar, Hash<key,value> &h )
-{
-        ar << h.size();
-        for( typename Hash<key,value>::iterator i = h.begin(); i != h.end(); i++ )
-        {
-                std::pair<key,value> p = *i;
-                ar << p.first << p.second;
-        }
+                for( uint32_t j = 0; j < nSize; j++ )
+                {
+                        key k; value v;
+                        ar >> k >> v;
+                        h.insert( k, v );
+                }
 
-        return ar;
-}
+                return ar;
+        }*/
 
-template<typename key, typename value>
-Serializer &operator>>( Serializer &ar, Hash<key,value> &h )
-{
-        h.clear();
-        uint32_t nSize;
-        ar >> nSize;
-
-        for( uint32_t j = 0; j < nSize; j++ )
+        /*
+        template<typename key, typename value>
+        Serializer &operator&&( Serializer &ar, Hash<key,value> &h )
         {
-                key k; value v;
-                ar >> k >> v;
-                h.insert( k, v );
-        }
-
-        return ar;
-}
-
-template<typename key, typename value>
-Serializer &operator&&( Serializer &ar, Hash<key,value> &h )
-{
-        if( ar.isLoading() )
-        {
-                return ar >> h;
-        }
-        else
-        {
-                return ar << h;
-        }
+                if( ar.isLoading() )
+                {
+                        return ar >> h;
+                }
+                else
+                {
+                        return ar << h;
+                }
+        }*/
 }
 
 #endif
diff --git a/src/hashable.cpp b/src/hashable.cpp
deleted file mode 100644
index 8565956..0000000
--- a/src/hashable.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "hashable.h"
diff --git a/src/hashable.h b/src/hashable.h
deleted file mode 100644
index 98643d5..0000000
--- a/src/hashable.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef HASHABLE_H
-#define HASHABLE_H
-
-class Hashable
-{
-public:
-        virtual ~Hashable() {};
-        virtual unsigned long int getHashCode() = 0;
-        virtual bool compareForHash( Hashable &other ) = 0;
-};
-
-#endif
diff --git a/src/hashfunction.cpp b/src/hashfunction.cpp
deleted file mode 100644
index 51f2259..0000000
--- a/src/hashfunction.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "hashfunction.h"
-
-HashFunction::HashFunction()
-{
-}
-
-HashFunction::~HashFunction()
-{
-}
-
diff --git a/src/hashfunction.h b/src/hashfunction.h
deleted file mode 100644
index cbcf70f..0000000
--- a/src/hashfunction.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef HASH_FUNCTION
-#define HASH_FUNCTION
-
-/** This represents the shell of a hash function.  It must be aggregated in
-  * order to be used.  Please read about it's two functions for specificatins
-  * relating to what values will be passed to them and what they should return
-  * for creating your own hash functions.
-  *@author Mike Buland.
-  */
-class HashFunction
-{
-public:
-        /**
-         * Standard Constructor.
-         */
-        HashFunction();
-
-        /**
-         * Standard Deconstructor.
-         */
-        virtual ~HashFunction();
-
-        /** Hashes the value represnted by id.  This must return a fairly unique
-          * number in the range of 0-2^32 (or whatever the size of an unsigned long
-          * is on your system) based on the id given.  The faster the number changes
-          * the better in a general sence.  The return value will be the index
-          * (after probing takes place) to the data assosiated with an id, so this
-          * function should always produce the same number for any given id.
-          *@param id The identifier to use to create a unique numerical identifier.
-          *@returns A mostly unique numerical identifier generated using the given
-          * id.
-          */
-        virtual unsigned long int hash( const void *id ) = 0;
-
-        /** This function must compare two ids in the format that this hashfunction
-          * accepts.  For example, if the hash function hashes strings it should
-          * probably { return strcmp( id1, id2 ) == 0 }.
-          *@param id1 One value to use in the comparison
-          *@param id2 Another value to use in the comparison
-          *@returns True if the two values match, otherwise false.
-          */
-        virtual bool cmpIDs( const void *id1, const void *id2 ) = 0;
-        
-//      virtual void *createPersistantID( const void *id ) = 0;
-//      virtual void destroyPersistantID( const void *id ) = 0;
-};
-
-#endif
diff --git a/src/hashfunctioncasestring.cpp b/src/hashfunctioncasestring.cpp
deleted file mode 100644
index 6361f45..0000000
--- a/src/hashfunctioncasestring.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include "hashfunctioncasestring.h"
-
-HashFunctionCaseString::HashFunctionCaseString()
-{
-}
-
-HashFunctionCaseString::~HashFunctionCaseString()
-{
-}
-
-unsigned long int HashFunctionCaseString::hash( const void *id )
-{
-        const char *str = (const char *)id;
-        unsigned long int nPos = 0;
-        for( int j = 0; str[j] != '\0'; j++ )
-        {
-                nPos = tolower(str[j]) + (nPos << 6) + (nPos << 16) - nPos;
-//              nPos += nPos<<16|(((unsigned long int)tolower(str[j]))<<((j*7)%24));
-        }
-        return nPos;
-}
-
-bool HashFunctionCaseString::cmpIDs( const void *id1, const void *id2 )
-{
-        const char *str1 = (const char *)id1;
-        const char *str2 = (const char *)id2;
-
-        int j;
-        for( j = 0; str1[j] != '\0' && str2[j] != '\0'; j++ )
-        {
-                if( tolower(str1[j]) != tolower(str2[j]) )
-                        return false;
-        }
-        return (str1[j]==str2[j]);
-}
-
diff --git a/src/hashfunctioncasestring.h b/src/hashfunctioncasestring.h
deleted file mode 100644
index 7816a1b..0000000
--- a/src/hashfunctioncasestring.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef HASH_FUNCTION_CASE_STRING
-#define HASH_FUNCTION_CASE_STRING
-
-#include "hashfunction.h"
-
-/** A hash function for string data.  This hash function does strings, but is
-  * actually generalized to handle any binary stream of characters terminated
-  * by a null character.  This is different than HashFunctionString in that
-  * this does comparisons without regaurd to case.
-  *@author Mike Buland.
-  */
-class HashFunctionCaseString : public HashFunction
-{
-public:
-        /**
-         * Standard Constructor.
-         */
-        HashFunctionCaseString();
-        
-        /**
-         * Standard Deconstructor.
-         */
-        virtual ~HashFunctionCaseString();
-        unsigned long int hash( const void *id );
-        bool cmpIDs( const void *id1, const void *id2 );
-};
-
-#endif
diff --git a/src/hashfunctionint.cpp b/src/hashfunctionint.cpp
deleted file mode 100644
index 4bd0feb..0000000
--- a/src/hashfunctionint.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "hashfunctionint.h"
-
-HashFunctionInt::HashFunctionInt()
-{
-}
-
-HashFunctionInt::~HashFunctionInt()
-{
-}
-
-unsigned long int HashFunctionInt::hash( const void *id )
-{
-        return (unsigned long)(id);
-}
-
-bool HashFunctionInt::cmpIDs( const void *id1, const void *id2 )
-{
-        return (unsigned long)(id1) == (unsigned long)(id2);
-}
-
diff --git a/src/hashfunctionint.h b/src/hashfunctionint.h
deleted file mode 100644
index 0fbc764..0000000
--- a/src/hashfunctionint.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef HASH_FUNCTION_INT
-#define HASH_FUNCTION_INT
-
-#include "hashfunction.h"
-
-/** A hash function for integer data.  Really, this does almost nothing except
-  * ensure we're dealing with positive indicies.
-  *@author Mike Buland.
-  */
-class HashFunctionInt : public HashFunction
-{
-public:
-        /**
-         * Standard Constructor.
-         */
-        HashFunctionInt();
-        
-        /**
-         * Standard Deconstructor.
-         */
-        virtual ~HashFunctionInt();
-        unsigned long int hash( const void *id );
-        bool cmpIDs( const void *id1, const void *id2 );
-};
-
-#endif
diff --git a/src/hashfunctionstring.cpp b/src/hashfunctionstring.cpp
deleted file mode 100644
index bd14643..0000000
--- a/src/hashfunctionstring.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "hashfunctionstring.h"
-#ifndef NULL
-#define NULL ((void *) 0)
-#endif
-
-HashFunctionString::HashFunctionString()
-{
-}
-
-HashFunctionString::~HashFunctionString()
-{
-}
-
-unsigned long int HashFunctionString::hash( const void *id )
-{
-        if (id == NULL)
-        {
-                return 0;
-        }
-        
-        unsigned long int nPos = 0;
-        for( const char *s = (const char *)id; *s; s++ )
-        {
-                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
-        }
-        return nPos;
-}
-
-bool HashFunctionString::cmpIDs( const void *id1, const void *id2 )
-{
-        if (id1 == NULL || id2 == NULL)
-        {
-                return false;
-        }
-        if (id1 == id2)
-        {
-                return true;
-        }
-        
-        const char *str1 = (const char *)id1;
-        const char *str2 = (const char *)id2;
-
-        int j;
-        for( j = 0; str1[j] != '\0' && str2[j] != '\0'; j++ )
-        {
-                if( str1[j] != str2[j] )
-                        return false;
-        }
-        return (str1[j]==str2[j]);
-}
-
diff --git a/src/hashfunctionstring.h b/src/hashfunctionstring.h
deleted file mode 100644
index 7d2a1a6..0000000
--- a/src/hashfunctionstring.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef HASH_FUNCTION_STRING
-#define HASH_FUNCTION_STRING
-
-#include "hashfunction.h"
-
-/** A hash function for string data.  This hash function does strings, but is
-  * actually generalized to handle any binary stream of characters terminated
-  * by a null character.
-  *@author Mike Buland.
-  */
-class HashFunctionString : public HashFunction
-{
-public:
-        /**
-         * Standard Constructor.
-         */
-        HashFunctionString();
-        
-        /**
-         * Standard Deconstructor.
-         */
-        virtual ~HashFunctionString();
-        unsigned long int hash( const void *id );
-        bool cmpIDs( const void *id1, const void *id2 );
-};
-
-#endif
diff --git a/src/hashtable.cpp b/src/hashtable.cpp
deleted file mode 100644
index dbcd964..0000000
--- a/src/hashtable.cpp
+++ /dev/null
@@ -1,424 +0,0 @@
-#include <string.h>
-#include <stdio.h>
-#include <math.h>
-
-#include "hashtable.h"
-
-HashTable::HashTable( HashFunction *hNewFunc, unsigned long int nInitSize, bool bAllowDupes )
-{
-        hFunc = hNewFunc;
-        nTableSize = nextPrime( nInitSize );
-        aTable = new HashNode[nTableSize];
-        //for( int j = 0; j < nTableSize; j++ ) if( aTable[j].id || aTable[j].data || aTable[j].bDeleted ) printf("Unclean entry\n");
-        nSize = 0;
-        nFilled = 0;
-        this->bAllowDupes = bAllowDupes;
-}
-
-HashTable::~HashTable()
-{
-        delete[] aTable;
-        delete hFunc;
-}
-
-void HashTable::set( int j, const void *newID, const void *newData )
-{
-        if( newData == NULL )
-        {
-                printf("Inserting NULL data is indestinguishable from uninserted data!\n");
-        }
-        aTable[j].id = newID;
-        aTable[j].data = newData;
-}
-
-void HashTable::clear()
-{
-        memset( aTable, 0, sizeof(HashNode) * nTableSize );
-}
-
-bool HashTable::isFilled( int j )
-{
-        return (aTable[j].id != NULL)||(aTable[j].bDeleted);
-}
-
-void HashTable::reHash( unsigned long int nNewSize )
-{
-        HashNode *aOldTable = aTable;
-        unsigned long int oldSize = nTableSize;
-
-        // If the table can still be used if we just get rid of deleted items, don't
-        // change the size of the table, otherwise, go ahead and use the number
-        // passed in.
-        if( nSize > nTableSize>>1 )
-        {
-                nTableSize = nextPrime( nNewSize );
-        }
-
-        aTable = newTable( nTableSize );
-        //for( int j = 0; j < nTableSize; j++ ) if( aTable[j].id || aTable[j].data || aTable[j].bDeleted ) printf("Unclean entry\n");
-
-        nSize = 0;
-        nFilled = 0;
-
-        for( unsigned long int j = 0; j < oldSize; j++ )
-        {
-                if( aOldTable[j].id != NULL && aOldTable[j].bDeleted == false )
-                {
-                        insert( aOldTable[j].id, aOldTable[j].data );
-                }
-        }
-
-        delete[] aOldTable;
-}
-
-unsigned long int HashTable::probe( unsigned long int nStart, const void *id )
-{
-        int nHash = nStart;
-        nStart = nStart%nTableSize;
-        if( bAllowDupes == true )
-        {
-                for(
-                        unsigned long int j=0;
-                        isFilled( nStart ) && j < 32;
-                        nStart = (nStart+(1<<j))%nTableSize, j++
-                        );
-
-                /**
-                 * This is an ugly little hack.  If the hash table is too full in allow-
-                 * dups mode we have to fall back on a linear search, otherwise you can
-                 * only get up to 32 entries with the same name.
-                 */
-                if( isFilled( nStart ) )
-                {
-                        unsigned long int nOldStart = nStart;
-                        for(
-                                nStart++;
-                                isFilled( nStart ) && nStart != nOldStart;
-                                nStart = (nStart+1)%nTableSize
-                           );
-                }
-        }
-        else
-        {
-                for(
-                        unsigned long int j=0;
-                        isFilled( nStart ) && j < 32;
-                        nStart = (nStart+(1<<j))%nTableSize, j++
-                        )
-                {
-                        if( isFilled( nStart ) )
-                        {
-                                if( hFunc->cmpIDs( aTable[nStart].id, id ) == true &&
-                                        aTable[nStart].bDeleted == false )
-                                {
-                                        return nStart;
-                                }
-                        }
-                }
-        }
-        // This is our insurance, if the table is full, then go ahead and rehash,
-        // then try again.
-        if( isFilled( nStart ) )
-        {
-                reHash( getCapacity()*2 );
-                return probe( nHash, id );
-        }
-        return nStart;
-}
-
-HashTable::HashNode *HashTable::newTable( unsigned long int nNewSize )
-{
-        return new HashNode[nNewSize];
-}
-
-#ifdef HASH_DEBUG_VIS
-void HashTable::printDebugLine( const char *exData )
-{
-        char *buf = new char[getCapacity()+3];
-        int j;
-        buf[0] = '[';
-        for( j = 0; j < getCapacity(); j++ )
-        {
-                buf[j+1] = (aTable[j].bDeleted)?('X'):((isFilled( j ))?('#'):('-'));
-        }
-        buf[j+1] = ']';
-        buf[j+2] = '\0';
-        printf("%s %s\n", buf, exData );
-        delete[] buf;
-}
-#endif
-
-bool HashTable::insert( const void *id, const void *data )
-{
-        unsigned long int nPos = probe( hFunc->hash( id ), id )%nTableSize;
-
-        if( bAllowDupes == true )
-        {
-                if( aTable[nPos].id == NULL && aTable[nPos].bDeleted == false )
-                {
-                        set( nPos, id, data );
-#ifdef HASH_DEBUG_VIS
-                        printDebugLine( (const char *)id );
-#endif
-                        nSize++;
-                        nFilled++;
-                        return true;
-                }
-                else
-                {
-                        return false;
-                }
-        }
-        else
-        {
-                if( aTable[nPos].id == NULL && aTable[nPos].bDeleted == false )
-                {
-                        set( nPos, id, data );
-#ifdef HASH_DEBUG_VIS
-                        printDebugLine( (const char *)id );
-#endif
-                        nSize++;
-                        nFilled++;
-                        return true;
-                }
-                else if( hFunc->cmpIDs( aTable[nPos].id, id ) == true )
-                {
-                        set( nPos, id, data );
-#ifdef HASH_DEBUG_VIS
-                        printDebugLine( (const char *)id );
-#endif
-                        return true;
-                }
-                else
-                {
-                        return false;
-                }
-        }
-}
-
-const void *HashTable::get( const void *id, unsigned long int nSkip )
-{
-        unsigned long int nPos = hFunc->hash( id )%nTableSize;
-
-        for( unsigned long int j=0; j < 32; nPos = (nPos+(1<<j))%nTableSize, j++ )
-        {
-                if( !isFilled( nPos ) ) return NULL;
-                if( aTable[nPos].bDeleted == false )
-                {
-                        if( hFunc->cmpIDs( id, aTable[nPos].id ) )
-                        {
-                                if( nSkip == 0 )
-                                {
-                                        return aTable[nPos].data;
-                                }
-                                else
-                                {
-                                        nSkip--;
-                                }
-                        }
-                }
-        }
-
-        if( bAllowDupes )
-        {
-                unsigned long int nOldPos = nPos;
-                for( nPos++; nPos != nOldPos; nPos=(nPos+1)%nTableSize )
-                {
-                        if( !isFilled( nPos ) ) return NULL;
-                        if( aTable[nPos].bDeleted == false )
-                        {
-                                if( hFunc->cmpIDs( id, aTable[nPos].id ) )
-                                {
-                                        if( nSkip == 0 )
-                                        {
-                                                return aTable[nPos].data;
-                                        }
-                                        else
-                                        {
-                                                nSkip--;
-                                        }
-                                }
-                        }
-                }
-        }
-
-        return NULL;
-}
-
-const void *HashTable::getKey( const void *id, unsigned long int nSkip )
-{
-        unsigned long int nPos = hFunc->hash( id )%nTableSize;
-
-        for( unsigned long int j=0; j < 32; nPos = (nPos+(1<<j))%nTableSize, j++ )
-        {
-                if( !isFilled( nPos ) ) return NULL;
-                if( aTable[nPos].bDeleted == false )
-                {
-                        if( hFunc->cmpIDs( id, aTable[nPos].id ) )
-                        {
-                                if( nSkip == 0 )
-                                {
-                                        return aTable[nPos].id;
-                                }
-                                else
-                                {
-                                        nSkip--;
-                                }
-                        }
-                }
-        }
-
-        if( bAllowDupes )
-        {
-                unsigned long int nOldPos = nPos;
-                for( nPos++; nPos != nOldPos; nPos=(nPos+1)%nTableSize )
-                {
-                        if( !isFilled( nPos ) ) return NULL;
-                        if( aTable[nPos].bDeleted == false )
-                        {
-                                if( hFunc->cmpIDs( id, aTable[nPos].id ) )
-                                {
-                                        if( nSkip == 0 )
-                                        {
-                                                return aTable[nPos].id;
-                                        }
-                                        else
-                                        {
-                                                nSkip--;
-                                        }
-                                }
-                        }
-                }
-        }
-
-        return NULL;
-}
-
-void *HashTable::getFirstItemPos()
-{
-        HashPos *pos = new HashPos;
-        return pos;
-}
-
-const void *HashTable::getItemData( void *xPos )
-{
-        return aTable[((HashPos *)xPos)->nPos].data;
-}
-
-const void *HashTable::getItemID( void *xPos )
-{
-        return aTable[((HashPos *)xPos)->nPos].id;
-}
-
-void *HashTable::getNextItemPos( void *xPos )
-{
-        HashPos *pos = (HashPos *)xPos;
-        if( pos->bStarted == false )
-        {
-                pos->bStarted = true;
-                pos->nPos = 0;
-        }
-        else
-        {
-                pos->nPos++;
-        }
-        if( pos->nPos < nTableSize )
-        {
-                for( ; pos->nPos < nTableSize; pos->nPos++ )
-                {
-                        if( isFilled( pos->nPos ) &&
-                                aTable[pos->nPos].bDeleted == false )
-                        {
-                                return xPos;
-                        }
-                }
-        }
-
-        delete pos;
-
-        return NULL;
-}
-
-// Big-O sqrt(n)
-// Change this to be erethpothynies table with a storage
-// lookup later on.
-bool HashTable::isPrime (int num)
-{
-    if (num == 2)         // the only even prime
-        return true;
-    else if (num % 2 == 0)     // other even numbers are composite
-        return false;
-    else
-    {
-        //bool prime = true;
-        int divisor = 3;
-        int upperLimit = static_cast<int>(sqrt(num) + 1);
-        while (divisor <= upperLimit)
-        {
-            if (num % divisor == 0)
-                                return false;
-            //    prime = false;
-            divisor +=2;
-        }
-        return true;
-    }
-}
-
-// Big-O n^(3/2)
-int HashTable::nextPrime( int base )
-{
-        int nPrime;
-        for( nPrime = base; isPrime( nPrime ) == false; nPrime++ );
-        return nPrime;
-}
-
-unsigned long int HashTable::getCapacity()
-{
-        return nTableSize;
-}
-
-unsigned long int HashTable::getSize()
-{
-        return nSize;
-}
-
-double HashTable::getLoad()
-{
-        return (double)(nFilled)/(double)(nTableSize);
-}
-
-const void *HashTable::operator[](const void *id)
-{
-        return get( id );
-}
-
-bool HashTable::del( const void *id, int nSkip )
-{
-        unsigned long int nPos = hFunc->hash( id )%nTableSize;
-
-        for( unsigned long int j=0; j < 32; nPos = (nPos+(1<<j))%nTableSize, j++ )
-        {
-                if( !isFilled( nPos ) ) return false;
-                //printf("0x%08X \"%s\" == 0x%08X \"%s\" (%d)\n", id, id, aTable[nPos].id, aTable[nPos].id, nPos );
-                if( hFunc->cmpIDs( id, aTable[nPos].id ) &&
-                        aTable[nPos].bDeleted == false )
-                {
-                        if( nSkip == 0 )
-                        {
-                                aTable[nPos].bDeleted = true;
-                                nSize--;
-#ifdef HASH_DEBUG_VIS
-                                printDebugLine( (const char *)id );
-#endif
-                                return true;
-                        }
-                        else
-                        {
-                                nSkip--;
-                        }
-                }
-        }
-
-        return false;
-}
-
diff --git a/src/hashtable.h b/src/hashtable.h
deleted file mode 100644
index 179b694..0000000
--- a/src/hashtable.h
+++ /dev/null
@@ -1,308 +0,0 @@
-/**\hashtable.h
- * Describes the HashFunction, HashFunctionString, and HashTable classes.  It
- * was just easier to put them all in one set of files.
- *@author Mike Buland
- */
-
-#ifndef HASH_TABLE_H
-#define HASH_TABLE_H
-
-//Uncomment this line to see a cool text-mode visualization of what's going on
-//#define HASH_DEBUG_VIS 1
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-
-#include "hashfunction.h"
-
-/**
- * A simple yet flexable hash-table.  This uses several tricks to help ensure
- * that the table is always running at maximum efficiency.  You no longer have
- * to specify a "danger fill level" when more space is needed a rehash is
- * automatically trigered.  Deleting elements is fully supported, as well as
- * duplicate elements.  To work with and allow duplicates simple construct your
- * HashTable the way you normally would, but when deleting or getting elements
- * you can specify a skip value.  This effectively allows you to treat elements
- * with duplicate ID's as though they were in a zero-based array.  The first
- * element inserted with a given ID would be at skip zero, the next at skip 1
- * and so on.  This allows you to quickly search for elements with duplicate
- * names, just stop when you get a null for a skip number, i.e.
- * <pre>
- *   for( int j = 0;; j++ )
- *   {
- *       void *pData = hash.get( myID, j );
- *       if( !pData ) break;
- *       // Do something interesting with pData
- *   }
- * </pre>
- * There are new features in this HashTable that also allow for memory saving
- * when dealing with systems where many elements are being deleted from the
- * table.  In those cases the elements deleted cannot be simply deleted, instead
- * they have to be marked as deleted and hidden from the user, but maintained in
- * the table so that future hashing operations don't fail.  When rehashing
- * occurs all elements marked as deleted are quietly removed.  In these cases,
- * if the number of deleted items would free enough space in the table for the
- * table to be used efficiently without resizing, it is left the same size and
- * rehashing is performed effectively in place, allowing the deleted items to
- * be removed.
- * <br>
- * For info on adding new hashing algorithms, please see the HashFunction class.
- *@author Mike Buland
- *@todo Fix probing for tables that allow duplicates, and delete an item, then
- * insert an item with the same name.
- */
-class HashTable
-{
-public:
-        /** Constructs a hash table.
-          *@param hNewFunc A pointer to a hashfunction class to use.  If this is
-          * null the default general string type will be used.
-          *@param nInitSize The initial size of the hashtable.
-          *@param bAllowDupes Setting this value to true allows the system to
-          * insert more than one copy of any given key.  This can be tricky, and
-          * will require you to use the nSkip parameter on the get function.
-          */
-        HashTable( HashFunction *hNewFunc, unsigned long int nInitSize, bool bAllowDupes=false );
-        
-        /**
-         * Destroys the hashtable, cleaning up all internal storage, but not stored
-         * elements.  Also deletes the HashFunction passed in in the constructor.
-         */
-        virtual ~HashTable();
-
-        /** Inserts an item into the hashtable.  This function will trigger a
-          * rehash if adding another item would force the table's load factor over
-          * the danger level.
-          *@param id used to find the data later.
-          *@param data The data item to insert into the table with the identifier
-          * id
-          *@returns True if insertion was successfull, and false if it failed.
-          */
-        bool insert( const void *id, const void *data );
-
-        /** Gets an item in the hashtable based on the id of that item.  If there
-          * is more than one item with the same id you can use the nSkip parameter
-          * to access all of them.
-          *@param id The id of the item you're trying to find.
-          *@param nSkip The number of items with that id to skip before returning
-          * with the requested item.
-          *@returns A pointer to the data stored at the given id.
-          */
-        const void *get( const void *id, unsigned long int nSkip=0 );
-        
-        const void *getKey( const void *id, unsigned long int nSkip=0 );
-
-        /** Gets the total capacity of the hashtable.  This is actually the number
-          * of total positions available inside the hashtable at the moment.  This
-          * will change when the hashtable's load exceeds the danger level.
-          * Please note that this is NOT the actual amount of space available.
-          * In reality you can only access about 45-50 percent of that space.
-          *@returns The total capacity.
-          */
-        unsigned long int getCapacity();
-
-        /** Gets the number of filled in items in the hash table.  This is roughly
-          * equivelent to the getSize function assosiated with the Lists.
-          *@returns The number of filled in items in the hash table.
-          */
-        unsigned long int getSize();
-
-        /** Gets the load (percentage) of filled in items in the table.  This is
-          * technically the size divided by the capacity, but is definately usefull
-          * since it's required to check if it's time to rehash.
-          *@returns The table load in the range 0.0 to 1.0
-          */
-        double getLoad();
-
-        /** Sets up an xPos object for use indexing the items in the table.  Call
-          * this first and follow the directions for getNextItemPos below to
-          * iterate through every item in the table, while avoiding the empty
-          * spaces.
-          *@returns A pointer to a xPos object telling the hashtable where to find
-          * the item you're looking at.
-          */
-        void *getFirstItemPos();
-
-        /** Get the item's data that is being pointed to by xPos.  This is only
-          * valid after xPos was created using getFirstItemPos and getNextItemPos
-          * was called at least once.
-          *@param xPos supplied by getFirstItemPos.
-          *@returns The key value that was used to insert the data into the table.
-          */
-        const void *getItemData( void *xPos );
-
-        /** Get the item's ID that is being pointed to by xPos.  This is only
-          * valid after xPos was created using getFirstItemPos and getNextItemPos
-          * was called at least once.
-          *@param xPos supplied by getFirstItemPos.
-          *@returns The key value that was used to insert the data into the table.
-          */
-        const void *getItemID( void *xPos );
-
-        /** Used for iterating through a hash table sequentially.  This will
-          * update the xPos pointer to point to the next time, all ready to
-          * be accessed with getItemID and getItemData.  This must be called at
-          * least once before xPos is meaningful, and will return a NULL when it
-          * has reached the last item.
-          *@param xPos This must be an object created by a call to the function
-          * getFirstItemPos, and is only meaningful to the internal routines.
-          * Aborting a call in the middle (not running to the end of the table)
-          * may result in a memory leak at the moment.
-          *@returns xPos if still iterating through the list, otherwise it will
-          * return NULL when the end has been reached and the xPos variable has
-          * been deleted.
-          */
-        void *getNextItemPos( void *xPos );
-
-        /** A helpful operator to make accessing items easier.  Please note that
-          * this simply returns a pointer to the data stored internally, and cannot
-          * be used like the STL operator to store new data, use insert for that.
-          *@param id The identifier used to store the requested item.
-          *@returns The data value assosiated with the given id, or NULL if it
-          * wasn't found in the table.
-          */
-        const void *operator[](const void *id);
-
-        /**
-         * Delete the specified item from the hashtable.  This actually keeps the
-         * data and marks it deleted.  For all intents and purposes to the user it
-         * is deleted, except that the space is still used until a rehash is forced.
-         * This means that in hashtables where elements are being inserted and
-         * deleted frequently you may run into a higher rate of expansion.
-         *@param id The ID to delete.
-         *@param nSkip The number of similar id's to skip before deleting in a
-         * hashtable that allows duplicates.
-         *@returns True if the element was found and deleted, false otherwise.
-         */
-        bool del( const void *id, int nSkip=0 );
-
-        /**
-         * Deletes every entry in the hash table.  See the notes on del to see what
-         * this means, except that since no data is being kept, the entire table is
-         * just marked as usable space.
-         */
-        void clear();
-
-private:
-        /**
-         * Contains info related to a position in the hashtable.  Used for
-         * searching through hashtables one item at a time, in order.  This class
-         * should never be created by anything but a HashTable, and should never
-         * be referenced directly.  Instead the hashtable returns a void pointer,
-         * which is what should be passed back in next time you use a search
-         * function.  Always finish a search, since the object is deleted at the
-         * end of the search.
-         *@author Mike Buland
-         */
-        class HashPos
-        {
-        public:
-                /** Create a blank HashPos. */
-                HashPos() { bStarted=false; nPos = 0; };
-                /** Has the search been started?  */
-                bool bStarted;
-                /** The position (index) into the backend storage structure. */
-                unsigned long int nPos;
-        };
-
-        /**
-         * All data related to a single element in the hashtable.  This should
-         * really only be used and manipulated by the HashTable itself.
-         *@author Mike Buland
-         */
-        typedef struct HashNode
-        {
-        public:
-                /** Create a new, empty HashNode. */
-                HashNode() { id = NULL; data = NULL; bDeleted = false; };
-                /** A pointer to the original ID that was used to key the data. */
-                const void *id;
-                /** A pointer to the data stored along with the above ID. */
-                const void *data;
-                /** Weather or not this data should really...exist */
-                bool bDeleted;
-        } HashNode;
-
-private:
-        /**
-         * Just sets the values in the element to some friendly values.
-         *@param newID The new ID to store.
-         *@param newData The new Data to store.
-         */
-        void set( int j, const void *newID, const void *newData );
-        /**
-         * Tells you if the node is filled or not.
-         *@returns True=an ID has been stored here, False=no ID.
-         */
-        bool isFilled( int j );
-        /**
-         * This actually resizes, but since every resize requires a reHash to go
-         * along with it, that's the name.  This actually creates a new buffer for
-         * all of the contained data and then pulls every old element that was in
-         * the old table out and performs the hashing placement calculations again.
-         * This function skips all data that was marked as deleted, so at this
-         * point it really will be.
-         *@param nNewSize The new size to set the table to while re-hashing.
-         *@returns True if the operation was successful, false otherwise.
-         */
-        void reHash( unsigned long int nNewSize );
-
-        /**
-         * Helper function to allocate a new table.  Really just does the memory
-         * allocation.
-         *@param nNewSize The size of the table to generate.
-         *@returns A new, blank array of HashNode objects the size you specified.
-         */
-        HashNode *newTable( unsigned long int nNewSize );
-
-        /**
-         * This function is used once an actual hash code is obtained.  nStart is
-         * the given hash code, which is then wrapped to the size of the table.  If
-         * there is data at that location, tests are performed to see if it's the
-         * right one.  If it is, then it is returned, otherwise a series of further
-         * tests based on a 2^n search pattern is performed.  The position of the
-         * requested data in the back-end storage is returned if found, otherwise
-         * another less useful value is returned...
-         *@param nStart The initial hashcode of the ID testing for.
-         *@param id A pointer to the id that is being searched for.
-         *@returns The real location of the data requested.
-         */
-        unsigned long int probe( unsigned long int nStart, const void *id );
-
-        /**
-         * Simple helper function to determine if a number is prime or not.
-         * This function runs in sqrt(n) time.
-         *@param num Number to test for prime-hood.
-         *@returns True if the number is prime, false otherwise.
-         */
-        bool isPrime( int num );
-
-        /**
-         * Given any number, this function finds the first number after it that is
-         * prime.  Since this number is a multiple internally it's rare that the
-         * starting number would be prime.
-         *@param base The number to start the prime search on.
-         *@returns The first prime after the number given.
-         */
-        int nextPrime( int base );
-        
-#ifdef HASH_DEBUG_VIS
-        void printDebugLine( const char *exData );
-#endif
-
-        /** A pointer to the HashFunction subclass instance to use. */
-        HashFunction *hFunc;
-        /** The complete array of HashNode objects to store data in. */
-        HashNode *aTable;
-        /** The actual size of the table, not how many elements are in it. */
-        unsigned long int nTableSize;
-        /** The number of elements that are in the table. */
-        unsigned long int nSize;
-        /** The number of elements that are unavailable now. */
-        unsigned long int nFilled;
-        /** Allow duplicate ID's in the table. */
-        bool bAllowDupes;
-};
-
-#endif
diff --git a/src/inprogress/xmldocument.cpp b/src/inprogress/xmldocument.cpp
new file mode 100644
index 0000000..cb21826
--- /dev/null
+++ b/src/inprogress/xmldocument.cpp
@@ -0,0 +1,9 @@
+#include "xmldocument.h"
+
+Bu::XmlDocument::XmlDocument()
+{
+}
+
+Bu::XmlDocument::~XmlDocument()
+{
+}
diff --git a/src/inprogress/xmldocument.h b/src/inprogress/xmldocument.h
new file mode 100644
index 0000000..e16e3ea
--- /dev/null
+++ b/src/inprogress/xmldocument.h
@@ -0,0 +1,22 @@
+#ifndef XML_DOCUMENT_H
+#define XML_DOCUMENT_H
+
+#include <stdint.h>
+
+namespace Bu
+{
+        /**
+         *
+         */
+        class XmlDocument
+        {
+        public:
+                XmlDocument();
+                virtual ~XmlDocument();
+
+        private:
+
+        };
+}
+
+#endif
diff --git a/src/inprogress/xmlnode.cpp b/src/inprogress/xmlnode.cpp
new file mode 100644
index 0000000..58ef5c5
--- /dev/null
+++ b/src/inprogress/xmlnode.cpp
@@ -0,0 +1,9 @@
+#include "xmlnode.h"
+
+Bu::XmlNode::XmlNode()
+{
+}
+
+Bu::XmlNode::~XmlNode()
+{
+}
diff --git a/src/inprogress/xmlnode.h b/src/inprogress/xmlnode.h
new file mode 100644
index 0000000..cd9961a
--- /dev/null
+++ b/src/inprogress/xmlnode.h
@@ -0,0 +1,22 @@
+#ifndef XML_NODE_H
+#define XML_NODE_H
+
+#include <stdint.h>
+
+namespace Bu
+{
+        /**
+         *
+         */
+        class XmlNode
+        {
+        public:
+                XmlNode();
+                virtual ~XmlNode();
+
+        private:
+
+        };
+}
+
+#endif
diff --git a/src/inprogress/xmlreader.cpp b/src/inprogress/xmlreader.cpp
new file mode 100644
index 0000000..bd241cf
--- /dev/null
+++ b/src/inprogress/xmlreader.cpp
@@ -0,0 +1,267 @@
+#include "xmlreader.h"
+
+Bu::XmlReader::XmlReader( Bu::Stream &sIn ) :
+        sIn( sIn )
+{
+}
+
+Bu::XmlReader::~XmlReader()
+{
+}
+
+const char *Bu::XmlReader::lookahead( int nAmnt )
+{
+        if( sBuf.getSize() >= nAmnt )
+                return sBuf.getStr();
+
+        int nNew = nAmnt - sBuf.getSize();
+        char *buf = new char[nNew];
+        sIn.read( buf, nNew );
+        sBuf.append( buf );
+
+        return sBuf.getStr();
+}
+
+void Bu::XmlReader::burn( int nAmnt )
+{
+        if( sBuf.getSize() < nAmnt )
+        {
+                lookahead( nAmnt );
+        }
+
+        //sBuf.remove( nAmnt );
+}
+
+void Bu::XmlReader::checkString( const char *str, int nLen )
+{
+        if( !strncmp( str, lookahead( nLen ), nLen ) )
+        {
+                burn( nLen );
+                return;
+        }
+
+        throw Bu::ExceptionBase("Expected string '%s'", str );
+}
+
+Bu::XmlNode *Bu::XmlReader::read()
+{
+        prolog();
+}
+
+void Bu::XmlReader::prolog()
+{
+        XMLDecl();
+        Misc();
+}
+
+void Bu::XmlReader::XMLDecl()
+{
+        checkString("<?xml", 5 );
+        S();
+        VersionInfo();
+        EncodingDecl();
+        SDDecl();
+        Sq();
+        checkString("?>", 2 );
+}
+
+void Bu::XmlReader::Misc()
+{
+        for(;;)
+        {
+                S();
+                if( !strncmp("<!--", lookahead( 4 ), 4 ) )
+                {
+                        Comment();
+                }
+                else if( !strncmp("<?", lookahead( 2 ), 2 ) )
+                {
+                        PI();
+                }
+                else
+                {
+                        return;
+                }
+        }
+}
+
+void Bu::XmlReader::Comment()
+{
+        checkString("<!--", 4 );
+        for(;;)
+        {
+                unsigned char c = *lookahead(1);
+                if( c == '-' )
+                {
+                        if( lookahead(2)[1] == '-' )
+                        {
+                                checkString("-->", 3 );
+                                return;
+                        }
+                }
+                burn( 1 );
+        }
+}
+
+void Bu::XmlReader::PI()
+{
+        checkString("<?", 2 );
+        FString sName = Name();
+        printf("PI: %s\n---\n", sName.getStr() );
+        S();
+        for(int j = 0;; j++ )
+        {
+                if( !strncmp( "?>", lookahead(j+2)+j, 2 ) )
+                {
+                        burn( j+2 );
+                        return;
+                }
+        }
+}
+
+void Bu::XmlReader::S()
+{
+        for( int j = 0;; j++ )
+        {
+                char c = *lookahead( 1 );
+                if( c == 0x20 || c == 0x9 || c == 0xD || c == 0xA )
+                        continue;
+                if( j == 0 )
+                        throw ExceptionBase("Expected whitespace.");
+                return;
+        }
+}
+
+void Bu::XmlReader::Sq()
+{
+        for(;;)
+        {
+                char c = *lookahead( 1 );
+                if( c == 0x20 || c == 0x9 || c == 0xD || c == 0xA )
+                        continue;
+                return;
+        }
+}
+
+void Bu::XmlReader::VersionInfo()
+{
+        try
+        {
+                S();
+                checkString("version", 7 );
+        }
+        catch( ExceptionBase &e )
+        {
+                return;
+        }
+        Eq();
+        Bu::FString ver = AttValue();
+        if( ver != "1.1" )
+                throw ExceptionBase("Currently we only support xml version 1.1\n");
+}
+
+void Bu::XmlReader::Eq()
+{
+        Sq();
+        checkString("=", 1 );
+        Sq();
+}
+
+void Bu::XmlReader::EncodingDecl()
+{
+        S();
+        try
+        {
+                checkString("encoding", 8 );
+        }
+        catch( ExceptionBase &e )
+        {
+                return;
+        }
+
+        Eq();
+        AttValue();
+}
+
+void Bu::XmlReader::SDDecl()
+{
+        S();
+        try
+        {
+                checkString("standalone", 10 );
+        }
+        catch( ExceptionBase &e )
+        {
+                return;
+        }
+
+        Eq();
+        AttValue();
+}
+
+Bu::FString Bu::XmlReader::AttValue()
+{
+        char q = *lookahead(1);
+        if( q == '\"' )
+        {
+                for( int j = 2;; j++ )
+                {
+                        if( lookahead(j)[j-1] == '\"' )
+                        {
+                                Bu::FString ret( lookahead(j)+1, j-2 );
+                                burn( j );
+                                return ret;
+                        }
+                }
+        }
+        else if( q == '\'' )
+        {
+                for( int j = 2;; j++ )
+                {
+                        if( lookahead(j)[j-1] == '\'' )
+                        {
+                                Bu::FString ret( lookahead(j)+1, j-2 );
+                                burn( j );
+                                return ret;
+                        }
+                }
+        }
+
+        throw ExceptionBase("Excpected either \' or \".\n");
+}
+
+Bu::FString Bu::XmlReader::Name()
+{
+        unsigned char c = *lookahead( 1 );
+        if( c != ':' && c != '_' &&
+                (c < 'A' || c > 'Z') &&
+                (c < 'a' || c > 'z') &&
+                (c < 0xC0 || c > 0xD6 ) &&
+                (c < 0xD8 || c > 0xF6 ) &&
+                (c < 0xF8))
+        {
+                throw ExceptionBase("Invalid entity name starting character.");
+        }
+
+        for( int j = 1;; j++ )
+        {
+                unsigned char c = lookahead(j+1)[j];
+                if( isS( c ) )
+                {
+                        FString ret( lookahead(j+1), j+1 );
+                        burn( j+1 );
+                        return ret;
+                }
+                if( c != ':' && c != '_' && c != '-' && c != '.' && c != 0xB7 &&
+                        (c < 'A' || c > 'Z') &&
+                        (c < 'a' || c > 'z') &&
+                        (c < '0' || c > '9') && 
+                        (c < 0xC0 || c > 0xD6 ) &&
+                        (c < 0xD8 || c > 0xF6 ) &&
+                        (c < 0xF8))
+                {
+                        throw ExceptionBase("Invalid character in name.");
+                }
+        }
+}
+
diff --git a/src/inprogress/xmlreader.h b/src/inprogress/xmlreader.h
new file mode 100644
index 0000000..708a386
--- /dev/null
+++ b/src/inprogress/xmlreader.h
@@ -0,0 +1,121 @@
+#ifndef XML_READER_H
+#define XML_READER_H
+
+#include <stdint.h>
+#include "bu/stream.h"
+#include "bu/fstring.h"
+#include "bu/xmlnode.h"
+
+namespace Bu
+{
+        /**
+         * An Xml 1.1 reader.  I've decided to write this, this time, based on the
+         * official W3C reccomendation, now included with the source code.  I've
+         * named the productions in the parser states the same as in that document,
+         * which may make them easier to find, etc, although possibly slightly less
+         * optimized than writing my own reduced grammer.
+         *
+         * Below I will list differences between my parser and the official standard
+         * as I come up with them.
+         *  - Encoding and Standalone headings are ignored for the moment. (4.3.3,
+         *    2.9)
+         *  - The standalone heading attribute can have any standard whitespace
+         *    before it (the specs say only spaces, no newlines). (2.9)
+         *  - Since standalone is ignored, it is currently allowed to have any
+         *    value (should be restricted to "yes" or "no"). (2.9)
+         *  - Currently only UTF-8 / ascii are parsed.
+         *  - [optional] The content of comments is thrown away. (2.5)
+         *  - The content of processing instruction blocks is parsed properly, but
+         *    thrown away. (2.6)
+         */
+        class XmlReader
+        {
+        public:
+                XmlReader( Bu::Stream &sIn );
+                virtual ~XmlReader();
+
+                XmlNode *read();
+
+        private:
+                Bu::Stream &sIn;
+                Bu::FString sBuf;
+
+        private: // Helpers
+                const char *lookahead( int nAmnt );
+                void burn( int nAmnt );
+                void checkString( const char *str, int nLen );
+
+        private: // States
+                /**
+                 * The headers, etc.
+                 */
+                void prolog();
+
+                /**
+                 * The xml decleration (version, encoding, etc).
+                 */
+                void XMLDecl();
+
+                /**
+                 * Misc things, Includes Comments and PIData (Processing Instructions).
+                 */
+                void Misc();
+
+                /**
+                 * Comments
+                 */
+                void Comment();
+
+                /**
+                 * Processing Instructions
+                 */
+                void PI();
+
+                /**
+                 * Whitespace eater.
+                 */
+                void S();
+
+                /**
+                 * Optional whitespace eater.
+                 */
+                void Sq();
+
+                /**
+                 * XML Version spec
+                 */
+                void VersionInfo();
+
+                /**
+                 * Your basic equals sign with surrounding whitespace.
+                 */
+                void Eq();
+
+                /**
+                 * Read in an attribute value.
+                 */
+                FString AttValue();
+
+                /**
+                 * Read in the name of something.
+                 */
+                FString Name();
+
+                /**
+                 * Encoding decleration in the header
+                 */
+                void EncodingDecl();
+
+                /**
+                 * Standalone decleration in the header
+                 */
+                void SDDecl();
+
+                bool isS( unsigned char c )
+                {
+                        return ( c == 0x20 || c == 0x9 || c == 0xD || c == 0xA );
+                }
+        };
+}
+
+#endif
diff --git a/src/inprogress/xmlwriter.cpp b/src/inprogress/xmlwriter.cpp
new file mode 100644
index 0000000..23a5175
--- /dev/null
+++ b/src/inprogress/xmlwriter.cpp
@@ -0,0 +1,9 @@
+#include "xmlwriter.h"
+
+Bu::XmlWriter::XmlWriter()
+{
+}
+
+Bu::XmlWriter::~XmlWriter()
+{
+}
diff --git a/src/inprogress/xmlwriter.h b/src/inprogress/xmlwriter.h
new file mode 100644
index 0000000..796d6fb
--- /dev/null
+++ b/src/inprogress/xmlwriter.h
@@ -0,0 +1,22 @@
+#ifndef XML_WRITER_H
+#define XML_WRITER_H
+
+#include <stdint.h>
+
+namespace Bu
+{
+        /**
+         *
+         */
+        class XmlWriter
+        {
+        public:
+                XmlWriter();
+                virtual ~XmlWriter();
+
+        private:
+
+        };
+}
+
+#endif
diff --git a/src/ito.cpp b/src/ito.cpp
new file mode 100644
index 0000000..001ca06
--- /dev/null
+++ b/src/ito.cpp
@@ -0,0 +1,40 @@
+#include "ito.h"
+
+Bu::Ito::Ito()
+{
+}
+
+Bu::Ito::~Ito()
+{
+}
+
+bool Bu::Ito::start()
+{
+        nHandle = pthread_create( &ptHandle, NULL, threadRunner, this );
+
+        return true;
+}
+
+bool Bu::Ito::stop()
+{
+        pthread_exit( &ptHandle );
+
+        return true;
+}
+
+void *Bu::Ito::threadRunner( void *pThread )
+{
+        return ((Ito *)pThread)->run();
+}
+
+bool Bu::Ito::join()
+{
+        pthread_join( ptHandle, NULL );
+        return true;
+}
+
+void Bu::Ito::yield()
+{
+        pthread_yield();
+}
+
diff --git a/src/ito.h b/src/ito.h
new file mode 100644
index 0000000..c062052
--- /dev/null
+++ b/src/ito.h
@@ -0,0 +1,98 @@
+#ifndef BU_ITO_H
+#define BU_ITO_H
+
+#include <pthread.h>
+
+namespace Bu
+{
+        /**
+         * Simple thread class.  This wraps the basic pthread (posix threads) system in
+         * an object oriented sort of way.  It allows you to create a class with
+         * standard member variables and callable functions that can be run in it's own
+         * thread, one per class instance.
+         *@author Mike Buland
+         */
+        class Ito
+        {
+        public:
+                /**
+                 * Construct an Ito thread.
+                 */
+                Ito();
+
+                /**
+                 * Destroy an Ito thread.
+                 */
+                virtual ~Ito();
+
+                /**
+                 * Begin thread execution.  This will call the overridden run function,
+                 * which will simply execute in it's own thread until the function exits,
+                 * the thread is killed, or the thread is cancelled (optionally).  The
+                 * thread started in this manner has access to all of it's class variables,
+                 * but be sure to protect possible multiple-access with ItoMutex objects.
+                 *@returns True if starting the thread was successful.  False if something
+                 * went wrong and the thread has not started.
+                 */
+                bool start();
+
+                /**
+                 * Forcibly kill a thread.  This is not generally considered a good thing to
+                 * do, but in those rare cases you need it, it's invaluable.  The problem
+                 * with stopping (or killing) a thread is that it stops it the moment you
+                 * call stop, no matter what it's doing.  The object oriented approach to
+                 * this will help clean up any class variables that were used, but anything
+                 * not managed as a member variable will probably create a memory leak type
+                 * of situation.  Instead of stop, consider using cancel, which can be
+                 * handled by the running thread in a graceful manner.
+                 *@returns True if the thread was stopped, false otherwise.  When this
+                 * function returns the thread may not have stopped, to ensure that the
+                 * thread has really stopped, call join.
+                 */
+                bool stop();
+
+                /**
+                 * The workhorse of the Ito class.  This is the function that will run in
+                 * the thread, when this function exits the thread dies and is cleaned up
+                 * by the system.  Make sure to read up on ItoMutex, ItoCondition, and
+                 * cancel to see how to control and protect everything you do in a safe way
+                 * within this function.
+                 *@returns I'm not sure right now, but this is the posix standard form.
+                 */
+                virtual void *run()=0;
+
+                /**
+                 * Join the thread in action.  This function performs what is commonly
+                 * called a thread join.  That is that it effectively makes the calling
+                 * thread an the Ito thread contained in the called object one in the same,
+                 * and pauses the calling thread until the called thread exits.  That is,
+                 * when called from, say, your main(), mythread.join() will not return until
+                 * the thread mythread has exited.  This is very handy at the end of
+                 * programs to ensure all of your data was cleaned up.
+                 *@returns True if the thread was joined, false if the thread couldn't be
+                 * joined, usually because it isn't running to begin with.
+                 */
+                bool join();
+
+        private:
+                pthread_t ptHandle;     /**< Internal handle to the posix thread. */
+                int nHandle;    /**< Numeric handle to the posix thread. */
+
+        protected:
+                /**
+                 * This is the hidden-heard of the thread system.  While run is what the
+                 * user gets to override, and everything said about it is true, this is
+                 * the function that actually makes up the thread, it simply calls the
+                 * run member function in an OO-friendly way.  This is what allows us to
+                 * use member variables from within the thread itself.
+                 *@param Should always be this.
+                 *@returns This is specified by posix, I'm not sure yet.
+                 */
+                static void *threadRunner( void *pThread );
+
+                void yield();
+                
+        };
+}
+
+#endif
diff --git a/src/itoatom.h b/src/itoatom.h
new file mode 100644
index 0000000..7fc9090
--- /dev/null
+++ b/src/itoatom.h
@@ -0,0 +1,56 @@
+#ifndef BU_ITO_QUEUE_H
+#define BU_ITO_QUEUE_H
+
+#include <pthread.h>
+
+#include "itomutex.h"
+#include "itocondition.h"
+
+/**
+ * A thread-safe wrapper class.
+ *@author Mike Buland
+ */
+template <class T>
+class ItoAtom
+{
+public:
+        /**
+         * Construct an empty queue.
+         */
+        ItoAtom()
+        {
+        }
+
+        ItoAtom( const T &src ) :
+                data( src )
+        {
+        }
+        
+        ~ItoQueue()
+        {
+        }
+
+        T get()
+        {
+                mOperate.lock();
+                mOperate.unlock();
+                return data;
+        }
+
+        void set( const T &val )
+        {
+                mOperate.lock();
+                data = val;
+                cBlock.signal();
+                mOperate.unlock();
+        }
+
+private:
+        Item *pStart;   /**< The start of the queue, the next element to dequeue. */
+        Item *pEnd;             /**< The end of the queue, the last element to dequeue. */
+
+        ItoMutex mOperate;      /**< The master mutex, used on all operations. */
+        ItoCondition cBlock;    /**< The condition for blocking dequeues. */
+};
+
+#endif
diff --git a/src/itocondition.cpp b/src/itocondition.cpp
new file mode 100644
index 0000000..d8f5375
--- /dev/null
+++ b/src/itocondition.cpp
@@ -0,0 +1,42 @@
+#include <sys/time.h>
+
+#include "itocondition.h"
+
+Bu::ItoCondition::ItoCondition()
+{
+        pthread_cond_init( &cond, NULL );
+}
+
+Bu::ItoCondition::~ItoCondition()
+{
+        pthread_cond_destroy( &cond );
+}
+
+int Bu::ItoCondition::wait()
+{
+        return pthread_cond_wait( &cond, &mutex );
+}
+
+int Bu::ItoCondition::wait( int nSec, int nUSec )
+{
+        struct timeval now;
+        struct timespec timeout;
+        struct timezone tz;
+        
+        gettimeofday( &now, &tz );
+        timeout.tv_sec = now.tv_sec + nSec + ((now.tv_usec + nUSec)/1000000);
+        timeout.tv_nsec = ((now.tv_usec + nUSec)%1000000)*1000;
+
+        return pthread_cond_timedwait( &cond, &mutex, &timeout );
+}
+
+int Bu::ItoCondition::signal()
+{
+        return pthread_cond_signal( &cond );
+}
+
+int Bu::ItoCondition::broadcast()
+{
+        return pthread_cond_broadcast( &cond );
+}
+
diff --git a/src/itocondition.h b/src/itocondition.h
new file mode 100644
index 0000000..1793f81
--- /dev/null
+++ b/src/itocondition.h
@@ -0,0 +1,81 @@
+#ifndef BU_ITO_CONDITION_H
+#define BU_ITO_CONDITION_H
+
+#include <pthread.h>
+
+#include "itomutex.h"
+
+namespace Bu
+{
+        /**
+         * Ito condition.  This is a fairly simple condition mechanism.  As you may
+         * notice this class inherits from the ItoMutex class, this is because all
+         * conditions must be within a locked block.  The standard usage of a condition
+         * is to pause one thread, perhaps indefinately, until another thread signals
+         * that it is alright to procede.
+         * <br>
+         * Standard usage for the thread that wants to wait is as follows:
+         * <pre>
+         * ItoCondition cond;
+         * ... // Perform setup and enter your run loop
+         * cond.lock();
+         * while( !isFinished() ) // Could be anything you're waiting for
+         *     cond.wait();
+         * ...  // Take care of what you have to.
+         * cond.unlock();
+         * </pre>
+         * The usage for the triggering thread is much simpler, when it needs to tell
+         * the others that it's time to grab some data it calls either signal or
+         * broadcast.  See both of those functions for the difference.
+         *@author Mike Buland
+         */
+        class ItoCondition : public ItoMutex
+        {
+        public:
+                /**
+                 * Create a condition.
+                 */
+                ItoCondition();
+
+                /**
+                 * Destroy a condition.
+                 */
+                ~ItoCondition();
+
+                /**
+                 * Wait forever, or until signalled.  This has to be called from within a
+                 * locked section, i.e. before calling this this object's lock function
+                 * should be called.
+                 */
+                int wait();
+
+                /**
+                 * Wait for a maximum of nSec seconds and nUSec micro-seconds or until
+                 * signalled.  This is a little more friendly function if you want to
+                 * perform other operations in the thrad loop that calls this function.
+                 * Like the other wait function, this must be inside a locked section.
+                 *@param nSec The seconds to wait.
+                 *@param nUSec the micro-seconds to wait.
+                 */
+                int wait( int nSec, int nUSec );
+
+                /**
+                 * Notify the next thread waiting on this condition that they can go ahead.
+                 * This only signals one thread, the next one in the condition queue, that
+                 * it is safe to procede with whatever operation was being waited on.
+                 */
+                int signal();
+
+                /**
+                 * Notify all threads waiting on this condition that they can go ahead now.
+                 * This function is slower than signal, but more effective in certain
+                 * situations where you may not know how many threads should be activated.
+                 */
+                int broadcast();
+
+        private:
+                pthread_cond_t cond;    /**< Internal condition reference. */
+        };
+}
+
+#endif
diff --git a/src/itomutex.cpp b/src/itomutex.cpp
new file mode 100644
index 0000000..dc51af9
--- /dev/null
+++ b/src/itomutex.cpp
@@ -0,0 +1,27 @@
+#include "itomutex.h"
+
+Bu::ItoMutex::ItoMutex()
+{
+        pthread_mutex_init( &mutex, NULL );
+}
+
+Bu::ItoMutex::~ItoMutex()
+{
+        pthread_mutex_destroy( &mutex );
+}
+
+int Bu::ItoMutex::lock()
+{
+        return pthread_mutex_lock( &mutex );
+}
+
+int Bu::ItoMutex::unlock()
+{
+        return pthread_mutex_unlock( &mutex );
+}
+
+int Bu::ItoMutex::trylock()
+{
+        return pthread_mutex_trylock( &mutex );
+}
+
diff --git a/src/itomutex.h b/src/itomutex.h
new file mode 100644
index 0000000..9c9d205
--- /dev/null
+++ b/src/itomutex.h
@@ -0,0 +1,61 @@
+#ifndef BU_ITO_MUTEX_H
+#define BU_ITO_MUTEX_H
+
+#include <pthread.h>
+
+namespace Bu
+{
+        /**
+         * Simple mutex wrapper.  Currently this doesn't do anything extra for you
+         * except keep all of the functionality together in an OO sorta' way and keep
+         * you from having to worry about cleaning up your mutexes properly, or initing
+         * them.
+         *@author Mike Buland
+         */
+        class ItoMutex
+        {
+        public:
+                /**
+                 * Create an unlocked mutex.
+                 */
+                ItoMutex();
+                
+                /**
+                 * Destroy a mutex.  This can only be done when a mutex is unlocked.
+                 * Failure to unlock before destroying a mutex object could cause it to
+                 * wait for the mutex to unlock, the odds of which are usually farily low
+                 * at deconstruction time.
+                 */
+                ~ItoMutex();
+
+                /**
+                 * Lock the mutex.  This causes all future calls to lock on this instance
+                 * of mutex to block until the first thread that called mutex unlocks it.
+                 * At that point the next thread that called lock will get a chance to go
+                 * to work.  Because of the nature of a mutex lock it is a very bad idea to
+                 * do any kind of serious or rather time consuming computation within a
+                 * locked section.  This can cause thread-deadlock and your program may
+                 * hang.
+                 */
+                int lock();
+
+                /**
+                 * Unlock the mutex.  This allows the next thread that asked for a lock to
+                 * lock the mutex and continue with execution.
+                 */
+                int unlock();
+
+                /**
+                 * Try to lock the mutex.  This is the option to go with if you cannot avoid
+                 * putting lengthy operations within a locked section.  trylock will attempt
+                 * to lock the mutex, if the mutex is already locked this function returns
+                 * immediately with an error code.
+                 */
+                int trylock();
+
+        protected:
+                pthread_mutex_t mutex;  /**< The internal mutex reference. */
+        };
+}
+
+#endif
diff --git a/src/itoqueue.h b/src/itoqueue.h
new file mode 100644
index 0000000..75a2f27
--- /dev/null
+++ b/src/itoqueue.h
@@ -0,0 +1,231 @@
+#ifndef BU_ITO_QUEUE_H
+#define BU_ITO_QUEUE_H
+
+#include <pthread.h>
+
+#include "itomutex.h"
+#include "itocondition.h"
+
+namespace Bu
+{
+        /**
+         * A thread-safe queue class.  This class is a very simple queue with some cool
+         * extra functionality for use with the Ito system.  The main extra that it
+         * provides is the option to either dequeue without blocking, with infinite
+         * blocking, or with timed blocking, which will return a value if something is
+         * enqueued within the specified time limit, or NULL if the time limit is
+         * exceded.
+         *@author Mike Buland
+         */
+        template <class T>
+        class ItoQueue
+        {
+        private:
+                /**
+                 * Helper struct.  Keeps track of linked-list items for the queue data.
+                 */
+                typedef struct Item
+                {
+                        T pData;
+                        Item *pNext;
+                } Item;
+
+        public:
+                /**
+                 * Construct an empty queue.
+                 */
+                ItoQueue() :
+                        pStart( NULL ),
+                        pEnd( NULL ),
+                        nSize( 0 )
+                {
+                }
+                
+                /**
+                 * Destroy the queue.  This function will simply free all contained
+                 * structures.  If you stored pointers in the queue, this will lose the
+                 * pointers without cleaning up the memory they pointed to.  Make sure
+                 * you're queue is empty before allowing it to be destroyed!
+                 */
+                ~ItoQueue()
+                {
+                        Item *pCur = pStart;
+                        while( pCur )
+                        {
+                                Item *pTmp = pCur->pNext;
+                                delete pCur;
+                                pCur = pTmp;
+                        }
+                }
+
+                /**
+                 * Enqueue a pieces of data.  The new data will go at the end of the queue,
+                 * and unless another piece of data is enqueued, will be the last piece of
+                 * data to be dequeued.
+                 *@param pData The data to enqueue.  If this is not a primitive data type
+                 * it's probably best to use a pointer type.
+                 */
+                void enqueue( T pData )
+                {
+                        mOperate.lock();
+
+                        if( pStart == NULL )
+                        {
+                                pStart = pEnd = new Item;
+                                pStart->pData = pData;
+                                pStart->pNext = NULL;
+                                nSize++;
+                        }
+                        else
+                        {
+                                pEnd->pNext = new Item;
+                                pEnd = pEnd->pNext;
+                                pEnd->pData = pData;
+                                pEnd->pNext = NULL;
+                                nSize++;
+                        }
+
+                        cBlock.signal();
+                
+                        mOperate.unlock();
+                }
+
+                /**
+                 * Dequeue the first item from the queue.  This function can operate in two
+                 * different modes, blocking and non-blocking.  In non-blocking mode it will
+                 * return immediately weather there was data in the queue or not.  If there
+                 * was data it will remove it from the queue and return it to the caller.
+                 * In blocking mode it will block forever wating for data to be enqueued.
+                 * When data finally is enqueued this function will return immediately with
+                 * the new data.  The only way this function should ever return a null in
+                 * blocking mode is if the calling thread was cancelled.  It's probably a
+                 * good idea to check for NULL return values even if you use blocking, just
+                 * to be on the safe side.
+                 *@param bBlock Set to true to enable blocking, leave as false to work in
+                 * non-blocking mode.
+                 *@returns The next piece of data in the queue, or NULL if no data was in
+                 * the queue.
+                 */
+                T dequeue( bool bBlock=false )
+                {
+                        mOperate.lock();
+                        if( pStart == NULL )
+                        {
+                                mOperate.unlock();
+
+                                if( bBlock )
+                                {
+                                        cBlock.lock();
+
+                                        while( pStart == NULL )
+                                                cBlock.wait();
+                                
+                                        T tmp = dequeue( false );
+                                        
+                                        cBlock.unlock();
+                                        return tmp;
+
+                                }
+
+                                return NULL;
+                        }
+                        else
+                        {
+                                T pTmp = pStart->pData;
+                                Item *pDel = pStart;
+                                pStart = pStart->pNext;
+                                delete pDel;
+                                nSize--;
+                        
+                                mOperate.unlock();
+                                return pTmp;
+                        }
+                }
+
+                /**
+                 * Operates just like the other dequeue function in blocking mode with one
+                 * twist.  This function will block for at most nSec seconds and nUSec
+                 * micro-seconds.  If the timer is up and no data is available, this will
+                 * just return NULL.  If data is enqueued before the timeout expires, it
+                 * will dequeue and exit immediately.
+                 *@param nSec The number of seconds to wait, max.
+                 *@param nUSec The number of micro-seconds to wait, max.
+                 *@returns The next piece of data in the queue, or NULL if the timeout was
+                 * exceeded.
+                 */
+                T dequeue( int nSec, int nUSec )
+                {
+                        mOperate.lock();
+                        if( pStart == NULL )
+                        {
+                                mOperate.unlock();
+
+                                cBlock.lock();
+                                
+                                cBlock.wait( nSec, nUSec );
+
+                                if( pStart == NULL )
+                                {
+                                        cBlock.unlock();
+                                        return NULL;
+                                }
+                        
+                                mOperate.lock();
+                                T pTmp = pStart->pData;
+                                Item *pDel = pStart;
+                                pStart = pStart->pNext;
+                                delete pDel;
+                                nSize--;
+                                mOperate.unlock();
+                                        
+                                cBlock.unlock();
+                                return pTmp;
+                        }
+                        else
+                        {
+                                T pTmp = pStart->pData;
+                                Item *pDel = pStart;
+                                pStart = pStart->pNext;
+                                delete pDel;
+                                nSize--;
+                        
+                                mOperate.unlock();
+                                return pTmp;
+                        }
+                }
+
+                /**
+                 * Checks to see if the queue has data in it or not.  Note that there is no
+                 * function to determine the length of the queue.  This data isn't kept
+                 * track of.  If you really need to know, fix this.
+                 *@returns True if the queue is empty, false if it has data in it.
+                 */
+                bool isEmpty()
+                {
+                        mOperate.lock();
+                        bool bEmpty = (pStart == NULL );
+                        mOperate.unlock();
+
+                        return bEmpty;
+                }
+
+                long getSize()
+                {
+                        mOperate.lock();
+                        long nRet = nSize;
+                        mOperate.unlock();
+
+                        return nRet;
+                }
+
+        private:
+                Item *pStart;   /**< The start of the queue, the next element to dequeue. */
+                Item *pEnd;             /**< The end of the queue, the last element to dequeue. */
+                long nSize;             /**< The number of items in the queue. */
+
+                ItoMutex mOperate;      /**< The master mutex, used on all operations. */
+                ItoCondition cBlock;    /**< The condition for blocking dequeues. */
+        };
+}
+
+#endif
diff --git a/src/linkmessage.cpp b/src/linkmessage.cpp
index cf3df42..abe113c 100644
--- a/src/linkmessage.cpp
+++ b/src/linkmessage.cpp
@@ -1,12 +1,11 @@
-#include "linkmessage.h"
-#include <string.h>
+#include "bu/linkmessage.h"
 
-LinkMessage::LinkMessage( int nNewMsg )
+Bu::LinkMessage::LinkMessage( int nNewMsg )
 {
         nMsg = nNewMsg;
 }
 
-LinkMessage::~LinkMessage()
+Bu::LinkMessage::~LinkMessage()
 {
 }
 
diff --git a/src/linkmessage.h b/src/linkmessage.h
index 6cdfb2f..baa22a6 100644
--- a/src/linkmessage.h
+++ b/src/linkmessage.h
@@ -1,39 +1,42 @@
 /**\file linkmessage.h
  */
 
-#ifndef LINKMESSAGE_H
-#define LINKMESSAGE_H
+#ifndef BU_LINKMESSAGE_H
+#define BU_LINKMESSAGE_H
 
-/**
- * A message to be broadcast accross ProgramLinks in a ProgramChain.  Generally
- * one would make a subclass of this in order to transmit more useful
- * information, but sometimes it isn't necesarry.
- *@author Mike Buland
- */
-class LinkMessage
+namespace Bu
 {
-public:
         /**
-         * Construct a blank LinkMessage.
+         * A message to be broadcast accross ProgramLinks in a ProgramChain.  Generally
+         * one would make a subclass of this in order to transmit more useful
+         * information, but sometimes it isn't necesarry.
+         *@author Mike Buland
          */
-        LinkMessage() {};
+        class LinkMessage
+        {
+        public:
+                /**
+                 * Construct a blank LinkMessage.
+                 */
+                LinkMessage() {};
 
-        /**
-         * Deconstruct a LinkMessage.
-         */
-        virtual ~LinkMessage();
-        
-        /**
-         * Create a LinkMessage object with a specific message assosiated with it
-         * to start with.
-         *@param nNewMsg The message to use in the Message object.
-         */
-        LinkMessage( int nNewMsg );
+                /**
+                 * Deconstruct a LinkMessage.
+                 */
+                virtual ~LinkMessage();
+                
+                /**
+                 * Create a LinkMessage object with a specific message assosiated with it
+                 * to start with.
+                 *@param nNewMsg The message to use in the Message object.
+                 */
+                LinkMessage( int nNewMsg );
 
-        /**
-         * The message contained in the Message object.
-         */
-        int nMsg;
-};
+                /**
+                 * The message contained in the Message object.
+                 */
+                int nMsg;
+        };
+}
 
 #endif
diff --git a/src/list.cpp b/src/list.cpp
index 18f1a66..abe92ad 100644
--- a/src/list.cpp
+++ b/src/list.cpp
@@ -1,10 +1,2 @@
-#include "list.h"
-
-List::List(  )
-{
-}
-
-List::~List(  )
-{
-}
+#include "bu/list.h"
 
diff --git a/src/list.h b/src/list.h
index c71b328..e05ebbc 100644
--- a/src/list.h
+++ b/src/list.h
@@ -1,101 +1,489 @@
-#ifndef LIST_H
-#define LIST_H
+#ifndef BU_LIST_H
+#define BU_LIST_H
 
+#include <memory>
+#include "bu/exceptionbase.h"
 
-/** The basic List class ADT.  This, on it's own, does absolutely nothing, but
-  * does define all standard interface functions to access a list.
-  *@author Mike Buland
-  */
-class List
+namespace Bu
 {
-public:
-        /**
-         * Construct a list.
-         */
-        List();
+        template<typename value>
+        struct ListLink
+        {
+                value *pValue;
+                ListLink *pNext;
+                ListLink *pPrev;
+        };
 
         /**
-         * Desconstruct a list.
+         * Linked list template container.  This class is similar to the stl list
+         * class except for a few minor changes.  First, it doesn't mimic a stack or
+         * queue, use the Stack or Queue clasess for that.  Second, when const, all
+         * members are only accessable const.  Third, erasing a location does not
+         * invalidate the iterator, it simply points to the next valid location, or
+         * end() if there are no more.
+         *
+         *@param value (typename) The type of data to store in your list
+         *@param valuealloc (typename) Memory Allocator for your value type
+         *@param linkalloc (typename) Memory Allocator for the list links.
          */
-        virtual ~List();
-
-        /** Gets the value at a specified index.
-          *@param nIndex The index of the item to return.
-          *@returns The specified item, or NULL if the index was beyond the range
-          * of the list.
-          *@author Mike Buland
-          */
-        virtual void *getAt( int nIndex ) = 0;
-
-        /** Append the given data to the end of the list.  This increases the
-          * size of the list by one.
-          *@param pData The data to append to the list.
-          *@author Mike Buland
-          */
-        virtual void append( void *pData ) = 0;
-
-        /** Inserts an item at the specified position in the list.  The
-          * new item takes the index that you specify, and all other items
-          * are moved up one position.  The size of the list is increased by
-          * one.
-          *@param pData The value to insert into the list.
-          *@param nPos Where to insert the data into the list.
-          *@author Mike Buland
-          */
-        virtual void insertBefore( void *pData, int nPos = 0 ) = 0;
-
-        /** Determines the size of the list, in elements.
-          *@returns The size of the list.
-          *@author Mike Buland
-          */
-        virtual int getSize(  ) = 0;
-
-        /** Determines if the list is empty or not.
-          *@returns True if the list is empty, or false if the list has
-          * data in it (if the size is greater than zero).
-          *@author Mike Buland
-          */
-        virtual bool isEmpty(  ) = 0;
-
-        /** Deletes an item at the specified index and moves all other
-          * values down one index.  The size of the list is decreased by one.
-          *@param nIndex The index of the item to delete.
-          *@author Mike Buland
-          */
-        virtual void deleteAt( int nIndex ) = 0;
-
-        /** Completely empties the list, and sets the effective size to
-          * zero.
-          *@author Mike Buland
-          */
-        virtual void empty() = 0;
-
-        /** Sets the size of the list.  This can be larger or smaller
-          * than what it was previously.  If larger, new blank items will
-          * be added to the end of the list.  If smaller than the old list
-          * items will be deleted from the end.
-          *@param nNewSize The new size of the list.
-          *@author Mike Buland
-          */
-        virtual void setSize( int nNewSize ) = 0;
-
-        /** Sets a member at a specified location to a new value.
-          * If the member being set is outside of the range of the
-          * current list it should be expanded.
-          *@param nIndex The zero-based index of the item to change.
-          *@param pData The new value for that index.
-          *@author Mike Buland
-          */
-        virtual void setAt( int nIndex, void *pData ) = 0;
-
-        /** Makes the List work like an array.  Just say listObj[2] to get
-          * the third element.
-          *@param nIndex The index to access in the list.
-          *@returns A pointer to the data at element index.
-          *@author Mike Buland
-          */
-        void *operator[]( int nIndex ) { return getAt( nIndex ); };
-};
+        template<typename value, typename valuealloc=std::allocator<value>, typename linkalloc=std::allocator<struct ListLink<value> > >
+        class List
+        {
+        private:
+                typedef struct ListLink<value> Link;
+                typedef class List<value, valuealloc, linkalloc> MyType;
 
-#endif
+        public:
+                List() :
+                        pFirst( NULL ),
+                        pLast( NULL ),
+                        nSize( 0 )
+                {
+                }
+
+                List( const MyType &src ) :
+                        pFirst( NULL ),
+                        pLast( NULL ),
+                        nSize( 0 )
+                {
+                        for( Link *pCur = src.pFirst; pCur; pCur = pCur->pNext )
+                        {
+                                append( *pCur->pValue );
+                        }
+                }
+
+                ~List()
+                {
+                        clear();
+                }
+
+                /**
+                 * Assignment operator.
+                 *@param src (const MyType &) The list to assign to your list.
+                 */
+                MyType &operator=( const MyType &src )
+                {
+                        clear();
+                        for( Link *pCur = src.pFirst; pCur; pCur = pCur->pNext )
+                        {
+                                append( *pCur->pValue );
+                        }
+                }
+
+                /**
+                 * Clear the data from the list.
+                 */
+                void clear()
+                {
+                        Link *pCur = pFirst;
+                        for(;;)
+                        {
+                                if( pCur == NULL ) break;
+                                va.destroy( pCur->pValue );
+                                va.deallocate( pCur->pValue, 1 );
+                                Link *pTmp = pCur->pNext;
+                                la.destroy( pCur );
+                                la.deallocate( pCur, 1 );
+                                pCur = pTmp;
+                        }
+                        pFirst = pLast = NULL;
+                        nSize = 0;
+                }
+
+                /**
+                 * Append a value to the list.
+                 *@param v (const value_type &) The value to append.
+                 */
+                void append( const value &v )
+                {
+                        Link *pNew = la.allocate( 1 );
+                        pNew->pValue = va.allocate( 1 );
+                        va.construct( pNew->pValue, v );
+                        nSize++;
+                        if( pFirst == NULL )
+                        {
+                                // Empty list
+                                pFirst = pLast = pNew;
+                                pNew->pNext = pNew->pPrev = NULL;
+                        }
+                        else
+                        {
+                                pNew->pNext = NULL;
+                                pNew->pPrev = pLast;
+                                pLast->pNext = pNew;
+                                pLast = pNew;
+                        }
+                }
+
+                /**
+                 * Prepend a value to the list.
+                 *@param v (const value_type &) The value to prepend.
+                 */
+                void prepend( const value &v )
+                {
+                        Link *pNew = la.allocate( 1 );
+                        pNew->pValue = va.allocate( 1 );
+                        va.construct( pNew->pValue, v );
+                        nSize++;
+                        if( pFirst == NULL )
+                        {
+                                // Empty list
+                                pFirst = pLast = pNew;
+                                pNew->pNext = pNew->pPrev = NULL;
+                        }
+                        else
+                        {
+                                pNew->pNext = pFirst;
+                                pNew->pPrev = NULL;
+                                pFirst->pPrev = pNew;
+                                pFirst = pNew;
+                        }
+                }
+
+                /**
+                 * An iterator to iterate through your list.
+                 */
+                typedef struct iterator
+                {
+                        friend class List<value, valuealloc, linkalloc>;
+                private:
+                        Link *pLink;
+                        iterator() :
+                                pLink( NULL )
+                        {
+                        }
+
+                        iterator( Link *pLink ) :
+                                pLink( pLink )
+                        {
+                        }
+
+                public:
+                        /**
+                         * Equals comparison operator.
+                         *@param oth (const iterator &) The iterator to compare to.
+                         *@returns (bool) Are they equal?
+                         */
+                        bool operator==( const iterator &oth ) const
+                        {
+                                return ( pLink == oth.pLink );
+                        }
+
+                        /**
+                         * Equals comparison operator.
+                         *@param pOth (const Link *) The link to compare to.
+                         *@returns (bool) Are they equal?
+                         */
+                        bool operator==( const Link *pOth ) const
+                        {
+                                return ( pLink == pOth );
+                        }
+
+                        /**
+                         * Not equals comparison operator.
+                         *@param oth (const iterator &) The iterator to compare to.
+                         *@returns (bool) Are they not equal?
+                         */
+                        bool operator!=( const iterator &oth ) const
+                        {
+                                return ( pLink != oth.pLink );
+                        }
+
+                        /**
+                         * Not equals comparison operator.
+                         *@param pOth (const Link *) The link to compare to.
+                         *@returns (bool) Are they not equal?
+                         */
+                        bool operator!=( const Link *pOth ) const
+                        {
+                                return ( pLink != pOth );
+                        }
+
+                        /**
+                         * Dereference operator.
+                         *@returns (value_type &) The value.
+                         */
+                        value &operator*()
+                        {
+                                return *(pLink->pValue);
+                        }
+
+                        /**
+                         * Pointer access operator.
+                         *@returns (value_type *) A pointer to the value.
+                         */
+                        value *operator->()
+                        {
+                                return pLink->pValue;
+                        }
+
+                        /**
+                         * Increment operator.
+                         */
+                        iterator &operator++()
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pNext;
+                                return *this;
+                        }
+
+                        /**
+                         * Decrement operator.
+                         */
+                        iterator &operator--()
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pPrev;
+                                return *this;
+                        }
+                        
+                        /**
+                         * Increment operator.
+                         */
+                        iterator &operator++( int )
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pNext;
+                                return *this;
+                        }
+
+                        /**
+                         * Decrement operator.
+                         */
+                        iterator &operator--( int )
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pPrev;
+                                return *this;
+                        }
+
+                        /**
+                         * Assignment operator.
+                         *@param oth (const iterator &) The other iterator to set this
+                         *              one to.
+                         */
+                        iterator &operator=( const iterator &oth )
+                        {
+                                pLink = oth.pLink;
+                                return *this;
+                        }
+                };
+                
+                /**
+                 *@see iterator
+                 */
+                typedef struct const_iterator
+                {
+                        friend class List<value, valuealloc, linkalloc>;
+                private:
+                        Link *pLink;
+                        const_iterator() :
+                                pLink( NULL )
+                        {
+                        }
 
+                        const_iterator( Link *pLink ) :
+                                pLink( pLink )
+                        {
+                        }
+
+                        const_iterator( const iterator &i ) :
+                                pLink( i.pLink )
+                        {
+                        }
+
+                public:
+                        bool operator==( const const_iterator &oth ) const
+                        {
+                                return ( pLink == oth.pLink );
+                        }
+
+                        bool operator==( const Link *pOth ) const
+                        {
+                                return ( pLink == pOth );
+                        }
+
+                        bool operator!=( const const_iterator &oth ) const
+                        {
+                                return ( pLink != oth.pLink );
+                        }
+
+                        bool operator!=( const Link *pOth ) const
+                        {
+                                return ( pLink != pOth );
+                        }
+
+                        const value &operator*()
+                        {
+                                return *(pLink->pValue);
+                        }
+
+                        const value *operator->()
+                        {
+                                return pLink->pValue;
+                        }
+
+                        const_iterator &operator++()
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pNext;
+                                return *this;
+                        }
+
+                        const_iterator &operator--()
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pPrev;
+                                return *this;
+                        }
+                        
+                        const_iterator &operator++( int )
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pNext;
+                                return *this;
+                        }
+
+                        const_iterator &operator--( int )
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pPrev;
+                                return *this;
+                        }
+
+                        const_iterator &operator=( const iterator &oth )
+                        {
+                                pLink = oth.pLink;
+                                return *this;
+                        }
+
+                        const_iterator &operator=( const const_iterator &oth )
+                        {
+                                pLink = oth.pLink;
+                                return *this;
+                        }
+                };
+
+                /**
+                 * Get an iterator pointing to the first item in the list.
+                 *@returns (iterator)
+                 */
+                iterator begin()
+                {
+                        return iterator( pFirst );
+                }
+
+                /**
+                 * Get a const iterator pointing to the first item in the list.
+                 *@returns (const const_iterator)
+                 */
+                const const_iterator begin() const
+                {
+                        return const_iterator( pFirst );
+                }
+
+                /**
+                 * Get an iterator pointing to a place just past the last item in
+                 *              the list.
+                 *@returns (const Link *)
+                 */
+                const Link *end() const
+                {
+                        return NULL;
+                }
+
+                /**
+                 * Erase an item from the list.
+                 *@param i (iterator) The item to erase.
+                 */
+                void erase( iterator &i )
+                {
+                        Link *pCur = i.pLink;
+                        Link *pPrev = pCur->pPrev;
+                        if( pPrev == NULL )
+                        {
+                                va.destroy( pCur->pValue );
+                                va.deallocate( pCur->pValue, 1 );
+                                pFirst = pCur->pNext;
+                                la.destroy( pCur );
+                                la.deallocate( pCur, 1 );
+                                if( pFirst == NULL )
+                                        pLast = NULL;
+                                nSize--;
+                                i.pLink = pFirst;
+                        }
+                        else
+                        {
+                                va.destroy( pCur->pValue );
+                                va.deallocate( pCur->pValue, 1 );
+                                Link *pTmp = pCur->pNext;
+                                la.destroy( pCur );
+                                la.deallocate( pCur, 1 );
+                                pPrev->pNext = pTmp;
+                                if( pTmp != NULL )
+                                        pTmp->pPrev = pPrev;
+                                nSize--;
+                                i.pLink = pTmp;
+                        }
+                }
+
+                /**
+                 * Get the current size of the list.
+                 *@returns (int) The current size of the list.
+                 */
+                int getSize() const
+                {
+                        return nSize;
+                }
+
+                /**
+                 * Get the first item in the list.
+                 *@returns (value_type &) The first item in the list.
+                 */
+                value &first()
+                {
+                        return *pFirst->pValue;
+                }
+                
+                /**
+                 * Get the first item in the list.
+                 *@returns (const value_type &) The first item in the list.
+                 */
+                const value &first() const
+                {
+                        return *pFirst->pValue;
+                }
+                
+                /**
+                 * Get the last item in the list.
+                 *@returns (value_type &) The last item in the list.
+                 */
+                value &last()
+                {
+                        return *pLast->pValue;
+                }
+                
+                /**
+                 * Get the last item in the list.
+                 *@returns (const value_type &) The last item in the list.
+                 */
+                const value &last() const
+                {
+                        return *pLast->pValue;
+                }
+
+                const bool isEmpty() const
+                {
+                        return (nSize == 0);
+                }
+                
+        private:
+                Link *pFirst;
+                Link *pLast;
+                linkalloc la;
+                valuealloc va;
+                int nSize;
+        };
+}
+
+#endif
diff --git a/src/logger.cpp b/src/logger.cpp
new file mode 100644
index 0000000..1fc2262
--- /dev/null
+++ b/src/logger.cpp
@@ -0,0 +1,131 @@
+#include "bu/logger.h"
+#include <stdarg.h>
+#include <time.h>
+#include <stdio.h>
+
+Bu::Logger::Logger()
+{
+}
+
+Bu::Logger::~Logger()
+{
+}
+
+void Bu::Logger::log( int nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...)
+{
+        if( (nLevel&nLevelMask) == 0 )
+                return;
+
+        va_list ap;
+        va_start( ap, sFormat );
+        char *text;
+        vasprintf( &text, sFormat, ap );
+        va_end(ap);
+        
+        time_t t = time(NULL);
+        
+        char *line = NULL;
+        struct tm *pTime;
+        pTime = localtime( &t );
+        asprintf(
+                &line,
+                sLogFormat.getStr(),
+                pTime->tm_year+1900,
+                pTime->tm_mon+1,
+                pTime->tm_mday,
+                pTime->tm_hour,
+                pTime->tm_min,
+                pTime->tm_sec,
+                nLevel,
+                sFile,
+                nLine,
+                text,
+                sFunction
+                );
+        write( fileno(stdout), line, strlen(line) );
+        free( text );
+        free( line );
+}
+
+void Bu::Logger::setFormat( const Bu::FString &str )
+{
+        sLogFormat = "";
+
+        static char fmts[][4]={
+                {'y', 'd', '0', '1'},
+                {'m', 'd', '0', '2'},
+                {'d', 'd', '0', '3'},
+                {'h', 'd', '0', '4'},
+                {'M', 'd', '0', '5'},
+                {'s', 'd', '0', '6'},
+                {'L', 'd', '0', '7'},
+                {'f', 's', '0', '8'},
+                {'l', 'd', '0', '9'},
+                {'t', 's', '1', '0'},
+                {'F', 's', '1', '1'},
+                {'\0', '\0', '\0', '\0'},
+        };
+        
+        for( const char *s = str.getStr(); *s; s++ )
+        {
+                if( *s == '%' )
+                {
+                        sLogFormat += '%';
+                        Bu::FString sBuf;
+                        for(;;)
+                        {
+                                s++;
+                                int l;
+                                for( l = 0;; l++ )
+                                {
+                                        if( fmts[l][0] == '\0' )
+                                        {
+                                                sBuf += *s;
+                                                break;
+                                        }
+                                        else if( *s == fmts[l][0] )
+                                        {
+                                                sLogFormat += fmts[l][2];
+                                                sLogFormat += fmts[l][3];
+                                                sLogFormat += '$';
+                                                sLogFormat += sBuf;
+                                                sLogFormat += fmts[l][1];
+                                                break;
+                                        }
+                                }
+                                if( fmts[l][0] != '\0' )
+                                        break;
+                        }
+                }
+                else
+                {
+                        sLogFormat += *s;
+                }
+        }
+        sLogFormat += '\n';
+
+        write( fileno(stdout), sLogFormat.getStr(), sLogFormat.getSize() );
+}
+
+void Bu::Logger::setMask( int n )
+{
+        nLevelMask = n;
+}
+
+void Bu::Logger::setLevel( int n )
+{
+        int j;
+        for( j = 31; j > 0; j-- )
+        {
+                if( (n&(1<<j)) )
+                {
+                        for(; j >= 0; j-- )
+                        {
+                                n |= (1<<j);
+                        }
+                        nLevelMask = n;
+                        return;
+                }
+        }
+}
+
diff --git a/src/logger.h b/src/logger.h
new file mode 100644
index 0000000..f8e1692
--- /dev/null
+++ b/src/logger.h
@@ -0,0 +1,112 @@
+#ifndef BU_LOGGER_H
+#define BU_LOGGER_H
+
+#include "bu/singleton.h"
+#include "bu/fstring.h"
+
+namespace Bu
+{
+        /**
+         * Simple logging facility.  All output goes straight to stdout, unlike the
+         * old multi-log system.  Generally we expect any program complex enough to
+         * want to use this will have other facilities for processing the logging
+         * output, but if we need it we can add other output methods.
+         *
+         * Currently implemented as a singleton to avoid clutter with globals, you
+         * generally never want to use the logging system directly, it's annoying.
+         * Instead use the handy macros lineLog, setLogMask, setLogFormat, and
+         * setLogLevel.  They do all the real work for you.
+         *
+         * In the log format, you can specify extra information that will be written
+         * to the log with every message, and extras in printf style.  Use %X flags
+         * where X is one of the following:
+         * - L - Logging level of the log message (not the current mask)
+         * - y - Full year
+         * - m - Month
+         * - d - Day of month
+         * - h - Hour (24-hour format)
+         * - M - Minutes
+         * - s - Seconds 
+         * - f - Source file
+         * - l - Line number
+         * - F - function name
+         * - t - Text of message (usually important)
+         *
+         * You can include anything extra that you would like, a newline will always
+         * be added automatically, so no need to worry about that.  You can also
+         * include any extra printf style formatting that you would like, for
+         * example: "%h:%02M:%02s" for the time 4:02:09 instead of 4:2:9.
+         *
+         * It's generally handy to create an enum of values you use as levels during
+         * program execution (such as error, warning, info, debug, etc).  These
+         * levels should be treated as bitflags, and the most desirable messages,
+         * i.e. serious errors and the like should be low order (0x01), and the much
+         * less desirable messages, like debugging info, should be higher order
+         * (0xF0).  During operation you can then set either an explicit mask,
+         * selecting just the levels that you would like to see printed, or set the
+         * mask using the setLevel helper function, which simulates verbosity
+         * levels, enabling every flag lower order than the highest order set bit
+         * passed.  I.E. if you had the following enumerated levels:
+         * 
+         *@code
+         enum {
+                logError        = 0x01,
+                logWarning      = 0x02,
+                logInfo         = 0x04,
+                logDebug        = 0x08
+         };
+         @endcode
+         * And you set the mask with setMask( logInfo ) the only messages you would
+         * see are the ones catagorized logInfo.  However, if you used 
+         * setLevel( logInfo ) then you would see logInfo, logWarning, and logError
+         * type messages, since they are lower order.
+         */
+        class Logger : public Bu::Singleton<Bu::Logger>
+        {
+                friend class Bu::Singleton<Bu::Logger>;
+        private:
+                Logger();
+                virtual ~Logger();
+
+        public:
+                void log( int nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...);
+
+                void setFormat( const Bu::FString &str );
+                void setMask( int n );
+                void setLevel( int n );
+
+        private:
+                Bu::FString sLogFormat;
+                int nLevelMask;
+        };
+}
+
+/**
+ * Use Bu::Logger to log a message at the given level and with the given message
+ * using printf style formatting, and include extra data such as the current
+ * file, line number, and function.
+ */
+#define lineLog( nLevel, sFrmt, ...) \
+        Bu::Logger::getInstance().log( nLevel, __FILE__, __PRETTY_FUNCTION__, __LINE__, sFrmt, ##__VA_ARGS__ ) 
+
+/**
+ * Set the Bu::Logger logging mask directly.  See Bu::Logger::setMask for
+ * details.
+ */
+#define setLogMask( nLevel ) \
+        Bu::Logger::getInstance().setMask( nLevel ) 
+
+/**
+ * Set the Bu::Logger format. See Bu::Logger::setFormat for details.
+ */
+#define setLogFormat( sFrmt ) \
+        Bu::Logger::getInstance().setFormat( sFrmt ) 
+
+/**
+ * Set the Bu::Logger logging mask simulating levels.  See Bu::Logger::setLevel
+ * for details.
+ */
+#define setLogLevel( nLevel ) \
+        Bu::Logger::getInstance().setLevel( nLevel ) 
+
+#endif
diff --git a/src/main.dox b/src/main.dox
new file mode 100644
index 0000000..668d2e3
--- /dev/null
+++ b/src/main.dox
@@ -0,0 +1,14 @@
+/**
+ *@mainpage libbu++ utility library
+ * 
+ *@section secIntro Introduction
+ *
+ * Libbu++ is a C++ library of general utility classes and functions.  They
+ * cover a wide range of topics from streams and sockets to data structures to
+ * data serialization and xml handling to threading.
+ *
+ */
+
+/**
+ *@namespace Bu The core libbu++ namespace, to ensure things don't get muddied.
+ */
diff --git a/src/membuf.cpp b/src/membuf.cpp
new file mode 100644
index 0000000..45ff5bd
--- /dev/null
+++ b/src/membuf.cpp
@@ -0,0 +1,120 @@
+#include "bu/membuf.h"
+
+using namespace Bu;
+
+Bu::MemBuf::MemBuf() :
+        nPos( 0 )
+{
+}
+
+Bu::MemBuf::MemBuf( const Bu::FString &str ) :
+        sBuf( str ),
+        nPos( 0 )
+{
+}
+
+Bu::MemBuf::~MemBuf()
+{
+}
+
+void Bu::MemBuf::close()
+{
+}
+
+size_t Bu::MemBuf::read( void *pBuf, size_t nBytes )
+{
+        if( (size_t)sBuf.getSize()-(size_t)nPos < nBytes )
+                nBytes = sBuf.getSize()-nPos;
+
+        memcpy( pBuf, sBuf.getStr()+nPos, nBytes );
+        nPos += nBytes;
+
+        return nBytes;
+}
+        
+size_t Bu::MemBuf::write( const void *pBuf, size_t nBytes )
+{
+        sBuf.append( (const char *)pBuf, nBytes );
+        nPos += nBytes;
+        return nBytes;
+}
+
+long Bu::MemBuf::tell()
+{
+        return nPos;
+}
+
+void Bu::MemBuf::seek( long offset )
+{
+        nPos += offset;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+}
+
+void Bu::MemBuf::setPos( long pos )
+{
+        nPos = pos;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+}
+
+void Bu::MemBuf::setPosEnd( long pos )
+{
+        nPos = sBuf.getSize()-pos;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+}
+
+bool Bu::MemBuf::isEOS()
+{
+        return (nPos == sBuf.getSize());
+}
+
+bool Bu::MemBuf::isOpen()
+{
+        return true;
+}
+
+void Bu::MemBuf::flush()
+{
+}
+
+bool Bu::MemBuf::canRead()
+{
+        return !isEOS();
+}
+
+bool Bu::MemBuf::canWrite()
+{
+        return isEOS();
+}
+
+bool Bu::MemBuf::isReadable()
+{
+        return true;
+}
+
+bool Bu::MemBuf::isWritable()
+{
+        return true;
+}
+
+bool Bu::MemBuf::isSeekable()
+{
+        return true;
+}
+
+bool Bu::MemBuf::isBlocking()
+{
+        return true;
+}
+
+void Bu::MemBuf::setBlocking( bool bBlocking )
+{
+}
+
+Bu::FString &Bu::MemBuf::getString()
+{
+        return sBuf;
+}
+
diff --git a/src/membuf.h b/src/membuf.h
new file mode 100644
index 0000000..8f53d4b
--- /dev/null
+++ b/src/membuf.h
@@ -0,0 +1,53 @@
+#ifndef BU_MEM_BUF_H
+#define BU_MEM_BUF_H
+
+#include <stdint.h>
+
+#include "bu/stream.h"
+#include "bu/fstring.h"
+
+namespace Bu
+{
+        /**
+         * A memory buffer stream.
+         */
+        class MemBuf : public Stream
+        {
+        public:
+                MemBuf();
+                MemBuf( const Bu::FString &str );
+                virtual ~MemBuf();
+
+                virtual void close();
+                virtual size_t read( void *pBuf, size_t nBytes );
+
+                /**
+                 *@todo Allow writes at the current position, not just appending to
+                 * the current buffer.  This is a silly way to do it, but it covers all
+                 * of our bases for now.
+                 */
+                virtual size_t write( const void *pBuf, size_t nBytes );
+                virtual long tell();
+                virtual void seek( long offset );
+                virtual void setPos( long pos );
+                virtual void setPosEnd( long pos );
+                virtual bool isEOS();
+                virtual bool isOpen();
+                virtual void flush();
+                virtual bool canRead();
+                virtual bool canWrite();
+                virtual bool isReadable();
+                virtual bool isWritable();
+                virtual bool isSeekable();
+                virtual bool isBlocking();
+                virtual void setBlocking( bool bBlocking=true );
+
+                Bu::FString &getString();
+
+        private:
+                Bu::FString sBuf;
+                long nPos;
+        };
+}
+
+#endif
diff --git a/src/cgi.cpp b/src/old/cgi.cpp
index 1fecbbe..1fecbbe 100644
--- a/src/cgi.cpp
+++ b/src/old/cgi.cpp
diff --git a/src/cgi.h b/src/old/cgi.h
index 01142b5..01142b5 100644
--- a/src/cgi.h
+++ b/src/old/cgi.h
diff --git a/src/configmanagerbase.cpp b/src/old/configmanagerbase.cpp
index ac55fe0..ac55fe0 100644
--- a/src/configmanagerbase.cpp
+++ b/src/old/configmanagerbase.cpp
diff --git a/src/configmanagerbase.h b/src/old/configmanagerbase.h
index 381cc1f..381cc1f 100644
--- a/src/configmanagerbase.h
+++ b/src/old/configmanagerbase.h
diff --git a/src/confpair.cpp b/src/old/confpair.cpp
index 4741401..4741401 100644
--- a/src/confpair.cpp
+++ b/src/old/confpair.cpp
diff --git a/src/confpair.h b/src/old/confpair.h
index 56eb06e..56eb06e 100644
--- a/src/confpair.h
+++ b/src/old/confpair.h
diff --git a/src/confpairbase.cpp b/src/old/confpairbase.cpp
index 1203dc0..1203dc0 100644
--- a/src/confpairbase.cpp
+++ b/src/old/confpairbase.cpp
diff --git a/src/confpairbase.h b/src/old/confpairbase.h
index 2530756..2530756 100644
--- a/src/confpairbase.h
+++ b/src/old/confpairbase.h
diff --git a/src/conftree.cpp b/src/old/conftree.cpp
index d9a3a3f..d9a3a3f 100644
--- a/src/conftree.cpp
+++ b/src/old/conftree.cpp
diff --git a/src/conftree.h b/src/old/conftree.h
index 197b1ef..197b1ef 100644
--- a/src/conftree.h
+++ b/src/old/conftree.h
diff --git a/src/connection.cpp b/src/old/connection.cpp
index efef144..efef144 100644
--- a/src/connection.cpp
+++ b/src/old/connection.cpp
diff --git a/src/connection.h b/src/old/connection.h
index 0e991c7..0e991c7 100644
--- a/src/connection.h
+++ b/src/old/connection.h
diff --git a/src/connectionmanager.cpp b/src/old/connectionmanager.cpp
index ea60b2b..ea60b2b 100644
--- a/src/connectionmanager.cpp
+++ b/src/old/connectionmanager.cpp
diff --git a/src/connectionmanager.h b/src/old/connectionmanager.h
index cff036b..cff036b 100644
--- a/src/connectionmanager.h
+++ b/src/old/connectionmanager.h
diff --git a/src/connectionmonitor.cpp b/src/old/connectionmonitor.cpp
index 4f90ee6..4f90ee6 100644
--- a/src/connectionmonitor.cpp
+++ b/src/old/connectionmonitor.cpp
diff --git a/src/connectionmonitor.h b/src/old/connectionmonitor.h
index 9910556..9910556 100644
--- a/src/connectionmonitor.h
+++ b/src/old/connectionmonitor.h
diff --git a/src/flexbuf.cpp b/src/old/flexbuf.cpp
index 6d55294..6d55294 100644
--- a/src/flexbuf.cpp
+++ b/src/old/flexbuf.cpp
diff --git a/src/flexbuf.h b/src/old/flexbuf.h
index 7d7f11a..7d7f11a 100644
--- a/src/flexbuf.h
+++ b/src/old/flexbuf.h
diff --git a/src/formula.cpp b/src/old/formula.cpp
index cf63cf3..cf63cf3 100644
--- a/src/formula.cpp
+++ b/src/old/formula.cpp
diff --git a/src/formula.h b/src/old/formula.h
index 939eb09..939eb09 100644
--- a/src/formula.h
+++ b/src/old/formula.h
diff --git a/src/http.cpp b/src/old/http.cpp
index df7dafe..df7dafe 100644
--- a/src/http.cpp
+++ b/src/old/http.cpp
diff --git a/src/http.h b/src/old/http.h
index 7e9f9a0..7e9f9a0 100644
--- a/src/http.h
+++ b/src/old/http.h
diff --git a/src/httpget.cpp b/src/old/httpget.cpp
index ee1f29c..ee1f29c 100644
--- a/src/httpget.cpp
+++ b/src/old/httpget.cpp
diff --git a/src/httpget.h b/src/old/httpget.h
index 8272641..8272641 100644
--- a/src/httpget.h
+++ b/src/old/httpget.h
diff --git a/src/linkedlist.cpp b/src/old/linkedlist.cpp
index a9902bc..a9902bc 100644
--- a/src/linkedlist.cpp
+++ b/src/old/linkedlist.cpp
diff --git a/src/linkedlist.h b/src/old/linkedlist.h
index e430108..e430108 100644
--- a/src/linkedlist.h
+++ b/src/old/linkedlist.h
diff --git a/src/linkmessenger.cpp b/src/old/linkmessenger.cpp
index 3bd401a..3bd401a 100644
--- a/src/linkmessenger.cpp
+++ b/src/old/linkmessenger.cpp
diff --git a/src/linkmessenger.h b/src/old/linkmessenger.h
index ed52639..ed52639 100644
--- a/src/linkmessenger.h
+++ b/src/old/linkmessenger.h
diff --git a/src/old/list.cpp b/src/old/list.cpp
new file mode 100644
index 0000000..18f1a66
--- /dev/null
+++ b/src/old/list.cpp
@@ -0,0 +1,10 @@
+#include "list.h"
+
+List::List(  )
+{
+}
+
+List::~List(  )
+{
+}
+
diff --git a/src/old/list.h b/src/old/list.h
new file mode 100644
index 0000000..c71b328
--- /dev/null
+++ b/src/old/list.h
@@ -0,0 +1,101 @@
+#ifndef LIST_H
+#define LIST_H
+
+
+/** The basic List class ADT.  This, on it's own, does absolutely nothing, but
+  * does define all standard interface functions to access a list.
+  *@author Mike Buland
+  */
+class List
+{
+public:
+        /**
+         * Construct a list.
+         */
+        List();
+
+        /**
+         * Desconstruct a list.
+         */
+        virtual ~List();
+
+        /** Gets the value at a specified index.
+          *@param nIndex The index of the item to return.
+          *@returns The specified item, or NULL if the index was beyond the range
+          * of the list.
+          *@author Mike Buland
+          */
+        virtual void *getAt( int nIndex ) = 0;
+
+        /** Append the given data to the end of the list.  This increases the
+          * size of the list by one.
+          *@param pData The data to append to the list.
+          *@author Mike Buland
+          */
+        virtual void append( void *pData ) = 0;
+
+        /** Inserts an item at the specified position in the list.  The
+          * new item takes the index that you specify, and all other items
+          * are moved up one position.  The size of the list is increased by
+          * one.
+          *@param pData The value to insert into the list.
+          *@param nPos Where to insert the data into the list.
+          *@author Mike Buland
+          */
+        virtual void insertBefore( void *pData, int nPos = 0 ) = 0;
+
+        /** Determines the size of the list, in elements.
+          *@returns The size of the list.
+          *@author Mike Buland
+          */
+        virtual int getSize(  ) = 0;
+
+        /** Determines if the list is empty or not.
+          *@returns True if the list is empty, or false if the list has
+          * data in it (if the size is greater than zero).
+          *@author Mike Buland
+          */
+        virtual bool isEmpty(  ) = 0;
+
+        /** Deletes an item at the specified index and moves all other
+          * values down one index.  The size of the list is decreased by one.
+          *@param nIndex The index of the item to delete.
+          *@author Mike Buland
+          */
+        virtual void deleteAt( int nIndex ) = 0;
+
+        /** Completely empties the list, and sets the effective size to
+          * zero.
+          *@author Mike Buland
+          */
+        virtual void empty() = 0;
+
+        /** Sets the size of the list.  This can be larger or smaller
+          * than what it was previously.  If larger, new blank items will
+          * be added to the end of the list.  If smaller than the old list
+          * items will be deleted from the end.
+          *@param nNewSize The new size of the list.
+          *@author Mike Buland
+          */
+        virtual void setSize( int nNewSize ) = 0;
+
+        /** Sets a member at a specified location to a new value.
+          * If the member being set is outside of the range of the
+          * current list it should be expanded.
+          *@param nIndex The zero-based index of the item to change.
+          *@param pData The new value for that index.
+          *@author Mike Buland
+          */
+        virtual void setAt( int nIndex, void *pData ) = 0;
+
+        /** Makes the List work like an array.  Just say listObj[2] to get
+          * the third element.
+          *@param nIndex The index to access in the list.
+          *@returns A pointer to the data at element index.
+          *@author Mike Buland
+          */
+        void *operator[]( int nIndex ) { return getAt( nIndex ); };
+};
+
+#endif
+
diff --git a/src/md5.cpp b/src/old/md5.cpp
index c0cacdd..c0cacdd 100644
--- a/src/md5.cpp
+++ b/src/old/md5.cpp
diff --git a/src/md5.h b/src/old/md5.h
index 7f77d83..7f77d83 100644
--- a/src/md5.h
+++ b/src/old/md5.h
diff --git a/src/multilog.cpp b/src/old/multilog.cpp
index 143ee89..143ee89 100644
--- a/src/multilog.cpp
+++ b/src/old/multilog.cpp
diff --git a/src/multilog.h b/src/old/multilog.h
index 692095a..692095a 100644
--- a/src/multilog.h
+++ b/src/old/multilog.h
diff --git a/src/multilogchannel.cpp b/src/old/multilogchannel.cpp
index ee4c9bf..ee4c9bf 100644
--- a/src/multilogchannel.cpp
+++ b/src/old/multilogchannel.cpp
diff --git a/src/multilogchannel.h b/src/old/multilogchannel.h
index d891a65..d891a65 100644
--- a/src/multilogchannel.h
+++ b/src/old/multilogchannel.h
diff --git a/src/multilogtext.cpp b/src/old/multilogtext.cpp
index 4337cc9..4337cc9 100644
--- a/src/multilogtext.cpp
+++ b/src/old/multilogtext.cpp
diff --git a/src/multilogtext.h b/src/old/multilogtext.h
index 197aef1..197aef1 100644
--- a/src/multilogtext.h
+++ b/src/old/multilogtext.h
diff --git a/src/ordhash.cpp b/src/old/ordhash.cpp
index 77cbd61..77cbd61 100644
--- a/src/ordhash.cpp
+++ b/src/old/ordhash.cpp
diff --git a/src/ordhash.h b/src/old/ordhash.h
index e946f95..e946f95 100644
--- a/src/ordhash.h
+++ b/src/old/ordhash.h
diff --git a/src/pqueue.cpp b/src/old/pqueue.cpp
index 1f0b8b5..1f0b8b5 100644
--- a/src/pqueue.cpp
+++ b/src/old/pqueue.cpp
diff --git a/src/pqueue.h b/src/old/pqueue.h
index 8307d56..8307d56 100644
--- a/src/pqueue.h
+++ b/src/old/pqueue.h
diff --git a/src/old/protocol.cpp b/src/old/protocol.cpp
new file mode 100644
index 0000000..78b3ee2
--- /dev/null
+++ b/src/old/protocol.cpp
@@ -0,0 +1,20 @@
+#include "protocol.h"
+
+Protocol::Protocol()
+{
+        pConnection = NULL;
+}
+
+Protocol::~Protocol()
+{
+}
+
+void Protocol::setConnection( Connection *pNewConnection )
+{
+        pConnection = pNewConnection;
+}
+
+Connection *Protocol::getConnection()
+{
+        return pConnection;
+}
diff --git a/src/old/protocol.h b/src/old/protocol.h
new file mode 100644
index 0000000..09e1c98
--- /dev/null
+++ b/src/old/protocol.h
@@ -0,0 +1,62 @@
+#ifndef PROTOCOL_H
+#define PROTOCOL_H
+
+#include "connection.h"
+
+/** This is the template for a class that handles specialized input and output
+  * to connections of different types with different protocols.
+  *@author Mike Buland
+  */
+class Protocol
+{
+public:
+        /** Constructor */
+    Protocol();
+        /** Deconstructor */
+    virtual ~Protocol();
+
+        /**
+         * Function is called every time there is new data on the line.  This is
+         * called directly from the Connection class to process data.  This is not
+         * called whever there is pending data on the input, but every time new data
+         * is added to the input buffer.
+         *@returns True if processing went alright, false if something went wrong,
+         * I suppose.  In truth this value is thrown away right now.
+         *@todo Either make a return value of false mean something, or make these
+         * void.
+         */
+        virtual bool onNewData()=0;
+
+        /**
+         * Function is called when there is a new connection.  This should only
+         * happen once per Protocol object, but gives each protocol object a
+         * chance to perform connection handshaking and initialization at a point
+         * where they know that they have a handle to an active Connection.
+         *@returns See onNewData
+         */
+        virtual bool onNewConnection()=0;
+
+        virtual void onNewClientConnection(){};
+
+        virtual void poll(){};
+
+        /**
+         * Sets the Protocol's Connection object.  This is rather important, and
+         * handled usually by the ConnectionManager.
+         *@param pNewConnection The Connection object that this protocol will use to
+         * deal with the outside world.
+         */
+        void setConnection( class Connection *pNewConnection );
+
+        /**
+         * Get a pointer to this object's Connection object, or NULL if one was
+         * never set.  If used with the ConnectionManager that should never happen.
+         *@returns A pointer to the active Connection.
+         */
+        Connection *getConnection();
+
+private:
+        class Connection *pConnection; /**< The pointer to the Connection. */
+};
+
+#endif
diff --git a/src/protocoltelnet.cpp b/src/old/protocoltelnet.cpp
index b169a51..b169a51 100644
--- a/src/protocoltelnet.cpp
+++ b/src/old/protocoltelnet.cpp
diff --git a/src/protocoltelnet.h b/src/old/protocoltelnet.h
index a6d2e49..a6d2e49 100644
--- a/src/protocoltelnet.h
+++ b/src/old/protocoltelnet.h
diff --git a/src/queue.cpp b/src/old/queue.cpp
index 42999fe..42999fe 100644
--- a/src/queue.cpp
+++ b/src/old/queue.cpp
diff --git a/src/queue.h b/src/old/queue.h
index 692f5d8..692f5d8 100644
--- a/src/queue.h
+++ b/src/old/queue.h
diff --git a/src/ringlist.cpp b/src/old/ringlist.cpp
index 9efbbc4..9efbbc4 100644
--- a/src/ringlist.cpp
+++ b/src/old/ringlist.cpp
diff --git a/src/ringlist.h b/src/old/ringlist.h
index bc069f3..bc069f3 100644
--- a/src/ringlist.h
+++ b/src/old/ringlist.h
diff --git a/src/sbuffer.cpp b/src/old/sbuffer.cpp
index f84f8a3..f84f8a3 100644
--- a/src/sbuffer.cpp
+++ b/src/old/sbuffer.cpp
diff --git a/src/sbuffer.h b/src/old/sbuffer.h
index 65feb71..65feb71 100644
--- a/src/sbuffer.h
+++ b/src/old/sbuffer.h
diff --git a/src/serializerbinary.cpp b/src/old/serializerbinary.cpp
index ea7ed93..ea7ed93 100644
--- a/src/serializerbinary.cpp
+++ b/src/old/serializerbinary.cpp
diff --git a/src/serializerbinary.h b/src/old/serializerbinary.h
index 8510fcd..8510fcd 100644
--- a/src/serializerbinary.h
+++ b/src/old/serializerbinary.h
diff --git a/src/serializerbzip2.cpp b/src/old/serializerbzip2.cpp
index bafabc8..bafabc8 100644
--- a/src/serializerbzip2.cpp
+++ b/src/old/serializerbzip2.cpp
diff --git a/src/serializerbzip2.h b/src/old/serializerbzip2.h
index 4aeb22e..4aeb22e 100644
--- a/src/serializerbzip2.h
+++ b/src/old/serializerbzip2.h
diff --git a/src/serializerconnection.cpp b/src/old/serializerconnection.cpp
index 2934c8b..2934c8b 100644
--- a/src/serializerconnection.cpp
+++ b/src/old/serializerconnection.cpp
diff --git a/src/serializerconnection.h b/src/old/serializerconnection.h
index e8d85c6..e8d85c6 100644
--- a/src/serializerconnection.h
+++ b/src/old/serializerconnection.h
diff --git a/src/serializertext.cpp b/src/old/serializertext.cpp
index 9cf4394..9cf4394 100644
--- a/src/serializertext.cpp
+++ b/src/old/serializertext.cpp
diff --git a/src/serializertext.h b/src/old/serializertext.h
index 01b7f7b..01b7f7b 100644
--- a/src/serializertext.h
+++ b/src/old/serializertext.h
diff --git a/src/sha1.cpp b/src/old/sha1.cpp
index 8270c3b..8270c3b 100644
--- a/src/sha1.cpp
+++ b/src/old/sha1.cpp
diff --git a/src/sha1.h b/src/old/sha1.h
index ab6081d..ab6081d 100644
--- a/src/sha1.h
+++ b/src/old/sha1.h
diff --git a/src/stack.cpp b/src/old/stack.cpp
index 8d9565c..8d9565c 100644
--- a/src/stack.cpp
+++ b/src/old/stack.cpp
diff --git a/src/stack.h b/src/old/stack.h
index 30e2a19..30e2a19 100644
--- a/src/stack.h
+++ b/src/old/stack.h
diff --git a/src/staticstring.cpp b/src/old/staticstring.cpp
index 60f130f..60f130f 100644
--- a/src/staticstring.cpp
+++ b/src/old/staticstring.cpp
diff --git a/src/staticstring.h b/src/old/staticstring.h
index 4c3f7b8..4c3f7b8 100644
--- a/src/staticstring.h
+++ b/src/old/staticstring.h
diff --git a/src/stringrep.cpp b/src/old/stringrep.cpp
index a505f8a..a505f8a 100644
--- a/src/stringrep.cpp
+++ b/src/old/stringrep.cpp
diff --git a/src/stringrep.h b/src/old/stringrep.h
index eaa4a12..eaa4a12 100644
--- a/src/stringrep.h
+++ b/src/old/stringrep.h
diff --git a/src/tests/clistress.cpp b/src/old/tests/clistress.cpp
index 6b0ac66..6b0ac66 100644
--- a/src/tests/clistress.cpp
+++ b/src/old/tests/clistress.cpp
diff --git a/src/tests/confpair.cpp b/src/old/tests/confpair.cpp
index fb1b0d3..fb1b0d3 100644
--- a/src/tests/confpair.cpp
+++ b/src/old/tests/confpair.cpp
diff --git a/src/tests/connect.cpp b/src/old/tests/connect.cpp
index a9fca64..a9fca64 100644
--- a/src/tests/connect.cpp
+++ b/src/old/tests/connect.cpp
diff --git a/src/tests/exception.cpp b/src/old/tests/exception.cpp
index 6417692..6417692 100644
--- a/src/tests/exception.cpp
+++ b/src/old/tests/exception.cpp
diff --git a/src/tests/formula.cpp b/src/old/tests/formula.cpp
index 976b039..976b039 100644
--- a/src/tests/formula.cpp
+++ b/src/old/tests/formula.cpp
diff --git a/src/old/tests/hash.cpp b/src/old/tests/hash.cpp
new file mode 100644
index 0000000..2fc6968
--- /dev/null
+++ b/src/old/tests/hash.cpp
@@ -0,0 +1,116 @@
+#include "hash.h"
+#include "staticstring.h"
+
+int main()
+{
+        const char *names[]={
+                "Homer the Great",
+                "And Maggie Makes Three",
+                "Bart's Comet",
+                "Homie The Clown",
+                "Bart Vs Australia",
+                "Homer vs Patty and Selma",
+                "A star is burns",
+                "Lisa's Wedding",
+                "Two Dozen and One Greyhounds",
+                "The PTA Disbands",
+                "Round Springfield",
+                "The Springfield connection",
+                "Lemon of Troy",
+                "Who Shot Mr. Burns (Pt. 1)",
+                "Who Shot Mr. Burns (pt. 2)",
+                "Radioactive Man",
+                "Home Sweet Homediddly-dum-doodly",
+                "Bart Sells His Soul",
+                "Lisa the Vegetarian",
+                "Treehouse of horror VI",
+                "King Size Homer",
+                "Mother Simpson",
+                "Sideshow Bob's Last Gleaming",
+                "The Simpson's 138th Show Spectacular",
+                "Marge Be Not Proud",
+                "Team Homer",
+                "Two Bad Neighbors",
+                "Scenes From the Class Struggle in Springfield",
+                "Bart the Fink",
+                "Lisa the Iconoclast",
+                "Homer the Smithers",
+                "The Day the Violence Died",
+                "A Fish Called Selma",
+                "Bart on the road",
+                "22 Short Films about Springfield",
+                "The Curse of the Flying Hellfish",
+                "Much Apu about Nothing",
+                "Homerpalooza",
+                "The Summer of 4 Ft 2",
+                "Treehouse of Horror VII",
+                "You Only Move Twice",
+                "The Homer They Fall",
+                "Burns Baby Burns",
+                "Bart After Dark",
+                "A Millhouse Divided",
+                "Lisas Date With Destiny",
+                "Hurricane Neddy",
+                "The Mysterious Voyage of Our Homer",
+                "The Springfield Files",
+                "The Twisted World of Marge Simpson",
+                "Mountain of Madness",
+                NULL
+        };
+
+        Hash<const char *, int> sTest;
+
+        printf("Inserting\n-------------------\n\n");
+        for( int j = 0; j < 33; j++ )
+        {
+                sTest[names[j]] = j;
+        }
+        
+        printf("Test1: %d, Test2: %d\n", sTest.has("Lemon of Troy"), sTest.has(std::string("Lemon of Troy").c_str() ) );
+
+        sTest.has(std::string("Lemon of Troy").c_str() );
+
+        printf("Getting\n-------------------\n\n");
+
+        sTest.erase("Homer the Great");
+        sTest["Bart's Comet"].erase();
+
+        for( Hash<const char *, int>::iterator i = sTest.begin();
+                 i != sTest.end(); i++ )
+        {
+                Hash<const char *, int>::iterator j = i;
+                printf("%d: %s\n", (*j).second, (*j).first );
+        }
+
+        printf("Testing\n-------------------\n\n");
+        for( int j = 0; j < 33; j++ )
+        {
+                if( sTest.has(names[j]) )
+                {
+                        if( sTest[names[j]] != j )
+                        {
+                                printf("'%s' should be %d, is %d\n",
+                                        names[j], j,
+                                        sTest[names[j]].value()
+                                        );
+                        }
+                }
+                else
+                {
+                        printf("Missing element %d, '%s'\n", j, names[j] );
+                }
+        }
+
+        printf("Clearing\n-------------------\n\n");
+
+        sTest.clear();
+        
+        for( Hash<const char *, int>::iterator i = sTest.begin();
+                 i != sTest.end(); i++ )
+        {
+                Hash<const char *, int>::iterator j = i;
+                printf("%d: %s\n", (*j).second, (*j).first );
+        }
+
+}
+
diff --git a/src/tests/hashtest.cpp b/src/old/tests/hashtest.cpp
index eaa84a0..eaa84a0 100644
--- a/src/tests/hashtest.cpp
+++ b/src/old/tests/hashtest.cpp
diff --git a/src/tests/hashtest2.cpp b/src/old/tests/hashtest2.cpp
index 74700fd..74700fd 100644
--- a/src/tests/hashtest2.cpp
+++ b/src/old/tests/hashtest2.cpp
diff --git a/src/tests/httpsrv/httpconnectionmonitor.cpp b/src/old/tests/httpsrv/httpconnectionmonitor.cpp
index 51d82f3..51d82f3 100644
--- a/src/tests/httpsrv/httpconnectionmonitor.cpp
+++ b/src/old/tests/httpsrv/httpconnectionmonitor.cpp
diff --git a/src/tests/httpsrv/httpconnectionmonitor.h b/src/old/tests/httpsrv/httpconnectionmonitor.h
index 30c0afd..30c0afd 100644
--- a/src/tests/httpsrv/httpconnectionmonitor.h
+++ b/src/old/tests/httpsrv/httpconnectionmonitor.h
diff --git a/src/tests/httpsrv/main.cpp b/src/old/tests/httpsrv/main.cpp
index 2f1563c..2f1563c 100644
--- a/src/tests/httpsrv/main.cpp
+++ b/src/old/tests/httpsrv/main.cpp
diff --git a/src/tests/log.cpp b/src/old/tests/log.cpp
index d7cfa0b..d7cfa0b 100644
--- a/src/tests/log.cpp
+++ b/src/old/tests/log.cpp
diff --git a/src/tests/md5test.cpp b/src/old/tests/md5test.cpp
index 6f832df..6f832df 100644
--- a/src/tests/md5test.cpp
+++ b/src/old/tests/md5test.cpp
diff --git a/src/tests/ordhash.cpp b/src/old/tests/ordhash.cpp
index f1d96ec..f1d96ec 100644
--- a/src/tests/ordhash.cpp
+++ b/src/old/tests/ordhash.cpp
diff --git a/src/tests/param.cpp b/src/old/tests/param.cpp
index a4d2824..a4d2824 100644
--- a/src/tests/param.cpp
+++ b/src/old/tests/param.cpp
diff --git a/src/tests/param.h b/src/old/tests/param.h
index 2756b69..2756b69 100644
--- a/src/tests/param.h
+++ b/src/old/tests/param.h
diff --git a/src/tests/plugin/main.cpp b/src/old/tests/plugin/main.cpp
index 51c8390..51c8390 100644
--- a/src/tests/plugin/main.cpp
+++ b/src/old/tests/plugin/main.cpp
diff --git a/src/tests/plugin/plugin.cpp b/src/old/tests/plugin/plugin.cpp
index ea558fd..ea558fd 100644
--- a/src/tests/plugin/plugin.cpp
+++ b/src/old/tests/plugin/plugin.cpp
diff --git a/src/tests/plugin/plugin.h b/src/old/tests/plugin/plugin.h
index f726867..f726867 100644
--- a/src/tests/plugin/plugin.h
+++ b/src/old/tests/plugin/plugin.h
diff --git a/src/tests/qsort.cpp b/src/old/tests/qsort.cpp
index 28c6f03..28c6f03 100644
--- a/src/tests/qsort.cpp
+++ b/src/old/tests/qsort.cpp
diff --git a/src/tests/sbuffer.cpp b/src/old/tests/sbuffer.cpp
index 02798cb..02798cb 100644
--- a/src/tests/sbuffer.cpp
+++ b/src/old/tests/sbuffer.cpp
diff --git a/src/tests/serialize.cpp b/src/old/tests/serialize.cpp
index e233704..e233704 100644
--- a/src/tests/serialize.cpp
+++ b/src/old/tests/serialize.cpp
diff --git a/src/tests/serializetext.cpp b/src/old/tests/serializetext.cpp
index f6be7d3..f6be7d3 100644
--- a/src/tests/serializetext.cpp
+++ b/src/old/tests/serializetext.cpp
diff --git a/src/tests/sha1.cpp b/src/old/tests/sha1.cpp
index df3113c..df3113c 100644
--- a/src/tests/sha1.cpp
+++ b/src/old/tests/sha1.cpp
diff --git a/src/tests/sptr.cpp b/src/old/tests/sptr.cpp
index 252463b..38d3675 100644
--- a/src/tests/sptr.cpp
+++ b/src/old/tests/sptr.cpp
@@ -9,12 +9,12 @@ public:
                 printf("Created.\n");
         }
 
-        virtual ~Annoy()
+        ~Annoy()
         {
                 printf("Destroyed.\n");
         }
 
-        virtual void go()
+        void go()
         {
                 printf("%d: I'm annoying.\n", ++nCnt);
         }
@@ -22,22 +22,6 @@ public:
         int nCnt;
 };
 
-class Annoy2: public Annoy
-{
-public:
-        Annoy2(){};
-        virtual ~Annoy2(){};
-        virtual void go()
-        {
-                printf("{{I'm Annoy2!!}} ");
-                Annoy::go();
-        }
-        virtual void go2()
-        {
-                printf("This is me, on my own...\n");
-        }
-};
-
 void beAnnoying( SPtr<Annoy> bob )
 {
         printf("bob-Count: %d\n", bob.count() );
@@ -46,7 +30,7 @@ void beAnnoying( SPtr<Annoy> bob )
 
 int main()
 {
-        SPtr<Annoy> pt( new Annoy2 );
+        SPtr<Annoy> pt( new Annoy );
         printf("Count: %d\n", pt.count() );
         pt->go();
 
@@ -63,14 +47,6 @@ int main()
                         pt3->go();
 
                         beAnnoying( pt3 );
-
-                        {
-                                SPtr<Annoy2> pt4( SPtrCast<Annoy2>( pt3 ) );
-                                printf("Count: %d\n", pt4.count() );
-
-                                pt4->go2();
-                        }
-                        printf("Count: %d\n", pt.count() );
                 }
                 printf("Count: %d\n", pt.count() );
         }
diff --git a/src/tests/srvstress.cpp b/src/old/tests/srvstress.cpp
index d9a9a1c..d9a9a1c 100644
--- a/src/tests/srvstress.cpp
+++ b/src/old/tests/srvstress.cpp
diff --git a/src/tests/strhash.cpp b/src/old/tests/strhash.cpp
index f6528ca..f6528ca 100644
--- a/src/tests/strhash.cpp
+++ b/src/old/tests/strhash.cpp
diff --git a/src/tests/teltest/main.cpp b/src/old/tests/teltest/main.cpp
index 5d3ec26..5d3ec26 100644
--- a/src/tests/teltest/main.cpp
+++ b/src/old/tests/teltest/main.cpp
diff --git a/src/tests/teltest/telnetmonitor.cpp b/src/old/tests/teltest/telnetmonitor.cpp
index 65954eb..65954eb 100644
--- a/src/tests/teltest/telnetmonitor.cpp
+++ b/src/old/tests/teltest/telnetmonitor.cpp
diff --git a/src/tests/teltest/telnetmonitor.h b/src/old/tests/teltest/telnetmonitor.h
index ba5761e..ba5761e 100644
--- a/src/tests/teltest/telnetmonitor.h
+++ b/src/old/tests/teltest/telnetmonitor.h
diff --git a/src/tests/xmlreadtest.cpp b/src/old/tests/xmlreadtest.cpp
index d061810..d061810 100644
--- a/src/tests/xmlreadtest.cpp
+++ b/src/old/tests/xmlreadtest.cpp
diff --git a/src/tests/xmlrepltest.cpp b/src/old/tests/xmlrepltest.cpp
index 9667705..9667705 100644
--- a/src/tests/xmlrepltest.cpp
+++ b/src/old/tests/xmlrepltest.cpp
diff --git a/src/tests/xmlwritetest.cpp b/src/old/tests/xmlwritetest.cpp
index a22d19d..a22d19d 100644
--- a/src/tests/xmlwritetest.cpp
+++ b/src/old/tests/xmlwritetest.cpp
diff --git a/src/tokenstring.cpp b/src/old/tokenstring.cpp
index e57ba69..e57ba69 100644
--- a/src/tokenstring.cpp
+++ b/src/old/tokenstring.cpp
diff --git a/src/tokenstring.h b/src/old/tokenstring.h
index 42f7309..42f7309 100644
--- a/src/tokenstring.h
+++ b/src/old/tokenstring.h
diff --git a/src/tqsort.h b/src/old/tqsort.h
index c836b4f..c836b4f 100644
--- a/src/tqsort.h
+++ b/src/old/tqsort.h
diff --git a/src/unit/hashtable/hashtable.cpp b/src/old/unit/hashtable/hashtable.cpp
index b2e1cf5..b2e1cf5 100644
--- a/src/unit/hashtable/hashtable.cpp
+++ b/src/old/unit/hashtable/hashtable.cpp
diff --git a/src/unit/xml/xml.cpp b/src/old/unit/xml/xml.cpp
index e4d779c..e4d779c 100644
--- a/src/unit/xml/xml.cpp
+++ b/src/old/unit/xml/xml.cpp
diff --git a/src/xmldocument.cpp b/src/old/xmldocument.cpp
index d7867d5..95b9788 100644
--- a/src/xmldocument.cpp
+++ b/src/old/xmldocument.cpp
@@ -1,6 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include "xmlwriter.h"
+#include "xmldocument.h"
 
 XmlDocument::XmlDocument( XmlNode *pRoot )
 {
@@ -17,28 +17,23 @@ XmlDocument::~XmlDocument()
         }
 }
 
-void XmlDocument::addNode( const char *sName, const char *sContent, bool bClose )
+void XmlDocument::addNode( const Bu::FString &sName )
 {
         if( pRoot == NULL )
         {
                 // This is the first node, so ignore position and just insert it.
-                pCurrent = pRoot = new XmlNode( sName, NULL, sContent );
+                pCurrent = pRoot = new XmlNode( sName );
         }
         else
         {
-                pCurrent = pCurrent->addChild( sName, sContent );
-        }
-
-        if( bClose )
-        {
-                closeNode();
+                pCurrent = pCurrent->addChild( sName );
         }
 }
-
+/*
 void XmlDocument::setName( const char *sName )
 {
         pCurrent->setName( sName );
-}
+}*/
 
 bool XmlDocument::isCompleted()
 {
@@ -143,7 +138,8 @@ void XmlDocument::setContent( const char *sContent )
 {
         if( pCurrent )
         {
-                pCurrent->setContent( sContent );
+                printf("XmlDocument::setContent:  not yet implemented.\n");
+                //pCurrent->setContent( sContent );
         }
 }
 
diff --git a/src/xmldocument.h b/src/old/xmldocument.h
index 6671c41..e0c36eb 100644
--- a/src/xmldocument.h
+++ b/src/old/xmldocument.h
@@ -39,13 +39,7 @@ public:
          * the node and setting the content and name.  If this is set to true the
          * node is appended, but the context node doesn't change.
          */
-        void addNode( const char *sName=NULL, const char *sContent=NULL, bool bClose=false );
-
-        /**
-         * Set the name of the current node context.
-         *@param sName The new name of the node.
-         */
-        void setName( const char *sName );
+        void addNode( const Bu::FString &sName );
 
         /**
          * Close the current node context.  This will move the current context to
diff --git a/src/xmlfilereader.cpp b/src/old/xmlfilereader.cpp
index ed674a8..ed674a8 100644
--- a/src/xmlfilereader.cpp
+++ b/src/old/xmlfilereader.cpp
diff --git a/src/xmlfilereader.h b/src/old/xmlfilereader.h
index e3e02c2..e3e02c2 100644
--- a/src/xmlfilereader.h
+++ b/src/old/xmlfilereader.h
diff --git a/src/xmlfilewriter.cpp b/src/old/xmlfilewriter.cpp
index 3c6fb41..3c6fb41 100644
--- a/src/xmlfilewriter.cpp
+++ b/src/old/xmlfilewriter.cpp
diff --git a/src/xmlfilewriter.h b/src/old/xmlfilewriter.h
index e328f96..e328f96 100644
--- a/src/xmlfilewriter.h
+++ b/src/old/xmlfilewriter.h
diff --git a/src/xmlnode.cpp b/src/old/xmlnode.cpp
index b1ed9a9..96d5850 100644
--- a/src/xmlnode.cpp
+++ b/src/old/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 )
 {
 }
-
+*/
diff --git a/src/xmlnode.h b/src/old/xmlnode.h
index 7525306..c895cd8 100644
--- a/src/xmlnode.h
+++ b/src/old/xmlnode.h
@@ -2,8 +2,9 @@
 #define XMLNODE
 
 #include <iostream>
-#include "linkedlist.h"
-#include "hashtable.h"
+#include "bu/list.h"
+#include "bu/hash.h"
+#include "bu/fstring.h"
 
 /**
  * Maintains all data pertient to an XML node, including sub-nodes and content.
@@ -25,9 +26,8 @@ public:
          *@param sContent The initial content string.
          */
         XmlNode(
-                const char *sName=NULL,
-                XmlNode *pParent = NULL,
-                const char *sContent=NULL
+                const Bu::FString &sName,
+                XmlNode *pParent=NULL
                 );
         
         /**
@@ -39,7 +39,7 @@ public:
          * Change the name of the node.
          *@param sName The new name of the node.
          */
-        void setName( const char *sName );
+        //void setName( const char *sName );
 
         /**
          * Construct a new node and add it as a child to this node, also return a
@@ -48,7 +48,7 @@ public:
          *@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 );
+        XmlNode *addChild( const Bu::FString &sName );
 
         /**
          * Add an already created XmlNode as a child to this node.  The new child
@@ -65,7 +65,7 @@ public:
          * in use will overwrite that property.
          *@param sValue The textual value of the property.
          */
-        void addProperty( const char *sName, const char *sValue );
+        void addProperty( const Bu::FString &sName, const Bu::FString &sValue );
 
         /**
          * Get a pointer to the parent node, if any.
@@ -86,14 +86,6 @@ public:
         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.
@@ -101,14 +93,14 @@ public:
          *@returns A pointer to the child, or NULL if no child with that name was
          * found.
          */
-        XmlNode *getChild( const char *sName, int nSkip=0 );
+        XmlNode *getChild( const Bu::FString &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();
+        Bu::FString getName();
 
         /**
          * Set the content of this node, optionally at a specific index.  Using the
@@ -116,14 +108,7 @@ public:
          *@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 );
+        //void setContent( const char *sContent, int nIndex=-1 );
 
         /**
          * Get the number of properties in this node.
@@ -132,36 +117,12 @@ public:
         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.
-         */
-        void deleteProperty( int nIndex );
+        Bu::FString getProperty( const Bu::FString &sName );
 
         /**
          * Delete a child node, possibly replacing it with some text.  This actually
@@ -171,7 +132,7 @@ public:
          *@returns True of the node was found, and deleted, false if it wasn't
          * found.
          */
-        void deleteNode( int nIndex, const char *sReplacementText = NULL );
+        //void deleteNode( int nIndex, const char *sReplacementText = NULL );
 
         /**
          * Delete a given node, but move all of it's children and content up to
@@ -180,7 +141,7 @@ public:
          *@param nIndex The node to delete.
          *@returns True if the node was found and deleted, false if it wasn't.
          */
-        void deleteNodeKeepChildren( int nIndex );
+        //void deleteNodeKeepChildren( int nIndex );
 
         /**
          * Detatch a given child node from this node.  This effectively works just
@@ -192,7 +153,7 @@ public:
          *@returns A pointer to the newly detatched node, which then passes
          * ownership to the caller.
          */
-        XmlNode *detatchNode( int nIndex, const char *sReplacementText = NULL );
+        //XmlNode *detatchNode( int nIndex, const char *sReplacementText = NULL );
 
         /**
          * Replace a given node with a different node that is not currently owned by
@@ -201,7 +162,7 @@ public:
          *@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.
          */
-        void replaceNode( int nIndex, XmlNode *pNewNode );
+        //void replaceNode( int nIndex, XmlNode *pNewNode );
 
         /**
          * Replace a given node with the children and content of a given node.
@@ -210,24 +171,34 @@ public:
          * replace the node specified by nIndex.
          *@returns True if the node was found and replaced, false if it wasn't.
          */
-        void replaceNodeWithChildren( int nIndex, XmlNode *pNewNode );
+        //void 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();
+        //XmlNode *getCopy();
+        
+        enum ChildType
+        {
+                typeNode,
+                typeContent
+        };
 
 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. */
+        typedef struct
+        {
+                uint8_t nType;
+                union {
+                        XmlNode *pNode;
+                        Bu::FString *pContent;
+                };
+        } Child;
+        Bu::FString sName;      /**< The name of the node. */
+        Bu::List<Child> lChildren;      /**< The children. */
+        Bu::Hash<Bu::FString, Bu::FString> hProperties; /**< Property hashtable. */
+        Bu::Hash<Bu::FString, Bu::List<XmlNode *> > hChildren;  /**< Children hashtable. */
         XmlNode *pParent;       /**< A pointer to the parent of this node. */
         int nCurContent;        /**< The current content we're on, for using the -1 on
                                                          setContent. */
diff --git a/src/xmlreader.cpp b/src/old/xmlreader.cpp
index 18df69c..38cad5f 100644
--- a/src/xmlreader.cpp
+++ b/src/old/xmlreader.cpp
@@ -1,32 +1,49 @@
-#include "xmlreader.h"
-#include "exceptions.h"
+#include "bu/xmlreader.h"
+#include "bu/exceptions.h"
 #include <string.h>
-#include "hashfunctionstring.h"
 
-XmlReader::XmlReader( bool bStrip ) :
-        bStrip( bStrip ),
-        htEntity( new HashFunctionString(), 11 )
+XmlReader::XmlReader( Bu::Stream &sIn, bool bStrip ) :
+        sIn( sIn ),
+        bStrip( bStrip )
 {
+        buildDoc();
 }
 
 XmlReader::~XmlReader()
 {
-        void *i = htEntity.getFirstItemPos();
-        while( (i = htEntity.getNextItemPos( i ) ) )
+}
+
+char XmlReader::getChar( int nIndex )
+{
+        if( sBuf.getSize() <= nIndex )
         {
-                free( (char *)(htEntity.getItemID( i )) );
-                delete (StaticString *)htEntity.getItemData( i );
+                int nInc = nIndex-sBuf.getSize()+1;
+                char *buf = new char[nInc];
+                sIn.read( buf, nInc );
+                sBuf.append( buf, nInc );
+                delete[] buf;
         }
+
+        return sBuf[nIndex];
 }
 
-void XmlReader::addEntity( const char *name, const char *value )
+void XmlReader::usedChar( int nAmnt )
 {
-        if( htEntity[name] ) return;
-
-        char *sName = strdup( name );
-        StaticString *sValue = new StaticString( value );
+        if( nAmnt >= sBuf.getSize() )
+        {
+                sBuf.clear();
+        }
+        else
+        {
+                char *s = sBuf.getStr();
+                memcpy( s, s+nAmnt, sBuf.getSize()-nAmnt );
+                sBuf.resize( sBuf.getSize()-nAmnt );
+        }
+}
 
-        htEntity.insert( sName, sValue );
+void XmlReader::addEntity( const Bu::FString &name, const Bu::FString &value )
+{
+        htEntity[name] = value;
 }
 
 #define gcall( x ) if( x == false ) return false;
@@ -99,7 +116,7 @@ void XmlReader::entity()
                 {
                         usedChar( 2 );
                         ws();
-                        std::string buf;
+                        Bu::FString buf;
                         for(;;)
                         {
                                 char chr = getChar();
@@ -111,7 +128,7 @@ void XmlReader::entity()
                         if( strcmp( buf.c_str(), "ENTITY") == 0 )
                         {
                                 ws();
-                                std::string name;
+                                Bu::FString name;
                                 for(;;)
                                 {
                                         char chr = getChar();
@@ -124,21 +141,19 @@ void XmlReader::entity()
                                 usedChar();
                                 if( quot != '\'' && quot != '\"' )
                                 {
-                                        throw XmlException(
+                                        throw Bu::XmlException(
                                                 "Only quoted entity values are supported."
                                                 );
                                 }
-                                std::string value;
+                                Bu::FString value;
                                 for(;;)
                                 {
                                         char chr = getChar();
                                         usedChar();
                                         if( chr == '&' )
                                         {
-                                                StaticString *tmp = getEscape();
-                                                if( tmp == NULL ) throw XmlException("Entity thing");
-                                                value += tmp->getString();
-                                                delete tmp;
+                                                Bu::FString tmp = getEscape();
+                                                value += tmp;
                                         }
                                         else if( chr == quot )
                                         {
@@ -158,7 +173,7 @@ void XmlReader::entity()
                                 }
                                 else
                                 {
-                                        throw XmlException(
+                                        throw Bu::XmlException(
                                                 "Malformed ENTITY:  unexpected '%c' found.",
                                                 getChar()
                                                 );
@@ -166,7 +181,7 @@ void XmlReader::entity()
                         }
                         else
                         {
-                                throw XmlException(
+                                throw Bu::XmlException(
                                         "Unsupported header symbol: %s",
                                         buf.c_str()
                                         );
@@ -203,12 +218,12 @@ bool XmlReader::node()
                 }
                 else
                 {
-                        throw XmlException("Close node in singleNode malformed!");
+                        throw Bu::XmlException("Close node in singleNode malformed!");
                 }
         }
         else
         {
-                throw XmlException("Close node expected, but not found.");
+                throw Bu::XmlException("Close node expected, but not found.");
                 return false;
         }
 
@@ -224,7 +239,7 @@ bool XmlReader::startNode()
                 if( getChar() == '/' )
                 {
                         // Heh, it's actually a close node, go figure
-                        FlexBuf fbName;
+                        Bu::FString sName;
                         usedChar();
                         gcall( ws() );
 
@@ -235,19 +250,19 @@ bool XmlReader::startNode()
                                 {
                                         // Here we actually compare the name we got to the name
                                         // we already set, they have to match exactly.
-                                        if( !strcasecmp( getCurrent()->getName(), fbName.getData() ) )
+                                        if( getCurrent()->getName() == sName )
                                         {
                                                 closeNode();
                                                 break;
                                         }
                                         else
                                         {
-                                                throw XmlException("Got a mismatched node close tag.");
+                                                throw Bu::XmlException("Got a mismatched node close tag.");
                                         }
                                 }
                                 else
                                 {
-                                        fbName.appendData( chr );
+                                        sName += chr;
                                         usedChar();
                                 }
                         }
@@ -260,13 +275,13 @@ bool XmlReader::startNode()
                         }
                         else
                         {
-                                throw XmlException("Got extra junk data instead of node close tag.");
+                                throw Bu::XmlException("Got extra junk data instead of node close tag.");
                         }
                 }
                 else
                 {
                         // We're good, format is consistant
-                        addNode();
+                        //addNode();
 
                         // Skip extra whitespace
                         gcall( ws() );
@@ -278,7 +293,7 @@ bool XmlReader::startNode()
         }
         else
         {
-                throw XmlException("Expected to find node opening char, '<'.");
+                throw Bu::XmlException("Expected to find node opening char, '<'.");
         }
 
         return true;
@@ -286,19 +301,19 @@ bool XmlReader::startNode()
 
 bool XmlReader::name()
 {
-        FlexBuf fbName;
+        Bu::FString sName;
         
         while( true )
         {
                 char chr = getChar();
                 if( isws( chr ) || chr == '>' || chr == '/' )
                 {
-                        setName( fbName.getData() );
+                        addNode( sName );
                         return true;
                 }
                 else
                 {
-                        fbName.appendData( chr );
+                        sName += chr;
                         usedChar();
                 }
         }
@@ -325,7 +340,7 @@ bool XmlReader::paramlist()
         return true;
 }
 
-StaticString *XmlReader::getEscape()
+Bu::FString XmlReader::getEscape()
 {
         if( getChar( 1 ) == '#' )
         {
@@ -349,12 +364,12 @@ StaticString *XmlReader::getEscape()
                 buf[0] = (char)strtol( buf, (char **)NULL, base );
                 buf[1] = '\0';
 
-                return new StaticString( buf );
+                return buf;
         }
         else
         {
                 // ...otherwise replace with the appropriate string...
-                std::string buf;
+                Bu::FString buf;
                 usedChar();
                 for(;;)
                 {
@@ -364,18 +379,14 @@ StaticString *XmlReader::getEscape()
                         buf += cbuf;
                 }
 
-                StaticString *tmp = (StaticString *)htEntity[buf.c_str()];
-                if( tmp == NULL ) return NULL;
-
-                StaticString *ret = new StaticString( *tmp );
-                return ret;
+                return htEntity[buf];
         }
 }
 
 bool XmlReader::param()
 {
-        FlexBuf fbName;
-        FlexBuf fbValue;
+        Bu::FString sName;
+        Bu::FString sValue;
 
         while( true )
         {
@@ -386,7 +397,7 @@ bool XmlReader::param()
                 }
                 else
                 {
-                        fbName.appendData( chr );
+                        sName.append( chr );
                         usedChar();
                 }
         }
@@ -411,21 +422,18 @@ bool XmlReader::param()
                                 if( chr == '"' )
                                 {
                                         usedChar();
-                                        addProperty( fbName.getData(), fbValue.getData() );
+                                        addProperty( sName.getStr(), sValue.getStr() );
                                         return true;
                                 }
                                 else
                                 {
                                         if( chr == '&' )
                                         {
-                                                StaticString *tmp = getEscape();
-                                                if( tmp == NULL ) return false;
-                                                fbValue.appendData( tmp->getString() );
-                                                delete tmp;
+                                                sValue += getEscape();
                                         }
                                         else
                                         {
-                                                fbValue.appendData( chr );
+                                                sValue += chr;
                                                 usedChar();
                                         }
                                 }
@@ -439,21 +447,18 @@ bool XmlReader::param()
                                 chr = getChar();
                                 if( isws( chr ) || chr == '/' || chr == '>' )
                                 {
-                                        addProperty( fbName.getData(), fbValue.getData() );
+                                        addProperty( sName.getStr(), sValue.getStr() );
                                         return true;
                                 }
                                 else
                                 {
                                         if( chr == '&' )
                                         {
-                                                StaticString *tmp = getEscape();
-                                                if( tmp == NULL ) return false;
-                                                fbValue.appendData( tmp->getString() );
-                                                delete tmp;
+                                                sValue += getEscape();
                                         }
                                         else
                                         {
-                                                fbValue.appendData( chr );
+                                                sValue += chr;
                                                 usedChar();
                                         }
                                 }
@@ -462,7 +467,7 @@ bool XmlReader::param()
         }
         else
         {
-                throw XmlException("Expected an equals to seperate the params.");
+                throw Bu::XmlException("Expected an equals to seperate the params.");
                 return false;
         }
 
@@ -471,7 +476,7 @@ bool XmlReader::param()
 
 bool XmlReader::content()
 {
-        FlexBuf fbContent;
+        Bu::FString sContent;
 
         if( bStrip ) gcall( ws() );
 
@@ -482,37 +487,37 @@ bool XmlReader::content()
                 {
                         if( getChar(1) == '/' )
                         {
-                                if( fbContent.getLength() > 0 )
+                                if( sContent.getSize() > 0 )
                                 {
                                         if( bStrip )
                                         {
                                                 int j;
-                                                for( j = fbContent.getLength()-1; isws(fbContent.getData()[j]); j-- );
-                                                ((char *)fbContent.getData())[j+1] = '\0';
+                                                for( j = sContent.getSize()-1; isws(sContent[j]); j-- );
+                                                sContent[j+1] = '\0';
                                         }
-                                        setContent( fbContent.getData() );
+                                        setContent( sContent.getStr() );
                                 }
                                 usedChar( 2 );
                                 gcall( ws() );
-                                FlexBuf fbName;
+                                Bu::FString sName;
                                 while( true )
                                 {
                                         chr = getChar();
                                         if( isws( chr ) || chr == '>' )
                                         {
-                                                if( !strcasecmp( getCurrent()->getName(), fbName.getData() ) )
+                                                if( !strcasecmp( getCurrent()->getName().getStr(), sName.getStr() ) )
                                                 {
                                                         closeNode();
                                                         break;
                                                 }
                                                 else
                                                 {
-                                                        throw XmlException("Mismatched close tag found: <%s> to <%s>.", getCurrent()->getName(), fbName.getData() );
+                                                        throw Bu::XmlException("Mismatched close tag found: <%s> to <%s>.", getCurrent()->getName().getStr(), sName.getStr() );
                                                 }
                                         }
                                         else
                                         {
-                                                fbName.appendData( chr );
+                                                sName += chr;
                                                 usedChar();
                                         }
                                 }
@@ -524,7 +529,7 @@ bool XmlReader::content()
                                 }
                                 else
                                 {
-                                        throw XmlException("Malformed close tag.");
+                                        throw Bu::XmlException("Malformed close tag.");
                                 }
                         }
                         else if( getChar(1) == '!' )
@@ -534,7 +539,7 @@ bool XmlReader::content()
                                         getChar(3) != '-' )
                                 {
                                         // Not a valid XML comment
-                                        throw XmlException("Malformed comment start tag found.");
+                                        throw Bu::XmlException("Malformed comment start tag found.");
                                 }
 
                                 usedChar( 4 );
@@ -549,7 +554,7 @@ bool XmlReader::content()
                                                         // The next one has to be a '>' now
                                                         if( getChar( 2 ) != '>' )
                                                         {
-                                                                throw XmlException("Malformed comment close tag found.  You cannot have a '--' that isn't followed by a '>' in a comment.");
+                                                                throw Bu::XmlException("Malformed comment close tag found.  You cannot have a '--' that isn't followed by a '>' in a comment.");
                                                         }
                                                         usedChar( 3 );
                                                         break;
@@ -569,16 +574,16 @@ bool XmlReader::content()
                         }
                         else
                         {
-                                if( fbContent.getLength() > 0 )
+                                if( sContent.getSize() > 0 )
                                 {
                                         if( bStrip )
                                         {
                                                 int j;
-                                                for( j = fbContent.getLength()-1; isws(fbContent.getData()[j]); j-- );
-                                                ((char *)fbContent.getData())[j+1] = '\0';
+                                                for( j = sContent.getSize()-1; isws(sContent[j]); j-- );
+                                                sContent[j+1] = '\0';
                                         }
-                                        setContent( fbContent.getData() );
-                                        fbContent.clearData();
+                                        setContent( sContent.getStr() );
+                                        sContent.clear();
                                 }
                                 gcall( node() );
                         }
@@ -587,14 +592,11 @@ bool XmlReader::content()
                 }
                 else if( chr == '&' )
                 {
-                        StaticString *tmp = getEscape();
-                        if( tmp == NULL ) return false;
-                        fbContent.appendData( tmp->getString() );
-                        delete tmp;
+                        sContent += getEscape();
                 }
                 else
                 {
-                        fbContent.appendData( chr );
+                        sContent += chr;
                         usedChar();
                 }
         }
diff --git a/src/xmlreader.h b/src/old/xmlreader.h
index c8f7202..7c85ddb 100644
--- a/src/xmlreader.h
+++ b/src/old/xmlreader.h
@@ -2,10 +2,10 @@
 #define XMLREADER
 
 #include <stdio.h>
-#include "xmldocument.h"
-#include "flexbuf.h"
-#include "hashtable.h"
-#include "staticstring.h"
+#include "bu/xmldocument.h"
+#include "bu/hash.h"
+#include "bu/fstring.h"
+#include "bu/stream.h"
 
 /**
  * Takes care of reading in xml formatted data from a file.  This could/should
@@ -32,7 +32,7 @@ public:
          * in content, a-la html.
          *@param bStrip Strip out leading and trailing whitespace?
          */
-        XmlReader( bool bStrip=false );
+        XmlReader( Bu::Stream &sIn, bool bStrip=false );
 
         /**
          * Destroy this XmlReader.
@@ -54,12 +54,12 @@ private:
          *@returns A single character at the requested position, or 0 for end of
          * stream.
          */
-        virtual char getChar( int nIndex = 0 ) = 0;
+        virtual char getChar( int nIndex = 0 );
 
         /**
          * Called to increment the current stream position by a single character.
          */
-        virtual void usedChar( int nAmnt = 1) = 0;
+        virtual void usedChar( int nAmnt = 1 );
 
         /**
          * Automoton function: is whitespace.
@@ -108,9 +108,9 @@ private:
          *@param name The name of the entity
          *@param value The value of the entity
          */
-        void addEntity( const char *name, const char *value );
+        void addEntity( const Bu::FString &name, const Bu::FString &value );
 
-        StaticString *getEscape();
+        Bu::FString getEscape();
 
         /**
          * Automoton function: paramlist.  Processes a list of node params.
@@ -130,12 +130,15 @@ private:
          */
         bool content();
         
-        FlexBuf fbContent;              /**< buffer for the current node's content. */
-        FlexBuf fbParamName;    /**< buffer for the current param's name. */
-        FlexBuf fbParamValue;   /**< buffer for the current param's value. */
-        bool bStrip;    /**< Are we stripping whitespace? */
+        Bu::FString sContent;           /**< buffer for the current node's content. */
+        Bu::FString sParamName;         /**< buffer for the current param's name. */
+        Bu::FString sParamValue;        /**< buffer for the current param's value. */
+        Bu::Stream &sIn;
+        bool bStrip;                    /**< Are we stripping whitespace? */
 
-        HashTable htEntity;             /**< Entity type definitions. */
+        Bu::Hash<Bu::FString,Bu::FString> htEntity;             /**< Entity type definitions. */
+
+        Bu::FString sBuf;
 };
 
 #endif
diff --git a/src/xmlstringreader.cpp b/src/old/xmlstringreader.cpp
index 3956ff3..3956ff3 100644
--- a/src/xmlstringreader.cpp
+++ b/src/old/xmlstringreader.cpp
diff --git a/src/xmlstringreader.h b/src/old/xmlstringreader.h
index 1239ef4..1239ef4 100644
--- a/src/xmlstringreader.h
+++ b/src/old/xmlstringreader.h
diff --git a/src/xmlstringwriter.cpp b/src/old/xmlstringwriter.cpp
index adeed6a..adeed6a 100644
--- a/src/xmlstringwriter.cpp
+++ b/src/old/xmlstringwriter.cpp
diff --git a/src/xmlstringwriter.h b/src/old/xmlstringwriter.h
index 0d567b9..0d567b9 100644
--- a/src/xmlstringwriter.h
+++ b/src/old/xmlstringwriter.h
diff --git a/src/xmlwriter.cpp b/src/old/xmlwriter.cpp
index 56880b6..7dc6ca9 100644
--- a/src/xmlwriter.cpp
+++ b/src/old/xmlwriter.cpp
@@ -2,17 +2,10 @@
 #include <stdlib.h>
 #include "xmlwriter.h"
 
-XmlWriter::XmlWriter( const char *sIndent, XmlNode *pRoot ) :
-        XmlDocument( pRoot )
+XmlWriter::XmlWriter( const Bu::FString &sIndent, XmlNode *pRoot ) :
+        XmlDocument( pRoot ),
+        sIndent( sIndent )
 {
-        if( sIndent == NULL )
-        {
-                this->sIndent = "";
-        }
-        else
-        {
-                this->sIndent = sIndent;
-        }
 }
 
 XmlWriter::~XmlWriter()
@@ -24,7 +17,7 @@ void XmlWriter::write()
         write( getRoot(), sIndent.c_str() );
 }
 
-void XmlWriter::write( XmlNode *pRoot, const char *sIndent )
+void XmlWriter::write( XmlNode *pRoot, const Bu::FString &sIndent )
 {
         writeNode( pRoot, 0, sIndent );
 }
@@ -39,7 +32,7 @@ void XmlWriter::closeNode()
         }
 }
 
-void XmlWriter::writeIndent( int nIndent, const char *sIndent )
+void XmlWriter::writeIndent( int nIndent, const Bu::FString &sIndent )
 {
         if( sIndent == NULL ) return;
         for( int j = 0; j < nIndent; j++ )
@@ -48,26 +41,27 @@ void XmlWriter::writeIndent( int nIndent, const char *sIndent )
         }
 }
 
-std::string XmlWriter::escape( std::string sIn )
+Bu::FString XmlWriter::escape( const Bu::FString &sIn )
 {
-        std::string sOut;
+        Bu::FString sOut;
 
-        std::string::const_iterator i;
-        for( i = sIn.begin(); i != sIn.end(); i++ )
+        int nMax = sIn.getSize();
+        for( int j = 0; j < nMax; j++ )
         {
-                if( ((*i >= ' ' && *i <= '9') ||
-                        (*i >= 'a' && *i <= 'z') ||
-                        (*i >= 'A' && *i <= 'Z') ) &&
-                        (*i != '\"' && *i != '\'' && *i != '&')
+                char c = sIn[j];
+                if( ((c >= ' ' && c <= '9') ||
+                        (c >= 'a' && c <= 'z') ||
+                        (c >= 'A' && c <= 'Z') ) &&
+                        (c != '\"' && c != '\'' && c != '&')
                   )
                 {
-                        sOut += *i;
+                        sOut += c;
                 }
                 else
                 {
                         sOut += "&#";
                         char buf[4];
-                        sprintf( buf, "%u", (unsigned char)*i );
+                        sprintf( buf, "%u", (unsigned char)c );
                         sOut += buf;
                         sOut += ';';
                 }
@@ -76,19 +70,19 @@ std::string XmlWriter::escape( std::string sIn )
         return sOut;
 }
 
-void XmlWriter::writeNodeProps( XmlNode *pNode, int nIndent, const char *sIndent )
+void XmlWriter::writeNodeProps( XmlNode *pNode, int nIndent, const Bu::FString &sIndent )
 {
         for( int j = 0; j < pNode->getNumProperties(); j++ )
         {
                 writeString(" ");
-                writeString( pNode->getPropertyName( j ) );
+                //writeString( pNode->getPropertyName( j ) );
                 writeString("=\"");
-                writeString( escape( pNode->getProperty( j ) ).c_str() );
+                //writeString( escape( pNode->getProperty( j ) ).c_str() );
                 writeString("\"");
         }
 }
 
-void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
+void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const Bu::FString &sIndent )
 {
         if( pNode->hasChildren() )
         {
@@ -96,15 +90,15 @@ void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
                 writeString("<");
                 writeString( pNode->getName() );
                 writeNodeProps( pNode, nIndent, sIndent );
-                if( sIndent )
+                if( sIndent != "" )
                         writeString(">\n");
                 else
                         writeString(">");
-
+/*
                 if( pNode->getContent( 0 ) )
                 {
                         writeIndent( nIndent+1, sIndent );
-                        if( sIndent )
+                        if( sIndent != "" )
                         {
                                 writeString( pNode->getContent( 0 ) );
                                 writeString("\n");
@@ -129,9 +123,9 @@ void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
                                         writeString( pNode->getContent( j+1 ) );
                         }
                 }
-                
+*/              
                 writeIndent( nIndent, sIndent );
-                if( sIndent )
+                if( sIndent != "" )
                 {
                         writeString("</");
                         writeString( pNode->getName() );
@@ -143,7 +137,7 @@ void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
                         writeString( pNode->getName() );
                         writeString(">");
                 }
-        }
+        }/*
         else if( pNode->getContent() )
         {
                 writeIndent( nIndent, sIndent );
@@ -157,14 +151,14 @@ void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
                 writeString(">");
                 if( sIndent )
                         writeString("\n");
-        }
+        }*/
         else
         {
                 writeIndent( nIndent, sIndent );
                 writeString("<");
                 writeString( pNode->getName() );
                 writeNodeProps( pNode, nIndent, sIndent );
-                if( sIndent )
+                if( sIndent != "" )
                         writeString("/>\n");
                 else
                         writeString("/>");
diff --git a/src/xmlwriter.h b/src/old/xmlwriter.h
index c48e810..7e3c876 100644
--- a/src/xmlwriter.h
+++ b/src/old/xmlwriter.h
@@ -31,7 +31,7 @@ public:
          * this to a tab or some spaces it will never effect the content of your
          * file.
          */
-        XmlWriter( const char *sIndent=NULL, XmlNode *pRoot=NULL );
+        XmlWriter( const Bu::FString &sIndent="", XmlNode *pRoot=NULL );
 
         /**
          * Destroy the writer.
@@ -49,16 +49,16 @@ public:
         void write();
 
 private:
-        std::string sIndent;    /**< The indent string */
+        Bu::FString sIndent;    /**< The indent string */
 
-        std::string escape( std::string sIn );
+        Bu::FString escape( const Bu::FString &sIn );
         
         /**
          * Write the file.
          *@param pNode The root node
          *@param sIndent The indent text.
          */
-        void write( XmlNode *pNode, const char *sIndent=NULL );
+        void write( XmlNode *pNode, const Bu::FString &sIndent );
 
         /**
          * Write a node in the file, including children.
@@ -66,7 +66,7 @@ private:
          *@param nIndent The indent level (the number of times to include sIndent)
          *@param sIndent The indent text.
          */
-        void writeNode( XmlNode *pNode, int nIndent, const char *sIndent );
+        void writeNode( XmlNode *pNode, int nIndent, const Bu::FString &sIndent );
 
         /**
          * Write the properties of a node.
@@ -74,14 +74,14 @@ private:
          *@param nIndent The indent level of the containing node
          *@param sIndent The indent text.
          */
-        void writeNodeProps( XmlNode *pNode, int nIndent, const char *sIndent );
+        void writeNodeProps( XmlNode *pNode, int nIndent, const Bu::FString &sIndent );
 
         /**
          * Called to write the actual indent.
          *@param nIndent The indent level.
          *@param sIndent The indent text.
          */
-        void writeIndent( int nIndent, const char *sIndent );
+        void writeIndent( int nIndent, const Bu::FString &sIndent );
 
         /**
          * This is the function that must be overridden in order to use this class.
@@ -90,7 +90,7 @@ private:
          * will break the XML formatting.
          *@param sString The string data to write to the output.
          */
-        virtual void writeString( const char *sString ) = 0;
+        virtual void writeString( const Bu::FString &sString ) = 0;
 };
 
 #endif
diff --git a/src/paramproc.cpp b/src/paramproc.cpp
index a352e66..34e973e 100644
--- a/src/paramproc.cpp
+++ b/src/paramproc.cpp
@@ -2,10 +2,10 @@
 #include <stdio.h>
 
 #define ptrtype( iitype, iiname ) \
-        ParamProc::ParamPtr::ParamPtr( iitype *iiname ) :       \
+        Bu::ParamProc::ParamPtr::ParamPtr( iitype *iiname ) :   \
                 type( vt ##iiname ) { val.iiname = iiname; }
 
-ParamProc::ParamPtr::ParamPtr()
+Bu::ParamProc::ParamPtr::ParamPtr()
 {
         val.str = NULL;
         type = vtunset;
@@ -25,7 +25,7 @@ ptrtype( double,      float64 );
 ptrtype( long double, float96 );
 ptrtype( bool,        bln     );
 
-ParamProc::ParamPtr &ParamProc::ParamPtr::operator=( ParamProc::ParamPtr &ptr )
+Bu::ParamProc::ParamPtr &Bu::ParamProc::ParamPtr::operator=( ParamProc::ParamPtr &ptr )
 {
         val = ptr.val;
         type = ptr.type;
@@ -33,12 +33,12 @@ ParamProc::ParamPtr &ParamProc::ParamPtr::operator=( ParamProc::ParamPtr &ptr )
         return *this;
 }
 
-bool ParamProc::ParamPtr::isSet()
+bool Bu::ParamProc::ParamPtr::isSet()
 {
         return type != vtunset;
 }
 
-ParamProc::ParamPtr &ParamProc::ParamPtr::operator=( const char *str )
+Bu::ParamProc::ParamPtr &Bu::ParamProc::ParamPtr::operator=( const char *str )
 {
         if( !isSet() ) return *this;
         switch( type )
@@ -107,11 +107,11 @@ ParamProc::ParamPtr &ParamProc::ParamPtr::operator=( const char *str )
         return *this;
 }
 
-ParamProc::ParamProc()
+Bu::ParamProc::ParamProc()
 {
 }
 
-ParamProc::~ParamProc()
+Bu::ParamProc::~ParamProc()
 {
         for( std::list<ArgSpec *>::iterator i = lArg.begin();
                  i != lArg.end(); i++ )
@@ -127,14 +127,14 @@ ParamProc::~ParamProc()
 
 }
 /*
-void ParamProc::addParam( const char *lpWord, char cChar, Proc proc, ParamPtr val )
+void Bu::ParamProc::addParam( const char *lpWord, char cChar, Proc proc, ParamPtr val )
 {
         printf("Calling callback...\n");
         val = "Hello there, this is set in the ParamProc";
         (this->*proc)();
 }*/
 
-void ParamProc::addParam( const char *lpWord, char cChar, Proc proc,
+void Bu::ParamProc::addParam( const char *lpWord, char cChar, Proc proc,
         ParamPtr val, const char *lpDesc, const char *lpExtra,
         const char *lpValue )
 {
@@ -161,63 +161,63 @@ void ParamProc::addParam( const char *lpWord, char cChar, Proc proc,
         }
 }
 
-void ParamProc::addParam( const char *lpWord, char cChar, Proc proc,
+void Bu::ParamProc::addParam( const char *lpWord, char cChar, Proc proc,
         const char *lpDesc, const char *lpExtra,
         const char *lpValue )
 {
         addParam( lpWord, cChar, proc, ParamPtr(), lpDesc, lpExtra, lpValue );
 }
 
-void ParamProc::addParam( const char *lpWord, char cChar, ParamPtr val,
+void Bu::ParamProc::addParam( const char *lpWord, char cChar, ParamPtr val,
         const char *lpDesc, const char *lpExtra,
         const char *lpValue )
 {
         addParam( lpWord, cChar, NULL, val, lpDesc, lpExtra, lpValue );
 }
 
-void ParamProc::addParam( const char *lpWord, Proc proc, ParamPtr val,
+void Bu::ParamProc::addParam( const char *lpWord, Proc proc, ParamPtr val,
         const char *lpDesc, const char *lpExtra,
         const char *lpValue )
 {
         addParam( lpWord, '\0', proc, val, lpDesc, lpExtra, lpValue );
 }
 
-void ParamProc::addParam( const char *lpWord, Proc proc,
+void Bu::ParamProc::addParam( const char *lpWord, Proc proc,
         const char *lpDesc, const char *lpExtra,
         const char *lpValue )
 {
         addParam( lpWord, '\0', proc, ParamPtr(), lpDesc, lpExtra, lpValue );
 }
 
-void ParamProc::addParam( const char *lpWord, ParamPtr val,
+void Bu::ParamProc::addParam( const char *lpWord, ParamPtr val,
         const char *lpDesc, const char *lpExtra,
         const char *lpValue )
 {
         addParam( lpWord, '\0', NULL, val, lpDesc, lpExtra, lpValue );
 }
 
-void ParamProc::addParam( char cChar, Proc proc, ParamPtr val,
+void Bu::ParamProc::addParam( char cChar, Proc proc, ParamPtr val,
         const char *lpDesc, const char *lpExtra,
         const char *lpValue )
 {
         addParam( NULL, cChar, proc, val, lpDesc, lpExtra, lpValue );
 }
 
-void ParamProc::addParam( char cChar, Proc proc,
+void Bu::ParamProc::addParam( char cChar, Proc proc,
         const char *lpDesc, const char *lpExtra,
         const char *lpValue )
 {
         addParam( NULL, cChar, proc, ParamPtr(), lpDesc, lpExtra, lpValue );
 }
 
-void ParamProc::addParam( char cChar, ParamPtr val,
+void Bu::ParamProc::addParam( char cChar, ParamPtr val,
         const char *lpDesc, const char *lpExtra,
         const char *lpValue )
 {
         addParam( NULL, cChar, NULL, val, lpDesc, lpExtra, lpValue );
 }
 
-void ParamProc::process( int argc, char *argv[] )
+void Bu::ParamProc::process( int argc, char *argv[] )
 {
         for( int arg = 1; arg < argc; arg++ )
         {
@@ -229,23 +229,23 @@ void ParamProc::process( int argc, char *argv[] )
                                 ArgSpec *s = checkWord( argv[arg]+2 );
                                 if( s )
                                 {
-                                        if( argv[arg][s->sWord.getLength()+2] == '=' )
+                                        if( argv[arg][s->sWord.getSize()+2] == '=' )
                                         {
                                                 if( s->val.isSet() )
                                                 {
-                                                        if( s->sValue.getString() == NULL )
+                                                        if( s->sValue.getStr() == NULL )
                                                         {
-                                                                s->val = argv[arg]+s->sWord.getLength()+3;
+                                                                s->val = argv[arg]+s->sWord.getSize()+3;
                                                         }
                                                         else
                                                         {
-                                                                s->val = s->sValue.getString();
+                                                                s->val = s->sValue.getStr();
                                                         }
                                                 }
                                                 if( s->proc )
                                                 {
                                                         char **tmp = new char*[argc-arg];
-                                                        tmp[0] = argv[arg]+s->sWord.getLength()+3;
+                                                        tmp[0] = argv[arg]+s->sWord.getSize()+3;
                                                         for( int k = 1; k < argc-arg; k++ )
                                                                 tmp[k] = argv[arg+k];
                                                         int ret = (this->*s->proc)( argc-arg, tmp );
@@ -261,7 +261,7 @@ void ParamProc::process( int argc, char *argv[] )
                                                 int add = 0;
                                                 if( s->val.isSet() )
                                                 {
-                                                        if( s->sValue.getString() == NULL )
+                                                        if( s->sValue.getStr() == NULL )
                                                         {
                                                                 if( arg+1 >= argc )
                                                                 {
@@ -272,7 +272,7 @@ void ParamProc::process( int argc, char *argv[] )
                                                         }
                                                         else
                                                         {
-                                                                s->val = s->sValue.getString();
+                                                                s->val = s->sValue.getStr();
                                                         }
                                                 }
                                                 if( s->proc )
@@ -307,14 +307,14 @@ void ParamProc::process( int argc, char *argv[] )
                                                         bool bUsed = false;
                                                         if( s->val.isSet() )
                                                         {
-                                                                if( s->sValue.getString() == NULL )
+                                                                if( s->sValue.getStr() == NULL )
                                                                 {
                                                                         s->val = argv[arg]+chr+1;
                                                                         bUsed = true;
                                                                 }
                                                                 else
                                                                 {
-                                                                        s->val = s->sValue.getString();
+                                                                        s->val = s->sValue.getStr();
                                                                 }
                                                         }
                                                         if( s->proc )
@@ -342,14 +342,14 @@ void ParamProc::process( int argc, char *argv[] )
                                                         bool bUsed = false;
                                                         if( s->val.isSet() )
                                                         {
-                                                                if( s->sValue.getString() == NULL )
+                                                                if( s->sValue.getStr() == NULL )
                                                                 {
                                                                         s->val = argv[arg+1];
                                                                         bUsed = true;
                                                                 }
                                                                 else
                                                                 {
-                                                                        s->val = s->sValue.getString();
+                                                                        s->val = s->sValue.getStr();
                                                                 }
                                                         }
                                                         if( s->proc )
@@ -384,22 +384,22 @@ void ParamProc::process( int argc, char *argv[] )
         }
 }
 
-ParamProc::ArgSpec *ParamProc::checkWord( const char *arg )
+Bu::ParamProc::ArgSpec *Bu::ParamProc::checkWord( const char *arg )
 {
         //printf("Checking \"%s\"...\n", arg );
         std::list<ArgSpec *>::const_iterator i;
         for( i = lArg.begin(); i != lArg.end(); i++ )
         {
-                if( (*i)->sWord.getString() == NULL )
+                if( (*i)->sWord.getStr() == NULL )
                         continue;
 
-                if( !strcmp( (*i)->sWord, arg ) )
+                if( !strcmp( (*i)->sWord.getStr(), arg ) )
                         return *i;
 
                 if( (*i)->val.isSet() )
                 {
-                        if( !strncmp( (*i)->sWord, arg, (*i)->sWord.getLength() ) &&
-                                arg[(*i)->sWord.getLength()] == '=' )
+                        if( !strncmp( (*i)->sWord.getStr(), arg, (*i)->sWord.getSize() ) &&
+                                arg[(*i)->sWord.getSize()] == '=' )
                         {
                                 return *i;
                         }
@@ -409,7 +409,7 @@ ParamProc::ArgSpec *ParamProc::checkWord( const char *arg )
         return NULL;
 }
 
-ParamProc::ArgSpec *ParamProc::checkLetr( const char arg )
+Bu::ParamProc::ArgSpec *Bu::ParamProc::checkLetr( const char arg )
 {
         //printf("Checking \'%c\'...\n", arg );
         std::list<ArgSpec *>::const_iterator i;
@@ -427,27 +427,27 @@ ParamProc::ArgSpec *ParamProc::checkLetr( const char arg )
         return NULL;
 }
 
-int ParamProc::cmdParam( int argc, char *argv[] )
+int Bu::ParamProc::cmdParam( int argc, char *argv[] )
 {
         printf("Unhandled command parameter \"%s\" found!\n", argv[0] );
         return 0;
 }
 
-int ParamProc::unknownParam( int argc, char *argv[] )
+int Bu::ParamProc::unknownParam( int argc, char *argv[] )
 {
         printf("Unknown parameter \"%s\" found!\n", argv[0] );
         return 0;
 }
 
-int ParamProc::help( int argc, char *argv[] )
+int Bu::ParamProc::help( int argc, char *argv[] )
 {
         std::list<Banner *>::const_iterator b = lBan.begin();
         std::list<ArgSpec *>::const_iterator i;
         int len=0;
         for( i = lArg.begin(); i != lArg.end(); i++ )
         {
-                if( len < (*i)->sWord.getLength() + (*i)->sExtra.getLength() )
-                        len = (*i)->sWord.getLength() + (*i)->sExtra.getLength();
+                if( len < (*i)->sWord.getSize() + (*i)->sExtra.getSize() )
+                        len = (*i)->sWord.getSize() + (*i)->sExtra.getSize();
         }
         char fmt[10];
         sprintf( fmt, "%%-%ds   ", len );
@@ -458,14 +458,14 @@ int ParamProc::help( int argc, char *argv[] )
                 {
                         if( (*b)->pBefore == (*i) )
                         {
-                                printf( (*b)->sBanner.getString() );
+                                printf( (*b)->sBanner.getStr() );
                                 b++;
                         }
                 }
                 printf("  ");
                 if( (*i)->cChar )
                 {
-                        if( (*i)->sWord.getString() )
+                        if( (*i)->sWord.getStr() )
                         {
                                 printf("-%c, ", (*i)->cChar );
                         }
@@ -478,12 +478,12 @@ int ParamProc::help( int argc, char *argv[] )
                 {
                         printf("    ");
                 }
-                if( (*i)->sWord.getString() )
+                if( (*i)->sWord.getStr() )
                 {
                         printf("--");
-                        std::string sTmp = (*i)->sWord.getString();
-                        if( (*i)->sExtra.getString() )
-                                sTmp += (*i)->sExtra.getString();
+                        std::string sTmp = (*i)->sWord.getStr();
+                        if( (*i)->sExtra.getStr() )
+                                sTmp += (*i)->sExtra.getStr();
                         printf( fmt, sTmp.c_str() );
                 }
                 else
@@ -491,20 +491,20 @@ int ParamProc::help( int argc, char *argv[] )
                         printf("  ");
                         printf(fmt, "" );
                 }
-                printf("%s\n", (*i)->sDesc.getString() );
+                printf("%s\n", (*i)->sDesc.getStr() );
         }
         if( b != lBan.end() )
         {
                 if( (*b)->pBefore == NULL )
                 {
-                        printf( (*b)->sBanner.getString() );
+                        printf( (*b)->sBanner.getStr() );
                 }
         }
 
         exit( 0 );
 }
 
-void ParamProc::addHelpBanner( const char *sHelpBanner )
+void Bu::ParamProc::addHelpBanner( const char *sHelpBanner )
 {
         Banner *pBan = new Banner;
         pBan->sBanner = sHelpBanner;
diff --git a/src/paramproc.h b/src/paramproc.h
index d857193..2bca588 100644
--- a/src/paramproc.h
+++ b/src/paramproc.h
@@ -1,153 +1,156 @@
-#ifndef PARAM_PROC_H
-#define PARAM_PROC_H
+#ifndef BU_PARAM_PROC_H
+#define BU_PARAM_PROC_H
 
 #include <stdint.h>
 #include <string>
 #include <list>
-#include "staticstring.h"
+#include "bu/fstring.h"
 
-class ParamProc
+namespace Bu
 {
-public:
-        class ParamPtr
+        class ParamProc
         {
         public:
-                ParamPtr();
-                ParamPtr( std::string *str );
-                ParamPtr( uint64_t    *uint64  );
-                ParamPtr( uint32_t    *uint32  );
-                ParamPtr( uint16_t    *uint16  );
-                ParamPtr( uint8_t     *uint8   );
-                ParamPtr( int64_t     *int64   );
-                ParamPtr( int32_t     *int32   );
-                ParamPtr( int16_t     *int16   );
-                ParamPtr( int8_t      *int8    );
-                ParamPtr( float       *float32 );
-                ParamPtr( double      *float64 );
-                ParamPtr( long double *float96 );
-                ParamPtr( bool        *bln     );
-
-                enum
+                class ParamPtr
                 {
-                        vtunset,
-                        vtstr,
-                        vtuint64,
-                        vtuint32,
-                        vtuint16,
-                        vtuint8,
-                        vtint64,
-                        vtint32,
-                        vtint16,
-                        vtint8,
-                        vtfloat32,
-                        vtfloat64,
-                        vtfloat96,
-                        vtbln,
-                };
-                ParamPtr &operator=( ParamPtr &ptr );
-                ParamPtr &operator=( const char *str );
+                public:
+                        ParamPtr();
+                        ParamPtr( std::string *str );
+                        ParamPtr( uint64_t    *uint64  );
+                        ParamPtr( uint32_t    *uint32  );
+                        ParamPtr( uint16_t    *uint16  );
+                        ParamPtr( uint8_t     *uint8   );
+                        ParamPtr( int64_t     *int64   );
+                        ParamPtr( int32_t     *int32   );
+                        ParamPtr( int16_t     *int16   );
+                        ParamPtr( int8_t      *int8    );
+                        ParamPtr( float       *float32 );
+                        ParamPtr( double      *float64 );
+                        ParamPtr( long double *float96 );
+                        ParamPtr( bool        *bln     );
 
-                bool isSet();
+                        enum
+                        {
+                                vtunset,
+                                vtstr,
+                                vtuint64,
+                                vtuint32,
+                                vtuint16,
+                                vtuint8,
+                                vtint64,
+                                vtint32,
+                                vtint16,
+                                vtint8,
+                                vtfloat32,
+                                vtfloat64,
+                                vtfloat96,
+                                vtbln,
+                        };
+                        ParamPtr &operator=( ParamPtr &ptr );
+                        ParamPtr &operator=( const char *str );
 
-        private:
-                int type;
-                union
-                {
-                        std::string *str;
-                        uint64_t *uint64;
-                        uint32_t *uint32;
-                        uint16_t *uint16;
-                        uint8_t *uint8;
-                        int64_t *int64;
-                        int32_t *int32;
-                        int16_t *int16;
-                        int8_t *int8;
-                        float *float32;
-                        double *float64;
-                        long double *float96;
-                        bool *bln;
-                } val;
-        };
+                        bool isSet();
+
+                private:
+                        int type;
+                        union
+                        {
+                                std::string *str;
+                                uint64_t *uint64;
+                                uint32_t *uint32;
+                                uint16_t *uint16;
+                                uint8_t *uint8;
+                                int64_t *int64;
+                                int32_t *int32;
+                                int16_t *int16;
+                                int8_t *int8;
+                                float *float32;
+                                double *float64;
+                                long double *float96;
+                                bool *bln;
+                        } val;
+                };
 
-        typedef int (ParamProc::*Proc)( int, char *[] );
+                typedef int (ParamProc::*Proc)( int, char *[] );
 
-        typedef struct ArgSpec
-        {
-                uint8_t nFlags;
-                StaticString sWord;
-                char cChar;
-                Proc proc;
-                ParamProc::ParamPtr val;
-                StaticString sExtra;
-                StaticString sDesc;
-                StaticString sValue;
-        } ArgSpec;
+                typedef struct ArgSpec
+                {
+                        uint8_t nFlags;
+                        Bu::FString sWord;
+                        char cChar;
+                        Proc proc;
+                        ParamProc::ParamPtr val;
+                        Bu::FString sExtra;
+                        Bu::FString sDesc;
+                        Bu::FString sValue;
+                } ArgSpec;
 
-public:
-        ParamProc();
-        virtual ~ParamProc();
-        
-        void addParam( const char *lpWord, char cChar, Proc proc, ParamPtr val,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
-                );
-        void addParam( const char *lpWord, char cChar, Proc proc,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
-                );
-        void addParam( const char *lpWord, char cChar, ParamPtr val,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
-                );
+        public:
+                ParamProc();
+                virtual ~ParamProc();
+                
+                void addParam( const char *lpWord, char cChar, Proc proc, ParamPtr val,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpValue=NULL
+                        );
+                void addParam( const char *lpWord, char cChar, Proc proc,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpValue=NULL
+                        );
+                void addParam( const char *lpWord, char cChar, ParamPtr val,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpValue=NULL
+                        );
 
-        void addParam( const char *lpWord, Proc proc, ParamPtr val,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
-                );
-        void addParam( const char *lpWord, Proc proc,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
-                );
-        void addParam( const char *lpWord, ParamPtr val,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
-                );
-        
-        void addParam( char cChar, Proc proc, ParamPtr val,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
-                );
-        void addParam( char cChar, Proc proc,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
-                );
-        void addParam( char cChar, ParamPtr val,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
-                );
+                void addParam( const char *lpWord, Proc proc, ParamPtr val,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpValue=NULL
+                        );
+                void addParam( const char *lpWord, Proc proc,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpValue=NULL
+                        );
+                void addParam( const char *lpWord, ParamPtr val,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpValue=NULL
+                        );
+                
+                void addParam( char cChar, Proc proc, ParamPtr val,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpValue=NULL
+                        );
+                void addParam( char cChar, Proc proc,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpValue=NULL
+                        );
+                void addParam( char cChar, ParamPtr val,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpValue=NULL
+                        );
 
-        void process( int argc, char *argv[] );
-        void addHelpBanner( const char *sHelpBanner );
+                void process( int argc, char *argv[] );
+                void addHelpBanner( const char *sHelpBanner );
 
-private:
-        ArgSpec *checkWord( const char *arg );
-        ArgSpec *checkLetr( const char arg );
+        private:
+                ArgSpec *checkWord( const char *arg );
+                ArgSpec *checkLetr( const char arg );
 
-public:
-        virtual int cmdParam( int argc, char *argv[] );
-        virtual int unknownParam( int argc, char *argv[] );
-        virtual int help( int argc, char *argv[] );
+        public:
+                virtual int cmdParam( int argc, char *argv[] );
+                virtual int unknownParam( int argc, char *argv[] );
+                virtual int help( int argc, char *argv[] );
 
-private:
-        typedef struct Banner
-        {
-                StaticString sBanner;
-                ArgSpec *pBefore;
-        } Banner;
-        std::list<Banner *> lBan;
-        std::list<ArgSpec *> lArg;
-};
+        private:
+                typedef struct Banner
+                {
+                        Bu::FString sBanner;
+                        ArgSpec *pBefore;
+                } Banner;
+                std::list<Banner *> lBan;
+                std::list<ArgSpec *> lArg;
+        };
+}
 
-#define mkproc( cls ) static_cast<int (ParamProc::*)( int, char *[])>(&cls)
+#define mkproc( cls ) static_cast<int (Bu::ParamProc::*)( int, char *[])>(&cls)
 
 #endif
diff --git a/src/plugger.h b/src/plugger.h
index d92f194..2124b7a 100644
--- a/src/plugger.h
+++ b/src/plugger.h
@@ -1,198 +1,198 @@
-#ifndef PLUGGER_H
-#define PLUGGER_H
+#ifndef BU_PLUGGER_H
+#define BU_PLUGGER_H
 
 
-#include "hashtable.h"
-#include "list"
-#include "hashfunctionstring.h"
-#include "hashfunctionint.h"
-#include "dlfcn.h"
-#include "exceptions.h"
+#include "bu/hash.h"
+#include "bu/list.h"
+#include <dlfcn.h>
+#include "bu/exceptions.h"
+#include "bu/fstring.h"
 
-typedef struct PluginInfo
+namespace Bu
 {
-        const char *sID;
-        const char *sAuthor;
-        unsigned short nVersion;
-        unsigned short nRevision;
-        void *(*createPlugin)();
-        void (*destroyPlugin)( void * );
-} PluginInfo;
-
-typedef struct PluginReg
-{
-        bool bBuiltin;
-        void *dlHandle;
-        PluginInfo *pInfo;
-} PluginReg;
+        typedef struct PluginInfo
+        {
+                const char *sID;
+                const char *sAuthor;
+                unsigned short nVersion;
+                unsigned short nRevision;
+                void *(*createPlugin)();
+                void (*destroyPlugin)( void * );
+        } PluginInfo;
+
+        typedef struct PluginReg
+        {
+                bool bBuiltin;
+                void *dlHandle;
+                PluginInfo *pInfo;
+        } PluginReg;
 
 #define PluginInterface( classname, baseclass, name, ver, rev )                 \
-extern "C" {                                                                                                                    \
-        baseclass *create ##classname()                                                         \
-        {                                                                                                                                       \
-                return new classname();                                                                                 \
-        }                                                                                                                                       \
-        void destroy ##classname( baseclass *pCls )                                     \
-        {                                                                                                                                       \
-                delete pCls;                                                                                                    \
-        }                                                                                                                                       \
-        PluginInfo classname = {                                                \
-                #classname, name, ver, rev,                                                                             \
-                create ##classname, destroy ##classname };                                              \
-}
+        extern "C" {                                                                                                                    \
+                baseclass *create ##classname()                                                         \
+                {                                                                                                                                       \
+                        return new classname();                                                                                 \
+                }                                                                                                                                       \
+                void destroy ##classname( baseclass *pCls )                                     \
+                {                                                                                                                                       \
+                        delete pCls;                                                                                                    \
+                }                                                                                                                                       \
+                Bu::PluginInfo classname = {                                            \
+                        #classname, name, ver, rev,                                                                             \
+                        create ##classname, destroy ##classname };                                              \
+        }
 
 #define PluginInterface2( pluginname, classname, baseclass, name, ver, rev ) \
-extern "C" {                                                                                                                    \
-        baseclass *create ##classname()                                                                         \
-        {                                                                                                                                       \
-                return new classname();                                                                                 \
-        }                                                                                                                                       \
-        void destroy ##classname( baseclass *pCls )                                                     \
-        {                                                                                                                                       \
-                delete pCls;                                                                                                    \
-        }                                                                                                                                       \
-        PluginInfo pluginname = {                                                                                       \
-                #pluginname, name, ver, rev,                                                                    \
-                (void *(*)())(create ##classname),                                                              \
-                (void (*)( void * ))(destroy ##classname) };                                    \
-}
+        extern "C" {                                                                                                                    \
+                baseclass *create ##classname()                                                                         \
+                {                                                                                                                                       \
+                        return new classname();                                                                                 \
+                }                                                                                                                                       \
+                void destroy ##classname( baseclass *pCls )                                                     \
+                {                                                                                                                                       \
+                        delete pCls;                                                                                                    \
+                }                                                                                                                                       \
+                Bu::PluginInfo pluginname = {                                                                                   \
+                        #pluginname, name, ver, rev,                                                                    \
+                        (void *(*)())(create ##classname),                                                              \
+                        (void (*)( void * ))(destroy ##classname) };                                    \
+        }
 
 #define PluginInterface3( structname, pluginname, classname, baseclass, name, ver, rev ) \
-extern "C" {                                                                                                                    \
-        baseclass *create ##classname()                                                                         \
-        {                                                                                                                                       \
-                return new classname();                                                                                 \
-        }                                                                                                                                       \
-        void destroy ##classname( baseclass *pCls )                                                     \
-        {                                                                                                                                       \
-                delete pCls;                                                                                                    \
-        }                                                                                                                                       \
-        PluginInfo structname = {                                                                                       \
-                #pluginname, name, ver, rev,                                                                    \
-                (void *(*)())(create ##classname),                                                              \
-                (void (*)( void * ))(destroy ##classname) };                                    \
-}
-
-template<class T>
-class Plugger
-{
-public:
-
-public:
-        Plugger() :
-                hPlugin( new HashFunctionString(), 11 ),
-                hObj( new HashFunctionInt(), 11 )
-        {
+        extern "C" {                                                                                                                    \
+                baseclass *create ##classname()                                                                         \
+                {                                                                                                                                       \
+                        return new classname();                                                                                 \
+                }                                                                                                                                       \
+                void destroy ##classname( baseclass *pCls )                                                     \
+                {                                                                                                                                       \
+                        delete pCls;                                                                                                    \
+                }                                                                                                                                       \
+                Bu::PluginInfo structname = {                                                                                   \
+                        #pluginname, name, ver, rev,                                                                    \
+                        (void *(*)())(create ##classname),                                                              \
+                        (void (*)( void * ))(destroy ##classname) };                                    \
         }
 
-        virtual ~Plugger()
+        template<class T>
+        class Plugger
         {
-                void *pos = hObj.getFirstItemPos();
-                while( (pos = hObj.getNextItemPos( pos )) )
+        public:
+                typedef Bu::Hash<Bu::FString, PluginReg *> PluginHash;
+                typedef Bu::Hash<int, void *> InstHash;
+
+        public:
+                Plugger()
                 {
-                        T *pPlug = (T *)hObj.getItemID( pos );
-                        PluginReg *pReg = (PluginReg *)hObj.getItemData( pos );
-                        pReg->pInfo->destroyPlugin( pPlug );
                 }
 
-                std::list<PluginReg *>::iterator i;
-                for( i = lPlugin.begin(); i != lPlugin.end(); i++ )
+                virtual ~Plugger()
                 {
-                        if( (*i)->bBuiltin == false )
+                        for( InstHash::iterator i = hObj.begin(); i != hObj.end(); i++ )
                         {
-                                dlclose( (*i)->dlHandle );
+                                T *pPlug = (T *)i.getKey();
+                                PluginReg *pReg = (PluginReg *)*i;
+                                pReg->pInfo->destroyPlugin( pPlug );
                         }
-                        delete (*i);
-                }
-        }
 
-        void registerBuiltinPlugin( PluginInfo *pInfo )
-        {
-                PluginReg *pReg = new PluginReg;
-                pReg->bBuiltin = true;
-                pReg->pInfo = pInfo;
-                lPlugin.insert( lPlugin.end(), pReg );
-                hPlugin.insert( pInfo->sID, pReg );
-        }
+                        for( PluginHash::iterator i = hPlugin.begin();
+                                 i != hPlugin.end(); i++ )
+                        {
+                                if( (*i)->bBuiltin == false )
+                                {
+                                        dlclose( (*i)->dlHandle );
+                                }
+                                delete (*i);
+                        }
+                }
 
-        void registerExternalPlugin( const char *sFName, const char *sPluginName )
-        {
-                PluginReg *pReg = (PluginReg *)hPlugin[sPluginName];
-                if( pReg != NULL )
+                void registerBuiltinPlugin( PluginInfo *pInfo )
                 {
-                        hPlugin.del( sPluginName );
-                        dlclose( pReg->dlHandle );
-                        delete pReg;
-                        pReg = NULL;
+                        PluginReg *pReg = new PluginReg;
+                        pReg->bBuiltin = true;
+                        pReg->pInfo = pInfo;
+                        hPlugin.insert( pInfo->sID, pReg );
                 }
 
-                pReg = new PluginReg;
-
-                pReg->bBuiltin = false;
-                pReg->dlHandle = dlopen( sFName, RTLD_NOW );
-                if( pReg->dlHandle == NULL )
+                void registerExternalPlugin( const char *sFName, const char *sPluginName )
                 {
-                        throw PluginException( 1, "Error on %s: %s", sFName, dlerror() );
+                        PluginReg *pReg;
+                        try {
+                                pReg = (PluginReg *)hPlugin[sPluginName];
+                                hPlugin.erase( sPluginName );
+                                dlclose( pReg->dlHandle );
+                                delete pReg;
+                                pReg = NULL;
+                        } catch( Bu::HashException &e )
+                        {
+                        }
+
+                        pReg = new PluginReg;
+
+                        pReg->bBuiltin = false;
+                        pReg->dlHandle = dlopen( sFName, RTLD_NOW );
+                        if( pReg->dlHandle == NULL )
+                        {
+                                throw PluginException( 1, "Error on %s: %s", sFName, dlerror() );
+                        }
+                        pReg->pInfo = (PluginInfo *)dlsym( pReg->dlHandle, sPluginName );
+                        if( pReg->pInfo == NULL )
+                        {
+                                throw PluginException( 2, "Error on %s: %s", sFName, dlerror() );
+                        }
+                        hPlugin.insert( pReg->pInfo->sID, pReg );
                 }
-                pReg->pInfo = (PluginInfo *)dlsym( pReg->dlHandle, sPluginName );
-                if( pReg->pInfo == NULL )
+
+                T *instantiate( const char *lpName )
                 {
-                        throw PluginException( 2, "Error on %s: %s", sFName, dlerror() );
+                        PluginReg *pReg = (PluginReg *)hPlugin[lpName];
+                        if( pReg == NULL )
+                                return NULL;
+
+                        T *p = (T *)pReg->pInfo->createPlugin();
+                        hObj.insert( (int )p, pReg );
+                        //printf("pReg:  %08X, pPlug: %08X\n", pReg, p );
+                
+                        return p;
                 }
-                hPlugin.insert( pReg->pInfo->sID, pReg );
-                lPlugin.insert( lPlugin.end(), pReg );
-        }
-
-        T *instantiate( const char *lpName )
-        {
-                PluginReg *pReg = (PluginReg *)hPlugin[lpName];
-                if( pReg == NULL )
-                        return NULL;
-
-                T *p = (T *)pReg->pInfo->createPlugin();
-                hObj.insert( p, pReg );
-                //printf("pReg:  %08X, pPlug: %08X\n", pReg, p );
-        
-                return p;
-        }
 
-        bool hasPlugin( const char *lpName )
-        {
-                if( hPlugin[lpName] == NULL )
-                        return false;
-                return true;
-        }
+                bool hasPlugin( const char *lpName )
+                {
+                        if( hPlugin[lpName] == NULL )
+                                return false;
+                        return true;
+                }
 
-        void destroy( T *pPlug )
-        {
-                PluginReg *pReg = (PluginReg *)hObj[pPlug];
-                //printf("pReg:  %08X, pPlug: %08X\n", pReg, pPlug );
-                if( pReg == NULL )
-                        return;
+                void destroy( T *pPlug )
+                {
+                        PluginReg *pReg = (PluginReg *)hObj.get((int)pPlug);
+                        //printf("pReg:  %08X, pPlug: %08X\n", pReg, pPlug );
+                        if( pReg == NULL )
+                                return;
 
-                pReg->pInfo->destroyPlugin( pPlug );
+                        pReg->pInfo->destroyPlugin( pPlug );
 
-                hObj.del( pPlug );
-        }
+                        hObj.erase( (int)pPlug );
+                }
 
-        void unloadAll()
-        {
-                std::list<PluginReg *>::iterator i;
-                for( i = lPlugin.begin(); i != lPlugin.end(); i++ )
+                void unloadAll()
                 {
-                        if( (*i)->bBuiltin == false )
+                        for( PluginHash::iterator i = hPlugin.begin();
+                                 i != hPlugin.end(); i++ )
                         {
-                                dlclose( (*i)->dlHandle );
+                                if( (*i)->bBuiltin == false )
+                                {
+                                        dlclose( (*i)->dlHandle );
+                                }
+                                delete (*i);
                         }
-                        delete (*i);
+                        hPlugin.clear();
                 }
-                hPlugin.clear();
-        }
 
-private:
-        std::list<PluginReg *> lPlugin;
-        HashTable hPlugin;
-        HashTable hObj;
-};
+        private:
+                PluginHash hPlugin;
+                InstHash hObj;
+        };
+}
 
 #endif
diff --git a/src/programchain.cpp b/src/programchain.cpp
index 6120d58..0bb7a77 100644
--- a/src/programchain.cpp
+++ b/src/programchain.cpp
@@ -1,17 +1,18 @@
 #include <stdlib.h>
-#include "programchain.h"
+#include "bu/programchain.h"
+#include "bu/programlink.h"
 
-ProgramChain::ProgramChain() :
-        xLog( MultiLog::getInstance() )
+using namespace Bu;
+
+Bu::ProgramChain::ProgramChain()
 {
-        xLog.LineLog( MultiLog::LStatus, "Program Chain Initialized." );
 }
 
-ProgramChain::~ProgramChain()
+Bu::ProgramChain::~ProgramChain()
 {
 }
 
-bool ProgramChain::addLink( ProgramLink *pLink )
+bool Bu::ProgramChain::addLink( ProgramLink *pLink )
 {
         if( pLink->init() == false )
         {
@@ -26,26 +27,25 @@ bool ProgramChain::addLink( ProgramLink *pLink )
         return true;
 }
 
-ProgramLink *ProgramChain::getLink( const char *lpName )
+ProgramLink *Bu::ProgramChain::getLink( const char *lpName )
 {
         char a;
         a = lpName[0];
         return NULL;
 }
 
-ProgramLink *ProgramChain::getBaseLink()
+ProgramLink *Bu::ProgramChain::getBaseLink()
 {
         return NULL;
 }
 
-bool ProgramChain::execChainOnce()
+bool Bu::ProgramChain::execChainOnce()
 {
-        int nLen = lLink.getSize();
-        for( int j = 0; j < nLen; j++ )
+        for( Bu::List<Bu::ProgramLink *>::iterator i = lLink.begin();
+                 i != lLink.end(); i++ )
         {
-                if( ((ProgramLink *)lLink[j])->timeSlice() == false )
+                if( (*i)->timeSlice() == false )
                 {
-                        xLog.LineLog( MultiLog::LInfo, "Shutting down due to signal from link #%d", j );
                         emergencyShutdown();
                         return false;
                 }
@@ -54,7 +54,7 @@ bool ProgramChain::execChainOnce()
         return true;
 }
 
-bool ProgramChain::enterChainLoop()
+bool Bu::ProgramChain::enterChainLoop()
 {
         for(;;)
         {
@@ -67,23 +67,23 @@ bool ProgramChain::enterChainLoop()
         return true;
 }
 
-void ProgramChain::emergencyShutdown()
+void Bu::ProgramChain::emergencyShutdown()
 {
-        int nLen = lLink.getSize();
-        for( int j = 0; j < nLen; j++ )
+        for( Bu::List<Bu::ProgramLink *>::iterator i = lLink.begin();
+                 i != lLink.end(); i++ )
         {
-                ((ProgramLink *)lLink[j])->deInit();
-                delete (ProgramLink *)lLink[j];
+                (*i)->deInit();
+                delete *i;
         }
-        lLink.empty();
+        lLink.clear();
 }
 
-LinkMessage *ProgramChain::broadcastIRM( LinkMessage *pMsgOut, ProgramLink *pSender )
+LinkMessage *Bu::ProgramChain::broadcastIRM( LinkMessage *pMsgOut, ProgramLink *pSender )
 {
-        int nLen = lLink.getSize();
-        for( int j = 0; j < nLen; j++ )
+        for( Bu::List<Bu::ProgramLink *>::iterator i = lLink.begin();
+                 i != lLink.end(); i++ )
         {
-                LinkMessage *pMsg = ((ProgramLink *)lLink[j])->processIRM( pMsgOut );
+                LinkMessage *pMsg = (*i)->processIRM( pMsgOut );
                 if( pMsg != NULL )
                 {
                         delete pMsgOut;
@@ -94,3 +94,4 @@ LinkMessage *ProgramChain::broadcastIRM( LinkMessage *pMsgOut, ProgramLink *pSen
         delete pMsgOut;
         return NULL;
 }
+
diff --git a/src/programchain.h b/src/programchain.h
index 2bdfeee..336a9f1 100644
--- a/src/programchain.h
+++ b/src/programchain.h
@@ -1,95 +1,98 @@
-#ifndef PROGRAMCHAIN_H
-#define PROGRAMCHAIN_H
+#ifndef BU_PROGRAMCHAIN_H
+#define BU_PROGRAMCHAIN_H
 
-#include "linkedlist.h"
-#include "multilog.h"
-#include "programlink.h"
+#include "bu/list.h"
+#include "bu/linkmessage.h"
 
-/**
- * The Program Chain links together program "chunks" to more easily facilitate
- * a generalized program loop with modular extensions.
- *@author Mike Buland
- */
-class ProgramChain
+namespace Bu
 {
-public:
+        class ProgramLink;
         /**
-         * Construct an empty chain.
+         * The Program Chain links together program "chunks" to more easily facilitate
+         * a generalized program loop with modular extensions.
+         *@author Mike Buland
          */
-        ProgramChain();
+        class ProgramChain
+        {
+        public:
+                /**
+                 * Construct an empty chain.
+                 */
+                ProgramChain();
 
-        /**
-         * Destroy your chain.
-         */
-        virtual ~ProgramChain();
+                /**
+                 * Destroy your chain.
+                 */
+                virtual ~ProgramChain();
 
-        /**
-         * Adds a link to the end of the chain.
-         *@param pLink A pointer to the link to add to the chain.
-         *@returns True if adding the link was successful, otherwise false
-         *@author Mike Buland
-         */
-        bool addLink( ProgramLink *pLink );
+                /**
+                 * Adds a link to the end of the chain.
+                 *@param pLink A pointer to the link to add to the chain.
+                 *@returns True if adding the link was successful, otherwise false
+                 *@author Mike Buland
+                 */
+                bool addLink( Bu::ProgramLink *pLink );
 
-        /**
-         * Gets a link by name.
-         *@param lpName The name of the link you're looking for.  Every link has a
-         * name, apparently.
-         *@returns A pointer to the specified ProgramLink, or NULL if none were
-         * found matching your criteria.
-         *@author Mike Buland
-         */
-        class ProgramLink *getLink( const char *lpName );
+                /**
+                 * Gets a link by name.
+                 *@param lpName The name of the link you're looking for.  Every link has a
+                 * name, apparently.
+                 *@returns A pointer to the specified ProgramLink, or NULL if none were
+                 * found matching your criteria.
+                 *@author Mike Buland
+                 */
+                class ProgramLink *getLink( const char *lpName );
 
-        /**
-         * Gets the very first link in the chain.
-         *@returns A pointer to the first link in the chain.
-         *@author Mike Buland
-         */
-        class ProgramLink *getBaseLink();
+                /**
+                 * Gets the very first link in the chain.
+                 *@returns A pointer to the first link in the chain.
+                 *@author Mike Buland
+                 */
+                class ProgramLink *getBaseLink();
 
-        /**
-         * Runs through the chain once.  Useful if you want to have more control
-         * over the operation of the chain.
-         *@returns true if every link returned true.  If at least one link returns
-         * false, then returns false.
-         *@author Mike Buland
-         */
-        bool execChainOnce();
+                /**
+                 * Runs through the chain once.  Useful if you want to have more control
+                 * over the operation of the chain.
+                 *@returns true if every link returned true.  If at least one link returns
+                 * false, then returns false.
+                 *@author Mike Buland
+                 */
+                bool execChainOnce();
 
-        /**
-         * Enters the master chain loop, looping over the entire chain and
-         * executing every link's TimeSlice routine in order, over and over, until
-         * a link returns a false value.
-         *@returns False, always.  It returns true unless a link returned false,
-         * but loops until a link does return false.
-         *@author Mike Buland
-         **/
-        bool enterChainLoop();
+                /**
+                 * Enters the master chain loop, looping over the entire chain and
+                 * executing every link's TimeSlice routine in order, over and over, until
+                 * a link returns a false value.
+                 *@returns False, always.  It returns true unless a link returned false,
+                 * but loops until a link does return false.
+                 *@author Mike Buland
+                 **/
+                bool enterChainLoop();
 
-        /**
-         * Broadcasts an Immediate Response Message to all active links, save the
-         * sender.  Whatever link first responds with a non-null response message
-         * will have it's messages sent back to the broadcasting link as the returns
-         * of this function call.  Therefore it is very important that all message
-         * processing code is handled in a fairly timely fasion.
-         *@param pMsgOut The message to broadcast in hopes of a response.
-         *@param pSender The message that sent out the message and doesn't want to
-         * receive it's own message.  This should always just be "this".
-         *@returns The message that was returned by the first link to return a
-         * non-null response.  If all messages return null responses then this also
-         * returns null.  Please note that whoever calls this will be responsible
-         * for deleting the message returned by it, if non-null.
-         */
-        class LinkMessage *broadcastIRM( LinkMessage *pMsgOut, ProgramLink *pSender );
+                /**
+                 * Broadcasts an Immediate Response Message to all active links, save the
+                 * sender.  Whatever link first responds with a non-null response message
+                 * will have it's messages sent back to the broadcasting link as the returns
+                 * of this function call.  Therefore it is very important that all message
+                 * processing code is handled in a fairly timely fasion.
+                 *@param pMsgOut The message to broadcast in hopes of a response.
+                 *@param pSender The message that sent out the message and doesn't want to
+                 * receive it's own message.  This should always just be "this".
+                 *@returns The message that was returned by the first link to return a
+                 * non-null response.  If all messages return null responses then this also
+                 * returns null.  Please note that whoever calls this will be responsible
+                 * for deleting the message returned by it, if non-null.
+                 */
+                class LinkMessage *broadcastIRM( LinkMessage *pMsgOut, ProgramLink *pSender );
+
+        private:
+                /**
+                 * Shuts down all operation no matter what point in the operation we were.
+                 */
+                void emergencyShutdown();
+                Bu::List<Bu::ProgramLink *> lLink; /**< The linked list that contains all of the links. */
+        };
+}
 
-private:
-        /**
-         * Shuts down all operation no matter what point in the operation we were.
-         */
-        void emergencyShutdown();
-        MultiLog &xLog; /**< A reference to the log. */
-        LinkedList lLink; /**< The linked list that contains all of the links. */
-};
 
 #endif
diff --git a/src/programlink.cpp b/src/programlink.cpp
index 21c6fe4..e5c624c 100644
--- a/src/programlink.cpp
+++ b/src/programlink.cpp
@@ -1,20 +1,22 @@
-#include "programlink.h"
-#include "programchain.h"
+#include "bu/programlink.h"
+#include "bu/programchain.h"
 
-ProgramLink::ProgramLink()
+using namespace Bu;
+
+Bu::ProgramLink::ProgramLink()
 {
 }
 
-ProgramLink::~ProgramLink()
+Bu::ProgramLink::~ProgramLink()
 {
 }
 
-LinkMessage *ProgramLink::sendIRM( LinkMessage *pMsgOut )
+LinkMessage *Bu::ProgramLink::sendIRM( LinkMessage *pMsgOut )
 {
         return pChain->broadcastIRM( pMsgOut, this );
 }
 
-void ProgramLink::setChain( ProgramChain *pNewChain )
+void Bu::ProgramLink::setChain( ProgramChain *pNewChain )
 {
         pChain = pNewChain;
 }
diff --git a/src/programlink.h b/src/programlink.h
index f93edcc..07d7489 100644
--- a/src/programlink.h
+++ b/src/programlink.h
@@ -1,99 +1,100 @@
-#ifndef PROGRAMLINK_H
-#define PROGRAMLINK_H
+#ifndef BU_PROGRAMLINK_H
+#define BU_PROGRAMLINK_H
 
-class ProgramLink;
-#include "queue.h"
-#include "linkmessage.h"
-#include "programchain.h"
+#include "bu/linkmessage.h"
+#include "bu/programchain.h"
 
-/**
- * Program Link is the base class for any object that will be a piece of the
- * main program chain loop.
- *@author Mike Buland
- */
-class ProgramLink
+namespace Bu
 {
-friend class ProgramChain;
-public:
         /**
-         * Construct a program link.
+         * Program Link is the base class for any object that will be a piece of the
+         * main program chain loop.
+         *@author Mike Buland
          */
-        ProgramLink();
+        class ProgramLink
+        {
+        friend class Bu::ProgramChain;
+        public:
+                /**
+                 * Construct a program link.
+                 */
+                ProgramLink();
 
-        /**
-         * Deconstruct.
-         */
-        virtual ~ProgramLink();
+                /**
+                 * Deconstruct.
+                 */
+                virtual ~ProgramLink();
 
-        /**
-         * Initialization code required for a link that wasn't performed in the
-         * constructor.
-         *@returns true if initialization was successful.  A false value will halt
-         * the chain.
-         */
-        virtual bool init()=0;
+                /**
+                 * Initialization code required for a link that wasn't performed in the
+                 * constructor.
+                 *@returns true if initialization was successful.  A false value will halt
+                 * the chain.
+                 */
+                virtual bool init()=0;
 
-        /**
-         * DeInitialization code that should happen, but doesn't belong in the
-         * destructor.
-         *@returns true means everything worked, false means failure, but is
-         * meaningless.
-         */
-        virtual bool deInit()=0;
+                /**
+                 * DeInitialization code that should happen, but doesn't belong in the
+                 * destructor.
+                 *@returns true means everything worked, false means failure, but is
+                 * meaningless.
+                 */
+                virtual bool deInit()=0;
 
-        /**
-         * Executed once per link per chain pass.  Contains the guts of the program.
-         *@returns true if everything went well.  A false value will halt the chain.
-         */
-        virtual bool timeSlice()=0;
+                /**
+                 * Executed once per link per chain pass.  Contains the guts of the program.
+                 *@returns true if everything went well.  A false value will halt the chain.
+                 */
+                virtual bool timeSlice()=0;
 
-        /**
-         * This must be handled in order to process Instant Response Messages.
-     * This function should return null on all messages that it doesn't
-     * understand how to handle, and construct new messages to return to sender
-         * in the cases where it does understand.
-         *@param pMsgIn The message that must be processed.
-         *@returns Either a new message in cases where a response is required,
-         * or null if nothing needs to be done by this link.
-         */
-        virtual LinkMessage *processIRM( LinkMessage *pMsgIn ) = 0;
+                /**
+                 * This must be handled in order to process Instant Response Messages.
+                 * This function should return null on all messages that it doesn't
+                 * understand how to handle, and construct new messages to return to sender
+                 * in the cases where it does understand.
+                 *@param pMsgIn The message that must be processed.
+                 *@returns Either a new message in cases where a response is required,
+                 * or null if nothing needs to be done by this link.
+                 */
+                virtual LinkMessage *processIRM( LinkMessage *pMsgIn ) = 0;
 
-        /**
-         * Broadcast a LinkMessage to all other links in the system.  Each other
-         * link will get a call of their processIRM function.  If the message gets
-         * a response then you will regain control immediately, otherwise the system
-         * will give all other Links a chance to respond before returning NULL.
-         *@param pMsgOut The message to broadcast.
-         *@returns The message response, or NULL if no Link understood your message.
-         */
-        LinkMessage *sendIRM( LinkMessage *pMsgOut );
+                /**
+                 * Broadcast a LinkMessage to all other links in the system.  Each other
+                 * link will get a call of their processIRM function.  If the message gets
+                 * a response then you will regain control immediately, otherwise the system
+                 * will give all other Links a chance to respond before returning NULL.
+                 *@param pMsgOut The message to broadcast.
+                 *@returns The message response, or NULL if no Link understood your message.
+                 */
+                LinkMessage *sendIRM( LinkMessage *pMsgOut );
 
-private:
-        /**
-         * Set which chain we're assosiated with.  This is how IRM messages make
-         * it out to the rest of the world.
-         *@param pNewChain A pointer to the containing program chain.
-         */
-        void setChain( class ProgramChain *pNewChain );
+        private:
+                /**
+                 * Set which chain we're assosiated with.  This is how IRM messages make
+                 * it out to the rest of the world.
+                 *@param pNewChain A pointer to the containing program chain.
+                 */
+                void setChain( class ProgramChain *pNewChain );
 
-        /**
-         * The pointer to the containing chain.
-         */
-        class ProgramChain *pChain;
-/*
-        void postMessage( LinkMessage *pMsg, int nLvl );
-        LinkMessage *getMessage( int nLvl );
+                /**
+                 * The pointer to the containing chain.
+                 */
+                class ProgramChain *pChain;
+        /*
+                void postMessage( LinkMessage *pMsg, int nLvl );
+                LinkMessage *getMessage( int nLvl );
 
-        enum
-        {
-                msgToChain,
-                msgToLink
-        };
+                enum
+                {
+                        msgToChain,
+                        msgToLink
+                };
 
-private:
-        Queue qMsgToChain;
-        Queue qMsgToLink;
-*/
-};
+        private:
+                Queue qMsgToChain;
+                Queue qMsgToLink;
+        */
+        };
+}
 
 #endif
diff --git a/src/protocol.cpp b/src/protocol.cpp
index 78b3ee2..0976b3b 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -1,20 +1,12 @@
-#include "protocol.h"
+#include "bu/protocol.h"
 
-Protocol::Protocol()
-{
-        pConnection = NULL;
-}
+using namespace Bu;
 
-Protocol::~Protocol()
+Bu::Protocol::Protocol()
 {
 }
 
-void Protocol::setConnection( Connection *pNewConnection )
+Bu::Protocol::~Protocol()
 {
-        pConnection = pNewConnection;
 }
 
-Connection *Protocol::getConnection()
-{
-        return pConnection;
-}
diff --git a/src/protocol.h b/src/protocol.h
index 09e1c98..bca337f 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -1,62 +1,27 @@
-#ifndef PROTOCOL_H
-#define PROTOCOL_H
+#ifndef BU_PROTOCOL_H
+#define BU_PROTOCOL_H
 
-#include "connection.h"
+#include <stdint.h>
 
-/** This is the template for a class that handles specialized input and output
-  * to connections of different types with different protocols.
-  *@author Mike Buland
-  */
-class Protocol
+namespace Bu
 {
-public:
-        /** Constructor */
-    Protocol();
-        /** Deconstructor */
-    virtual ~Protocol();
+        class Client;
 
         /**
-         * Function is called every time there is new data on the line.  This is
-         * called directly from the Connection class to process data.  This is not
-         * called whever there is pending data on the input, but every time new data
-         * is added to the input buffer.
-         *@returns True if processing went alright, false if something went wrong,
-         * I suppose.  In truth this value is thrown away right now.
-         *@todo Either make a return value of false mean something, or make these
-         * void.
+         *
          */
-        virtual bool onNewData()=0;
+        class Protocol
+        {
+        public:
+                Protocol();
+                virtual ~Protocol();
 
-        /**
-         * Function is called when there is a new connection.  This should only
-         * happen once per Protocol object, but gives each protocol object a
-         * chance to perform connection handshaking and initialization at a point
-         * where they know that they have a handle to an active Connection.
-         *@returns See onNewData
-         */
-        virtual bool onNewConnection()=0;
-
-        virtual void onNewClientConnection(){};
+                virtual void onNewConnection( Bu::Client *pClient )=0;
+                virtual void onNewData( Bu::Client *pClient )=0;
 
-        virtual void poll(){};
-
-        /**
-         * Sets the Protocol's Connection object.  This is rather important, and
-         * handled usually by the ConnectionManager.
-         *@param pNewConnection The Connection object that this protocol will use to
-         * deal with the outside world.
-         */
-        void setConnection( class Connection *pNewConnection );
-
-        /**
-         * Get a pointer to this object's Connection object, or NULL if one was
-         * never set.  If used with the ConnectionManager that should never happen.
-         *@returns A pointer to the active Connection.
-         */
-        Connection *getConnection();
+        private:
 
-private:
-        class Connection *pConnection; /**< The pointer to the Connection. */
-};
+        };
+}
 
 #endif
diff --git a/src/ringbuffer.cpp b/src/ringbuffer.cpp
new file mode 100644
index 0000000..feb9bc7
--- /dev/null
+++ b/src/ringbuffer.cpp
@@ -0,0 +1,2 @@
+#include "bu/ringbuffer.h"
+
diff --git a/src/ringbuffer.h b/src/ringbuffer.h
new file mode 100644
index 0000000..be80e2f
--- /dev/null
+++ b/src/ringbuffer.h
@@ -0,0 +1,97 @@
+#ifndef BU_RING_BUFFER_H
+#define BU_RING_BUFFER_H
+
+#include <memory>
+#include "bu/exceptionbase.h"
+
+namespace Bu
+{
+        template<typename value, typename valuealloc=std::allocator<value> >
+        class RingBuffer
+        {
+        public:
+                RingBuffer( int nCapacity ) :
+                        nCapacity( nCapacity ),
+                        nStart( -1 ),
+                        nEnd( -2 )
+                {
+                        aData = va.allocate( nCapacity );
+                }
+
+                virtual ~RingBuffer()
+                {
+                        for( int j = nStart; j < nEnd; j=(j+1%nCapacity) )
+                        {
+                                va.destroy( &aData[j] );
+                        }
+                        va.deallocate( aData, nCapacity );
+                }
+
+                int getCapacity()
+                {
+                        return nCapacity;
+                }
+
+                bool isFilled()
+                {
+                        return (nStart == nEnd);
+                }
+
+                bool isEmpty()
+                {
+                        return (nStart == -1);
+                }
+
+                void enqueue( const value &v )
+                {
+                        if( nStart == -1 )
+                        {
+                                nStart = 0;
+                                nEnd = 1;
+                                va.construct( &aData[0], v );
+                        }
+                        else if( nStart == nEnd )
+                        {
+                                throw ExceptionBase("Hey, it's full!");
+                        }
+                        else
+                        {
+                                va.construct( &aData[nEnd], v );
+                                nEnd = (nEnd+1)%nCapacity;
+                        }
+                }
+
+                value dequeue()
+                {
+                        if( nStart == -1 )
+                        {
+                                throw ExceptionBase("No data");
+                        }
+                        else
+                        {
+                                value &v = aData[nStart];
+                                va.destroy( &aData[nStart] );
+                                nStart = (nStart+1)%nCapacity;
+                                if( nStart == nEnd )
+                                {
+                                        nStart = -1;
+                                        nEnd = -2;
+                                }
+                                return v;
+                        }
+                }
+
+                value &operator[]( int nIndex )
+                {
+                        return aData[(nIndex+nStart)%nCapacity];
+                }
+
+        private:
+                int nCapacity;
+                value *aData;
+                valuealloc va;
+                int nStart, nEnd;
+        };
+}
+
+#endif
diff --git a/src/serializable.cpp b/src/serializable.cpp
deleted file mode 100644
index fd50943..0000000
--- a/src/serializable.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "serializable.h"
-
-Serializable::Serializable()
-{
-}
-Serializable::~Serializable()
-{
-}
diff --git a/src/serializable.h b/src/serializable.h
deleted file mode 100644
index 06def29..0000000
--- a/src/serializable.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef SERIALIZER_H
-#define SERIALIZER_H
-
-//#include "serializer.h"
-
-/**
- * The base class for any class you want to serialize.  Simply include this as
- * a base class, implement the purely virtual serialize function and you've got
- * an easily serializable class.
- */
-class Serializable
-{
-public:
-        /**
-         * Does nothing, here for completeness.
-         */
-        Serializable();
-
-        /**
-         * Here to ensure the deconstructor is virtual.
-         */
-        virtual ~Serializable();
-
-        /**
-         * This is the main workhorse of the serialization system, just override and
-         * you've got a serializable class.  A reference to the Serializer archive
-         * used is passed in as your only parameter, query it to discover if you are
-         * loading or saving.
-         * @param ar A reference to the Serializer object to use.
-         */
-        virtual void serialize( class Serializer &ar )=0;
-};
-
-#endif
diff --git a/src/serializer.cpp b/src/serializer.cpp
deleted file mode 100644
index 636224e..0000000
--- a/src/serializer.cpp
+++ /dev/null
@@ -1,338 +0,0 @@
-#include "serializer.h"
-#include "serializable.h"
-#include <list>
-
-Serializer::Serializer(bool bLoading):
-        bLoading(bLoading)
-{
-}
-Serializer::~Serializer()
-{
-}
-
-bool Serializer::isLoading()
-{
-        return bLoading;
-}
-Serializer &Serializer::operator<<(bool p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(int8_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(int16_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(int32_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(int64_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(uint8_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(uint16_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(uint32_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(uint64_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(long p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(float p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(double p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(long double p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-
-Serializer &Serializer::operator>>(bool &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(int8_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(int16_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(int32_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(int64_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(uint8_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(uint16_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(uint32_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(uint64_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(long &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(float &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(double &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(long double &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-
-Serializer &Serializer::operator&&(bool &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-
-Serializer &Serializer::operator&&(int8_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-
-Serializer &Serializer::operator&&(int16_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-
-Serializer &Serializer::operator&&(int32_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-
-Serializer &Serializer::operator&&(int64_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-
-Serializer &Serializer::operator&&(uint8_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-
-Serializer &Serializer::operator&&(uint16_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-
-Serializer &Serializer::operator&&(uint32_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-
-Serializer &Serializer::operator&&(uint64_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-
-Serializer &Serializer::operator&&(float &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-
-Serializer &Serializer::operator&&(double &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-
-Serializer &Serializer::operator&&(long double &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-
-
-Serializer &operator<<(Serializer &s, Serializable &p)
-{
-        p.serialize( s );
-        return s;
-}
-
-Serializer &operator>>(Serializer &s, Serializable &p)
-{
-        p.serialize( s );
-        return s;
-}
-
-Serializer &operator&&(Serializer &s, Serializable &p)
-{
-        if (s.isLoading())
-        {
-                return s >> p;
-        }
-        else
-        {
-                return s << p;
-        }
-}
-
-Serializer &operator<<( Serializer &ar, std::string &s )
-{
-        ar << (uint32_t)s.length();
-        ar.write( s.c_str(), s.length() );
-
-        return ar;
-}
-
-Serializer &operator>>( Serializer &ar, std::string &s )
-{
-        uint32_t l;
-        ar >> l;
-        char *tmp = new char[l+1];
-        tmp[l] = '\0';
-        ar.read( tmp, l );
-        s = tmp;
-        delete[] tmp;
-
-        return ar;
-}
-
diff --git a/src/serializer.h b/src/serializer.h
deleted file mode 100644
index 3af489c..0000000
--- a/src/serializer.h
+++ /dev/null
@@ -1,80 +0,0 @@
-#ifndef SERIALIZABLE_H
-#define SERIALIZABLE_H
-
-#include <stdint.h>
-#include <string>
-#include <list>
-//#include "serializable.h"
-
-class Serializer
-{
-private:
-        bool bLoading;
-public:
-        bool isLoading();
-
-        enum
-        {
-                load    =       true,
-                save    =       false
-        };
-        
-        Serializer(bool bLoading);
-        virtual ~Serializer();
-        virtual void close()=0;
-
-        virtual void write(const void *, int32_t)=0;
-        virtual void read(void *, int32_t)=0;
-        
-        virtual Serializer &operator<<(bool);
-        virtual Serializer &operator<<(int8_t);
-        virtual Serializer &operator<<(int16_t);
-        virtual Serializer &operator<<(int32_t);
-        virtual Serializer &operator<<(int64_t);
-        virtual Serializer &operator<<(uint8_t);
-        virtual Serializer &operator<<(uint16_t);
-        virtual Serializer &operator<<(uint32_t);
-        virtual Serializer &operator<<(uint64_t);
-        virtual Serializer &operator<<(long);
-        virtual Serializer &operator<<(float);
-        virtual Serializer &operator<<(double);
-        virtual Serializer &operator<<(long double);
-
-        virtual Serializer &operator>>(bool &);
-        virtual Serializer &operator>>(int8_t &);
-        virtual Serializer &operator>>(int16_t &);
-        virtual Serializer &operator>>(int32_t &);
-        virtual Serializer &operator>>(int64_t &);
-        virtual Serializer &operator>>(uint8_t &);
-        virtual Serializer &operator>>(uint16_t &);
-        virtual Serializer &operator>>(uint32_t &);
-        virtual Serializer &operator>>(uint64_t &);
-        virtual Serializer &operator>>(long &);
-        virtual Serializer &operator>>(float &);
-        virtual Serializer &operator>>(double &);
-        virtual Serializer &operator>>(long double &);
-        
-        virtual Serializer &operator&&(bool &);
-        virtual Serializer &operator&&(int8_t &);
-        virtual Serializer &operator&&(int16_t &);
-        virtual Serializer &operator&&(int32_t &);
-        virtual Serializer &operator&&(int64_t &);
-        virtual Serializer &operator&&(uint8_t &);
-        virtual Serializer &operator&&(uint16_t &);
-        virtual Serializer &operator&&(uint32_t &);
-        virtual Serializer &operator&&(uint64_t &);
-        virtual Serializer &operator&&(float &);
-        virtual Serializer &operator&&(double &);
-        virtual Serializer &operator&&(long double &);
-
-        //virtual Serializer &operator&(Serializable &);
-};
-
-Serializer &operator<<(Serializer &, class Serializable &);
-Serializer &operator>>(Serializer &, class Serializable &);
-Serializer &operator&&(Serializer &s, class Serializable &p);
-
-Serializer &operator<<(Serializer &, std::string &);
-Serializer &operator>>(Serializer &, std::string &);
-
-#endif
diff --git a/src/server.cpp b/src/server.cpp
new file mode 100644
index 0000000..d07a597
--- /dev/null
+++ b/src/server.cpp
@@ -0,0 +1,96 @@
+#include "bu/server.h"
+#include <errno.h>
+#include "bu/serversocket.h"
+#include "bu/client.h"
+#include "bu/socket.h"
+
+Bu::Server::Server() :
+        nTimeoutSec( 0 ),
+        nTimeoutUSec( 0 )
+{
+        FD_ZERO( &fdActive );
+}
+
+Bu::Server::~Server()
+{
+}
+
+void Bu::Server::addPort( int nPort, int nPoolSize )
+{
+        ServerSocket *s = new ServerSocket( nPort, nPoolSize );
+        int nSocket = s->getSocket();
+        FD_SET( nSocket, &fdActive );
+        hServers.insert( nSocket, s );
+}
+
+void Bu::Server::addPort( const FString &sAddr, int nPort, int nPoolSize )
+{
+        ServerSocket *s = new ServerSocket( sAddr, nPort, nPoolSize );
+        int nSocket = s->getSocket();
+        FD_SET( nSocket, &fdActive );
+        hServers.insert( nSocket, s );
+}
+
+void Bu::Server::setTimeout( int nTimeoutSec, int nTimeoutUSec )
+{
+        this->nTimeoutSec = nTimeoutSec;
+        this->nTimeoutUSec = nTimeoutUSec;
+}
+
+void Bu::Server::scan()
+{
+        struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
+        
+        fd_set fdRead = fdActive;
+        fd_set fdWrite = fdActive;
+        fd_set fdException = fdActive;
+
+        if( TEMP_FAILURE_RETRY( select( FD_SETSIZE, &fdRead, NULL, &fdException, &xTimeout ) ) < 0 )
+        {
+                throw ExceptionBase("Error attempting to scan open connections.");
+        }
+
+        for( int j = 0; j < FD_SETSIZE; j++ )
+        {
+                if( FD_ISSET( j, &fdRead ) )
+                {
+                        if( hServers.has( j ) )
+                        {
+                                ServerSocket *pSrv = hServers.get( j );
+                                addClient( pSrv->accept(), pSrv->getPort() );
+                        }
+                        else
+                        {
+                                Client *pClient = hClients.get( j );
+                                pClient->processInput();
+                                if( !pClient->isOpen() )
+                                {
+                                        onClosedConnection( pClient );
+                                        hClients.erase( j );
+                                        FD_CLR( j, &fdActive );
+                                }
+                        }
+                }
+        }
+
+        // Now we just try to write all the pending data on all the sockets.
+        // this could be done better eventually, if we care about the socket
+        // wanting to accept writes (using a select).
+        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+        {
+                (*i)->processOutput();
+        }
+}
+
+void Bu::Server::addClient( int nSocket, int nPort )
+{
+        FD_SET( nSocket, &fdActive );
+
+        Client *c = new Client(
+                new Bu::Socket( nSocket )
+                );
+        hClients.insert( nSocket, c );
+
+        onNewConnection( c, nPort );
+}
+
diff --git a/src/server.h b/src/server.h
new file mode 100644
index 0000000..302b6e3
--- /dev/null
+++ b/src/server.h
@@ -0,0 +1,61 @@
+#ifndef BU_SERVER_H
+#define BU_SERVER_H
+
+#include <stdint.h>
+
+#include "bu/fstring.h"
+#include "bu/list.h"
+
+namespace Bu
+{
+        class ServerSocket;
+        class Socket;
+        class Client;
+
+        /**
+         * Core of a network server.  This class is distinct from a ServerSocket in
+         * that a ServerSocket is one listening socket, nothing more.  Socket will
+         * manage a pool of both ServerSockets and connected Sockets along with
+         * their protocols and buffers.
+         *
+         * To start serving on a new port, use the addPort functions.  Each call to
+         * addPort creates a new ServerSocket, starts it listening, and adds it to
+         * the server pool.
+         *
+         * All of the real work is done by scan, which will wait for up
+         * to the timeout set by setTimeout before returning if there is no data
+         * pending.  scan should probably be called in some sort of tight
+         * loop, possibly in it's own thread, or in the main control loop.
+         *
+         * In order to use a Server you must subclass it and implement the pure
+         * virtual functions.  These allow you to receive notification of events
+         * happening within the server itself, and actually makes it useful.
+         */
+        class Server
+        {
+        public:
+                Server();
+                virtual ~Server();
+
+                void addPort( int nPort, int nPoolSize=40 );
+                void addPort( const FString &sAddr, int nPort, int nPoolSize=40 );
+
+                void scan();
+                void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 );
+
+                void addClient( int nSocket, int nPort );
+
+                virtual void onNewConnection( Client *pClient, int nPort )=0;
+                virtual void onClosedConnection( Client *pClient )=0;
+
+        private:
+                int nTimeoutSec;
+                int nTimeoutUSec;
+                fd_set fdActive;
+                Hash<int,ServerSocket *> hServers;
+                typedef Hash<int,Client *> ClientHash;
+                ClientHash hClients;
+        };
+}
+
+#endif
diff --git a/src/serversocket.cpp b/src/serversocket.cpp
new file mode 100644
index 0000000..1424630
--- /dev/null
+++ b/src/serversocket.cpp
@@ -0,0 +1,158 @@
+#include <time.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <termios.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include "serversocket.h"
+#include "exceptions.h"
+
+Bu::ServerSocket::ServerSocket( int nPort, int nPoolSize ) :
+        nPort( nPort )
+{
+        /* Create the socket and set it up to accept connections. */
+        struct sockaddr_in name;
+
+        /* Give the socket a name. */
+        name.sin_family = AF_INET;
+        name.sin_port = htons( nPort );
+
+        // I think this specifies who we will accept connections from,
+        // a good thing to make configurable later on
+        name.sin_addr.s_addr = htonl( INADDR_ANY );
+
+        startServer( name, nPoolSize );
+}
+
+Bu::ServerSocket::ServerSocket(const FString &sAddr,int nPort, int nPoolSize) :
+        nPort( nPort )
+{
+        /* Create the socket and set it up to accept connections. */
+        struct sockaddr_in name;
+
+        /* Give the socket a name. */
+        name.sin_family = AF_INET;
+        name.sin_port = htons( nPort );
+
+        inet_aton( sAddr.getStr(), &name.sin_addr );
+
+        startServer( name, nPoolSize );
+}
+
+Bu::ServerSocket::~ServerSocket()
+{
+}
+
+void Bu::ServerSocket::startServer( struct sockaddr_in &name, int nPoolSize )
+{
+        /* Create the socket. */
+        nServer = socket( PF_INET, SOCK_STREAM, 0 );
+        if( nServer < 0 )
+        {
+                throw Bu::SocketException("Couldn't create a listen socket.");
+        }
+
+        int opt = 1;
+        setsockopt(
+                nServer,
+                SOL_SOCKET,
+                SO_REUSEADDR,
+                (char *)&opt,
+                sizeof( opt )
+                );
+
+        if( bind( nServer, (struct sockaddr *) &name, sizeof(name) ) < 0 )
+        {
+                throw Bu::SocketException("Couldn't bind to the listen socket.");
+        }
+
+        if( listen( nServer, nPoolSize ) < 0 )
+        {
+                throw Bu::SocketException(
+                        "Couldn't begin listening to the server socket."
+                        );
+        }
+
+        FD_ZERO( &fdActive );
+        /* Initialize the set of active sockets. */
+        FD_SET( nServer, &fdActive );
+}
+
+int Bu::ServerSocket::getSocket()
+{
+        return nServer;
+}
+
+int Bu::ServerSocket::accept( int nTimeoutSec, int nTimeoutUSec )
+{
+        fd_set fdRead = fdActive;
+
+        struct timeval xT;
+
+        xT.tv_sec = nTimeoutSec;
+        xT.tv_usec = nTimeoutUSec;      
+
+        if( TEMP_FAILURE_RETRY(select( nServer+1, &fdRead, NULL, NULL, &xT )) < 0 )
+        {
+                throw SocketException(
+                        "Error scanning for new connections: %s", strerror( errno )
+                        );
+        }
+
+        if( FD_ISSET( nServer, &fdRead ) )
+        {
+                struct sockaddr_in clientname;
+                size_t size;
+                int nClient;
+
+                size = sizeof( clientname );
+#ifdef __CYGWIN__
+                nClient = ::accept( nServer, (struct sockaddr *)&clientname,
+                                (int *)&size
+                                );
+#else
+                nClient = ::accept( nServer, (struct sockaddr *)&clientname, &size );
+#endif
+                if( nClient < 0 )
+                {
+                        throw SocketException(
+                                "Error accepting a new connection: %s", strerror( errno )
+                                );
+                }
+                char tmpa[20];
+                inet_ntop( AF_INET, (void *)&clientname.sin_addr, tmpa, 20 );
+                //"New connection from host %s, port %hd.",
+                //  tmpa, ntohs (clientname.sin_port) );
+                
+                {
+                        int flags;
+
+                        flags = fcntl( nClient, F_GETFL, 0 );
+                        flags |= O_NONBLOCK;
+                        if( fcntl( nClient, F_SETFL, flags ) < 0)
+                        {
+                                throw SocketException(
+                                        "Error setting option on client socket: %s",
+                                        strerror( errno )
+                                        );
+                        }
+                }
+
+                return nClient;
+        }
+
+        return -1;
+}
+
+int Bu::ServerSocket::getPort()
+{
+        return nPort;
+}
+
diff --git a/src/serversocket.h b/src/serversocket.h
new file mode 100644
index 0000000..b4ee247
--- /dev/null
+++ b/src/serversocket.h
@@ -0,0 +1,39 @@
+#ifndef BU_SERVER_SOCKET_H
+#define BU_SERVER_SOCKET_H
+
+#include <stdint.h>
+#include "bu/fstring.h"
+
+namespace Bu
+{
+        /**
+         * A single tcp/ip server socket.  When created the server socket will bind
+         * to the specified interface and port, and immediately begin listening for
+         * connections.  When connections come in they are pooled by the networking
+         * drivers in the kernel until they are accepted, this means that failure
+         * to keep space in the connection pool will result in connection refusals.
+         *
+         * Although the accept function returns an integral file descriptor, it is
+         * designed to be used with the Socket class.
+         */
+        class ServerSocket
+        {
+        public:
+                ServerSocket( int nPort, int nPoolSize=40 );
+                ServerSocket( const FString &sAddr, int nPort, int nPoolSize=40 );
+                virtual ~ServerSocket();
+
+                int accept( int nTimeoutSec=0, int nTimeoutUSec=0 );
+                int getSocket();
+                int getPort();
+
+        private:
+                void startServer( struct sockaddr_in &name, int nPoolSize );
+
+                fd_set fdActive;
+                int nServer;
+                int nPort;
+        };
+}
+
+#endif
diff --git a/src/sfile.cpp b/src/sfile.cpp
deleted file mode 100644
index f1de03c..0000000
--- a/src/sfile.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#include "sfile.h"
-#include "exceptions.h"
-
-SFile::SFile( const char *sName, const char *sFlags )
-{
-        fh = fopen( sName, sFlags );
-}
-
-SFile::~SFile()
-{
-}
-
-void SFile::close()
-{
-        if( fh )
-        {
-                fclose( fh );
-                fh = NULL;
-        }
-}
-
-size_t SFile::read( char *pBuf, size_t nBytes )
-{
-        if( !fh )
-                throw FileException("File not open.");
-
-        return fread( pBuf, 1, nBytes, fh );
-}
-
-size_t SFile::write( const char *pBuf, size_t nBytes )
-{
-        if( !fh )
-                throw FileException("File not open.");
-
-        return fwrite( pBuf, 1, nBytes, fh );
-}
-
-long SFile::tell()
-{
-        if( !fh )
-                throw FileException("File not open.");
-
-        return ftell( fh );
-}
-
-void SFile::seek( long offset )
-{
-        if( !fh )
-                throw FileException("File not open.");
-
-        fseek( fh, offset, SEEK_CUR );
-}
-
-void SFile::setPos( long pos )
-{
-        if( !fh )
-                throw FileException("File not open.");
-
-        fseek( fh, pos, SEEK_SET );
-}
-
-void SFile::setPosEnd( long pos )
-{
-        if( !fh )
-                throw FileException("File not open.");
-        
-        fseek( fh, pos, SEEK_END );
-}
-
-bool SFile::isEOS()
-{
-        return feof( fh );
-}
-
diff --git a/src/sfile.h b/src/sfile.h
deleted file mode 100644
index b51e5bc..0000000
--- a/src/sfile.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef SFILE_H
-#define SFILE_H
-
-#include <stdint.h>
-
-#include "stream.h"
-
-class SFile : public Stream
-{
-public:
-        SFile( const char *sName, const char *sFlags );
-        virtual ~SFile();
-
-        virtual void close();
-        virtual size_t read( char *pBuf, size_t nBytes );
-        virtual size_t write( const char *pBuf, size_t nBytes );
-
-        virtual long tell();
-        virtual void seek( long offset );
-        virtual void setPos( long pos );
-        virtual void setPosEnd( long pos );
-        virtual bool isEOS();
-
-private:
-        FILE *fh;
-
-};
-
-#endif
diff --git a/src/singleton.h b/src/singleton.h
index 47adbd5..c43d71b 100644
--- a/src/singleton.h
+++ b/src/singleton.h
@@ -1,59 +1,62 @@
-#ifndef SINGLETON_H
-#define SINGLETON_H
+#ifndef BU_SINGLETON_H
+#define BU_SINGLETON_H
 
 #include <stdio.h>
 
-/**
- * Provides singleton functionality in a modular sort of way.  Make this the
- * base class of any other class and you immediately gain singleton
- * functionality.  Be sure to make your constructor and various functions use
- * intellegent scoping.  Cleanup and instantiation are performed automatically
- * for you at first use and program exit.  There are two things that you must
- * do when using this template, first is to inherit from it with the name of
- * your class filling in for T and then make this class a friend of your class.
- *@code
- * // Making the Single Singleton:
- * class Single : public Singleton<Single>
- * {
- *              friend class Singleton<Single>;
- *      protected:
- *              Single();
- *              ...
- * };
- @endcode
- * You can still add public functions and variables to your new Singleton child
- * class, but your constructor should be protected (hence the need for the
- * friend decleration).
- *@author Mike Buland
- */
-template <class T>
-class Singleton
+namespace Bu
 {
-protected:
         /**
-         * Private constructor.  This constructor is empty but has a body so that
-         * you can make your own override of it.  Be sure that you're override is
-         * also protected.
+         * Provides singleton functionality in a modular sort of way.  Make this the
+         * base class of any other class and you immediately gain singleton
+         * functionality.  Be sure to make your constructor and various functions use
+         * intellegent scoping.  Cleanup and instantiation are performed automatically
+         * for you at first use and program exit.  There are two things that you must
+         * do when using this template, first is to inherit from it with the name of
+         * your class filling in for T and then make this class a friend of your class.
+         *@code
+         * // Making the Single Singleton:
+         * class Single : public Singleton<Single>
+         * {
+         *              friend class Singleton<Single>;
+         *      protected:
+         *              Single();
+         *              ...
+         * };
+         @endcode
+         * You can still add public functions and variables to your new Singleton child
+         * class, but your constructor should be protected (hence the need for the
+         * friend decleration).
+         *@author Mike Buland
          */
-        Singleton() {};
+        template <class T>
+        class Singleton
+        {
+        protected:
+                /**
+                 * Private constructor.  This constructor is empty but has a body so that
+                 * you can make your own override of it.  Be sure that you're override is
+                 * also protected.
+                 */
+                Singleton() {};
 
-private:
-        /**
-         * Copy constructor, defined so that you could write your own as well.
-         */
-        Singleton( const Singleton& );
+        private:
+                /**
+                 * Copy constructor, defined so that you could write your own as well.
+                 */
+                Singleton( const Singleton& );
 
-public:
-        /**
-         * Get a handle to the contained instance of the contained class.  It is
-         * a reference.
-         *@returns A reference to the contained object.
-         */
-        static T &getInstance()
-        {
-                static T i;
-                return i;
-        }
-};
+        public:
+                /**
+                 * Get a handle to the contained instance of the contained class.  It is
+                 * a reference.
+                 *@returns A reference to the contained object.
+                 */
+                static T &getInstance()
+                {
+                        static T i;
+                        return i;
+                }
+        };
+}
 
 #endif
diff --git a/src/socket.cpp b/src/socket.cpp
new file mode 100644
index 0000000..e567061
--- /dev/null
+++ b/src/socket.cpp
@@ -0,0 +1,294 @@
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <fcntl.h>
+#include "socket.h"
+#include "exceptions.h"
+
+#define RBS (1024*2)
+
+Bu::Socket::Socket( int nSocket ) :
+        nSocket( nSocket ),
+        bActive( true )
+{
+}
+
+Bu::Socket::Socket( const Bu::FString &sAddr, int nPort, int nTimeout )
+{
+        struct sockaddr_in xServerName;
+        bActive = false;
+     
+        /* Create the socket. */
+        nSocket = socket( PF_INET, SOCK_STREAM, 0 );
+        
+        if( nSocket < 0 )
+        {
+                throw ExceptionBase("Couldn't create socket.\n");
+        }
+
+        // These lines set the socket to non-blocking, a good thing?
+        int flags;
+        flags = fcntl(nSocket, F_GETFL, 0);
+        flags |= O_NONBLOCK;
+        if (fcntl(nSocket, F_SETFL, flags) < 0)
+        {
+                throw ExceptionBase("Couldn't set socket options.\n");
+        }
+     
+        /* Connect to the server. */
+        //printf("Resolving hostname (%s)...\n", sAddr );
+        {
+                struct hostent *hostinfo;
+     
+                xServerName.sin_family = AF_INET;
+                xServerName.sin_port = htons( nPort );
+                hostinfo = gethostbyname( sAddr.getStr() );
+                if (hostinfo == NULL)
+                {
+                        throw ExceptionBase("Couldn't resolve hostname.\n");
+                }
+                xServerName.sin_addr = *(struct in_addr *) hostinfo->h_addr;
+        }
+
+        //printf("Making actual connection...");
+        //fflush( stdout );
+        connect(
+                nSocket,
+                (struct sockaddr *)&xServerName,
+                sizeof(xServerName)
+                );
+        //printf("Connected.\n");
+        
+        bActive = true;
+
+        if( nTimeout > 0 )
+        {
+                fd_set rfds, wfds, efds;
+                int retval;
+                
+                FD_ZERO(&rfds);
+                FD_SET(nSocket, &rfds);
+                FD_ZERO(&wfds);
+                FD_SET(nSocket, &wfds);
+                FD_ZERO(&efds);
+                FD_SET(nSocket, &efds);
+
+                struct timeval tv;
+                tv.tv_sec = nTimeout;
+                tv.tv_usec = 0;
+                
+                retval = select( nSocket+1, &rfds, &wfds, &efds, &tv );
+
+                if( retval == 0 )
+                {
+                        close();
+                        throw ExceptionBase("Connection timeout.\n");
+                }
+                
+        }
+}
+
+Bu::Socket::~Socket()
+{
+}
+
+void Bu::Socket::close()
+{
+        if( bActive )
+        {
+                fsync( nSocket );
+                ::close( nSocket );
+        }
+        bActive = false;
+}
+
+/*
+void Bu::Socket::read()
+{
+        char buffer[RBS];
+        int nbytes;
+        int nTotalRead=0;
+
+        for(;;)
+        {
+                //memset( buffer, 0, RBS );
+
+                nbytes = ::read( nSocket, buffer, RBS );
+                if( nbytes < 0 && errno != 0 && errno != EAGAIN )
+                {
+                        //printf("errno: %d, %s\n", errno, strerror( errno ) );
+                        //perror("readInput");
+                        throw ConnectionException(
+                                excodeReadError,
+                                "Read error: %s",
+                                strerror( errno )
+                                );
+                }
+                else
+                {
+                        if( nbytes <= 0 )
+                                break;
+                        nTotalRead += nbytes;
+                        sReadBuf.append( buffer, nbytes );
+                        if( nbytes < RBS )
+                        {
+                                break;
+                        }
+
+                        // New test, if data is divisible by RBS bytes on some libs the
+                        // read could block, this keeps it from happening.
+                        {
+                                fd_set rfds;
+                                FD_ZERO(&rfds);
+                                FD_SET(nSocket, &rfds);
+                                struct timeval tv = { 0, 0 };
+                                int retval = select( nSocket+1, &rfds, NULL, NULL, &tv );
+                                if( retval == -1 )
+                                        throw ConnectionException(
+                                                excodeBadReadError,
+                                                "Bad Read error"
+                                                );
+                                if( !FD_ISSET( nSocket, &rfds ) )
+                                        break;
+                        }
+                }
+        }
+}*/
+
+size_t Bu::Socket::read( void *pBuf, size_t nBytes )
+{
+        int nRead = TEMP_FAILURE_RETRY( ::read( nSocket, pBuf, nBytes ) );
+        if( nRead < 0 )
+        {
+                throw ConnectionException( excodeReadError, strerror(errno) );
+        }
+        return nRead;
+}
+
+//size_t Bu::Socket::read( void *pBuf, size_t nBytes, uint32_t nTimeout )
+//{
+//}
+
+size_t Bu::Socket::write( const void *pBuf, size_t nBytes )
+{
+        int nWrote = TEMP_FAILURE_RETRY( ::write( nSocket, pBuf, nBytes ) );
+        if( nWrote < 0 )
+        {
+                throw ConnectionException( excodeWriteError, strerror(errno) );
+        }
+        return nWrote;
+}
+
+long Bu::Socket::tell()
+{
+        throw UnsupportedException();
+}
+
+void Bu::Socket::seek( long offset )
+{
+        throw UnsupportedException();
+}
+
+void Bu::Socket::setPos( long pos )
+{
+        throw UnsupportedException();
+}
+
+void Bu::Socket::setPosEnd( long pos )
+{
+        throw UnsupportedException();
+}
+
+bool Bu::Socket::isEOS()
+{
+        return !bActive;
+}
+
+bool Bu::Socket::canRead()
+{
+        fd_set rfds;
+        FD_ZERO(&rfds);
+        FD_SET(nSocket, &rfds);
+        struct timeval tv = { 0, 0 };
+        int retval = select( nSocket+1, &rfds, NULL, NULL, &tv );
+        if( retval == -1 )
+                throw ConnectionException(
+                        excodeBadReadError,
+                        "Bad Read error"
+                        );
+        if( !FD_ISSET( nSocket, &rfds ) )
+                return false;
+        return true;
+}
+
+bool Bu::Socket::canWrite()
+{
+        fd_set wfds;
+        FD_ZERO(&wfds);
+        FD_SET(nSocket, &wfds);
+        struct timeval tv = { 0, 0 };
+        int retval = select( nSocket+1, NULL, &wfds, NULL, &tv );
+        if( retval == -1 )
+                throw ConnectionException(
+                        excodeBadReadError,
+                        "Bad Read error"
+                        );
+        if( !FD_ISSET( nSocket, &wfds ) )
+                return false;
+        return true;
+}
+
+bool Bu::Socket::isReadable()
+{
+        return true;
+}
+
+bool Bu::Socket::isWritable()
+{
+        return true;
+}
+
+bool Bu::Socket::isSeekable()
+{
+        return false;
+}
+
+bool Bu::Socket::isBlocking()
+{
+        return false;
+}
+
+void Bu::Socket::setBlocking( bool bBlocking )
+{
+}
+
+void Bu::Socket::flush()
+{
+}
+
+bool Bu::Socket::isOpen()
+{
+        return bActive;
+}
+
+Bu::FString Bu::Socket::getAddress() const
+{
+        struct sockaddr_in addr;
+        socklen_t len = sizeof(addr);
+        addr.sin_family = AF_INET;
+        getsockname( nSocket, (sockaddr *)(&addr), &len );
+        char buf[150];
+        sprintf( buf, "%s", inet_ntoa( addr.sin_addr ) );
+
+        return buf;
+}
+
diff --git a/src/socket.h b/src/socket.h
new file mode 100644
index 0000000..c291549
--- /dev/null
+++ b/src/socket.h
@@ -0,0 +1,55 @@
+#ifndef BU_SOCKET_H
+#define BU_SOCKET_H
+
+#include <stdint.h>
+
+#include "stream.h"
+#include "fstring.h"
+
+namespace Bu
+{
+        /**
+         *
+         */
+        class Socket : public Stream
+        {
+        public:
+                Socket( int nSocket );
+                Socket( const FString &sAddr, int nPort, int nTimeout=30 );
+                virtual ~Socket();
+                
+                virtual void close();
+                //virtual void read();
+                virtual size_t read( void *pBuf, size_t nBytes );
+                virtual size_t read( void *pBuf, size_t nBytes, uint32_t nTimeout );
+                virtual size_t write( const void *pBuf, size_t nBytes );
+
+                virtual long tell();
+                virtual void seek( long offset );
+                virtual void setPos( long pos );
+                virtual void setPosEnd( long pos );
+                virtual bool isEOS();
+                virtual bool isOpen();
+
+                virtual void flush();
+
+                virtual bool canRead();
+                virtual bool canWrite();
+
+                virtual bool isReadable();
+                virtual bool isWritable();
+                virtual bool isSeekable();
+
+                virtual bool isBlocking();
+                virtual void setBlocking( bool bBlocking=true );
+
+                Bu::FString getAddress() const;
+
+        private:
+                int nSocket;
+                bool bActive;
+                FString sReadBuf;
+        };
+}
+
+#endif
diff --git a/src/sptr.cpp b/src/sptr.cpp
index 7f5e894..8ea7f8f 100644
--- a/src/sptr.cpp
+++ b/src/sptr.cpp
@@ -1 +1 @@
-#include "sptr.h"
+#include "bu/sptr.h"
diff --git a/src/sptr.h b/src/sptr.h
index a3e6dc7..75851a6 100644
--- a/src/sptr.h
+++ b/src/sptr.h
@@ -1,144 +1,192 @@
-#ifndef SPTR_H
-#define SPTR_H
+#ifndef BU_SPTR_H
+#define BU_SPTR_H
 
 #include <stdint.h>
 #include <stdio.h>
 
-template<typename T> class SPtr;
-template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src );
-
-template<typename T>
-class SPtr
+namespace Bu
 {
-        template<typename Tb, typename Ta>
-        friend SPtr<Tb> SPtrCast( SPtr<Ta> pt );
-public:
-        SPtr() :
-                pRefCnt( NULL ),
-                pData( NULL )
-        {
-        }
+        template<typename T> class SPtr;
+        template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src );
+
+        template<typename T>
+        class SPtr
+        {
+                template<typename Tb, typename Ta>
+                friend SPtr<Tb> SPtrCast( SPtr<Ta> pt );
+        public:
+                SPtr() :
+                        pRefCnt( NULL ),
+                        pData( NULL )
+                {
+                }
 
-        ~SPtr()
-        {
-                decCount();
-        }
+                ~SPtr()
+                {
+                        decCount();
+                }
 
-        SPtr( const SPtr<T> &src ) :
-                pRefCnt( src.pRefCnt ),
-                pData( src.pData )
-        {
-                if( pRefCnt )
-                        (*pRefCnt) += 1;
-        }
+                SPtr( const SPtr<T> &src ) :
+                        pRefCnt( src.pRefCnt ),
+                        pData( src.pData )
+                {
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
+                }
 
-        SPtr( T *pSrc ) :
-                pRefCnt( NULL ),
-                pData( pSrc )
-        {
-                if( pData )
+                SPtr( T *pSrc ) :
+                        pRefCnt( NULL ),
+                        pData( pSrc )
                 {
-                        pRefCnt = new int32_t;
-                        (*pRefCnt) = 1;
+                        if( pData )
+                        {
+                                pRefCnt = new int32_t;
+                                (*pRefCnt) = 1;
+                        }
                 }
-        }
 
-        int32_t count() const
-        {
-                return *pRefCnt;
-        }
+                /**
+                 * Get the number of references to this pointer.
+                 *@returns (int32_t) The number of references to this pointer.
+                 */
+                int32_t count() const
+                {
+                        return *pRefCnt;
+                }
 
-        const T *operator->() const
-        {
-                return pData;
-        }
+                /**
+                 * Pointer access operator.
+                 *@returns (const T *)
+                 */
+                const T *operator->() const
+                {
+                        return pData;
+                }
 
-        const T &operator*() const
-        {
-                return *pData;
-        }
-        
-        T *operator->()
-        {
-                return pData;
-        }
+                /**
+                 * Dereference operator.
+                 *@returns (const T &) The value at the end of the pointer.
+                 */
+                const T &operator*() const
+                {
+                        return *pData;
+                }
+                
+                /**
+                 * Pointer access operator.
+                 *@returns (T *)
+                 */
+                T *operator->()
+                {
+                        return pData;
+                }
 
-        T &operator*()
-        {
-                return *pData;
-        }
+                /**
+                 * Dereference operator.
+                 *@returns (T &) The value at the end of the pointer.
+                 */
+                T &operator*()
+                {
+                        return *pData;
+                }
 
-        SPtr<T> operator=( const SPtr<T> &src )
-        {
-                decCount();
-                pRefCnt = src.pRefCnt;
-                pData = src.pData;
-                if( pRefCnt )
-                        (*pRefCnt) += 1;
+                /**
+                 * Assignment operator.
+                 *@param src (const SPtr<T> &)
+                 */
+                SPtr<T> operator=( const SPtr<T> &src )
+                {
+                        decCount();
+                        pRefCnt = src.pRefCnt;
+                        pData = src.pData;
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
 
-                return *this;
-        }
+                        return *this;
+                }
 
-        const SPtr<T> operator=( const SPtr<T> &src ) const
-        {
-                decCount();
-                pRefCnt = src.pRefCnt;
-                pData = src.pData;
-                if( pRefCnt )
-                        (*pRefCnt) += 1;
+                /**
+                 * Assignment operator.
+                 *@param src (const SPtr<T> &)
+                 */
+                const SPtr<T> operator=( const SPtr<T> &src ) const
+                {
+                        decCount();
+                        pRefCnt = src.pRefCnt;
+                        pData = src.pData;
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
 
-                return *this;
-        }
+                        return *this;
+                }
 
-        bool operator==( const SPtr<T> &src ) const
-        {
-                return pData == src.pData;
-        }
+                /**
+                 * Equals comparison operator.
+                 *@param src (const SPtr<T> &) The SPtr to compare to.
+                 *@returns (bool) Are the equal?
+                 */
+                bool operator==( const SPtr<T> &src ) const
+                {
+                        return pData == src.pData;
+                }
 
-        bool operator==( const T *src ) const
-        {
-                return pData == src;
-        }
+                /**
+                 * Equals comparison operator.
+                 *@param src (const T *) The pointer to compare to.
+                 *@returns (bool) Are the equal?
+                 */
+                bool operator==( const T *src ) const
+                {
+                        return pData == src;
+                }
 
-        operator bool() const
-        {
-                return pRefCnt != NULL;
-        }
+                /**
+                 * Boolean cast operator. Do we have a pointer?
+                 */
+                operator bool() const
+                {
+                        return pRefCnt != NULL;
+                }
 
-        bool isSet() const
-        {
-                return pRefCnt != NULL;
-        }
+                /**
+                 * Do we have a pointer?
+                 *@returns (bool) Do we have a pointer?
+                 */
+                bool isSet() const
+                {
+                        return pRefCnt != NULL;
+                }
 
-private:
-        void decCount() const
-        {
-                if( pRefCnt )
+        private:
+                void decCount() const
                 {
-                        (*pRefCnt) -= 1;
-                        //printf("Decrementing ref-count to %d\n", *pRefCnt );
-                        if( (*pRefCnt) == 0 )
+                        if( pRefCnt )
                         {
-                                delete pRefCnt;
-                                delete pData;
-                                pRefCnt = NULL;
-                                pData = NULL;
+                                (*pRefCnt) -= 1;
+                                //printf("Decrementing ref-count to %d\n", *pRefCnt );
+                                if( (*pRefCnt) == 0 )
+                                {
+                                        delete pRefCnt;
+                                        delete pData;
+                                        pRefCnt = NULL;
+                                        pData = NULL;
+                                }
                         }
                 }
-        }
 
-        mutable int32_t *pRefCnt;
-        mutable T *pData;
-};
+                mutable int32_t *pRefCnt;
+                mutable T *pData;
+        };
 
-template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src )
-{
-        SPtr<Tb> ret;
-        ret.pRefCnt = src.pRefCnt;
-        ret.pData = dynamic_cast<Tb *>(src.pData);
-        if( ret.pRefCnt )
-                (*(ret.pRefCnt)) += 1;
-        return ret;
+        template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src )
+        {
+                SPtr<Tb> ret;
+                ret.pRefCnt = src.pRefCnt;
+                ret.pData = dynamic_cast<Tb *>(src.pData);
+                if( ret.pRefCnt )
+                        (*(ret.pRefCnt)) += 1;
+                return ret;
+        }
 }
 
 #endif
diff --git a/src/stream.cpp b/src/stream.cpp
index 856a58d..267a7d1 100644
--- a/src/stream.cpp
+++ b/src/stream.cpp
@@ -1,10 +1,10 @@
 #include "stream.h"
 
-Stream::Stream()
+Bu::Stream::Stream()
 {
 }
 
-Stream::~Stream()
+Bu::Stream::~Stream()
 {
 }
 
diff --git a/src/stream.h b/src/stream.h
index e086e28..1e236a6 100644
--- a/src/stream.h
+++ b/src/stream.h
@@ -1,27 +1,143 @@
-#ifndef STREAM_H
-#define STREAM_H
+#ifndef BU_STREAM_H
+#define BU_STREAM_H
 
 #include <stdint.h>
 #include <stdio.h>
 
-class Stream
+namespace Bu
 {
-public:
-        Stream();
-        virtual ~Stream();
+        /**
+         * The basis for a completely general data transport mechanism.  Anything
+         * that inherits from this should provide at least the basic read and/or
+         * write functions, and very probably the close function.  Any functions
+         * that aren't supported should throw an exception if called.
+         *
+         * The constructor of a child class should pretty much universally be used
+         * to open the stream.  I can't think of anything that should require an
+         * exception.
+         */
+        class Stream
+        {
+        public:
+                Stream();
+                virtual ~Stream();
 
-        virtual void close() = 0;
-        virtual size_t read( char *pBuf, size_t nBytes ) = 0;
-        virtual size_t write( const char *pBuf, size_t nBytes ) = 0;
+                /**
+                 * Close the stream.
+                 */
+                virtual void close() = 0;
 
-        virtual long tell() = 0;
-        virtual void seek( long offset ) = 0;
-        virtual void setPos( long pos ) = 0;
-        virtual void setPosEnd( long pos ) = 0;
-        virtual bool isEOS() = 0;
+                /**
+                 * Read data from the stream into a buffer.
+                 *@param pBuf (void *) Buffer which will be filled.
+                 *@param nBytes (size_t) Max data to read.
+                 *@returns (size_t) Amount of data read.
+                 */
+                virtual size_t read( void *pBuf, size_t nBytes ) = 0;
 
-private:
+                /**
+                 * Write data to the stream.
+                 *@param pBuf (const void *) The data to be written.
+                 *@param nBytes (size_t) Amount of data to write from pBuf.
+                 *@returns (size_t) Amount of data actually written.
+                 */
+                virtual size_t write( const void *pBuf, size_t nBytes ) = 0;
 
-};
+                /**
+                 * Get the current position in the stream.
+                 *@returns (long) The current position in the stream.
+                 */
+                virtual long tell() = 0;
+
+                /**
+                 * Seek to a position in the stream relative to the current position.
+                 *@param offset (long) Offset from current position to seek to.
+                 */
+                virtual void seek( long offset ) = 0;
+
+                /**
+                 * Set position in the stream relative to the start of the stream.
+                 *@param pos (long) The position.
+                 */
+                virtual void setPos( long pos ) = 0;
+
+                /**
+                 * Set position in the stream relative to the end of the stream.
+                 *@param pos (long) The position.
+                 */
+                virtual void setPosEnd( long pos ) = 0;
+
+                /**
+                 * Are we at the end of the stream?
+                 *@returns (bool) Are we at the end of the stream?
+                 */
+                virtual bool isEOS() = 0;
+
+                /**
+                 * Is the stream open?
+                 *@returns (bool) Is the stream open?
+                 */
+                virtual bool isOpen() = 0;
+
+                /**
+                 * Flush any data still held in buffers.
+                 */
+                virtual void flush() = 0;
+
+                /**
+                 * In non-blocking streams this indicates if a read operation will
+                 * return data at the moment or not.  In blocking streams this should
+                 * return the same value as isEOS().
+                 */
+                virtual bool canRead() = 0;
+
+                /**
+                 * In non-blocking streams this indicates if a write operation will
+                 * succeed or fail.  In some cases writing is not allowed (e.g. 
+                 * internal buffers are full) temporarilly.  In blocking streams this
+                 * should return the same value as isWritable.
+                 */
+                virtual bool canWrite() = 0;
+
+                /**
+                 * Indicates if the stream is capable of read operations.  This does not
+                 * indicate if such operations will return useful data, see canRead for
+                 * that.
+                 */
+                virtual bool isReadable() = 0;
+
+                /**
+                 * Indicates if the stream is capable of write operations.  This does
+                 * not indicate if such operations will succeed or fail, see canWrite
+                 * for that.
+                 */
+                virtual bool isWritable() = 0;
+
+                /**
+                 * Indicates if the stream is capable of seek operations.  This is
+                 * generally false for non-blocking streams.  Some buffered streams may
+                 * support limited in-buffer seeking.
+                 */
+                virtual bool isSeekable() = 0;
+
+                /**
+                 * Are we currently set to block mode?
+                 *@returns (bool)
+                 */
+                virtual bool isBlocking() = 0;
+
+                /**
+                 * Set stream to blocking or non-blocking mode.
+                 *@param bBlocking (bool) Whether we should block or not.
+                 */
+                virtual void setBlocking( bool bBlocking=true ) = 0;
+
+        public: // Filters
+
+
+        private:
+
+        };
+}
 
 #endif
diff --git a/src/tafnode.cpp b/src/tafnode.cpp
new file mode 100644
index 0000000..53b782e
--- /dev/null
+++ b/src/tafnode.cpp
@@ -0,0 +1,165 @@
+#include "tafnode.h"
+
+Bu::TafNode::TafNode( NodeType eType ) :
+        eType( eType )
+{
+}
+
+Bu::TafNode::~TafNode()
+{
+}
+
+const Bu::TafNode::NodeType Bu::TafNode::getType() const
+{
+        return eType;
+}
+
+/*
+const Bu::TafNode::PropList &Bu::TafNode::getProperties( const Bu::FString &sName ) const
+{
+        return hProp.get( sName );
+}
+
+const Bu::TafNode::NodeList &Bu::TafNode::getChildren( const Bu::FString &sName ) const
+{
+        return hChildren.get( sName );
+}
+
+const Bu::FString &Bu::TafNode::getProperty( const Bu::FString &sName ) const
+{
+        return getProperties( sName ).first();
+}
+
+const Bu::TafNode *Bu::TafNode::getChild( const Bu::FString &sName ) const
+{
+        return getChildren( sName ).first();
+}
+*/
+
+Bu::TafGroup::TafGroup( const Bu::FString &sName ) :
+        TafNode( typeGroup ),
+        sName( sName )
+{
+}
+
+Bu::TafGroup::~TafGroup()
+{
+        //printf("Entering Bu::TafNode::~TafNode() \"%s\"\n", sName.getStr() );
+        for( NodeList::iterator i = lChildren.begin(); i != lChildren.end(); i++ )
+        {
+                delete (*i);
+        }
+}
+
+const Bu::FString &Bu::TafGroup::getName() const
+{
+        return sName;
+}
+
+Bu::TafNode *Bu::TafGroup::addChild( Bu::TafNode *pNode )
+{
+        switch( pNode->getType() )
+        {
+                case typeGroup:
+                        addChild( (Bu::TafGroup *)pNode );
+                        break;
+
+                case typeProperty:
+                        addChild( (Bu::TafProperty *)pNode );
+                        break;
+
+                case typeComment:
+                        addChild( (Bu::TafComment *)pNode );
+                        break;
+        }
+
+        return pNode;
+}
+
+Bu::TafGroup *Bu::TafGroup::addChild( TafGroup *pNode )
+{
+        TafGroup *pGroup = (TafGroup *)pNode;
+        if( !hChildren.has( pGroup->getName() ) )
+                hChildren.insert( pGroup->getName(), GroupList() );
+        hChildren.get( pGroup->getName() ).append( pGroup );
+        lChildren.append( pNode );
+        return pNode;
+}
+
+Bu::TafProperty *Bu::TafGroup::addChild( TafProperty *pNode )
+{
+        TafProperty *pProperty = (TafProperty *)pNode;
+        if( !hProp.has( pProperty->getName() ) )
+                hProp.insert( pProperty->getName(), PropList() );
+        hProp.get( pProperty->getName() ).append( pProperty->getValue() );
+        lChildren.append( pNode );
+        return pNode;
+}
+
+Bu::TafComment *Bu::TafGroup::addChild( TafComment *pNode )
+{
+        lChildren.append( pNode );
+        return pNode;
+}
+
+const Bu::TafGroup::GroupList &Bu::TafGroup::getChildren( const Bu::FString &sName ) const
+{
+        return hChildren.get( sName );
+}
+
+const Bu::TafGroup::NodeList &Bu::TafGroup::getChildren() const
+{
+        return lChildren;
+}
+
+const Bu::TafGroup *Bu::TafGroup::getChild( const Bu::FString &sName ) const
+{
+        return hChildren.get( sName ).first();
+}
+
+const Bu::TafGroup::PropList &Bu::TafGroup::getProperties( const Bu::FString &sName ) const
+{
+        return hProp.get( sName );
+}
+
+const Bu::FString &Bu::TafGroup::getProperty( const Bu::FString &sName ) const
+{
+        return hProp.get( sName ).first();
+}
+
+Bu::TafProperty::TafProperty( const Bu::FString &sName, const Bu::FString &sValue ) :
+        TafNode( typeProperty ),
+        sName( sName ),
+        sValue( sValue )
+{
+}
+
+Bu::TafProperty::~TafProperty()
+{
+}
+
+const Bu::FString &Bu::TafProperty::getName() const
+{
+        return sName;
+}
+
+const Bu::FString &Bu::TafProperty::getValue() const
+{
+        return sValue;
+}
+
+Bu::TafComment::TafComment( const Bu::FString &sText ) :
+        TafNode( typeComment ),
+        sText( sText )
+{
+}
+
+Bu::TafComment::~TafComment()
+{
+}
+
+const Bu::FString &Bu::TafComment::getText() const
+{
+        return sText;
+}
+
diff --git a/src/tafnode.h b/src/tafnode.h
new file mode 100644
index 0000000..cb4093f
--- /dev/null
+++ b/src/tafnode.h
@@ -0,0 +1,94 @@
+#ifndef BU_TAF_NODE_H
+#define BU_TAF_NODE_H
+
+#include <stdint.h>
+#include "bu/fstring.h"
+#include "bu/hash.h"
+#include "bu/list.h"
+
+namespace Bu
+{
+        /**
+         *
+         */
+        class TafNode
+        {
+        public:
+                enum NodeType
+                {
+                        typeGroup,
+                        typeProperty,
+                        typeComment
+                };
+
+        public:
+                TafNode( NodeType eType );
+                virtual ~TafNode();
+
+                const NodeType getType() const;
+
+        private:
+                NodeType eType;
+        };
+
+        class TafProperty;
+        class TafComment;
+        class TafGroup : public TafNode
+        {
+        public:
+                typedef Bu::List<Bu::FString> PropList;
+                typedef Bu::Hash<Bu::FString, PropList> PropHash;
+                typedef Bu::List<class Bu::TafGroup *> GroupList;
+                typedef Bu::Hash<Bu::FString, GroupList> GroupHash;
+                typedef Bu::List<class Bu::TafNode *> NodeList;
+
+                TafGroup( const Bu::FString &sName );
+                virtual ~TafGroup();
+
+                const Bu::FString &getName() const;
+
+                const Bu::FString &getProperty( const Bu::FString &sName ) const;
+                const PropList &getProperties( const Bu::FString &sName ) const;
+                const TafGroup *getChild( const Bu::FString &sName ) const;
+                const GroupList &getChildren( const Bu::FString &sName ) const;
+                TafNode *addChild( TafNode *pNode );
+                TafGroup *addChild( TafGroup *pNode );
+                TafProperty *addChild( TafProperty *pNode );
+                TafComment *addChild( TafComment *pNode );
+                const NodeList &getChildren() const;
+
+        private:
+                Bu::FString sName;
+                PropHash hProp;
+                GroupHash hChildren;
+                NodeList lChildren;
+        };
+
+        class TafProperty : public TafNode
+        {
+        public:
+                TafProperty( const Bu::FString &sName, const Bu::FString &sValue );
+                virtual ~TafProperty();
+
+                const Bu::FString &getName() const;
+                const Bu::FString &getValue() const;
+
+        private:
+                Bu::FString sName;
+                Bu::FString sValue;
+        };
+
+        class TafComment : public TafNode
+        {
+        public:
+                TafComment( const Bu::FString &sText );
+                virtual ~TafComment();
+
+                const Bu::FString &getText() const;
+
+        private:
+                Bu::FString sText;
+        };
+}
+
+#endif
diff --git a/src/tafreader.cpp b/src/tafreader.cpp
new file mode 100644
index 0000000..db465e9
--- /dev/null
+++ b/src/tafreader.cpp
@@ -0,0 +1,155 @@
+#include "bu/tafreader.h"
+#include "bu/exceptions.h"
+#include "bu/fstring.h"
+
+using namespace Bu;
+
+Bu::TafReader::TafReader( Bu::Stream &sIn ) :
+        c( 0 ),
+        sIn( sIn )
+{
+        next(); next();
+}
+
+Bu::TafReader::~TafReader()
+{
+
+}
+
+Bu::TafGroup *Bu::TafReader::readGroup()
+{
+        ws();
+        if( c != '{' )
+                throw TafException("Expected '{'");
+        next();
+        ws();
+        FString sName = readStr();
+        TafGroup *pGroup = new TafGroup( sName );
+        next();
+        //printf("Node[%s]:\n", sName.getStr() );
+
+        groupContent( pGroup );
+
+        if( c != '}' )
+                throw TafException("Expected '}'");
+
+        next();
+
+        return pGroup;
+}
+
+void Bu::TafReader::groupContent( Bu::TafGroup *pGroup )
+{
+        for(;;)
+        {
+                ws();
+                if( c == '{' )
+                        pGroup->addChild( readGroup() );
+                else if( c == '}' )
+                        return;
+                else if( c == '/' && la == '*' )
+                        pGroup->addChild( readComment() );
+                else
+                        pGroup->addChild( readProperty() );
+        }
+}
+
+Bu::TafProperty *Bu::TafReader::readProperty()
+{
+        FString sName = readStr();
+        ws();
+        if( c != '=' )
+        {
+                //printf("  %s (true)\n", sName.getStr() );
+                return new Bu::TafProperty( sName, "" );
+        }
+        next();
+        FString sValue = readStr();
+        return new Bu::TafProperty( sName, sValue );
+        //printf("  %s = %s\n", sName.getStr(), sValue.getStr() );
+}
+
+Bu::TafComment *Bu::TafReader::readComment()
+{
+        next();
+        FString sCmnt;
+        for(;;)
+        {
+                next();
+                if( c == '*' && la == '/' )
+                        break;
+                sCmnt += c;
+        }
+
+        return new TafComment( sCmnt );
+}
+
+Bu::FString Bu::TafReader::readStr()
+{
+        ws();
+        FString s;
+        if( c == '"' )
+        {
+                next();
+                for(;;)
+                {
+                        if( c == '\\' )
+                        {
+                                next();
+                                if( c == 'x' )
+                                {
+                                        char code[3]={'\0','\0','\0'};
+                                        next();
+                                        code[0] = c;
+                                        next();
+                                        code[1] = c;
+                                        c = (unsigned char)strtol( code, NULL, 16 );
+                                }
+                                else if( c == '"' )
+                                        c = '"';
+                                else
+                                        throw TafException("Invalid escape sequence.");
+                        }
+                        else if( c == '"' )
+                                break;
+                        s += c;
+                        next();
+                }
+                next();
+        }
+        else
+        {
+                for(;;)
+                {
+                        if( isws() || c == '}' || c == '{' || c == ':' || c == '=' )
+                                break;
+                        s += c;
+                        next();
+                }
+        }
+
+        return s;
+}
+
+void Bu::TafReader::ws()
+{
+        for(;;)
+        {
+                if( !isws() )
+                        return;
+
+                next();
+        }
+}
+
+bool Bu::TafReader::isws()
+{
+        return (c == ' ' || c == '\t' || c == '\n' || c == '\r');
+}
+
+void Bu::TafReader::next()
+{
+        c = la;
+        sIn.read( &la, 1 );
+}
+
diff --git a/src/tafreader.h b/src/tafreader.h
new file mode 100644
index 0000000..eeaafb3
--- /dev/null
+++ b/src/tafreader.h
@@ -0,0 +1,35 @@
+#ifndef BU_TAF_READER_H
+#define BU_TAF_READER_H
+
+#include <stdint.h>
+#include "bu/tafnode.h"
+#include "bu/stream.h"
+#include "bu/fstring.h"
+
+namespace Bu
+{
+        /**
+         *
+         */
+        class TafReader
+        {
+        public:
+                TafReader( Bu::Stream &sIn );
+                virtual ~TafReader();
+
+                Bu::TafGroup *readGroup();
+
+        private:
+                void groupContent( Bu::TafGroup *pNode );
+                Bu::TafProperty *readProperty();
+                Bu::TafComment *readComment();
+                void ws();
+                bool isws();
+                void next();
+                Bu::FString readStr();
+                char c, la;
+                Bu::Stream &sIn;
+        };
+}
+
+#endif
diff --git a/src/tafwriter.cpp b/src/tafwriter.cpp
new file mode 100644
index 0000000..6b505ef
--- /dev/null
+++ b/src/tafwriter.cpp
@@ -0,0 +1,70 @@
+#include "tafwriter.h"
+
+Bu::TafWriter::TafWriter( Bu::Stream &sOut ) :
+        sOut( sOut )
+{
+}
+
+Bu::TafWriter::~TafWriter()
+{
+}
+
+void Bu::TafWriter::writeGroup( const Bu::TafGroup *pRoot )
+{
+        sOut.write("{", 1 );
+        writeString( pRoot->getName() );
+        sOut.write(": ", 2 );
+        const Bu::TafGroup::NodeList &nl = pRoot->getChildren();
+        for( Bu::TafGroup::NodeList::const_iterator i = nl.begin(); i != nl.end(); i++ )
+        {
+                switch( (*i)->getType() )
+                {
+                        case Bu::TafNode::typeGroup:
+                                writeGroup( (Bu::TafGroup *)(*i) );
+                                break;
+
+                        case Bu::TafNode::typeProperty:
+                                writeProperty( (Bu::TafProperty *)(*i) );
+                                break;
+
+                        case Bu::TafNode::typeComment:
+                                writeComment( (Bu::TafComment *)(*i) );
+                                break;
+                }
+        }
+        sOut.write("}", 1 );
+}
+
+void Bu::TafWriter::writeProperty( const Bu::TafProperty *pProp )
+{
+        writeString( pProp->getName() );
+        if( pProp->getValue().getStr() != NULL )
+        {
+                sOut.write("=", 1 );
+                writeString( pProp->getValue() );
+        }
+        sOut.write(" ", 1 );
+}
+
+void Bu::TafWriter::writeComment( const Bu::TafComment *pComment )
+{
+        sOut.write("/*", 2 );
+        sOut.write( pComment->getText().getStr(), pComment->getText().getSize() );
+        sOut.write("*/ ", 3 );
+}
+
+void Bu::TafWriter::writeString( const Bu::FString &str )
+{
+        if( str.getStr() == NULL )
+                return;
+        sOut.write("\"", 1 );
+        for( const char *s = str.getStr(); *s; s++ )
+        {
+                if( *s == '\"' )
+                        sOut.write("\\\"", 2 );
+                else
+                        sOut.write( s, 1 );
+        }
+        sOut.write("\"", 1 );
+}
+
diff --git a/src/tafwriter.h b/src/tafwriter.h
new file mode 100644
index 0000000..5f80504
--- /dev/null
+++ b/src/tafwriter.h
@@ -0,0 +1,30 @@
+#ifndef BU_TAF_WRITER_H
+#define BU_TAF_WRITER_H
+
+#include <stdint.h>
+#include "bu/tafnode.h"
+#include "bu/stream.h"
+#include "bu/fstring.h"
+
+namespace Bu
+{
+        /**
+         *
+         */
+        class TafWriter
+        {
+        public:
+                TafWriter( Bu::Stream &sOut );
+                virtual ~TafWriter();
+
+                void writeGroup( const Bu::TafGroup *pRoot );
+
+        private:
+                void writeProperty( const Bu::TafProperty *pProp );
+                void writeComment( const Bu::TafComment *pComment );
+                void writeString( const Bu::FString &str );
+                Bu::Stream &sOut;
+        };
+}
+
+#endif
diff --git a/src/tests/archive.cpp b/src/tests/archive.cpp
new file mode 100644
index 0000000..2035aa6
--- /dev/null
+++ b/src/tests/archive.cpp
@@ -0,0 +1,16 @@
+#include "archive.h"
+#include "file.h"
+
+using namespace Bu;
+
+int main()
+{
+        File f("test.dat", "wb");
+        Archive ar( f, Archive::save );
+
+        std::string s("Hello there");
+        ar << s;
+
+        return 0;
+}
+
diff --git a/src/tests/atom.cpp b/src/tests/atom.cpp
new file mode 100644
index 0000000..2077bfd
--- /dev/null
+++ b/src/tests/atom.cpp
@@ -0,0 +1,25 @@
+#include "bu/atom.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct bob
+{
+        int a, b;
+} bob;
+int main()
+{
+        Bu::Atom<int> aInt;
+        Bu::Atom<char *> aStr;
+        Bu::Atom<bob> aBob;
+
+        aBob = bob();
+        aBob->a = 5;
+
+        aStr.set("Hey there, dude");
+        aInt.set( 55 );
+        int me = aInt;
+        aInt = 12;
+        printf("%d, %d\n", aInt.get(), me );
+        printf("%s\n", aStr.get() );
+}
+
diff --git a/src/tests/bzip2.cpp b/src/tests/bzip2.cpp
new file mode 100644
index 0000000..683d3d7
--- /dev/null
+++ b/src/tests/bzip2.cpp
@@ -0,0 +1,23 @@
+#include "bu/bzip2.h"
+#include "bu/file.h"
+
+int main( int argc, char *argv[] )
+{
+        char buf[1024];
+        size_t nRead;
+
+        Bu::File f( "test.bz2", "wb" );
+        Bu::BZip2 bz2( f );
+
+        Bu::File fin( argv[1], "rb");
+
+        for(;;)
+        {
+                nRead = fin.read( buf, 1024 );
+                if( nRead > 0 )
+                        bz2.write( buf, nRead );
+                if( fin.isEOS() )
+                        break;
+        }
+}
+
diff --git a/src/tests/constsptr.cpp b/src/tests/constsptr.cpp
deleted file mode 100644
index e6f87c7..0000000
--- a/src/tests/constsptr.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-#include <stdio.h>
-#include "sptr.h"
-
-template <typename T>
-class DataBase
-{
-public:
-        DataBase():
-                _bHas(false)
-        {
-        }
-        
-        virtual ~DataBase()
-        {
-                clr();
-        }
-        
-        virtual bool has() const
-        {
-                return _bHas;
-        }
-        
-        virtual void clr()
-        {
-                _bHas = false;
-        }
-
-        virtual void set(T d)
-        {
-                _tVal = d;
-                _bHas = true;
-        }
-
-        virtual T const &get() const
-        {
-                if(!has())
-                        throw "no data";
-                return _tVal;
-        }
-
-        virtual T &get()
-        {
-                if(!has())
-                        throw "no data";
-                return _tVal;
-        }
-        
-protected:
-        bool _bHas;
-        T _tVal;
-};
-
-
-class Test
-{
-public:
-        Test(){};
-        virtual ~Test(){};
-
-        void set(int i)
-        {
-                _i = i;
-        }
-        
-        int get() const
-        {
-                return _i;
-        }
-        
-private:
-        int _i;
-};
-
-int main()
-{
-        typedef SPtr<Test> TestPtr;
-
-        TestPtr t1(new Test);
-        t1->set(42);
-
-        printf("t1: %d.\n", t1->get());
-
-        const TestPtr t2 = t1;
-
-        printf("t2: %d.\n", t2->get());
-
-        typedef DataBase<const TestPtr> DBTP;
-
-        DBTP db;
-        db.set(t1);
-
-        printf("dbt1: %d.\n", db.get()->get());
-}
-
diff --git a/src/tests/constsptr2.cpp b/src/tests/constsptr2.cpp
deleted file mode 100644
index 8ccb20c..0000000
--- a/src/tests/constsptr2.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "sptr.h"
-
-void nonsptr()
-{
-        int a = 5;
-        int b = 10;
-        const int *p = &a;
-        p = &b;
-        printf("p = %d\n", (*p) );
-        //(*p)++;
-}
-
-void sptr()
-{
-        int a = 5;
-        int b = 10;
-        const SPtr<int> p = new int(a);
-        p = new int(b);
-        printf("p = %d\n", (*p) );
-        //(*p)++;
-}
-
-int main()
-{
-        printf("Non-sptr:\n");
-        nonsptr();
-        printf("sptr:\n");
-        sptr();
-}
-
diff --git a/src/tests/fstring.cpp b/src/tests/fstring.cpp
index 271738c..48dfc5f 100644
--- a/src/tests/fstring.cpp
+++ b/src/tests/fstring.cpp
@@ -1,9 +1,28 @@
-#include "hash.h"
-#include "fstring.h"
+#include "bu/hash.h"
+#include "bu/fstring.h"
+#include <sys/time.h>
+#include <string>
 
-FString genThing()
+#ifndef WIN32
+inline double getTime()
 {
-        FString bob;
+        struct timeval tv;
+        gettimeofday( &tv, NULL );
+        return ((double)tv.tv_sec) + ((double)tv.tv_usec/1000000.0);
+}
+#else
+#include "windows.h"
+#include "winbase.h"
+inline double getTime()
+{
+       uint32_t t = (uint32_t) GetTickCount();
+       return (double) t / 1000.0;
+}
+#endif
+
+Bu::FString genThing()
+{
+        Bu::FString bob;
         bob.append("ab ");
         bob += "cd ";
         bob += "efg";
@@ -12,20 +31,91 @@ FString genThing()
         return bob;
 }
 
-void thing( FString str )
+void thing( Bu::FString str )
 {
         printf("Hey:  %s\n", str.c_str() );
 }
 
+void copyfunc( std::string temp )
+{
+        temp += "Hi";
+}
+
+void copyfunc( Bu::FString temp )
+{
+        temp += "Hi";
+}
+
+void doTimings()
+{
+        Bu::FString fs1, fs2;
+        std::string ss1, ss2;
+        double dStart, dEnd, tfs1, tfs2, tfs3, tss1, tss2, tss3;
+        int nChars = 500000, nChunks=5000, nCopies=5000000, nChunkSize=1024*4;
+        char *buf = new char[nChunkSize];
+        memset( buf, '!', nChunkSize );
+
+        printf("Timing Bu::FString single chars...\n");
+        dStart = getTime();
+        for( int j = 0; j < nChars; j++ ) fs1 += (char)('a'+(j%26));
+        fs1.getStr();
+        dEnd = getTime();
+        tfs1 = dEnd-dStart;
+
+        printf("Timing std::string single chars...\n");
+        dStart = getTime();
+        for( int j = 0; j < nChars; j++ ) ss1 += (char)('a'+(j%26));
+        ss1.c_str();
+        dEnd = getTime();
+        tss1 = dEnd-dStart;
+
+        printf("Timing Bu::FString %d char chunks...\n", nChunkSize);
+        dStart = getTime();
+        for( int j = 0; j < nChunks; j++ ) fs2.append(buf, nChunkSize);
+        fs2.getStr();
+        dEnd = getTime();
+        tfs2 = dEnd-dStart;
+
+        printf("Timing std::string %d char chunks...\n", nChunkSize);
+        dStart = getTime();
+        for( int j = 0; j < nChunks; j++ ) ss2.append(buf, nChunkSize);
+        ss2.c_str();
+        dEnd = getTime();
+        tss2 = dEnd-dStart;
+
+        fs2 = "Hello there.";
+        ss2 = "Hello there.";
+        printf("Timing Bu::FString copies...\n");
+        dStart = getTime();
+        for( int j = 0; j < nCopies; j++ ) Bu::FString stmp = fs2;
+        dEnd = getTime();
+        tfs3 = dEnd-dStart;
+
+        printf("Timing std::string copies...\n");
+        dStart = getTime();
+        for( int j = 0; j < nCopies; j++ ) std::string stpm = ss2;
+        dEnd = getTime();
+        tss3 = dEnd-dStart;
+
+        printf(
+                "Results:       singles:        chunks:         copies:\n"
+                "Bu::FString    %10.2f/s   %10.2f/s   %10.2f/s\n"
+                "std::string    %10.2f/s   %10.2f/s   %10.2f/s\n",
+                nChars/tfs1, nChunks/tfs2, nCopies/tfs3,
+                nChars/tss1, nChunks/tss2, nCopies/tss3 );
+
+        delete[] buf;
+}
+
 #define pem printf("---------\n%08X: %s\n%08X: %s\n", (unsigned int)str.c_str(), str.c_str(), (unsigned int)str2.c_str(), str2.c_str() );
 int main( int argc, char *argv )
 {
-        FString str("th");
+        Bu::FString str("th");
 
         str.prepend("Hello ");
         str.append("ere.");
 
-        FString str2( str );
+        Bu::FString str2( str );
         pem;
         str += "  What's up?";
         pem;
@@ -43,6 +133,8 @@ int main( int argc, char *argv )
         thing( str2 );
         thing("test.");
         
-        printf("%d == %d\n", __calcHashCode( str ), __calcHashCode( str.c_str() ) );
+        printf("%d == %d\n", Bu::__calcHashCode( str ), Bu::__calcHashCode( str.c_str() ) );
+
+        doTimings();
 }
 
diff --git a/src/tests/hash.cpp b/src/tests/hash.cpp
index 2fc6968..73cfb27 100644
--- a/src/tests/hash.cpp
+++ b/src/tests/hash.cpp
@@ -1,116 +1,24 @@
-#include "hash.h"
-#include "staticstring.h"
+#include "bu/hash.h"
+#include "bu/sptr.h"
 
-int main()
+typedef struct Bob
 {
-        const char *names[]={
-                "Homer the Great",
-                "And Maggie Makes Three",
-                "Bart's Comet",
-                "Homie The Clown",
-                "Bart Vs Australia",
-                "Homer vs Patty and Selma",
-                "A star is burns",
-                "Lisa's Wedding",
-                "Two Dozen and One Greyhounds",
-                "The PTA Disbands",
-                "Round Springfield",
-                "The Springfield connection",
-                "Lemon of Troy",
-                "Who Shot Mr. Burns (Pt. 1)",
-                "Who Shot Mr. Burns (pt. 2)",
-                "Radioactive Man",
-                "Home Sweet Homediddly-dum-doodly",
-                "Bart Sells His Soul",
-                "Lisa the Vegetarian",
-                "Treehouse of horror VI",
-                "King Size Homer",
-                "Mother Simpson",
-                "Sideshow Bob's Last Gleaming",
-                "The Simpson's 138th Show Spectacular",
-                "Marge Be Not Proud",
-                "Team Homer",
-                "Two Bad Neighbors",
-                "Scenes From the Class Struggle in Springfield",
-                "Bart the Fink",
-                "Lisa the Iconoclast",
-                "Homer the Smithers",
-                "The Day the Violence Died",
-                "A Fish Called Selma",
-                "Bart on the road",
-                "22 Short Films about Springfield",
-                "The Curse of the Flying Hellfish",
-                "Much Apu about Nothing",
-                "Homerpalooza",
-                "The Summer of 4 Ft 2",
-                "Treehouse of Horror VII",
-                "You Only Move Twice",
-                "The Homer They Fall",
-                "Burns Baby Burns",
-                "Bart After Dark",
-                "A Millhouse Divided",
-                "Lisas Date With Destiny",
-                "Hurricane Neddy",
-                "The Mysterious Voyage of Our Homer",
-                "The Springfield Files",
-                "The Twisted World of Marge Simpson",
-                "Mountain of Madness",
-                NULL
-        };
-
-        Hash<const char *, int> sTest;
-
-        printf("Inserting\n-------------------\n\n");
-        for( int j = 0; j < 33; j++ )
-        {
-                sTest[names[j]] = j;
-        }
-        
-        printf("Test1: %d, Test2: %d\n", sTest.has("Lemon of Troy"), sTest.has(std::string("Lemon of Troy").c_str() ) );
-
-        sTest.has(std::string("Lemon of Troy").c_str() );
-
-        printf("Getting\n-------------------\n\n");
-
-        sTest.erase("Homer the Great");
-        sTest["Bart's Comet"].erase();
+        int nID;
+} Bob;
 
-        for( Hash<const char *, int>::iterator i = sTest.begin();
-                 i != sTest.end(); i++ )
-        {
-                Hash<const char *, int>::iterator j = i;
-                printf("%d: %s\n", (*j).second, (*j).first );
-        }
-
-        printf("Testing\n-------------------\n\n");
-        for( int j = 0; j < 33; j++ )
+int main()
+{
+        Bu::Hash<int, Bu::SPtr<const Bob> > lb;
+        for( int j = 0; j < 10; j++ )
         {
-                if( sTest.has(names[j]) )
-                {
-                        if( sTest[names[j]] != j )
-                        {
-                                printf("'%s' should be %d, is %d\n",
-                                        names[j], j,
-                                        sTest[names[j]].value()
-                                        );
-                        }
-                }
-                else
-                {
-                        printf("Missing element %d, '%s'\n", j, names[j] );
-                }
+                Bob *b = new Bob;
+                b->nID = j;
+                lb.insert( j, b );
         }
 
-        printf("Clearing\n-------------------\n\n");
-
-        sTest.clear();
-        
-        for( Hash<const char *, int>::iterator i = sTest.begin();
-                 i != sTest.end(); i++ )
+        for( int j = 0; j < 10; j++ )
         {
-                Hash<const char *, int>::iterator j = i;
-                printf("%d: %s\n", (*j).second, (*j).first );
+                printf("%d\n", lb[j].value()->nID );
         }
-
 }
 
diff --git a/src/tests/itoqueue1.cpp b/src/tests/itoqueue1.cpp
new file mode 100644
index 0000000..f73f4d3
--- /dev/null
+++ b/src/tests/itoqueue1.cpp
@@ -0,0 +1,110 @@
+#include <string>
+#include "bu/ito.h"
+#include "bu/itoqueue.h"
+
+class Reader : public Bu::Ito
+{
+public:
+        Reader( Bu::ItoQueue<std::string *> &q, int id ) :
+                q( q ),
+                id( id )
+        {
+        }
+
+        void *run()
+        {
+                for( int i = 0; i < 10; i++ )
+                {
+                        std::string *pStr = q.dequeue( true );
+                        if( pStr == NULL )
+                        {
+                                printf("Null received...\n");
+                        }
+                        else
+                        {
+                                printf("[%d] read:  %s\n", id, pStr->c_str() );
+                                delete pStr;
+                        }
+                        usleep( (int)(((double)rand())/((double)RAND_MAX)*2000000.0) );
+                }
+
+                return NULL;
+        }
+
+private:
+        Bu::ItoQueue<std::string *> &q;
+        int id;
+};
+
+class Writer : public Bu::Ito
+{
+public:
+        Writer( Bu::ItoQueue<std::string *> &q, int id, const char *strbase ) :
+                q( q ),
+                strbase( strbase ),
+                id( id )
+        {
+        }
+
+        void *run()
+        {
+                for( int i = 0; i < 11; i++ )
+                {
+                        usleep( (int)(((double)rand())/((double)RAND_MAX)*2000000.0) );
+                        q.enqueue( new std::string( strbase ) );
+                        printf("[%d] write: %s\n", id, strbase );
+                }
+
+                return NULL;
+        }
+
+private:
+        Bu::ItoQueue<std::string *> &q;
+        const char *strbase;
+        int id;
+};
+
+int main()
+{
+        Writer *wr[5];
+        Reader *rd[5];
+        const char bob[][7]={
+                {"Test 1"},
+                {"Test 2"},
+                {"Test 3"},
+                {"Test 4"},
+                {"Test 5"}
+        };
+
+        Bu::ItoQueue<std::string *> q;
+
+        for( int j = 0; j < 5; j++ )
+        {
+                wr[j] = new Writer( q, j, bob[j] );
+                rd[j] = new Reader( q, j );
+        }
+
+        for( int j = 0; j < 5; j++ )
+        {
+                rd[j]->start();
+        }
+
+        for( int j = 0; j < 5; j++ )
+        {
+                wr[j]->start();
+        }
+
+        for( int j = 0; j < 5; j++ )
+        {
+                rd[j]->join();
+        }
+
+        for( int j = 0; j < 5; j++ )
+        {
+                delete wr[j];
+                delete rd[j];
+        }
+
+        return 0;
+}
+
diff --git a/src/tests/itoqueue2.cpp b/src/tests/itoqueue2.cpp
new file mode 100644
index 0000000..f4b5e19
--- /dev/null
+++ b/src/tests/itoqueue2.cpp
@@ -0,0 +1,83 @@
+#include <string>
+#include "bu/ito.h"
+#include "bu/itoqueue.h"
+#include <errno.h>
+
+class Reader : public Bu::Ito
+{
+public:
+        Reader( Bu::ItoQueue<std::string *> &q, int id ) :
+                q( q ),
+                id( id )
+        {
+        }
+
+        void *run()
+        {
+                for( int i = 0; i < 10; i++ )
+                {
+                        std::string *pStr = q.dequeue( 0, 500000 );
+                        if( pStr == NULL )
+                        {
+                                printf("Null received...\n");
+                                i--;
+                        }
+                        else
+                        {
+                                printf("[%d] read:  %s\n", id, pStr->c_str() );
+                                delete pStr;
+                        }
+                }
+
+                return NULL;
+        }
+
+private:
+        Bu::ItoQueue<std::string *> &q;
+        int id;
+};
+
+class Writer : public Bu::Ito
+{
+public:
+        Writer( Bu::ItoQueue<std::string *> &q, int id, const char *strbase ) :
+                q( q ),
+                strbase( strbase ),
+                id( id )
+        {
+        }
+
+        void *run()
+        {
+                for( int i = 0; i < 11; i++ )
+                {
+                        sleep( 2 );
+                        printf("[%d] write: %s\n", id, strbase );
+                        q.enqueue( new std::string( strbase ) );
+                }
+
+                return NULL;
+        }
+
+private:
+        Bu::ItoQueue<std::string *> &q;
+        const char *strbase;
+        int id;
+};
+
+int main()
+{
+        printf("ETIMEDOUT: %d\n", ETIMEDOUT );
+        Bu::ItoQueue<std::string *> q;
+        Writer wr( q, 0, "writer" );
+        Reader rd( q, 0 );
+
+        rd.start();
+        wr.start();
+
+        rd.join();
+        wr.join();
+
+        return 0;
+}
+
diff --git a/src/tests/list.cpp b/src/tests/list.cpp
new file mode 100644
index 0000000..12807a5
--- /dev/null
+++ b/src/tests/list.cpp
@@ -0,0 +1,53 @@
+#include "bu/list.h"
+#include <list>
+
+typedef struct Bob
+{
+        int nID;
+} Bob;
+
+int main()
+{
+        Bu::List<int> l;
+
+        l.append( 0 );
+
+        for( int j = 3; j <= 21; j += 3 )
+        {
+                l.append( j );
+                l.prepend( -j );
+        }
+
+        for( Bu::List<int>::iterator i = l.begin(); i != l.end(); i++ )
+        {
+                printf("%d ", *i );
+        }
+        printf("\n");
+        for( Bu::List<int>::iterator i = l.begin(); i != l.end(); i++ )
+        {
+                l.erase( i );
+                if( i != l.end() )
+                        printf("%d ", *i );
+        }
+
+        printf("\n\n");
+
+        Bu::List<Bob> lb;
+        for( int j = 0; j < 10; j++ )
+        {
+                Bob b;
+                b.nID = j;
+                lb.append( b );
+        }
+
+        const Bu::List<Bob> rb = lb;
+
+        for( Bu::List<Bob>::const_iterator i = rb.begin(); i != rb.end(); i++ )
+        {
+                //i->nID += 2;
+                //(*i).nID = 4;
+                printf("%d ", i->nID );
+        }
+        printf("\n\n");
+}
+
diff --git a/src/tests/logger.cpp b/src/tests/logger.cpp
new file mode 100644
index 0000000..290f479
--- /dev/null
+++ b/src/tests/logger.cpp
@@ -0,0 +1,28 @@
+#include "bu/logger.h"
+#include <errno.h>
+#include <stdlib.h>
+
+class Thing
+{
+        public:
+                Thing()
+                {
+                        lineLog( 2, "Want a thing?");
+                }
+
+                void go( int i )
+                {
+                        lineLog( 1, "GO!!!!");
+                }
+};
+
+int main()
+{
+        setLogLevel( 4 );
+        setLogFormat("%L: %y-%02m-%02d %h:%02M:%02s %f:%l:%F: %t");
+        lineLog( 5, "Hey, error: %s", strerror( errno ) );
+
+        Thing gh;
+        gh.go( 6);
+}
+
diff --git a/src/tests/ringbuffer.cpp b/src/tests/ringbuffer.cpp
new file mode 100644
index 0000000..259ec1f
--- /dev/null
+++ b/src/tests/ringbuffer.cpp
@@ -0,0 +1,29 @@
+#include "bu/ringbuffer.h"
+#include <stdlib.h>
+
+int main()
+{
+        Bu::RingBuffer<uint32_t> ibuf( 10 );
+
+        for( int k = 0; k < 2; k++ )
+        {
+                int j = 1;
+                for(; j < 7; j++ )
+                {
+                        ibuf.enqueue( j );
+                }
+
+                for(; j < 20; j++ )
+                {
+                        ibuf.enqueue( j );
+                        printf("- %d\n", ibuf.dequeue() );
+                }
+
+                for(;;)
+                {
+                        if( ibuf.isEmpty() ) break;
+                        printf(". %d\n", ibuf.dequeue() );
+                }
+        }
+}
+
diff --git a/src/tests/taf.cpp b/src/tests/taf.cpp
new file mode 100644
index 0000000..e3da120
--- /dev/null
+++ b/src/tests/taf.cpp
@@ -0,0 +1,24 @@
+#include "bu/tafreader.h"
+#include "bu/tafwriter.h"
+#include "bu/file.h"
+
+int main()
+{
+        Bu::File f("test.taf", "rb");
+        Bu::TafReader tr( f );
+
+        Bu::TafGroup *pGroup = tr.readGroup();
+
+        const Bu::TafGroup *pStats = pGroup->getChild("stats");
+        printf("%s\n", pStats->getName().getStr() );
+        printf("  str = %s\n", pStats->getProperty("str").getStr() );
+
+        {
+                Bu::File fo("out.taf", "wb");
+                Bu::TafWriter tw( fo );
+                tw.writeGroup( pGroup );
+        }
+
+        delete pGroup;
+}
+
diff --git a/src/unit/entities/unit b/src/unit/entities/unit
new file mode 100644
index 0000000..28db45f
--- /dev/null
+++ b/src/unit/entities/unit
@@ -0,0 +1,30 @@
+<?xml version="1.1" ?>
+<entity desc="Unit test framework">
+        <param name="name" required="yes" desc="Name of the class"/>
+        <file
+                name="source"
+                filename="{=name:%tolower}.cpp"
+>#include "bu/unitsuite.h"
+
+class Unit : public Bu::UnitSuite
+{
+public:
+        Unit()
+        {
+                setName("{=name}");
+                addTest( Unit::test01 );
+        }
+
+        virtual ~Unit()
+        {
+        }
+
+        void test01()
+        {
+                unitTest( 0 == 5 );
+        }
+};
+
+int main( int argc, char *argv[] ){ return Unit().run( argc, argv ); }
+</file>
+</entity>
diff --git a/src/unit/file.cpp b/src/unit/file.cpp
new file mode 100644
index 0000000..1eaaf36
--- /dev/null
+++ b/src/unit/file.cpp
@@ -0,0 +1,111 @@
+#include "unitsuite.h"
+#include "file.h"
+#include "exceptions.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+class Unit : public Bu::UnitSuite
+{
+public:
+        Unit()
+        {
+                setName("File");
+                addTest( Unit::writeFull );
+                addTest( Unit::readBlocks );
+                addTest( Unit::readError1 );
+                addTest( Unit::readError2 );
+        }
+
+        virtual ~Unit() { }
+
+        //
+        // Tests go here
+        //
+        void writeFull()
+        {
+                Bu::File sf("testfile1", "wb");
+                for( int c = 0; c < 256; c++ )
+                {
+                        unsigned char ch = (unsigned char)c;
+                        sf.write( &ch, 1 );
+                        unitTest( sf.tell() == c+1 );
+                }
+                //unitTest( sf.canRead() == false );
+                //unitTest( sf.canWrite() == true );
+                //unitTest( sf.canSeek() == true );
+                sf.close();
+                struct stat sdat;
+                stat("testfile1", &sdat );
+                unitTest( sdat.st_size == 256 );
+        }
+
+        void readBlocks()
+        {
+                Bu::File sf("testfile1", "rb");
+                unsigned char buf[50];
+                size_t total = 0;
+                for(;;)
+                {
+                        size_t s = sf.read( buf, 50 );
+                        for( size_t c = 0; c < s; c++ )
+                        {
+                                unitTest( buf[c] == (unsigned char)(c+total) );
+                        }
+                        total += s;
+                        if( s < 50 )
+                        {
+                                unitTest( total == 256 );
+                                unitTest( sf.isEOS() == true );
+                                break;
+                        }
+                }
+                sf.close();
+        }
+
+        void readError1()
+        {
+                try
+                {
+                        Bu::File sf("doesn'texist", "rb");
+                        unitFailed("No exception thrown");
+                }
+                catch( Bu::FileException &e )
+                {
+                        return;
+                }
+        }
+
+        void readError2()
+        {
+                Bu::File sf("testfile1", "rb");
+                char buf[256];
+                int r = sf.read( buf, 256 );
+                unitTest( r == 256 );
+                // You have to read past the end to set the EOS flag.
+                unitTest( sf.isEOS() == false );
+                try
+                {
+                        if( sf.read( buf, 5 ) > 0 )
+                        {
+                                unitFailed("Non-zero read result");
+                        }
+                        else
+                        {
+                                sf.close();
+                        }
+                }
+                catch( Bu::FileException &e )
+                {
+                        sf.close();
+                        return;
+                }
+        }
+};
+
+int main( int argc, char *argv[] )
+{
+        return Unit().run( argc, argv );
+}
+
diff --git a/src/unit/fstring.cpp b/src/unit/fstring.cpp
new file mode 100644
index 0000000..72755eb
--- /dev/null
+++ b/src/unit/fstring.cpp
@@ -0,0 +1,28 @@
+#include "fstring.h"
+#include "unitsuite.h"
+
+class Unit : public Bu::UnitSuite
+{
+public:
+        Unit()
+        {
+                setName("FString");
+                addTest( Unit::test1 );
+        }
+
+        virtual ~Unit()
+        {
+        }
+
+        void test1()
+        {
+                unitTest( 1 == 1 );
+                unitTest( 1 == 0 );
+        }
+};
+
+int main( int argc, char *argv[] )
+{
+        return Unit().run( argc, argv );
+}
+
diff --git a/src/unit/hash.cpp b/src/unit/hash.cpp
new file mode 100644
index 0000000..9ea933f
--- /dev/null
+++ b/src/unit/hash.cpp
@@ -0,0 +1,40 @@
+#include "bu/fstring.h"
+#include "bu/hash.h"
+#include "bu/unitsuite.h"
+
+#include <stdio.h>
+
+class Unit : public Bu::UnitSuite
+{
+private:
+        typedef Bu::Hash<Bu::FString, int> StrIntHash;
+public:
+        Unit()
+        {
+                setName("Hash");
+                addTest( Unit::test_probe );
+        }
+
+        virtual ~Unit()
+        {
+        }
+
+        void test_probe()
+        {
+                StrIntHash h;
+                char buf[20];
+                for(int i=1;i<10000;i++)
+                {
+                        sprintf(buf,"%d",i);
+                        Bu::FString sTmp(buf);
+                        h[sTmp] = i;
+                        unitTest( h.has(sTmp) );
+                }
+        }
+};
+
+int main( int argc, char *argv[] )
+{
+        return Unit().run( argc, argv );
+}
+
diff --git a/src/unit/membuf.cpp b/src/unit/membuf.cpp
new file mode 100644
index 0000000..65ba82a
--- /dev/null
+++ b/src/unit/membuf.cpp
@@ -0,0 +1,37 @@
+#include "bu/unitsuite.h"
+#include "bu/membuf.h"
+
+class Unit : public Bu::UnitSuite
+{
+public:
+        Unit()
+        {
+                setName("MemBuf");
+                addTest( Unit::testWriteRead01 );
+        }
+
+        virtual ~Unit()
+        {
+        }
+
+        void testWriteRead01()
+        {
+                Bu::MemBuf mb;
+                unitTest( mb.write("ab", 2 ) == 2 );
+                unitTest( mb.write("cde", 3 ) == 3 );
+                unitTest( mb.write("FG", 2 ) == 2 );
+
+                mb.setPos( 0 );
+
+                char buf[8];
+                buf[7] = '\0';
+                unitTest( mb.read( buf, 7 ) == 7 );
+                unitTest( !strncmp( buf, "abcdeFG", 7 ) );
+                unitTest( mb.read( buf, 7 ) == 0 );
+                mb.seek( -3 );
+                unitTest( mb.read( buf, 7 ) == 3 );
+                unitTest( !strncmp( buf, "eFG", 3 ) );
+        }
+};
+
+int main( int argc, char *argv[] ){ return Unit().run( argc, argv ); }
diff --git a/src/unit/taf.cpp b/src/unit/taf.cpp
new file mode 100644
index 0000000..5e0e914
--- /dev/null
+++ b/src/unit/taf.cpp
@@ -0,0 +1,48 @@
+#include "unitsuite.h"
+#include "file.h"
+#include "tafreader.h"
+
+#include <string.h>
+#include <unistd.h>
+
+class Unit : public Bu::UnitSuite
+{
+public:
+        Unit()
+        {
+                setName("taf");
+                addTest( Unit::read1 );
+        }
+
+        virtual ~Unit()
+        {
+        }
+
+        void read1()
+        {
+#define FN_TMP ("/tmp/tmpXXXXXXXX")
+                Bu::FString sFnTmp(FN_TMP);
+                Bu::File fOut = Bu::File::tempFile( sFnTmp, "wb" );
+                const char *data =
+"{test: name=\"Bob\"}"
+;
+                fOut.write(data,strlen(data));
+                fOut.close();
+
+                Bu::File fIn(sFnTmp.c_str(), "rb");
+                Bu::TafReader tr(fIn);
+                
+                Bu::TafGroup *tn = tr.readGroup();
+                unitTest( !strcmp("Bob", tn->getProperty("name").c_str()) );
+                delete tn;
+
+                unlink(sFnTmp.c_str());
+#undef FN_TMP
+        }
+};
+
+int main( int argc, char *argv[] )
+{
+        return Unit().run( argc, argv );
+}
+
diff --git a/src/unitsuite.cpp b/src/unitsuite.cpp
new file mode 100644
index 0000000..2a28eb5
--- /dev/null
+++ b/src/unitsuite.cpp
@@ -0,0 +1,67 @@
+#include "unitsuite.h"
+
+Bu::UnitSuite::UnitSuite()
+{
+}
+
+Bu::UnitSuite::~UnitSuite()
+{
+}
+
+int Bu::UnitSuite::run( int argc, char *argv[] )
+{
+        for( TestList::iterator i = lTests.begin(); i != lTests.end(); i++ )
+        {
+                printf("%s: ", i->sName.getStr() );
+                fflush( stdout );
+                try
+                {
+                        (this->*(i->fTest))();
+                        printf("passed.\n");
+                }
+                catch( Failed &e )
+                {
+                        if( e.bFile )
+                        {
+                                printf("unitTest(%s) failed. (%s:%d)\n",
+                                        e.str.getStr(),
+                                        e.sFile.getStr(),
+                                        e.nLine
+                                        );
+                        }
+                        else
+                        {
+                                printf("unitTest(%s) failed.\n",
+                                        e.str.getStr()
+                                        );
+                        }
+                }
+                catch( ... )
+                {
+                        printf("failed with external exception.\n");
+                }
+        }
+
+        return 0;
+}
+
+void Bu::UnitSuite::add( Test fTest, Bu::FString sName )
+{
+        TestInfo ti;
+        ti.sName = sName;
+        long index = ti.sName.rfind("::");
+        if( index != -1 )
+        {
+                FString tmp = sSuiteName;
+                tmp += ti.sName.getStr()+index;
+                ti.sName = tmp;
+        }
+        ti.fTest = fTest;
+        lTests.push_back( ti );
+}
+
+void Bu::UnitSuite::setName( const FString &sName )
+{
+        sSuiteName = sName;
+}
+
diff --git a/src/unitsuite.h b/src/unitsuite.h
new file mode 100644
index 0000000..578b4cc
--- /dev/null
+++ b/src/unitsuite.h
@@ -0,0 +1,96 @@
+#ifndef BU_UNIT_SUITE_H
+#define BU_UNIT_SUITE_H
+
+#include <stdint.h>
+#include <list>
+#include "fstring.h"
+
+namespace Bu
+{
+        /**
+         * Provides a unit testing framework.  This is pretty easy to use, probably
+         * the best way to get started is to use ch to generate a template, or use
+         * the code below with appropriate tweaks:
+         *@code
+         * #include "unitsuite.h"
+         * 
+         * class Unit : public Bu::UnitSuite
+         * {
+         * public:
+         *      Unit()
+         *      {
+         *              setName("Example");
+         *              addTest( Unit::test );
+         *      }
+         * 
+         *      virtual ~Unit() { }
+         * 
+         *      //
+         *      // Tests go here
+         *      //
+         *      void test()
+         *      {
+         *              unitTest( 1 == 1 );
+         *      }
+         * };
+         * 
+         * int main( int argc, char *argv[] )
+         * {
+         *      return Unit().run( argc, argv );
+         * }
+         *
+         @endcode
+         * The main function can contain other things, but using this one exactly
+         * makes all of the test suites work exactly the same.  Using the optional
+         * setName at the top of the constructor replaces the class name with the
+         * chosen name when printing out stats and info.
+         */
+        class UnitSuite
+        {
+        public:
+                UnitSuite();
+                virtual ~UnitSuite();
+
+                int run( int argc=0, char *argv[]=NULL );
+
+                typedef void (UnitSuite::*Test)();
+
+                class Failed
+                {
+                public:
+                        Failed() : str(""), bFile( false ) { }
+                        Failed( const FString &s ) : str( s ), bFile( false ) { }
+                        Failed( const FString &s, const FString &sFile, int nLine ) :
+                                str( s ), sFile( sFile ), nLine( nLine ), bFile( true ) { }
+
+                        FString str;
+                        FString sFile;
+                        int nLine;
+                        bool bFile;
+                };
+                
+        protected:
+                void add( Test fTest, Bu::FString sName );
+                void setName( const FString &sName );
+
+        private:
+                typedef struct TestInfo
+                {
+                        FString sName;
+                        Test fTest;
+                } TestInfo;
+
+                typedef std::list<TestInfo> TestList;
+                TestList lTests;
+                FString sSuiteName;
+        };
+}
+
+#define addTest( fn ) add( static_cast<Bu::UnitSuite::Test>(&fn), #fn )
+#define unitTest( tst ) if( !(tst) )                                                    \
+{                                                                                                                               \
+        throw Bu::UnitSuite::Failed( #tst, __FILE__, __LINE__ );        \
+}
+#define unitFailed( msg ) throw Bu::UnitSuite::Failed(msg, __FILE__, __LINE__);
+
+#endif