Code is all reorganized. We're about ready to release. I should write up a

little explenation of the arrangement.

154 files changed, 24481 insertions, 0 deletions

diff --git a/src/stable/archival.cpp b/src/stable/archival.cpp
new file mode 100644
index 0000000..687e8a3
--- /dev/null
+++ b/src/stable/archival.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/archival.h"
+
+Bu::Archival::Archival()
+{
+}
+
+Bu::Archival::~Archival()
+{
+}
+
+Bu::ArchiveBase &Bu::operator<<(Bu::ArchiveBase &s, const Bu::Archival &p)
+{
+        const_cast<Bu::Archival &>(p).archive( s );
+        return s;
+}
+
+Bu::ArchiveBase &Bu::operator<<(Bu::ArchiveBase &s, Bu::Archival &p)
+{
+        p.archive( s );
+        return s;
+}
+
+Bu::ArchiveBase &Bu::operator>>(Bu::ArchiveBase &s, Bu::Archival &p)
+{
+        p.archive( s );
+        return s;
+}
+
diff --git a/src/stable/archival.h b/src/stable/archival.h
new file mode 100644
index 0000000..946167a
--- /dev/null
+++ b/src/stable/archival.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_ARCHIVAL_H
+#define BU_ARCHIVAL_H
+
+#include "bu/archivebase.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 ArchiveBase &ar )=0;
+        };
+
+        ArchiveBase &operator<<(ArchiveBase &, const class Bu::Archival &);
+        ArchiveBase &operator<<(ArchiveBase &, class Bu::Archival &);
+        ArchiveBase &operator>>(ArchiveBase &, class Bu::Archival &);
+
+}
+
+#endif
diff --git a/src/stable/archive.cpp b/src/stable/archive.cpp
new file mode 100644
index 0000000..d300a87
--- /dev/null
+++ b/src/stable/archive.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/archive.h"
+#include "bu/stream.h"
+#include "bu/archival.h"
+
+#include "bu/sio.h"
+
+Bu::Archive::Archive( Stream &rStream, bool bLoading ) :
+        bLoading( bLoading ),
+        rStream( rStream ),
+        nNextID( 1 )
+{
+}
+
+Bu::Archive::~Archive()
+{
+}
+
+void Bu::Archive::write( const void *pData, size_t nSize )
+{
+        if( nSize == 0 || pData == NULL )
+                return;
+
+        rStream.write( (const char *)pData, nSize );
+}
+
+void Bu::Archive::read( void *pData, size_t nSize )
+{
+        if( nSize == 0 || pData == NULL )
+                return;
+
+        if( rStream.read( (char *)pData, nSize ) < nSize )
+                throw Bu::ExceptionBase("Insufficient data to unarchive object.");
+}
+
+void Bu::Archive::close()
+{
+        rStream.close();
+}
+
+bool Bu::Archive::isLoading()
+{
+        return bLoading;
+}
+
+uint32_t Bu::Archive::getID( const void *ptr )
+{
+        if( hPtrID.has( (ptrdiff_t)ptr ) )
+                return hPtrID.get( (ptrdiff_t)ptr );
+        hPtrID.insert( (ptrdiff_t)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].getValue().append( ptr );
+}
+
+void Bu::Archive::readID( const void *ptr, uint32_t id )
+{
+        hPtrID.insert( id, (ptrdiff_t)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/stable/archive.h b/src/stable/archive.h
new file mode 100644
index 0000000..61474a4
--- /dev/null
+++ b/src/stable/archive.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_ARCHIVE_H
+#define BU_ARCHIVE_H
+
+#include <stdint.h>
+#include "bu/archivebase.h"
+#include "bu/hash.h"
+#include "bu/util.h"
+#include "bu/variant.h"
+
+namespace Bu
+{
+        class Archival;
+        class Stream;
+
+        /**
+         * 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 : public ArchiveBase
+        {
+        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 *pData, size_t iSize );
+                virtual void read( void *pData, size_t iSize );
+                
+                /**
+                 * For storage, get an ID for the pointer to the object you're going to
+                 * write.
+                 */
+                uint32_t getID( const void *ptr );
+
+                /**
+                 * For loading.  Assosiates an empty pointer with an id.  When you wind
+                 * up loading an id reference to a pointer for an object that may or
+                 * may not have loaded yet, call this with the id, if it has been loaded
+                 * already, you'll immediately get a pointer, if not, it will write one
+                 * for you when the time comes.
+                 */
+                void assocPtrID( void **ptr, uint32_t id );
+
+                /**
+                 * For loading.  Call this when you load an object that other things may
+                 * have pointers to.  It will assosiate every pointer that's been
+                 * registered with assocPtrID to the pointer passed in, and id passed
+                 * in.  It will also set things up so future calls to assocPtrID will
+                 * automatically succeed immediately.
+                 */
+                void readID( const void *ptr, uint32_t id );
+
+                template<typename t>
+                void setProp( const Bu::String &sId, const t &val )
+                {
+                        if( !hProps.has( sId ) )
+                        {
+                                hProps.insert( sId, Variant() );
+                        }
+                        hProps.get( sId ) = val;
+                }
+
+                template<typename t>
+                t getProp( const Bu::String &sId )
+                {
+                        return hProps.get( sId );
+                }
+
+        private:
+                Stream &rStream;
+                uint32_t nNextID;
+                Hash<uint32_t,uint32_t> hPtrID;
+                Hash<uint32_t,List<void **> > hPtrDest;
+                Hash<Bu::String, Variant> hProps;
+        };
+}
+
+#endif
diff --git a/src/stable/archivebase.cpp b/src/stable/archivebase.cpp
new file mode 100644
index 0000000..d00b1a5
--- /dev/null
+++ b/src/stable/archivebase.cpp
@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/archivebase.h"
+
+Bu::ArchiveBase::ArchiveBase()
+{
+}
+
+Bu::ArchiveBase::~ArchiveBase()
+{
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, bool p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, char p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed char p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned char p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed short p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned short p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed int p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned int p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed long p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned long p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed long long p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned long long p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, float p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, double p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, long double p)
+{
+        ar.write( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, bool &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, char &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed char &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned char &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed short &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned short &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed int &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned int &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed long &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned long &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed long long &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned long long &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, float &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, double &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, long double &p)
+{
+        ar.read( &p, sizeof(p) );
+        return ar;
+}
+
diff --git a/src/stable/archivebase.h b/src/stable/archivebase.h
new file mode 100644
index 0000000..4745d91
--- /dev/null
+++ b/src/stable/archivebase.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_ARCHIVE_BASE_H
+#define BU_ARCHIVE_BASE_H
+
+#include <stdint.h>
+#include <unistd.h>
+
+namespace Bu
+{
+        class ArchiveBase
+        {
+        public:
+                ArchiveBase();
+                virtual ~ArchiveBase();
+
+                virtual void close()=0;
+                virtual void write( const void *pData, size_t iLength )=0;
+                virtual void read( void *pData, size_t iLength )=0;
+                virtual bool isLoading()=0;
+        };
+
+        template<typename T> ArchiveBase &operator&&( ArchiveBase &ar, T &dat )
+        {
+                if( ar.isLoading() )
+                {
+                        return ar >> dat;
+                }
+                else
+                {
+                        return ar << dat;
+                }
+        }
+
+        ArchiveBase &operator<<( ArchiveBase &ar, bool p );
+        ArchiveBase &operator<<( ArchiveBase &ar, char p );
+        ArchiveBase &operator<<( ArchiveBase &ar, signed char p );
+        ArchiveBase &operator<<( ArchiveBase &ar, unsigned char p );
+        ArchiveBase &operator<<( ArchiveBase &ar, signed short p );
+        ArchiveBase &operator<<( ArchiveBase &ar, unsigned short p );
+        ArchiveBase &operator<<( ArchiveBase &ar, signed int p );
+        ArchiveBase &operator<<( ArchiveBase &ar, unsigned int p );
+        ArchiveBase &operator<<( ArchiveBase &ar, signed long p );
+        ArchiveBase &operator<<( ArchiveBase &ar, unsigned long p );
+        ArchiveBase &operator<<( ArchiveBase &ar, signed long long p );
+        ArchiveBase &operator<<( ArchiveBase &ar, unsigned long long p );
+        ArchiveBase &operator<<( ArchiveBase &ar, float p );
+        ArchiveBase &operator<<( ArchiveBase &ar, double p );
+        ArchiveBase &operator<<( ArchiveBase &ar, long double p );
+        
+        ArchiveBase &operator>>( ArchiveBase &ar, bool &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, char &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, signed char &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, unsigned char &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, signed short &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, unsigned short &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, signed int &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, unsigned int &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, signed long &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, unsigned long &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, signed long long &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, unsigned long long &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, float &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, double &p );
+        ArchiveBase &operator>>( ArchiveBase &ar, long double &p );
+
+        
+};
+
+#endif
diff --git a/src/stable/array.cpp b/src/stable/array.cpp
new file mode 100644
index 0000000..b776fed
--- /dev/null
+++ b/src/stable/array.cpp
@@ -0,0 +1,10 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/array.h"
+
+namespace Bu { subExceptionDef( ArrayException ) }
diff --git a/src/stable/array.h b/src/stable/array.h
new file mode 100644
index 0000000..fcd800e
--- /dev/null
+++ b/src/stable/array.h
@@ -0,0 +1,703 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_ARRAY_H
+#define BU_ARRAY_H
+
+#include <memory>
+#include "bu/exceptionbase.h"
+#include "bu/archivebase.h"
+#include "bu/sharedcore.h"
+
+namespace Bu
+{
+        subExceptionDecl( ArrayException )
+
+        template<typename value, int inc, typename valuealloc>
+        class Array;
+
+        /** @cond DEVEL */
+        template<typename value, int inc, typename valuealloc>
+        class ArrayCore
+        {
+        friend class Array<value, inc, valuealloc>;
+        friend class SharedCore<
+                Array<value, inc, valuealloc>,
+                ArrayCore<value, inc, valuealloc>
+                >;
+        private:                
+                ArrayCore() :
+                        pData( NULL ),
+                        iSize( 0 ),
+                        iCapacity( 0 )
+                { }
+
+                void setCapacity( int iNewLen )
+                {
+                        //clear();
+                        //iCapacity = iCapacity;
+                        //pData = va.allocate( iCapacity );
+                        if( iNewLen <= iCapacity ) return;
+                        value *pNewData = va.allocate( iNewLen );
+                        if( pData )
+                        {
+                                for( int j = 0; j < iSize; j++ )
+                                {
+                                        va.construct( &pNewData[j], pData[j] );
+                                        va.destroy( &pData[j] );
+                                }
+                                va.deallocate( pData, iCapacity );
+                        }
+                        pData = pNewData;
+                        iCapacity = iNewLen;
+                }
+
+                virtual ~ArrayCore()
+                {
+                        clear();
+                }
+
+                void clear()
+                {
+                        if( pData )
+                        {
+                                for( int j = 0; j < iSize; j++ )
+                                {
+                                        va.destroy( &pData[j] );
+                                }
+                                va.deallocate( pData, iCapacity );
+                                pData = NULL;
+                        }
+                        iSize = 0;
+                        iCapacity = 0;
+                }
+
+                void erase( int iPos )
+                {
+                        for( int j = iPos; j < iSize; j++ )
+                        {
+                                va.destroy( &pData[j] );
+                                if( j == iSize-1 )
+                                {
+                                        iSize--;
+                                        return;
+                                }
+                                va.construct( &pData[j], pData[j+1] );
+                        }
+                }
+
+                void swapErase( int iPos )
+                {
+                        if( iPos == iSize-1 )
+                        {
+                                erase( iPos );
+                                return;
+                        }
+                        va.destroy( &pData[iPos] );
+                        va.construct( &pData[iPos], pData[iSize-1] );
+                        va.destroy( &pData[iSize-1] );
+                        iSize--;
+                }
+
+                valuealloc va;
+                value *pData;
+                long iSize;
+                long iCapacity;
+        };
+        /** @endcond */
+
+        /**
+         * Array type container, just like a normal array only flexible and keeps
+         * track of your memory for you.
+         *
+         *@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.
+         *@ingroup Containers
+         */
+        template<typename value, int inc=10, typename valuealloc=std::allocator<value> >
+        class Array : public SharedCore<
+                                  Array<value, inc, valuealloc>,
+                                  ArrayCore<value, inc, valuealloc>
+                                  >
+        {
+        private:
+                typedef class Array<value, inc, valuealloc> MyType;
+                typedef class ArrayCore<value, inc, valuealloc> Core;
+
+        protected:
+                using SharedCore<MyType, Core>::core;
+                using SharedCore<MyType, Core>::_hardCopy;
+                using SharedCore<MyType, Core>::_resetCore;
+                using SharedCore<MyType, Core>::_allocateCore;
+
+        public:
+                struct const_iterator;
+                struct iterator;
+
+                Array()
+                {
+                }
+
+                Array( const MyType &src ) :
+                        SharedCore<MyType, Core >( src )
+                {
+                }
+                
+                Array( long iSetCap )
+                {
+                        setCapacity( iSetCap );
+                }
+
+                ~Array()
+                {
+                }
+
+                bool operator==( const MyType &src ) const
+                {
+                        if( core == src.core )
+                                return true;
+                        if( core->iSize != src.core->iSize )
+                                return false;
+
+                        for( int j = 0; j < core->iSize; j++ )
+                        {
+                                if( core->pData[j] != src.core->pData[j] )
+                                        return false;
+                        }
+                        return true;
+                }
+
+                bool operator!=( const MyType &src ) const
+                {
+                        return !(*this == src);
+                }
+
+                /**
+                 * Clear the array.
+                 */
+                void clear()
+                {
+                        _resetCore();
+                }
+
+                MyType &append( const value &rVal )
+                {
+                        _hardCopy();
+                        if( core->iSize == core->iCapacity )
+                        {
+                                core->setCapacity( core->iCapacity + inc );
+                        }
+
+                        core->va.construct( &core->pData[core->iSize++], rVal );
+
+                        return *this;
+                }
+                
+                MyType &append( const MyType &rVal )
+                {
+                        _hardCopy();
+
+                        if( core->iSize + rVal.core->iSize > core->iCapacity )
+                        {
+                                core->setCapacity( core->iSize + rVal.core->iSize + inc );
+                        }
+                        
+                        for( int j = 0; j < rVal.core->iSize; j++ )
+                        {
+                                core->va.construct(
+                                        &core->pData[core->iSize++],
+                                        rVal.core->pData[j]
+                                        );
+                        }
+
+                        return *this;
+                }
+
+                //operator
+                value &operator[]( long iIndex )
+                {
+                        _hardCopy();
+                        if( iIndex < 0 || iIndex >= core->iSize )
+                                throw ArrayException(
+                                        "Index %d out of range 0:%d", iIndex, core->iSize );
+
+                        return core->pData[iIndex];
+                }
+                
+                const value &operator[]( long iIndex ) const
+                {
+                        if( iIndex < 0 || iIndex >= core->iSize )
+                                throw ArrayException(
+                                        "Index %d out of range 0:%d", iIndex, core->iSize );
+
+                        return core->pData[iIndex];
+                }
+
+                value &get( long iIndex )
+                {
+                        _hardCopy();
+                        if( iIndex < 0 || iIndex >= core->iSize )
+                                throw ArrayException(
+                                        "Index %d out of range 0:%d", iIndex, core->iSize );
+
+                        return core->pData[iIndex];
+                }
+
+                const value &get( long iIndex ) const
+                {
+                        if( iIndex < 0 || iIndex >= core->iSize )
+                                throw ArrayException(
+                                        "Index %d out of range 0:%d", iIndex, core->iSize );
+
+                        return core->pData[iIndex];
+                }
+
+                value &first()
+                {
+                        _hardCopy();
+                        return core->pData[0];
+                }
+
+                const value &first() const
+                {
+                        return core->pData[0];
+                }
+
+                value &last()
+                {
+                        _hardCopy();
+                        return core->pData[core->iSize-1];
+                }
+
+                const value &last() const
+                {
+                        return core->pData[core->iSize-1];
+                }
+
+                /**
+                 * Get the current size of the array.
+                 *@returns The current size of the array.
+                 */
+                long getSize() const
+                {
+                        return core->iSize;
+                }
+
+                /**
+                 * Get the capacity of the array.  This number will grow as data is
+                 * added, and is mainly for the curious, it doesn't really determine
+                 * much for the end user.
+                 *@returns The current capacity of the array.
+                 */
+                long getCapacity() const
+                {
+                        return core->iCapacity;
+                }
+
+                /**
+                 * Change the capacity of the array, very useful if you know you'll be
+                 * adding a large amount of already counted items to the array, makes
+                 * the appending much faster afterwords.
+                 *@param iNewLen The new capacity of the array.
+                 *@todo Set this up so it can reduce the size of the array as well as
+                 * make it bigger.
+                 */
+                void setCapacity( long iNewLen )
+                {
+                        _hardCopy();
+                        core->setCapacity( iNewLen );
+                }
+
+                typedef struct iterator
+                {
+                        friend class Array<value, inc, valuealloc>;
+                private:
+                        iterator( MyType &src, long iPos=0 ) :
+                                src( src ),
+                                iPos( iPos )
+                        {
+                                if( this->iPos >= src.getSize() )
+                                        this->iPos = -1;
+                        }
+
+                        MyType &src;
+                        long iPos;
+
+                public:
+                        iterator operator++( int )
+                        {
+                                if( iPos < 0 )
+                                        throw ArrayException(
+                                                "Cannot increment iterator past end of array.");
+                                        iPos++;
+                                if( iPos >= src.getSize() )
+                                        iPos = -1;
+                                return *this;
+                        }
+                        
+                        iterator operator++()
+                        {
+                                if( iPos >= 0 )
+                                        iPos++;
+                                if( iPos >= src.getSize() )
+                                        iPos = -1;
+                                return *this;
+                        }
+                        
+                        iterator operator+( int iAmnt )
+                        {
+                                if( iPos < 0 )
+                                        throw ArrayException(
+                                                "Cannot increment iterator past end of array.");
+                                        iPos += iAmnt;
+                                if( iPos >= src.getSize() )
+                                        iPos = -1;
+                                return *this;
+                        }
+                        
+                        iterator operator--( int )
+                        {
+                                if( iPos < 0 )
+                                        throw ArrayException(
+                                                "Cannot increment iterator past end of array.");
+                                        iPos--;
+                                if( iPos < 0 )
+                                        iPos = -1;
+                                return *this;
+                        }
+                        
+                        iterator operator--()
+                        {
+                                if( iPos < src.getSize() )
+                                        iPos--;
+                                if( iPos <= 0 )
+                                        iPos = -1;
+                                return *this;
+                        }
+                        
+                        iterator operator-( int iAmnt )
+                        {
+                                if( iPos < src.getSize() )
+                                        iPos -= iAmnt;
+                                if( iPos <= 0 )
+                                        iPos = -1;
+                                return *this;
+                        }
+
+                        bool operator==( const iterator &oth ) const
+                        {
+                                return iPos == oth.iPos;
+                        }
+
+                        bool operator!=( const iterator &oth ) const
+                        {
+                                return iPos != oth.iPos;
+                        }
+
+                        iterator operator=( const iterator &oth )
+                        {
+                                if( &src != &oth.src )
+                                        throw ArrayException(
+                                                "Cannot mix iterators from different array objects.");
+                                iPos = oth.iPos;
+                        }
+
+                        value &operator*()
+                        {
+                                if( iPos < 0 )
+                                        throw ArrayException(
+                                                "Cannot dereference finished iterator.");
+                                return src[iPos];
+                        }
+
+                        long getIndex() const
+                        {
+                                return iPos;
+                        }
+
+                        operator bool() const
+                        {
+                                return iPos >= 0;
+                        }
+
+                        bool isValid() const
+                        {
+                                return iPos >= 0;
+                        }
+                } iterator;
+                
+                typedef struct const_iterator
+                {
+                        friend class Array<value, inc, valuealloc>;
+                private:
+                        const_iterator( const MyType &src, long iPos=0 ) :
+                                src( src ),
+                                iPos( iPos )
+                        {
+                                if( this->iPos >= src.getSize() )
+                                        this->iPos = -1;
+                        }
+
+                        const MyType &src;
+                        long iPos;
+
+                public:
+                        const_iterator( iterator &rSrc ) :
+                                src( rSrc.src ),
+                                iPos( rSrc.iPos )
+                        {
+                        }
+                        const_iterator operator++( int )
+                        {
+                                if( iPos < 0 )
+                                        throw ArrayException(
+                                                "Cannot increment iterator past end of array.");
+                                        iPos++;
+                                if( iPos >= src.getSize() )
+                                        iPos = -1;
+                                return *this;
+                        }
+                        
+                        const_iterator operator++()
+                        {
+                                if( iPos >= 0 )
+                                        iPos++;
+                                if( iPos >= src.getSize() )
+                                        iPos = -1;
+                                return *this;
+                        }
+                        
+                        const_iterator operator--( int )
+                        {
+                                if( iPos < 0 )
+                                        throw ArrayException(
+                                                "Cannot increment iterator past end of array.");
+                                        iPos--;
+                                if( iPos < 0 )
+                                        iPos = -1;
+                                return *this;
+                        }
+                        
+                        const_iterator operator--()
+                        {
+                                if( iPos < src.getSize() )
+                                        iPos--;
+                                if( iPos <= 0 )
+                                        iPos = -1;
+                                return *this;
+                        }
+
+                        bool operator==( const const_iterator &oth ) const
+                        {
+                                return iPos == oth.iPos;
+                        }
+
+                        bool operator!=( const const_iterator &oth ) const
+                        {
+                                return iPos != oth.iPos;
+                        }
+
+                        const_iterator operator=( const const_iterator &oth )
+                        {
+                                if( &src != &oth.src )
+                                        throw ArrayException(
+                                                "Cannot mix iterators from different array objects.");
+                                iPos = oth.iPos;
+                        }
+
+                        const value &operator*() const
+                        {
+                                if( iPos < 0 )
+                                        throw ArrayException(
+                                                "Cannot dereference finished iterator.");
+                                return src[iPos];
+                        }
+
+                        long getIndex() const
+                        {
+                                return iPos;
+                        }
+                        
+                        operator bool() const
+                        {
+                                return iPos >= 0;
+                        }
+
+                        bool isValid() const
+                        {
+                                return iPos >= 0;
+                        }
+                } const_iterator;
+
+                iterator begin()
+                {
+                        return iterator( *this );
+                }
+
+                const_iterator begin() const
+                {
+                        return const_iterator( *this );
+                }
+
+                iterator end()
+                {
+                        return iterator( *this, -1 );
+                }
+
+                const_iterator end() const
+                {
+                        return const_iterator( *this, -1 );
+                }
+
+                MyType &insert( iterator i, const value &rVal )
+                {
+                        if( i.iPos == -1 )
+                        {
+                                append( rVal );
+                                return *this;
+                        }
+
+                        _hardCopy();
+                        if( core->iSize == core->iCapacity )
+                        {
+                                core->setCapacity( core->iCapacity + inc );
+                        }
+                        core->iSize++;
+
+                        core->va.construct(
+                                &core->pData[core->iSize-1],
+                                core->pData[core->iSize-2]
+                                );
+                        for( int iPos = core->iSize-2; iPos > i.iPos; iPos-- )
+                        {
+                                core->va.destroy( &core->pData[iPos] );
+                                core->va.construct( &core->pData[iPos], core->pData[iPos-1] );
+                        }
+                        core->va.destroy( &core->pData[i.iPos] );
+                        core->va.construct( &core->pData[i.iPos], rVal );
+
+                        return *this;
+                }
+
+                /**
+                 * If order is important, use this.  It will delete the suggested item
+                 * and move the rest of the data up a spot.  This is a time O(n)
+                 * operation.  If the order isn't important, check swapErase
+                 */
+                void erase( iterator i )
+                {
+                        _hardCopy();
+                        core->erase( i.iPos );
+                }
+
+                void erase( const value &v )
+                {
+                        _hardCopy();
+                        for( int j = 0; j < core->iSize; j++ )
+                        {
+                                if( core->pData[j] == v )
+                                {
+                                        core->erase( j );
+                                        return;
+                                }
+                        }
+                }
+
+                void eraseLast()
+                {
+                        _hardCopy();
+                        core->erase( core->iSize-1 );
+                }
+
+                void eraseFirst()
+                {
+                        _hardCopy();
+                        core->erase( 0 );
+                }
+
+                /**
+                 * In order to make swapErase faster, what it does is swap the given
+                 * item in the array with the last item, then make the array shorter
+                 * by one.  It changes the order of the elements in the array, so it
+                 * should be used carefully, but it is time O(1) instead of O(n) like
+                 * erase.
+                 */
+                void swapErase( iterator i )
+                {
+                        _hardCopy();
+                        core->swapErase( i.iPos );
+                }
+
+        protected:
+                virtual Core *_copyCore( Core *src )
+                {
+                        Core *pRet = _allocateCore();
+                        pRet->setCapacity( src->iCapacity );
+                        pRet->iSize = src->iSize;
+                        for( int j = 0; j < src->iSize; j++ )
+                        {       
+                                pRet->va.construct( &pRet->pData[j], src->pData[j] );
+                        }
+                        return pRet;
+                }
+
+        private:
+        };
+
+        class Formatter;
+        Formatter &operator<<( Formatter &rOut, char *sStr );
+        Formatter &operator<<( Formatter &rOut, signed char c );
+        template<typename value>
+        Formatter &operator<<( Formatter &f, const Bu::Array<value> &a )
+        {
+                f << '[';
+                for( typename Bu::Array<value>::const_iterator i = a.begin(); i; i++ )
+                {
+                        if( i != a.begin() )
+                                f << ", ";
+                        f << *i;
+                }
+                f << ']';
+
+                return f;
+        }
+
+        template<typename value, int inc, typename valuealloc>
+        ArchiveBase &operator<<( ArchiveBase &ar,
+                        const Array<value, inc, valuealloc> &h )
+        {
+                ar << h.getSize();
+                for( typename Array<value, inc, valuealloc>::const_iterator i =
+                         h.begin(); i != h.end(); i++ )
+                {
+                        ar << (*i);
+                }
+
+                return ar;
+        }
+
+        template<typename value, int inc, typename valuealloc>
+        ArchiveBase &operator>>(ArchiveBase &ar, Array<value, inc, valuealloc> &h )
+        {
+                h.clear();
+                long nSize;
+                ar >> nSize;
+
+                h.setCapacity( nSize );
+                for( long j = 0; j < nSize; j++ )
+                {
+                        value v;
+                        ar >> v;
+                        h.append( v );
+                }
+                return ar;
+        }
+
+}
+
+#endif
diff --git a/src/stable/atom.cpp b/src/stable/atom.cpp
new file mode 100644
index 0000000..3c77b90
--- /dev/null
+++ b/src/stable/atom.cpp
@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/atom.h"
diff --git a/src/stable/atom.h b/src/stable/atom.h
new file mode 100644
index 0000000..fd88f2d
--- /dev/null
+++ b/src/stable/atom.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_ATOM_H
+#define BU_ATOM_H
+
+#include <stdint.h>
+#include <memory>
+#include "bu/config.h"
+#include "bu/exceptionbase.h"
+
+namespace Bu
+{
+        /**
+         *
+         *@ingroup Containers
+         */
+        template <typename t, typename talloc=std::allocator<t> >
+        class Atom
+        {
+        private:
+                typedef struct Atom<t, talloc> MyType;
+
+        public:
+                Atom() :
+                        pData( NULL )
+                {
+                }
+
+                Atom( const MyType &oth ) :
+                        pData( NULL )
+                {
+                        if( oth.pData )
+                                set( *oth.pData );
+                }
+
+                Atom( const t &oth ) :
+                        pData( NULL )
+                {
+                        set( oth );
+                }
+
+                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;
+                }
+                
+                MyType &operator =( const MyType &oth )
+                {
+                        if( oth.pData )
+                                set( *oth.pData );
+
+                        return *this;
+                }
+                
+                bool operator ==( const MyType &oth )
+                {
+                        return (*pData) == (*oth.pData);
+                }
+
+                bool operator ==( const t &oth )
+                {
+                        return (*pData) == oth;
+                }
+
+                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/stable/base64.cpp b/src/stable/base64.cpp
new file mode 100644
index 0000000..4d659f0
--- /dev/null
+++ b/src/stable/base64.cpp
@@ -0,0 +1,219 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/base64.h"
+
+namespace Bu { subExceptionDef( Base64Exception ) }
+
+const char Bu::Base64::tblEnc[65] = {
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+};
+
+Bu::Base64::Base64( Bu::Stream &rNext, int iChunkSize ) :
+        Bu::Filter( rNext ),
+        iBPos( 0 ),
+        iBuf( 0 ),
+        iRPos( 0 ),
+        iChars( 0 ),
+        bEosIn( false ),
+        iTotalIn( 0 ),
+        iTotalOut( 0 ),
+        eMode( Nothing ),
+        iChunkSize( iChunkSize ),
+        iCurChunk( 0 )
+{
+        start();
+
+        memset( tblDec, 0, 80 );
+        for( int j = 0; j < 64; j++ )
+        {
+                tblDec[tblEnc[j]-'+'] = j;
+        //      printf("'%c' = %d\n", tblEnc[j], j );
+        }
+        /*
+        for( int j = 0; j < 64; j++ )
+        {
+                printf("'%c' = '%c' (%d = %d)\n",
+                        tblEnc[j], tblEnc[tblDec[tblEnc[j]-'+']],
+                        j, tblDec[tblEnc[j]-'+'] );
+        }*/
+
+        // The following is used to compute the table size for the decoding table.
+        /*
+        char low='A', high='A';
+        for( int j = 0; j < 64; j++ )
+        {
+                if( tblEnc[j] < low )
+                        low = tblEnc[j];
+                if( tblEnc[j] > high )
+                        high = tblEnc[j];
+        }
+
+        printf("'%c' - '%c' (%d - %d) (%d)\n", low, high, low, high, high-low );
+        */
+}
+
+Bu::Base64::~Base64()
+{
+        stop();
+}
+
+void Bu::Base64::start()
+{
+        iCurChunk = 0;
+}
+
+Bu::size Bu::Base64::stop()
+{
+        if( eMode == Encode )
+        {
+                char outBuf[4];
+                int iBUsed = 4-(3-iBPos);
+                if( iBPos == 0 )
+                        return iTotalOut;
+                for( int k = 0; k < 4; k++ )
+                {
+                        outBuf[3-k] = tblEnc[(iBuf>>(6*k))&0x3f];
+                }
+                for( int k = iBUsed; k < 4; k++ )
+                {
+                        outBuf[k] = '=';
+                }
+                iCurChunk += 4;
+                if( iChunkSize && iCurChunk >= iChunkSize )
+                {
+                        iCurChunk = iCurChunk-iChunkSize;
+                        iTotalOut += rNext.write( outBuf, 4-iCurChunk );
+                        iTotalOut += rNext.write("\r\n", 2 );
+                        iTotalOut += rNext.write( outBuf+(4-iCurChunk), iCurChunk );
+                }
+                else
+                        iTotalOut += rNext.write( outBuf, 4 );
+                return iTotalOut;
+        }
+        else
+        {
+                return iTotalIn;
+        }
+}
+
+Bu::size Bu::Base64::read( void *pBuf, Bu::size nBytes )
+{
+        if( eMode == Encode )
+                throw Bu::Base64Exception("Cannot read from an output stream.");
+        eMode = Decode;
+
+        if( bEosIn == true && iRPos == iChars )
+                return 0;
+        Bu::size sIn = 0;
+        char buf[4];
+        while( sIn < nBytes )
+        {
+                for(; iRPos < iChars && sIn < nBytes; iRPos++, sIn++ )
+                {
+                        ((unsigned char *)pBuf)[sIn] = (iBuf>>(8*(2-iRPos)))&0xFF;
+                }
+                if( iRPos == iChars )
+                {
+                        if( bEosIn == true )
+                                return sIn;
+                        else
+                                iRPos = 0;
+                }
+                else if( sIn == nBytes )
+                        return sIn;
+                //if( rNext.read( buf, 4 ) == 0 )
+                //      return sIn;
+                for( int j = 0; j < 4; j++ )
+                {
+                        if( rNext.read( &buf[j], 1 ) == 0 )
+                        {
+                                if( rNext.isEos() )
+                                {
+                                        if( iRPos == 0 )
+                                                iRPos = iChars;
+                                        bEosIn = true;
+                                        if( j != 0 )
+                                        {
+                                                throw Base64Exception(
+                                                        "Premature end of stream detected while "
+                                                        "decoding Base64 data."
+                                                        );
+                                        }
+                                }
+                                return sIn;
+                        }
+                        if( buf[j] == ' ' || buf[j] == '\t' ||
+                                buf[j] == '\n' || buf[j] == '\r' )
+                        {
+                                j--;
+                        }
+                }
+                iChars = 3;
+                iBuf = 0;
+                for( int j = 0; j < 4; j++ )
+                {
+                        if( buf[j] == '=' )
+                        {
+                                iChars--;
+                                bEosIn = true;
+                        }
+                        else
+                                iBuf |= (tblDec[buf[j]-'+']&0x3f)<<((3-j)*6);
+                        //printf("%d:  %06X (%02X)\n", j, iBuf, (tblDec[buf[j]-'+']&0x3f) );
+                }
+        }
+
+        return sIn;
+}
+
+Bu::size Bu::Base64::write( const void *pBuf, Bu::size nBytes )
+{
+        if( eMode == Decode )
+                throw Bu::Base64Exception("Cannot write to an input stream.");
+        eMode = Encode;
+
+        Bu::size sOut = 0;
+        char outBuf[4];
+        for( Bu::size j = 0; j < nBytes; j++ )
+        {
+                iBuf |= (((uint8_t *)pBuf)[j])<<((2-iBPos++)*8);
+                if( iBPos == 3 )
+                {
+                        for( int k = 0; k < 4; k++ )
+                        {
+                                outBuf[3-k] = tblEnc[(iBuf>>(6*k))&0x3f];
+                        }
+                        iCurChunk += 4;
+                        if( iChunkSize && iCurChunk >= iChunkSize )
+                        {
+                                iCurChunk = iCurChunk-iChunkSize;
+                                sOut += rNext.write( outBuf, 4-iCurChunk );
+                                sOut += rNext.write("\r\n", 2 );
+                                sOut += rNext.write( outBuf+(4-iCurChunk), iCurChunk );
+                        }
+                        else
+                                sOut += rNext.write( outBuf, 4 );
+                        iBPos = iBuf = 0;
+                }
+        }
+        iTotalOut += sOut;
+        return sOut;
+}
+
+bool Bu::Base64::isOpen()
+{
+        return true;
+}
+
+bool Bu::Base64::isEos()
+{
+        if( bEosIn == true && iRPos == iChars )
+                return true;
+        return false;
+}
+
diff --git a/src/stable/base64.h b/src/stable/base64.h
new file mode 100644
index 0000000..c081ac1
--- /dev/null
+++ b/src/stable/base64.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_BASE64_H
+#define BU_BASE64_H
+
+#include "bu/filter.h"
+#include "bu/exceptionbase.h"
+
+namespace Bu
+{
+        subExceptionDecl( Base64Exception );
+        
+        /**
+         *
+         *@ingroup Streams
+         */
+        class Base64 : public Bu::Filter
+        {
+        public:
+                Base64( Bu::Stream &rNext, int iChunkSize=0 );
+                virtual ~Base64();
+
+                virtual void start();
+                virtual Bu::size stop();
+                virtual Bu::size read( void *pBuf, Bu::size nBytes );
+                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+
+                virtual bool isOpen();
+
+                virtual bool isEos();
+
+        private:
+                int iBPos;
+                int iBuf;
+                int iRPos;
+                int iChars;
+                bool bEosIn;
+                Bu::size iTotalIn;
+                Bu::size iTotalOut;
+                static const char tblEnc[65];
+                char tblDec[80];
+                enum Mode
+                {
+                        Nothing         = 0x00,
+                        Encode          = 0x01,
+                        Decode          = 0x02,
+                };
+                Mode eMode;
+                int iChunkSize;
+                int iCurChunk;
+        };
+};
+
+#endif
diff --git a/src/stable/buffer.cpp b/src/stable/buffer.cpp
new file mode 100644
index 0000000..47fab70
--- /dev/null
+++ b/src/stable/buffer.cpp
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/buffer.h"
+
+Bu::Buffer::Buffer( Bu::Stream &rNext, int iWhat, int iBufSize ) :
+        Bu::Filter( rNext ),
+        sSoFar( 0 ),
+        iBufSize( iBufSize ),
+        sReadBuf( NULL ),
+        sWriteBuf( NULL ),
+        iReadBufFill( 0 ),
+        iReadPos( 0 ),
+        iWriteBufFill( 0 ),
+        iWritePos( 0 ),
+        iWhat( iWhat )
+{
+        sReadBuf = new char[iBufSize];
+        sWriteBuf = new char[iBufSize];
+}
+
+Bu::Buffer::~Buffer()
+{
+        delete[] sReadBuf;
+        delete[] sWriteBuf;
+}
+
+void Bu::Buffer::start()
+{
+}
+
+Bu::size Bu::Buffer::stop()
+{
+        iReadBufFill = iReadPos = iWriteBufFill = iWritePos = 0;
+        return sSoFar;
+}
+
+void Bu::Buffer::fillReadBuf()
+{
+        if( iReadBufFill+iReadPos < iBufSize )
+        {
+                iReadBufFill += rNext.read(
+                        sReadBuf+iReadPos+iReadBufFill,
+                        iBufSize-iReadBufFill-iReadPos
+                        );
+        }
+}
+
+Bu::size Bu::Buffer::read( void *pBuf, Bu::size nBytes )
+{
+        if( (iWhat&Read) == 0 )
+                return rNext.read( pBuf, nBytes );
+
+        if( nBytes <= 0 )
+        {
+                fillReadBuf();
+                return 0;
+        }
+
+        Bu::size nTotRead = 0;
+//      fillReadBuf();
+
+        do
+        {
+                int iAmnt = nBytes-nTotRead;
+                if( iAmnt > iReadBufFill )
+                {
+                        iAmnt = iReadBufFill;
+                }
+                if( iAmnt > 0 )
+                {
+                        memcpy( ((char *)pBuf)+nTotRead, sReadBuf+iReadPos, iAmnt );
+                        iReadPos += iAmnt;
+                        nTotRead += iAmnt;
+                        iReadBufFill -= iAmnt;
+                }
+                if( iReadBufFill == 0 )
+                {
+                        iReadPos = 0;
+                        fillReadBuf();
+                }
+        }
+        while( nTotRead < nBytes && iReadBufFill > 0 );
+
+        //printf("Buffer:  %db returned, %db remain in buffer.\n", nTotRead, iReadBufFill );
+
+        return nTotRead;
+}
+
+Bu::size Bu::Buffer::write( const void *pBuf, Bu::size nBytes )
+{
+        if( (iWhat&Write) == 0 )
+                return rNext.write( pBuf, nBytes );
+
+        Bu::size nTotWrote = 0;
+
+        do
+        {
+                int iAmnt = nBytes-nTotWrote;
+                if( iAmnt > iBufSize-iWritePos-iWriteBufFill )
+                {
+                        iAmnt = iBufSize-iWritePos-iWriteBufFill;
+                }
+                if( iAmnt > 0 )
+                {
+                        memcpy(
+                                sWriteBuf+iWritePos+iWriteBufFill,
+                                ((char *)pBuf)+nTotWrote,
+                                iAmnt
+                                );
+                        nTotWrote += iAmnt;
+                        iWriteBufFill += iAmnt;
+                        //printf("Buffer: Moved %db to write buffer, %db filled now.\n",
+                                        //iAmnt, iWriteBufFill );
+                }
+                while( iWritePos+iWriteBufFill == iBufSize )
+                {
+                        //printf("iWritePos = %d\n", iWritePos );
+                        int iWr = rNext.write( sWriteBuf+iWritePos, iWriteBufFill );
+                        //printf("Buffer: Wrote %db from buffer to stream, %db filled now.\n", iWr, iWriteBufFill-iWr );
+                        if( iWr == 0 )
+                        {
+                                return nTotWrote;
+                        }
+                        else if( iWr == iWriteBufFill )
+                        {
+                                iWritePos = iWriteBufFill = 0;
+                        }
+                        else
+                        {
+                                iWritePos += iWr;
+                                iWriteBufFill -= iWr;
+                        }
+                }
+        }
+        while( nTotWrote < nBytes && iWriteBufFill < iBufSize+iWritePos );
+
+        return nTotWrote;
+}
+
+void Bu::Buffer::flush()
+{
+        if( (iWhat&Write) == 0 )
+                return rNext.flush();
+
+        if( iWriteBufFill > 0 )
+        {
+                //printf("Buffer: Flushing remaining data, %db.\n", iWriteBufFill );
+                int iWr = 0;
+                do
+                {
+                        iWr = rNext.write( sWriteBuf+iWritePos, iWriteBufFill );
+                        //printf("Buffer: %db written to stream.\n", iWr );
+                        iWritePos += iWr;
+                        iWriteBufFill -= iWr;
+                } while( iWriteBufFill > 0 && iWr > 0 );
+        }
+}
+
+bool Bu::Buffer::isEos()
+{
+        return (iReadPos >= (iReadBufFill-1)) && (rNext.isEos());
+}
+
diff --git a/src/stable/buffer.h b/src/stable/buffer.h
new file mode 100644
index 0000000..91ec9c2
--- /dev/null
+++ b/src/stable/buffer.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_BUFFER_H
+#define BU_BUFFER_H
+
+#include "bu/filter.h"
+
+namespace Bu
+{
+        class Buffer : public Bu::Filter
+        {
+        public:
+                Buffer( Bu::Stream &rNext, int iWhat=Both, int iBufSize=4096 );
+                virtual ~Buffer();
+
+                enum
+                {
+                        Write   = 1,
+                        Read    = 2,
+                        Both    = 3
+                };
+
+                virtual void start();
+                virtual Bu::size stop();
+
+                virtual Bu::size read( void *pBuf, Bu::size nBytes );
+                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+                using Stream::write;
+
+                Bu::size getReadFill() { return iReadBufFill; }
+                bool isWritePending() { return iWriteBufFill > 0; }
+
+                virtual void flush();
+
+                virtual bool isEos();
+
+        private:
+                void fillReadBuf();
+
+        private:
+                Bu::size sSoFar;
+                int iBufSize;
+                char *sReadBuf;
+                char *sWriteBuf;
+                int iReadBufFill;
+                int iReadPos;
+                int iWriteBufFill;
+                int iWritePos;
+                int iWhat;
+        };
+};
+
+#endif
diff --git a/src/stable/bzip2.cpp b/src/stable/bzip2.cpp
new file mode 100644
index 0000000..ca007b0
--- /dev/null
+++ b/src/stable/bzip2.cpp
@@ -0,0 +1,233 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/bzip2.h"
+#include "bu/trace.h"
+
+#include <bzlib.h>
+
+#define pState ((bz_stream *)prState)
+
+using namespace Bu;
+
+Bu::BZip2::BZip2( Bu::Stream &rNext, int nCompression ) :
+        Bu::Filter( rNext ),
+        prState( NULL ),
+        nCompression( nCompression ),
+        sTotalOut( 0 )
+{
+        TRACE( nCompression );
+        start();
+}
+
+Bu::BZip2::~BZip2()
+{
+        TRACE();
+        stop();
+}
+
+void Bu::BZip2::start()
+{
+        TRACE();
+
+        prState = new bz_stream;
+        pState->state = NULL;
+        pState->bzalloc = NULL;
+        pState->bzfree = NULL;
+        pState->opaque = NULL;
+
+        nBufSize = 64*1024;
+        pBuf = new char[nBufSize];
+}
+
+Bu::size Bu::BZip2::stop()
+{
+        TRACE();
+        if( pState->state )
+        {
+                if( bReading )
+                {
+                        BZ2_bzDecompressEnd( pState );
+                        delete[] pBuf;
+                        pBuf = NULL;
+                        delete pState;
+                        prState = NULL;
+                        return 0;
+                }
+                else
+                {
+//                      Bu::size sTotal = 0;
+                        for(;;)
+                        {
+                                pState->next_in = NULL;
+                                pState->avail_in = 0;
+                                pState->avail_out = nBufSize;
+                                pState->next_out = pBuf;
+                                int res = BZ2_bzCompress( pState, BZ_FINISH );
+                                if( pState->avail_out < nBufSize )
+                                {
+                                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+                                }
+                                if( res == BZ_STREAM_END )
+                                        break;
+                        }
+                        BZ2_bzCompressEnd( pState );
+                        delete[] pBuf;
+                        pBuf = NULL;
+                        delete pState;
+                        prState = NULL;
+                        return sTotalOut;
+                }
+        }
+        return 0;
+}
+
+void Bu::BZip2::bzError( int code )
+{
+        TRACE( 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.");
+        
+        }
+}
+
+Bu::size Bu::BZip2::read( void *pData, Bu::size nBytes )
+{
+        TRACE( pData, nBytes );
+        if( !pState->state )
+        {
+                bReading = true;
+                BZ2_bzDecompressInit( pState, 0, 0 );
+                pState->next_in = pBuf;
+                pState->avail_in = 0;
+        }
+        if( bReading == false )
+                throw ExceptionBase("This bzip2 filter is in writing mode, you can't read.");
+
+        int nRead = 0;
+        int nReadTotal = pState->total_out_lo32;
+        pState->next_out = (char *)pData;
+        pState->avail_out = nBytes;
+        for(;;)
+        {
+                int ret = BZ2_bzDecompress( pState );
+        
+                nReadTotal += nRead-pState->avail_out;
+
+                if( ret == BZ_STREAM_END )
+                {
+                        if( pState->avail_in > 0 )
+                        {
+                                if( rNext.isSeekable() )
+                                {
+                                        rNext.seek( -pState->avail_in );
+                                }
+                        }
+                        return nBytes-pState->avail_out;
+                }
+                bzError( ret );
+
+                if( pState->avail_out )
+                {
+                        if( pState->avail_in == 0 )
+                        {
+                                nRead = rNext.read( pBuf, nBufSize );
+                                if( nRead == 0 && rNext.isEos() )
+                                {
+                                        throw Bu::ExceptionBase("Premature end of underlying "
+                                                        "stream found reading bzip2 stream.");
+                                }
+                                pState->next_in = pBuf;
+                                pState->avail_in = nRead;
+                        }
+                }
+                else
+                {
+                        return nBytes-pState->avail_out;
+                }
+        }
+        return 0;
+}
+
+Bu::size Bu::BZip2::write( const void *pData, Bu::size nBytes )
+{
+        TRACE( pData, nBytes );
+        if( !pState->state )
+        {
+                bReading = false;
+                BZ2_bzCompressInit( pState, nCompression, 0, 30 );
+        }
+        if( bReading == true )
+                throw ExceptionBase("This bzip2 filter is in reading mode, you can't write.");
+
+//      Bu::size sTotalOut = 0;
+        pState->next_in = (char *)pData;
+        pState->avail_in = nBytes;
+        for(;;)
+        {
+                pState->avail_out = nBufSize;
+                pState->next_out = pBuf;
+
+                bzError( BZ2_bzCompress( pState, BZ_RUN ) );
+
+                if( pState->avail_out < nBufSize )
+                {
+                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+                }
+                if( pState->avail_in == 0 )
+                        break;
+        }
+
+        return nBytes;
+}
+
+bool Bu::BZip2::isOpen()
+{
+        TRACE();
+        return (pState->state != NULL);
+}
+
+Bu::size Bu::BZip2::getCompressedSize()
+{
+        return sTotalOut;
+}
+
diff --git a/src/stable/bzip2.h b/src/stable/bzip2.h
new file mode 100644
index 0000000..9a8d172
--- /dev/null
+++ b/src/stable/bzip2.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_BZIP2_H
+#define BU_BZIP2_H
+
+#include <stdint.h>
+
+#include "bu/filter.h"
+
+namespace Bu
+{
+        /**
+         * Provides BZip2 type compression and decompression.
+         *
+         *@ingroup Streams
+         *@ingroup Compression
+         */
+        class BZip2 : public Bu::Filter
+        {
+        public:
+                BZip2( Bu::Stream &rNext, int nCompression=9 );
+                virtual ~BZip2();
+
+                virtual void start();
+                virtual Bu::size stop();
+                virtual Bu::size read( void *pBuf, Bu::size nBytes );
+                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+
+                virtual bool isOpen();
+
+                Bu::size getCompressedSize();
+
+        private:
+                void bzError( int code );
+                void *prState;
+                bool bReading;
+                int nCompression;
+                char *pBuf;
+                uint32_t nBufSize;
+                Bu::size sTotalOut;
+        };
+}
+
+#endif
diff --git a/src/stable/client.cpp b/src/stable/client.cpp
new file mode 100644
index 0000000..75f6158
--- /dev/null
+++ b/src/stable/client.cpp
@@ -0,0 +1,320 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/client.h"
+#include "bu/tcpsocket.h"
+#include <stdlib.h>
+#include <errno.h>
+#include "bu/protocol.h"
+#include "bu/clientlink.h"
+#include "bu/clientlinkfactory.h"
+
+/** Read buffer size. */
+#define RBS             (2000) // 1500 is the nominal MTU for ethernet, it's a good guess
+
+Bu::Client::Client( Bu::TcpSocket *pSocket,
+                class Bu::ClientLinkFactory *pfLink ) :
+        pTopStream( pSocket ),
+        pSocket( pSocket ),
+        pProto( NULL ),
+        bWantsDisconnect( false ),
+        pfLink( pfLink )
+{
+        lFilts.prepend( pSocket );
+}
+
+Bu::Client::~Client()
+{
+        for( FilterList::iterator i = lFilts.begin(); i; i++ )
+        {
+                delete *i;
+        }
+        pTopStream = pSocket = NULL;
+        delete pfLink;
+}
+
+void Bu::Client::processInput()
+{
+        char buf[RBS];
+        Bu::size nRead, nTotal=0;
+
+        for(;;)
+        {
+                try
+                {
+                        nRead = pTopStream->read( buf, RBS );
+
+                        if( nRead == 0 )
+                        {
+                                break;
+                        }
+                        else
+                        {
+                                nTotal += nRead;
+                                qbRead.write( buf, nRead );
+                                if( !pTopStream->canRead() )
+                                        break;
+                        }
+                }
+                catch( Bu::TcpSocketException &e )
+                {
+                        pTopStream->close();
+                        bWantsDisconnect = true;
+                        break;
+                }
+        }
+
+        if( nTotal == 0 )
+        {
+                pTopStream->close();
+                bWantsDisconnect = true;
+        }
+
+        if( pProto && nTotal )
+        {
+                pProto->onNewData( this );
+        }
+}
+
+void Bu::Client::processOutput()
+{
+        char buf[RBS];
+        if( qbWrite.getSize() > 0 )
+        {
+                int nAmnt = RBS;
+                nAmnt = qbWrite.peek( buf, nAmnt );
+                int nReal = pTopStream->write( buf, nAmnt );
+                qbWrite.seek( nReal );
+                pTopStream->flush();
+        }
+}
+
+void Bu::Client::setProtocol( Protocol *pProto )
+{
+        this->pProto = pProto;
+        this->pProto->onNewConnection( this );
+}
+
+Bu::Protocol *Bu::Client::getProtocol()
+{
+        return pProto;
+}
+
+void Bu::Client::clearProtocol()
+{
+        pProto = NULL;
+}
+/*
+Bu::String &Bu::Client::getInput()
+{
+        return sReadBuf;
+}
+
+Bu::String &Bu::Client::getOutput()
+{
+        return sWriteBuf;
+}
+*/
+
+bool Bu::Client::isOpen()
+{
+        if( !pTopStream ) return false;
+        return pTopStream->isOpen();
+}
+
+Bu::size Bu::Client::write( const Bu::String &sData )
+{
+        return qbWrite.write( sData.getStr(), sData.getSize() );
+}
+
+Bu::size Bu::Client::write( const void *pData, Bu::size nBytes )
+{
+        return qbWrite.write( pData, nBytes );
+}
+
+Bu::size Bu::Client::write( int8_t nData )
+{
+        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+}
+
+Bu::size Bu::Client::write( int16_t nData )
+{
+        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+}
+
+Bu::size Bu::Client::write( int32_t nData )
+{
+        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+}
+
+Bu::size Bu::Client::write( int64_t nData )
+{
+        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+}
+
+Bu::size Bu::Client::write( uint8_t nData )
+{
+        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+}
+
+Bu::size Bu::Client::write( uint16_t nData )
+{
+        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+}
+
+Bu::size Bu::Client::write( uint32_t nData )
+{
+        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+}
+
+Bu::size Bu::Client::write( uint64_t nData )
+{
+        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+}
+
+Bu::size Bu::Client::read( void *pData, Bu::size nBytes )
+{
+        return qbRead.read( pData, nBytes );
+}
+
+Bu::size Bu::Client::peek( void *pData, int nBytes, int nOffset )
+{
+        return qbRead.peek( pData, nBytes, nOffset );
+}
+
+Bu::size Bu::Client::getInputSize()
+{
+        return qbRead.getSize();
+}
+
+Bu::size Bu::Client::getOutputSize()
+{
+        return qbWrite.getSize();
+}
+
+const Bu::TcpSocket *Bu::Client::getSocket() const
+{
+        return pSocket;
+}
+
+void Bu::Client::disconnect()
+{
+        bWantsDisconnect = true;
+}
+
+bool Bu::Client::wantsDisconnect()
+{
+        return bWantsDisconnect;
+}
+
+void Bu::Client::close()
+{
+        pTopStream->close();
+}
+
+Bu::ClientLink *Bu::Client::getLink()
+{
+        return pfLink->createLink( this );
+}
+
+void Bu::Client::onMessage( const Bu::String &sMsg )
+{
+        if( pProto )
+                pProto->onMessage( this, sMsg );
+}
+
+void Bu::Client::tick()
+{
+        if( pProto )
+                pProto->onTick( this );
+}
+
+Bu::size Bu::Client::tell()
+{
+        return 0;
+}
+
+void Bu::Client::seek( Bu::size offset )
+{
+        return qbRead.seek( offset );
+}
+
+void Bu::Client::setPos( Bu::size )
+{
+        throw Bu::ExceptionBase();
+}
+
+void Bu::Client::setPosEnd( Bu::size )
+{
+        throw Bu::ExceptionBase();
+}
+
+bool Bu::Client::isEos()
+{
+        return true;
+}
+
+void Bu::Client::flush()
+{
+        processOutput();
+}
+
+bool Bu::Client::canRead()
+{
+        return qbRead.getSize() > 0;
+}
+
+bool Bu::Client::canWrite()
+{
+        return true;
+}
+
+bool Bu::Client::isReadable()
+{
+        return true;
+}
+
+bool Bu::Client::isWritable()
+{
+        return true;
+}
+
+bool Bu::Client::isSeekable()
+{
+        return false;
+}
+
+bool Bu::Client::isBlocking()
+{
+        return false;
+}
+
+void Bu::Client::setBlocking( bool )
+{
+        throw Bu::ExceptionBase();
+}
+
+void Bu::Client::setSize( Bu::size )
+{
+        throw Bu::ExceptionBase();
+}
+
+Bu::size Bu::Client::getSize() const
+{
+        return 0;
+}
+
+Bu::size Bu::Client::getBlockSize() const
+{
+        return pSocket->getBlockSize();
+}
+
+Bu::String Bu::Client::getLocation() const
+{
+        return pSocket->getLocation();
+}
+
diff --git a/src/stable/client.h b/src/stable/client.h
new file mode 100644
index 0000000..119c2c1
--- /dev/null
+++ b/src/stable/client.h
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_CLIENT_H
+#define BU_CLIENT_H
+
+#include <stdint.h>
+
+#include "bu/config.h"
+#include "bu/string.h"
+#include "bu/queuebuf.h"
+
+namespace Bu
+{
+        class Protocol;
+        class Stream;
+        class TcpSocket;
+        class ClientLinkFactory;
+
+        /**
+         *@ingroup Serving
+         */
+        class Client : public Bu::Stream
+        {
+        public:
+                Client( Bu::TcpSocket *pSocket, Bu::ClientLinkFactory *pfLink );
+                virtual ~Client();
+
+                void processInput();
+                void processOutput();
+
+                //Bu::String &getInput();
+                //Bu::String &getOutput();
+                Bu::size write( const Bu::String &sData );
+                Bu::size write( const void *pData, Bu::size nBytes );
+                Bu::size write( int8_t nData );
+                Bu::size write( int16_t nData );
+                Bu::size write( int32_t nData );
+                Bu::size write( int64_t nData );
+                Bu::size write( uint8_t nData );
+                Bu::size write( uint16_t nData );
+                Bu::size write( uint32_t nData );
+                Bu::size write( uint64_t nData );
+                Bu::size read( void *pData, Bu::size nBytes );
+                Bu::size peek( void *pData, int nBytes, int nOffset=0 );
+//              void seek( int nBytes );
+                Bu::size getInputSize();
+                Bu::size getOutputSize();
+
+                void setProtocol( Protocol *pProto );
+                Bu::Protocol *getProtocol();
+                void clearProtocol();
+
+                bool isOpen();
+                void close();
+                void tick();
+
+                const Bu::TcpSocket *getSocket() const;
+
+                void disconnect();
+                bool wantsDisconnect();
+
+                class ClientLink *getLink();
+
+                void onMessage( const Bu::String &sMsg );
+
+                bool hasOutput() { return qbWrite.getSize() > 0; }
+                bool hasInput() { return qbRead.getSize() > 0; }
+
+                template<typename filter>
+                void pushFilter()
+                {
+                        filter *pFlt = new filter( *pTopStream );
+                        pTopStream = pFlt;
+                        lFilts.prepend( pFlt );
+                }
+                
+                template<typename filter, typename p1t>
+                void pushFilter( p1t p1 )
+                {
+                        filter *pFlt = new filter( *pTopStream, p1 );
+                        pTopStream = pFlt;
+                        lFilts.prepend( pFlt );
+                }
+                
+                template<typename filter, typename p1t, typename p2t>
+                void pushFilter( p1t p1, p2t p2 )
+                {
+                        filter *pFlt = new filter( *pTopStream, p1, p2 );
+                        pTopStream = pFlt;
+                        lFilts.prepend( pFlt );
+                }
+
+                /*
+                 * These are required to qualify as a stream, I dunno how many will
+                 * be implemented.
+                 */
+                virtual Bu::size tell();
+                virtual void seek( Bu::size offset );
+                virtual void setPos( Bu::size pos );
+                virtual void setPosEnd( Bu::size pos );
+                virtual bool isEos();
+                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 );
+                virtual void setSize( Bu::size iSize );
+                virtual size getSize() const;
+                virtual size getBlockSize() const;
+                virtual Bu::String getLocation() const;
+
+        private:
+                typedef Bu::List<Bu::Stream *> FilterList;
+                FilterList lFilts;
+                Bu::Stream *pTopStream;
+                Bu::TcpSocket *pSocket;
+                Bu::Protocol *pProto;
+                Bu::QueueBuf qbRead;
+                Bu::QueueBuf qbWrite;
+                bool bWantsDisconnect;
+                class Bu::ClientLinkFactory *pfLink;
+        };
+}
+
+#endif
diff --git a/src/stable/clientlink.cpp b/src/stable/clientlink.cpp
new file mode 100644
index 0000000..ce8b2cb
--- /dev/null
+++ b/src/stable/clientlink.cpp
@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/clientlink.h"
+
+Bu::ClientLink::ClientLink()
+{
+}
+
+Bu::ClientLink::~ClientLink()
+{
+}
+
diff --git a/src/stable/clientlink.h b/src/stable/clientlink.h
new file mode 100644
index 0000000..e4618e7
--- /dev/null
+++ b/src/stable/clientlink.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_CLIENT_LINK_H
+#define BU_CLIENT_LINK_H
+
+#include "bu/string.h"
+
+namespace Bu
+{
+        class ClientLink
+        {
+        public:
+                ClientLink();
+                virtual ~ClientLink();
+
+                virtual void sendMessage( const Bu::String &sMsg )=0;
+        };
+};
+
+#endif
diff --git a/src/stable/clientlinkfactory.cpp b/src/stable/clientlinkfactory.cpp
new file mode 100644
index 0000000..f48e11e
--- /dev/null
+++ b/src/stable/clientlinkfactory.cpp
@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/clientlinkfactory.h"
+
+Bu::ClientLinkFactory::ClientLinkFactory()
+{
+}
+
+Bu::ClientLinkFactory::~ClientLinkFactory()
+{
+}
+
diff --git a/src/stable/clientlinkfactory.h b/src/stable/clientlinkfactory.h
new file mode 100644
index 0000000..21d3363
--- /dev/null
+++ b/src/stable/clientlinkfactory.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_CLIENT_LINK_FACTORY_H
+#define BU_CLIENT_LINK_FACTORY_H
+
+namespace Bu
+{
+        class Client;
+        class ClientLink;
+
+        class ClientLinkFactory
+        {
+        public:
+                ClientLinkFactory();
+                virtual ~ClientLinkFactory();
+
+                virtual Bu::ClientLink *createLink( Bu::Client *pClient )=0;
+        };
+};
+
+#endif
diff --git a/src/stable/condition.cpp b/src/stable/condition.cpp
new file mode 100644
index 0000000..2f55ce2
--- /dev/null
+++ b/src/stable/condition.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include <sys/time.h>
+
+#include "bu/condition.h"
+
+Bu::Condition::Condition()
+{
+        pthread_cond_init( &cond, NULL );
+}
+
+Bu::Condition::~Condition()
+{
+        pthread_cond_destroy( &cond );
+}
+
+int Bu::Condition::wait()
+{
+        return pthread_cond_wait( &cond, &mutex );
+}
+
+int Bu::Condition::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::Condition::signal()
+{
+        return pthread_cond_signal( &cond );
+}
+
+int Bu::Condition::broadcast()
+{
+        return pthread_cond_broadcast( &cond );
+}
+
diff --git a/src/stable/condition.h b/src/stable/condition.h
new file mode 100644
index 0000000..71634f5
--- /dev/null
+++ b/src/stable/condition.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_CONDITION_H
+#define BU_CONDITION_H
+
+#include <pthread.h>
+
+#include "bu/mutex.h"
+
+namespace Bu
+{
+        /**
+         * Ito condition.  This is a fairly simple condition mechanism.  As you may
+         * notice this class inherits from the Mutex 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>
+         * Condition 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.
+         *@ingroup Threading
+         */
+        class Condition : public Mutex
+        {
+        public:
+                /**
+                 * Create a condition.
+                 */
+                Condition();
+
+                /**
+                 * Destroy a condition.
+                 */
+                ~Condition();
+
+                /**
+                 * 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/stable/conduit.cpp b/src/stable/conduit.cpp
new file mode 100644
index 0000000..c9ccdc4
--- /dev/null
+++ b/src/stable/conduit.cpp
@@ -0,0 +1,233 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/conduit.h"
+
+Bu::Conduit::Conduit( int iBlockSize ) :
+        qb( iBlockSize ),
+        bBlocking( true ),
+        bOpen( true )
+{
+}
+
+Bu::Conduit::~Conduit()
+{
+}
+
+void Bu::Conduit::close()
+{
+        im.lock();
+//      qb.close();
+        bOpen = false;
+        
+        cBlock.signal();
+        im.unlock();
+}
+
+#include <stdio.h>
+Bu::size Bu::Conduit::read( void *pBuf, Bu::size nBytes )
+{
+        if( !isOpen() )
+        {
+                return 0;
+        }
+        im.lock();
+        if( bBlocking )
+        {
+                im.unlock();
+                cBlock.lock();
+                for(;;)
+                {
+                        im.lock();
+                        if( qb.getSize() == 0 && bOpen == false )
+                        {
+                                im.unlock();
+                                cBlock.unlock();
+                                return 0;
+                        }
+                        else if( qb.getSize() > 0 )
+                        {
+                                im.unlock();
+                                break;
+                        }
+                        im.unlock();
+
+                        cBlock.wait();
+                }
+
+                im.lock();
+                Bu::size iRet = qb.read( pBuf, nBytes );
+                im.unlock();
+
+                cBlock.unlock();
+                return iRet;
+        }
+        else
+        {
+                Bu::size iRet = qb.read( pBuf, nBytes );
+                im.unlock();
+
+                return iRet;
+        }
+}
+
+Bu::size Bu::Conduit::peek( void *pBuf, Bu::size nBytes )
+{
+        im.lock();
+        Bu::size iRet = qb.peek( pBuf, nBytes );
+        im.unlock();
+
+        return iRet;
+}
+
+Bu::size Bu::Conduit::peek( void *pBuf, Bu::size nBytes, Bu::size nSkip )
+{
+        im.lock();
+        Bu::size iRet = qb.peek( pBuf, nBytes, nSkip );
+        im.unlock();
+
+        return iRet;
+}
+
+Bu::size Bu::Conduit::write( const void *pBuf, Bu::size nBytes )
+{
+        im.lock();
+        if( bOpen == false )
+        {
+                im.unlock();
+                return 0;
+        }
+        Bu::size sRet = qb.write( pBuf, nBytes );
+        cBlock.signal();
+        im.unlock();
+
+        return sRet;
+}
+
+Bu::size Bu::Conduit::tell()
+{
+        im.lock();
+        Bu::size sRet = qb.tell();
+        im.unlock();
+        return sRet;
+}
+
+void Bu::Conduit::seek( Bu::size )
+{
+}
+
+void Bu::Conduit::setPos( Bu::size )
+{
+}
+
+void Bu::Conduit::setPosEnd( Bu::size )
+{
+}
+
+bool Bu::Conduit::isEos()
+{
+        im.lock();
+        bool bRet = qb.isEos();
+        im.unlock();
+        return bRet;
+}
+
+bool Bu::Conduit::isOpen()
+{
+        im.lock();
+        bool bRet = bOpen || (qb.getSize() > 0);
+        im.unlock();
+        return bRet;
+}
+
+void Bu::Conduit::flush()
+{
+}
+
+bool Bu::Conduit::canRead()
+{
+        im.lock();
+        bool bRet = qb.canRead();
+        im.unlock();
+        return bRet;
+}
+
+bool Bu::Conduit::canWrite()
+{
+        im.lock();
+        bool bRet = qb.canWrite();
+        im.unlock();
+        return bRet;
+}
+
+bool Bu::Conduit::isReadable()
+{
+        im.lock();
+        bool bRet = qb.isReadable();
+        im.unlock();
+        return bRet;
+}
+
+bool Bu::Conduit::isWritable()
+{
+        im.lock();
+        bool bRet = qb.isWritable();
+        im.unlock();
+        return bRet;
+}
+
+bool Bu::Conduit::isSeekable()
+{
+        im.lock();
+        bool bRet = qb.isSeekable();
+        im.unlock();
+        return bRet;
+}
+
+bool Bu::Conduit::isBlocking()
+{
+        im.lock();
+        bool bRet = bBlocking;
+        im.unlock();
+        return bRet;
+}
+
+void Bu::Conduit::setBlocking( bool bBlocking )
+{
+        im.lock();
+        this->bBlocking = bBlocking;
+        im.unlock();
+}
+
+void Bu::Conduit::setSize( Bu::size )
+{
+}
+
+Bu::size Bu::Conduit::getSize() const
+{
+        im.lock();
+        Bu::size sRet = qb.getSize();
+        im.unlock();
+        return sRet;
+}
+
+Bu::size Bu::Conduit::getBlockSize() const
+{
+        im.lock();
+        Bu::size sRet = qb.getBlockSize();
+        im.unlock();
+        return sRet;
+}
+
+Bu::String Bu::Conduit::getLocation() const
+{
+        im.lock();
+        Bu::String sRet = qb.getLocation();
+        im.unlock();
+        return sRet;
+}
+
diff --git a/src/stable/conduit.h b/src/stable/conduit.h
new file mode 100644
index 0000000..9babaaf
--- /dev/null
+++ b/src/stable/conduit.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_CONDUIT_H
+#define BU_CONDUIT_H
+
+#include "bu/stream.h"
+#include "bu/string.h"
+#include "bu/queuebuf.h"
+#include "bu/mutex.h"
+#include "bu/condition.h"
+
+namespace Bu
+{
+        /**
+         * Simple inter-thread communication stream.  This acts like a pair of
+         * pipes for stream communication between any two things, but without the
+         * use of pipes, making this a bad choice for IPC.
+         */
+        class Conduit : public Stream
+        {
+        public:
+                Conduit( int iBlockSize=256 );
+                virtual ~Conduit();
+
+                virtual void close();
+                virtual Bu::size read( void *pBuf, Bu::size nBytes );
+                virtual Bu::size peek( void *pBuf, Bu::size nBytes );
+                virtual Bu::size peek( void *pBuf, Bu::size nBytes, Bu::size nSkip );
+                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+                virtual Bu::size tell();
+                virtual void seek( Bu::size offset );
+                virtual void setPos( Bu::size pos );
+                virtual void setPosEnd( Bu::size 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 );
+                virtual void setSize( Bu::size iSize );
+
+                virtual size getSize() const;
+                virtual size getBlockSize() const;
+                virtual Bu::String getLocation() const;
+
+        private:
+                QueueBuf qb;
+                mutable Mutex im;
+                Condition cBlock;
+                bool bBlocking;
+                bool bOpen;
+        };
+}
+
+#endif
diff --git a/src/stable/crypt.cpp b/src/stable/crypt.cpp
new file mode 100644
index 0000000..eb87479
--- /dev/null
+++ b/src/stable/crypt.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/crypt.h"
+#include "bu/md5.h"
+#include "bu/base64.h"
+#include "bu/membuf.h"
+#include "bu/file.h"
+
+Bu::String Bu::cryptPass( const Bu::String &sPass, const Bu::String &sSalt )
+{
+        Bu::Md5 md5;
+        Bu::MemBuf mbOut;
+        Bu::Base64 b64Out( mbOut );
+        
+        Bu::String::const_iterator i = sSalt.find('$');
+        Bu::String sSaltSml = sSalt.getSubStr( sSalt.begin(), i );
+
+        md5.addData( sPass );
+        md5.addData( sSaltSml );
+        md5.writeResult( b64Out );
+
+        b64Out.stop();
+
+        return sSaltSml + "$" + mbOut.getString();
+}
+
+Bu::String Bu::cryptPass( const Bu::String &sPass )
+{
+        Bu::MemBuf mbSalt;
+        Bu::Base64 b64Salt( mbSalt );
+        Bu::File fRand("/dev/urandom", Bu::File::Read );
+
+#define STR 6
+        char buf[STR];
+        fRand.read( buf, STR );
+        b64Salt.write( buf, STR );
+
+        b64Salt.stop();
+
+        return cryptPass( sPass, mbSalt.getString() );
+}
+
diff --git a/src/stable/crypt.h b/src/stable/crypt.h
new file mode 100644
index 0000000..a94402a
--- /dev/null
+++ b/src/stable/crypt.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_CRYPT_H
+#define BU_CRYPT_H
+
+#include "bu/string.h"
+
+namespace Bu
+{
+        String cryptPass( const Bu::String &sPass, const Bu::String &sSalt );
+        String cryptPass( const Bu::String &sPass );
+};
+
+#endif
diff --git a/src/stable/cryptohash.cpp b/src/stable/cryptohash.cpp
new file mode 100644
index 0000000..ddd293c
--- /dev/null
+++ b/src/stable/cryptohash.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/cryptohash.h"
+
+Bu::CryptoHash::CryptoHash()
+{
+}
+
+Bu::CryptoHash::~CryptoHash()
+{
+}
+
+void Bu::CryptoHash::addData( const Bu::String &sData )
+{
+        addData( sData.getStr(), sData.getSize() );
+}
+
+Bu::String Bu::CryptoHash::getHexResult()
+{
+        Bu::String sResult = getResult();
+        Bu::String sRet( 2*sResult.getSize() );
+        static const char hex_tab[] = {"0123456789abcdef"};
+
+        int k = 0;
+        for( int i = 0; i < sResult.getSize(); i++ )
+        {
+                sRet[k++] = hex_tab[(((unsigned char)sResult[i])>>4) & 0xF];
+                sRet[k++] = hex_tab[((unsigned char)sResult[i]) & 0xF];
+        }
+
+        return sRet;    
+}
+
diff --git a/src/stable/cryptohash.h b/src/stable/cryptohash.h
new file mode 100644
index 0000000..bc5435f
--- /dev/null
+++ b/src/stable/cryptohash.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_CRYPTO_HASH_H
+#define BU_CRYPTO_HASH_H
+
+#include "bu/string.h"
+
+namespace Bu
+{
+        class Stream;
+
+        class CryptoHash
+        {
+        public:
+                CryptoHash();
+                virtual ~CryptoHash();
+
+                virtual void reset() = 0;
+                virtual void setSalt( const Bu::String &sSalt ) = 0;
+                virtual void addData( const void *sData, int iSize ) = 0;
+                virtual void addData( const Bu::String &sData );
+                virtual String getResult() = 0;
+                virtual void writeResult( Stream &sOut ) = 0;
+                virtual Bu::String getHexResult();
+        };
+};
+
+#endif
diff --git a/src/stable/csvreader.cpp b/src/stable/csvreader.cpp
new file mode 100644
index 0000000..4da7883
--- /dev/null
+++ b/src/stable/csvreader.cpp
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/csvreader.h"
+#include "bu/stream.h"
+
+#include "bu/sio.h"
+using namespace Bu;
+
+Bu::CsvReader::CsvReader( Bu::Stream &sIn, Bu::CsvReader::Style eStyle ) :
+        sIn( sIn )
+{
+        switch( eStyle )
+        {
+                case styleExcel:
+                        sDecode = Bu::slot( &decodeExcel );
+                        break;
+
+                case styleC:
+                        sDecode = Bu::slot( &decodeC );
+                        break;
+        }
+}
+
+Bu::CsvReader::CsvReader( Bu::Stream &sIn,
+                Bu::CsvReader::DecodeSignal sDecode ) :
+        sIn( sIn ),
+        sDecode( sDecode )
+{
+}
+
+Bu::CsvReader::~CsvReader()
+{
+}
+
+Bu::StrArray Bu::CsvReader::readLine()
+{
+        Bu::StrArray aVals;
+
+        Bu::String sLine = sIn.readLine();
+
+        if( !sLine.isSet() )
+                return Bu::StrArray();
+
+        Bu::String::iterator i = sLine.begin();
+
+        aVals.append( sDecode( i ) );
+
+        while( i )
+        {
+                if( *i == ',' )
+                {
+                        i++;
+                        if( !i )
+                        {
+                                aVals.append("");
+                                break;
+                        }
+                        aVals.append( sDecode( i ) );
+                }
+                else
+                {
+                        // Blanks and stuff?
+                        sio << "Out of bound:  '" << *i << "'" << sio.nl;
+                        i++;
+                }
+        }
+
+        return aVals;
+}
+
+Bu::String Bu::CsvReader::decodeExcel( Bu::String::iterator &i )
+{
+        Bu::String sRet;
+
+        for(; i && (*i == ' ' || *i == '\t'); i++ ) { }
+        
+        if( !i )
+                return sRet;
+
+        if( *i == '\"' )
+        {
+                for( i++ ; i; i++ )
+                {
+                        if( *i == '\"' )
+                        {
+                                i++;
+                                if( !i )
+                                {
+                                        return sRet;
+                                }
+                                else if( *i == '\"' )
+                                {
+                                        sRet += *i;
+                                }
+                                else
+                                {
+                                        return sRet;
+                                }
+                        }
+                        else
+                        {
+                                sRet += *i;
+                        }
+                }
+        }
+        else
+        {
+                for( ; i; i++ )
+                {
+                        if( *i == ',' )
+                        {
+                                return sRet;
+                        }
+                        sRet += *i;
+                }
+        }
+
+        return sRet;
+}
+
+Bu::String Bu::CsvReader::decodeC( Bu::String::iterator & )
+{
+        return "";
+}
+
diff --git a/src/stable/csvreader.h b/src/stable/csvreader.h
new file mode 100644
index 0000000..2e9e7b0
--- /dev/null
+++ b/src/stable/csvreader.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_CSV_READER_H
+#define BU_CSV_READER_H
+
+#include "bu/string.h"
+#include "bu/array.h"
+#include "bu/signals.h"
+
+namespace Bu
+{
+        class Stream;
+        typedef Bu::Array<Bu::String> StrArray;
+
+        class CsvReader
+        {
+        public:
+                typedef Bu::Signal1<Bu::String, Bu::String::iterator &> DecodeSignal;
+                enum Style
+                {
+                        styleExcel, ///< Excel style quotes around things that need em
+                        styleC          ///< Escape things that need it C-style
+                };
+
+                CsvReader( Stream &sIn, Style eStyle=styleExcel );
+                CsvReader( Stream &sIn, DecodeSignal sDecode );
+                virtual ~CsvReader();
+
+                StrArray readLine();
+
+        private:
+                Stream &sIn;
+                DecodeSignal sDecode;
+
+                static Bu::String decodeExcel( Bu::String::iterator &i );
+                static Bu::String decodeC( Bu::String::iterator &i );
+        };
+};
+
+#endif
diff --git a/src/stable/csvwriter.cpp b/src/stable/csvwriter.cpp
new file mode 100644
index 0000000..d8910aa
--- /dev/null
+++ b/src/stable/csvwriter.cpp
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/csvwriter.h"
+#include "bu/stream.h"
+
+Bu::CsvWriter::CsvWriter( Bu::Stream &sOut, Bu::CsvWriter::Style eStyle ) :
+        sOut( sOut )
+{
+        switch( eStyle )
+        {
+                case styleExcel:
+                        sEncode = Bu::slot( &encodeExcel );
+                        break;
+
+                case styleC:
+                        sEncode = Bu::slot( &encodeExcel );
+                        break;
+        }
+}
+
+Bu::CsvWriter::CsvWriter( Bu::Stream &sOut,
+                Bu::CsvWriter::EncodeSignal sEncode ) :
+        sOut( sOut ),
+        sEncode( sEncode )
+{
+}
+
+Bu::CsvWriter::~CsvWriter()
+{
+}
+
+void Bu::CsvWriter::writeLine( const StrArray &aStrs )
+{
+        Bu::String sBuf;
+        for( StrArray::const_iterator i = aStrs.begin(); i; i++ )
+        {
+                if( i != aStrs.begin() )
+                        sBuf += ",";
+                sBuf += sEncode( *i );
+        }
+        sBuf += "\n";
+
+        sOut.write( sBuf );
+}
+
+Bu::String Bu::CsvWriter::encodeExcel( const Bu::String &sIn )
+{
+        if( sIn.find('\"') || sIn.find(',') )
+        {
+                Bu::String sOut = "\"";
+                for( Bu::String::const_iterator i = sIn.begin(); i; i++ )
+                {
+                        if( *i == '\"' )
+                                sOut += "\"\"";
+                        else
+                                sOut += *i;
+                }
+                sOut += '\"';
+                return sOut;
+        }
+        return sIn;
+}
+
+Bu::String Bu::CsvWriter::encodeC( const Bu::String &sIn )
+{
+        Bu::String sOut = "";
+        for( Bu::String::const_iterator i = sIn.begin(); i; i++ )
+        {
+                if( *i == ',' )
+                        sOut += "\\,";
+                else
+                        sOut += *i;
+        }
+        return sOut;
+}
+
diff --git a/src/stable/csvwriter.h b/src/stable/csvwriter.h
new file mode 100644
index 0000000..4291ed5
--- /dev/null
+++ b/src/stable/csvwriter.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_CSV_WRITER_H
+#define BU_CSV_WRITER_H
+
+#include "bu/string.h"
+#include "bu/array.h"
+#include "bu/signals.h"
+
+namespace Bu
+{
+        class Stream;
+        typedef Bu::Array<Bu::String> StrArray;
+
+        class CsvWriter
+        {
+        public:
+                typedef Bu::Signal1<Bu::String, const Bu::String &> EncodeSignal;
+                enum Style
+                {
+                        styleExcel, ///< Excel style quotes around things that need em
+                        styleC          ///< Escape things that need it C-style
+                };
+
+                CsvWriter( Stream &sOut, Style eStyle=styleExcel );
+                CsvWriter( Stream &sOut, EncodeSignal sEncode );
+                virtual ~CsvWriter();
+
+                void writeLine( const StrArray &aStrs );
+
+        private:
+                Stream &sOut;
+                EncodeSignal sEncode;
+
+                static Bu::String encodeExcel( const Bu::String &sIn );
+                static Bu::String encodeC( const Bu::String &sIn );
+        };
+};
+
+#endif
diff --git a/src/stable/deflate.cpp b/src/stable/deflate.cpp
new file mode 100644
index 0000000..704d172
--- /dev/null
+++ b/src/stable/deflate.cpp
@@ -0,0 +1,253 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/deflate.h"
+#include "bu/trace.h"
+
+#include <zlib.h>
+
+#define pState ((z_stream *)prState)
+
+using namespace Bu;
+
+Bu::Deflate::Deflate( Bu::Stream &rNext, int nCompression, Format eFmt ) :
+        Bu::Filter( rNext ),
+        prState( NULL ),
+        nCompression( nCompression ),
+        sTotalOut( 0 ),
+        eFmt( eFmt ),
+        bEos( false )
+{
+        TRACE( nCompression );
+        start();
+}
+
+Bu::Deflate::~Deflate()
+{
+        TRACE();
+        stop();
+}
+
+void Bu::Deflate::start()
+{
+        TRACE();
+        prState = new z_stream;
+        pState->zalloc = NULL;
+        pState->zfree = NULL;
+        pState->opaque = NULL;
+        pState->state = NULL;
+
+        nBufSize = 64*1024;
+        pBuf = new char[nBufSize];
+}
+
+Bu::size Bu::Deflate::stop()
+{
+        TRACE();
+        if( pState && pState->state )
+        {
+                if( bReading )
+                {
+                        inflateEnd( pState );
+                        delete[] pBuf;
+                        pBuf = NULL;
+                        delete pState;
+                        prState = NULL;
+                        return 0;
+                }
+                else
+                {
+                        for(;;)
+                        {
+                                pState->next_in = NULL;
+                                pState->avail_in = 0;
+                                pState->avail_out = nBufSize;
+                                pState->next_out = (Bytef *)pBuf;
+                                int res = deflate( pState, Z_FINISH );
+                                if( pState->avail_out < nBufSize )
+                                {
+                                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+                                }
+                                if( res == Z_STREAM_END )
+                                        break;
+                        }
+                        deflateEnd( pState );
+                        delete[] pBuf;
+                        pBuf = NULL;
+                        delete pState;
+                        prState = NULL;
+                        return sTotalOut;
+                }
+        }
+        return 0;
+}
+
+void Bu::Deflate::zError( int code )
+{
+        TRACE( code );
+        switch( code )
+        {
+                case Z_OK:
+                case Z_STREAM_END:
+                case Z_NEED_DICT:
+                        return;
+
+                case Z_ERRNO:
+                        throw ExceptionBase("Deflate: Errno - %s", pState->msg );
+
+                case Z_STREAM_ERROR:
+                        throw ExceptionBase("Deflate: Stream Error - %s", pState->msg );
+
+                case Z_DATA_ERROR:
+                        throw ExceptionBase("Deflate: Data Error - %s", pState->msg );
+
+                case Z_MEM_ERROR:
+                        throw ExceptionBase("Deflate: Mem Error - %s", pState->msg );
+
+                case Z_BUF_ERROR:
+                        throw ExceptionBase("Deflate: Buf Error - %s", pState->msg );
+
+                case Z_VERSION_ERROR:
+                        throw ExceptionBase("Deflate: Version Error - %s", pState->msg );
+
+                default:
+                        throw ExceptionBase("Deflate: Unknown error encountered - %s.", pState->msg );
+        
+        }
+}
+
+Bu::size Bu::Deflate::read( void *pData, Bu::size nBytes )
+{
+        TRACE( pData, nBytes );
+        if( nBytes  <= 0 )
+                return 0;
+        if( !pState->state )
+        {
+                bReading = true;
+                if( eFmt&AutoDetect )
+                        inflateInit2( pState, 32+15 ); // Auto-detect, large window
+                else if( eFmt == Raw )
+                        inflateInit2( pState, -15 ); // Raw
+                else if( eFmt == Zlib )
+                        inflateInit2( pState, 15 ); // Zlib
+                else if( eFmt == Gzip )
+                        inflateInit2( pState, 16+15 ); // GZip
+                else
+                        throw Bu::ExceptionBase("Format mode for deflate read.");
+                pState->next_in = (Bytef *)pBuf;
+                pState->avail_in = 0;
+        }
+        if( bReading == false )
+                throw ExceptionBase("This deflate filter is in writing mode, you can't read.");
+
+        int nRead = 0;
+        int nReadTotal = pState->total_out;
+        pState->next_out = (Bytef *)pData;
+        pState->avail_out = nBytes;
+        for(;;)
+        {
+                int ret = inflate( pState, Z_NO_FLUSH );
+                nReadTotal += nRead-pState->avail_out;
+
+                if( ret == Z_STREAM_END )
+                {
+                        bEos = true;
+                        if( pState->avail_in > 0 )
+                        {
+                                if( rNext.isSeekable() )
+                                {
+                                        rNext.seek( -pState->avail_in );
+                                }
+                        }
+                        return nBytes-pState->avail_out;
+                }
+                if( ret != Z_BUF_ERROR )
+                        zError( ret );
+
+                if( pState->avail_out )
+                {
+                        if( pState->avail_in == 0 )
+                        {
+                                nRead = rNext.read( pBuf, nBufSize );
+                                if( nRead == 0 && rNext.isEos() )
+                                {
+                                        throw Bu::ExceptionBase("Premature end of underlying "
+                                                        "stream found reading deflate stream.");
+                                }
+                                pState->next_in = (Bytef *)pBuf;
+                                pState->avail_in = nRead;
+                        }
+                }
+                else
+                {
+                        return nBytes-pState->avail_out;
+                }
+        }
+        return 0;
+}
+
+Bu::size Bu::Deflate::write( const void *pData, Bu::size nBytes )
+{
+        TRACE( pData, nBytes );
+        if( nBytes  <= 0 )
+                return 0;
+        if( !pState->state )
+        {
+                bReading = false;
+                int iFmt = eFmt&Gzip;
+                if( iFmt == Raw )
+                        deflateInit2( pState, nCompression, Z_DEFLATED, -15, 9,
+                                Z_DEFAULT_STRATEGY );
+                else if( iFmt == Zlib )
+                        deflateInit2( pState, nCompression, Z_DEFLATED, 15, 9,
+                                Z_DEFAULT_STRATEGY );
+                else if( iFmt == Gzip )
+                        deflateInit2( pState, nCompression, Z_DEFLATED, 16+15, 9,
+                                Z_DEFAULT_STRATEGY );
+                else
+                        throw Bu::ExceptionBase("Invalid format for deflate.");
+        }
+        if( bReading == true )
+                throw ExceptionBase("This deflate filter is in reading mode, you can't write.");
+
+        pState->next_in = (Bytef *)pData;
+        pState->avail_in = nBytes;
+        for(;;)
+        {
+                pState->avail_out = nBufSize;
+                pState->next_out = (Bytef *)pBuf;
+
+                zError( deflate( pState, Z_NO_FLUSH ) );
+
+                if( pState->avail_out < nBufSize )
+                {
+                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+                }
+                if( pState->avail_in == 0 )
+                        break;
+        }
+
+        return nBytes;
+}
+
+bool Bu::Deflate::isOpen()
+{
+        TRACE();
+        return (pState != NULL && pState->state != NULL);
+}
+
+bool Bu::Deflate::isEos()
+{
+        TRACE();
+        return bEos;
+}
+
+Bu::size Bu::Deflate::getCompressedSize()
+{
+        return sTotalOut;
+}
+
diff --git a/src/stable/deflate.h b/src/stable/deflate.h
new file mode 100644
index 0000000..f835cfc
--- /dev/null
+++ b/src/stable/deflate.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_DEFLATE_H
+#define BU_DEFLATE_H
+
+#include <stdint.h>
+
+#include "bu/filter.h"
+
+namespace Bu
+{
+        /**
+         * Provides Deflate (LZ77) support via zlib.  This provides zlib, raw, and
+         * gzip stream types.  By default it will autodetect the input type and
+         * encode into a raw deflate stream.
+         *
+         *@ingroup Streams
+         *@ingroup Compression
+         */
+        class Deflate : public Bu::Filter
+        {
+        public:
+                enum Format
+                {
+                        Raw                     = 0x01,
+                        Zlib            = 0x02,
+                        Gzip            = 0x03,
+                        AutoDetect      = 0x04,
+
+                        AutoRaw         = 0x04|0x01,
+                        AutoZlib        = 0x04|0x02,
+                        AutoGzip        = 0x04|0x03
+                };
+
+                Deflate( Bu::Stream &rNext, int nCompression=-1, Format eFmt=AutoZlib );
+                virtual ~Deflate();
+
+                virtual void start();
+                virtual Bu::size stop();
+                virtual Bu::size read( void *pBuf, Bu::size nBytes );
+                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+
+                virtual bool isOpen();
+                virtual bool isEos();
+
+                Bu::size getCompressedSize();
+
+        private:
+                void zError( int code );
+                void *prState;
+                bool bReading;
+                int nCompression;
+                char *pBuf;
+                uint32_t nBufSize;
+                Bu::size sTotalOut;
+                Format eFmt;
+                bool bEos;
+        };
+}
+
+#endif
diff --git a/src/stable/exceptionbase.cpp b/src/stable/exceptionbase.cpp
new file mode 100644
index 0000000..13a98db
--- /dev/null
+++ b/src/stable/exceptionbase.cpp
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/exceptionbase.h"
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+
+Bu::ExceptionBase::ExceptionBase( const char *lpFormat, ... ) throw() :
+        nErrorCode( 0 ),
+        sWhat( NULL )
+{
+        va_list ap;
+
+        va_start(ap, lpFormat);
+        setWhat( lpFormat, ap );
+        va_end(ap);
+}
+
+Bu::ExceptionBase::ExceptionBase( int nCode, const char *lpFormat, ... ) throw() :
+        nErrorCode( nCode ),
+        sWhat( NULL )
+{
+        va_list ap;
+
+        va_start(ap, lpFormat);
+        setWhat( lpFormat, ap );
+        va_end(ap);
+}
+
+Bu::ExceptionBase::ExceptionBase( int nCode ) throw() :
+        nErrorCode( nCode ),
+        sWhat( NULL )
+{
+}
+
+Bu::ExceptionBase::ExceptionBase( const ExceptionBase &e ) throw () :
+        std::exception( e ),
+        nErrorCode( e.nErrorCode ),
+        sWhat( NULL )
+{
+        setWhat( e.sWhat );
+}
+
+Bu::ExceptionBase::~ExceptionBase() throw()
+{
+        delete[] sWhat;
+        sWhat = NULL;
+}
+
+void Bu::ExceptionBase::setWhat( const char *lpFormat, va_list &vargs )
+{
+        if( sWhat ) delete[] sWhat;
+        int nSize;
+
+        va_list vargs2;
+        va_copy( vargs2, vargs );
+        nSize = vsnprintf( NULL, 0, lpFormat, vargs2 );
+        va_end( vargs2 );
+        sWhat = new char[nSize+1];
+        vsnprintf( sWhat, nSize+1, lpFormat, vargs );
+}
+
+void Bu::ExceptionBase::setWhat( const char *lpText )
+{
+        if( sWhat ) delete[] sWhat;
+        int nSize;
+
+        nSize = strlen( lpText );
+        sWhat = new char[nSize+1];
+        strcpy( sWhat, lpText );
+}
+
+const char *Bu::ExceptionBase::what() const throw()
+{
+        return sWhat;
+}
+
+int Bu::ExceptionBase::getErrorCode()
+{
+        return nErrorCode;
+}
+
+Bu::UnsupportedException::UnsupportedException() throw() :
+        ExceptionBase( 0 )
+{
+        setWhat("An unsupperted operation was attempted.");
+}
+
diff --git a/src/stable/exceptionbase.h b/src/stable/exceptionbase.h
new file mode 100644
index 0000000..b6ad9ca
--- /dev/null
+++ b/src/stable/exceptionbase.h
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_EXCEPTION_BASE_H
+#define BU_EXCEPTION_BASE_H
+
+#include <exception>
+#include <stdarg.h>
+
+// This shouldn't normally be defined here, I don't think it's all that portable
+// and it also changes the class interface, we should find out how much of
+// an issue that is, we could just put in an empty getBacktrace() function for
+// when you don't have support for it...
+
+namespace Bu
+{
+        /**
+         * 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.
+         * 
+         * in your header:  subExceptionDecl( NewClassName );
+         * 
+         * in your source:  subExcpetienDef( NewClassName );
+         */
+        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();
+
+                ExceptionBase( const ExceptionBase &e ) 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 );
+
+                /**
+                 *
+                 * @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. */
+        };
+}
+
+#define subExceptionDecl( name )                                                                                        \
+class name : public Bu::ExceptionBase                                                                                   \
+{                                                                                                                                                       \
+        public:                                                                                                                                 \
+                name( const char *sFormat, ... ) throw ();                                                      \
+                name( int nCode, const char *sFormat, ... ) throw();                            \
+                name( int nCode=0 ) throw ();                                                                           \
+                name( const name &e ) throw ();                                                                         \
+};
+
+#define subExceptionDeclChild( name, parent )                                                           \
+class name : public parent                                                                                                      \
+{                                                                                                                                                       \
+        public:                                                                                                                                 \
+                name( const char *sFormat, ... ) throw ();                                                      \
+                name( int nCode, const char *sFormat, ... ) throw();                            \
+                name( int nCode=0 ) throw ();                                                                           \
+                name( const name &e ) throw ();                                                                         \
+};
+
+#define subExceptionDeclBegin( name )                                                                           \
+class name : public Bu::ExceptionBase                                                                           \
+{                                                                                                                                                       \
+        public:                                                                                                                                 \
+                name( const char *sFormat, ... ) throw ();                                                      \
+                name( int nCode, const char *sFormat, ... ) throw();                            \
+                name( int nCode=0 ) throw ();                                                                           \
+                name( const name &e ) throw ();
+
+#define subExceptionDeclEnd()                                                                                           \
+};
+
+#define subExceptionDef( name )                                                                                         \
+name::name( const char *lpFormat, ... ) throw() :                                                       \
+        ExceptionBase( 0 )                                                                                                              \
+{                                                                                                                                                       \
+        va_list ap;                                                                                                                             \
+        va_start( ap, lpFormat );                                                                                               \
+        setWhat( lpFormat, ap );                                                                                                \
+        va_end( ap );                                                                                                                   \
+}                                                                                                                                                       \
+name::name( int nCode, const char *lpFormat, ... ) throw() :                            \
+        ExceptionBase( nCode )                                                                                                  \
+{                                                                                                                                                       \
+        va_list ap;                                                                                                                             \
+        va_start( ap, lpFormat );                                                                                               \
+        setWhat( lpFormat, ap );                                                                                                \
+        va_end( ap );                                                                                                                   \
+}                                                                                                                                                       \
+name::name( int nCode ) throw() :                                                                                       \
+        ExceptionBase( nCode )                                                                                                  \
+{                                                                                                                                                       \
+}                                                                                                                                                       \
+name::name( const name &e ) throw() :                                                                           \
+        ExceptionBase( e )                                                                                                              \
+{                                                                                                                                                       \
+}
+
+#define subExceptionDefChild( name, parent )                                                            \
+name::name( const char *lpFormat, ... ) throw() :                                                       \
+        parent( 0 )                                                                                                                             \
+{                                                                                                                                                       \
+        va_list ap;                                                                                                                             \
+        va_start( ap, lpFormat );                                                                                               \
+        setWhat( lpFormat, ap );                                                                                                \
+        va_end( ap );                                                                                                                   \
+}                                                                                                                                                       \
+name::name( int nCode, const char *lpFormat, ... ) throw() :                            \
+        parent( nCode )                                                                                                                 \
+{                                                                                                                                                       \
+        va_list ap;                                                                                                                             \
+        va_start( ap, lpFormat );                                                                                               \
+        setWhat( lpFormat, ap );                                                                                                \
+        va_end( ap );                                                                                                                   \
+}                                                                                                                                                       \
+name::name( int nCode ) throw() :                                                                                       \
+        parent( nCode )                                                                                                                 \
+{                                                                                                                                                       \
+}                                                                                                                                                       \
+name::name( const name &e ) throw() :                                                                           \
+        ExceptionBase( e )                                                                                                              \
+{                                                                                                                                                       \
+}
+
+namespace Bu
+{
+        // Exceptions that are so general they could be used anywhere go here.
+        class UnsupportedException : public Bu::ExceptionBase
+        {
+        public:
+                UnsupportedException() throw ();
+        };
+}
+
+#endif
diff --git a/src/stable/extratypes.h b/src/stable/extratypes.h
new file mode 100644
index 0000000..656cd6d
--- /dev/null
+++ b/src/stable/extratypes.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef EXTRA_TYPES_H
+#define EXTRA_TYPES_H
+
+#include "bu/config.h"
+
+#include <stdint.h>
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+namespace Bu
+{
+#ifdef USE_64BIT_IO
+        typedef int64_t         size;
+        typedef uint64_t        usize;
+#else
+        typedef int32_t         size;
+        typedef uint32_t        usize;
+#endif
+};
+
+#endif
diff --git a/src/stable/file.cpp b/src/stable/file.cpp
new file mode 100644
index 0000000..8c8f540
--- /dev/null
+++ b/src/stable/file.cpp
@@ -0,0 +1,305 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/file.h"
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+
+#include "bu/config.h"
+
+namespace Bu { subExceptionDef( FileException ) }
+
+Bu::File::File( const Bu::String &sName, int iFlags ) :
+        fd( -1 ),
+        bEos( true )
+{
+#ifdef USE_64BIT_IO
+        fd = ::open64( sName.getStr(), getPosixFlags( iFlags ), 0666 );
+#else
+        fd = ::open( sName.getStr(), getPosixFlags( iFlags ), 0666 );
+#endif
+        if( fd < 0 )
+        {
+                throw Bu::FileException( errno, "%s: %s",
+                        strerror(errno), sName.getStr() );
+        }
+        bEos = false;
+}
+
+Bu::File::File( int fd ) :
+        fd( fd )
+{
+        bEos = false;
+}
+
+Bu::File::~File()
+{
+        close();
+}
+
+void Bu::File::close()
+{
+        if( fd >= 0 )
+        {
+                if( ::close( fd ) )
+                {
+                        throw Bu::FileException( errno, "%s",
+                                strerror(errno) );
+                }
+                fd = -1;
+                bEos = true;
+        }
+}
+
+Bu::size Bu::File::read( void *pBuf, Bu::size nBytes )
+{
+        if( fd < 0 )
+                throw FileException("File not open.");
+
+        Bu::size iRead = ::read( fd, pBuf, nBytes );
+        if( iRead == 0 )
+                bEos = true;
+        else if( iRead == -1 && errno == EAGAIN )
+                return 0;
+        else if( iRead < 0 )
+                throw FileException( errno, "%s", strerror( errno ) );
+        return iRead;
+}
+
+Bu::size Bu::File::write( const void *pBuf, Bu::size nBytes )
+{
+        if( fd < 0 )
+                throw FileException("File not open.");
+
+        Bu::size iWrote = ::write( fd, pBuf, nBytes );
+        if( iWrote < 0 )
+                throw FileException( errno, "%s", strerror( errno ) );
+        return iWrote;
+}
+
+Bu::size Bu::File::tell()
+{
+        if( fd < 0 )
+                throw FileException("File not open.");
+
+        return lseek( fd, 0, SEEK_CUR );
+}
+
+void Bu::File::seek( Bu::size offset )
+{
+        if( fd < 0 )
+                throw FileException("File not open.");
+
+        lseek( fd, offset, SEEK_CUR );
+        bEos = false;
+}
+
+void Bu::File::setPos( Bu::size pos )
+{
+        if( fd < 0 )
+                throw FileException("File not open.");
+
+        lseek( fd, pos, SEEK_SET );
+        bEos = false;
+}
+
+void Bu::File::setPosEnd( Bu::size pos )
+{
+        if( fd < 0 )
+                throw FileException("File not open.");
+        
+        lseek( fd, pos, SEEK_END );
+        bEos = false;
+}
+
+bool Bu::File::isEos()
+{
+        return bEos;
+}
+
+bool Bu::File::canRead()
+{
+#ifdef WIN32
+        return true;
+#else
+        int iMode = fcntl( fd, F_GETFL, 0 )&O_ACCMODE;
+        if( iMode == O_RDONLY || iMode == O_RDWR )
+                return true;
+        return false;
+#endif
+}
+
+bool Bu::File::canWrite()
+{
+#ifdef WIN32
+        return true;
+#else
+        int iMode = fcntl( fd, F_GETFL, 0 )&O_ACCMODE;
+        if( iMode == O_WRONLY || iMode == O_RDWR )
+                return true;
+        return false;
+#endif
+}
+
+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 )
+{
+#ifdef WIN32
+        fprintf(stderr, "STUB: Bu::File::setBlocking\n");
+#else
+        if( bBlocking )
+                fcntl( 
+                        fd,
+                        F_SETFL, fcntl( fd, F_GETFL, 0 )&(~O_NONBLOCK)
+                        );
+        else
+                fcntl( 
+                        fd,
+                        F_SETFL, fcntl( fd, F_GETFL, 0 )|O_NONBLOCK
+                        );
+#endif
+}
+
+Bu::File Bu::File::tempFile( Bu::String &sName )
+{
+        uint32_t iX;
+        iX = time( NULL ) + getpid();
+        int iXes;
+        for( iXes = sName.getSize()-1; iXes >= 0; iXes-- )
+        {
+                if( sName[iXes] != 'X' )
+                        break;
+        }
+        iXes++;
+        if( iXes == sName.getSize() )
+                throw Bu::ExceptionBase("Invalid temporary filename template.");
+        for( int iter = 0; iter < 100; iter++ )
+        {
+                for( int j = iXes; j < sName.getSize(); j++ )
+                {
+                        iX = (1103515245 * iX + 12345);
+                        sName[j] = ('A'+(iX%26)) | ((iX&0x1000)?(0x20):(0));
+                }
+
+                try
+                {
+                        return Bu::File( sName, Bu::File::Read|Bu::File::Write
+                                        |Bu::File::Create|Bu::File::Exclusive );
+                } catch(...) { }
+        }
+        throw Bu::FileException("Failed to create unique temporary file after 100"
+                        " iterations.");
+}
+
+void Bu::File::setSize( Bu::size iSize )
+{
+#ifdef WIN32
+        chsize( fd, iSize );
+#else
+        ftruncate( fd, iSize );
+#endif
+}
+
+Bu::size Bu::File::getSize() const
+{
+        struct stat st;
+        fstat( fd, &st );
+        return st.st_size;
+}
+
+Bu::size Bu::File::getBlockSize() const
+{
+#ifdef WIN32
+        return 4096;
+#else
+        struct stat st;
+        fstat( fd, &st );
+        return st.st_blksize;
+#endif
+}
+
+Bu::String Bu::File::getLocation() const
+{
+        return "to be implemented";
+}
+
+#ifndef WIN32
+void Bu::File::chmod( mode_t t )
+{
+        fchmod( fd, t );
+}
+#endif
+
+void Bu::File::flush()
+{
+        // There is no flushing with direct I/O...
+        //fflush( fh );
+}
+
+bool Bu::File::isOpen()
+{
+        return (fd > -1);
+}
+
+int Bu::File::getPosixFlags( int iFlags )
+{
+        int iRet = 0;
+        switch( (iFlags&ReadWrite) )
+        {
+                // According to posix, O_RDWR is not necesarilly O_RDONLY|O_WRONLY, so
+                // lets be proper and use the right value in the right place.
+                case Read:              iRet = O_RDONLY; break;
+                case Write:             iRet = O_WRONLY; break;
+                case ReadWrite: iRet = O_RDWR; break;
+                default:
+                        throw FileException(
+                                "You must specify Read, Write, or both when opening a file.");
+        }
+
+        if( (iFlags&Create) )
+                iRet |= O_CREAT;
+        if( (iFlags&Append) )
+                iRet |= O_APPEND;
+        if( (iFlags&Truncate) )
+                iRet |= O_TRUNC;
+#ifndef WIN32
+        if( (iFlags&NonBlock) )
+                iRet |= O_NONBLOCK;
+#endif
+        if( (iFlags&Exclusive) == Exclusive )
+                iRet |= O_EXCL;
+
+#ifdef O_BINARY
+        iRet |= O_BINARY;
+#endif
+
+        return iRet;
+}
+
diff --git a/src/stable/file.h b/src/stable/file.h
new file mode 100644
index 0000000..e3225fa
--- /dev/null
+++ b/src/stable/file.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_FILE_H
+#define BU_FILE_H
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include "bu/stream.h"
+#include "bu/string.h"
+#include "bu/exceptionbase.h"
+
+namespace Bu
+{
+        subExceptionDecl( FileException );
+
+        /**
+         * A file stream.
+         *@ingroup Streams
+         */
+        class File : public Bu::Stream
+        {
+        public:
+                File( const Bu::String &sName, int iFlags );
+                File( int fd );
+                virtual ~File();
+
+                virtual void close();
+                virtual Bu::size read( void *pBuf, Bu::size nBytes );
+                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+                using Stream::write;
+
+                virtual Bu::size tell();
+                virtual void seek( Bu::size offset );
+                virtual void setPos( Bu::size pos );
+                virtual void setPosEnd( Bu::size 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 );
+
+                enum {
+                        // Flags
+                        Read            = 0x01, ///< Open file for reading
+                        Write           = 0x02, ///< Open file for writing
+                        Create          = 0x04, ///< Create file if it doesn't exist
+                        Truncate        = 0x08, ///< Truncate file if it does exist
+                        Append          = 0x10, ///< Always append on every write
+                        NonBlock        = 0x20, ///< Open file in non-blocking mode
+                        Exclusive       = 0x44, ///< Create file, if it exists then fail
+
+                        // Helpful mixes
+                        ReadWrite       = 0x03, ///< Open for reading and writing
+                        WriteNew        = 0x0E  ///< Create a file (or truncate) for writing.
+                                                                /// Same as Write|Create|Truncate
+                };
+
+                virtual void setSize( Bu::size iSize );
+
+                virtual size getSize() const;
+                virtual size getBlockSize() const;
+                virtual Bu::String getLocation() const;
+
+                /**
+                 * Create a temp file and return its handle.  The file is opened 
+                 * Read/Write.
+                 *@param sName (Bu::String) Give in the form: "/tmp/tmpfileXXXXXXXX"
+                 *              It will alter your (sName) setting the 'X's to random
+                 *              characters.
+                 *@returns (Bu::File) A file object representing your temp file.
+                 */
+                static Bu::File tempFile( Bu::String &sName );
+
+#ifndef WIN32
+                /**
+                 * Change the file access permissions.
+                 *@param t (mode_t) The new file access permissions.
+                 */
+                void chmod( mode_t t );
+#endif
+
+        private:
+                int getPosixFlags( int iFlags );
+
+        private:
+                int fd;
+                bool bEos;
+        };
+}
+
+#endif
diff --git a/src/stable/filter.cpp b/src/stable/filter.cpp
new file mode 100644
index 0000000..3fe8f0e
--- /dev/null
+++ b/src/stable/filter.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/filter.h"
+
+Bu::Filter::Filter( Bu::Stream &rNext ) :
+        rNext( rNext )
+{
+}
+
+Bu::Filter::~Filter()
+{
+}
+
+void Bu::Filter::close()
+{
+        stop();
+        rNext.close();
+}
+
+Bu::size Bu::Filter::tell()
+{
+        return rNext.tell();
+}
+
+void Bu::Filter::seek( Bu::size offset )
+{
+        rNext.seek( offset );
+}
+
+void Bu::Filter::setPos( Bu::size pos )
+{
+        rNext.setPos( pos );
+}
+
+void Bu::Filter::setPosEnd( Bu::size 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::setSize( Bu::size )
+{
+}
+
+void Bu::Filter::flush()
+{
+        rNext.flush();
+}
+
+Bu::size Bu::Filter::getSize() const
+{
+        return rNext.getSize();
+}
+
+Bu::size Bu::Filter::getBlockSize() const
+{
+        return rNext.getBlockSize();
+}
+
+Bu::String Bu::Filter::getLocation() const
+{
+        return rNext.getLocation();
+}
+
diff --git a/src/stable/filter.h b/src/stable/filter.h
new file mode 100644
index 0000000..2c57805
--- /dev/null
+++ b/src/stable/filter.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#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.
+         *@ingroup Streams
+         */
+        class Filter : public Bu::Stream
+        {
+        public:
+                Filter( Bu::Stream &rNext );
+                virtual ~Filter();
+
+                virtual void start()=0;
+                virtual Bu::size stop()=0;
+                virtual void close();
+                virtual Bu::size tell();
+                virtual void seek( Bu::size offset );
+                virtual void setPos( Bu::size pos );
+                virtual void setPosEnd( Bu::size 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 );
+
+                /**
+                 * Most filters won't re-implement this, it doesn't make a lot of sense
+                 * for filters, in general.
+                 */
+                virtual void setSize( Bu::size iSize );
+
+                virtual size getSize() const;
+                virtual size getBlockSize() const;
+                virtual Bu::String getLocation() const;
+                
+        protected:
+                Bu::Stream &rNext;
+
+        private:
+
+        };
+}
+
+#endif
diff --git a/src/stable/fmt.h b/src/stable/fmt.h
new file mode 100644
index 0000000..15d8efc
--- /dev/null
+++ b/src/stable/fmt.h
@@ -0,0 +1,92 @@
+#ifndef BU_FMT_H
+#define BU_FMT_H
+
+namespace Bu
+{
+        typedef struct Fmt
+        {
+                enum Alignment
+                {
+                        Left    = 0,
+                        Center  = 1,
+                        Right   = 2
+                };
+                Fmt() :
+                        uMinWidth( 0 ),
+                        cFillChar(' '),
+                        uRadix( 10 ),
+                        uAlign( Right ),
+                        bPlus( false ),
+                        bCaps( true ),
+                        bTokenize( true )
+                {
+                }
+
+                Fmt( unsigned int uMinWidth, unsigned int uRadix=10,
+                                Alignment a=Right, bool bPlus=false, bool bCaps=true,
+                                char cFill=' ') :
+                        uMinWidth( uMinWidth ),
+                        cFillChar(cFill),
+                        uRadix( uRadix ),
+                        uAlign( a ),
+                        bPlus( bPlus ),
+                        bCaps( bCaps ),
+                        bTokenize( true )
+                {
+                }
+                Fmt( unsigned int uMinWidth, Alignment a,
+                                unsigned int uRadix=10, bool bPlus=false, bool bCaps=true,
+                                char cFill=' ') :
+                        uMinWidth( uMinWidth ),
+                        cFillChar(cFill),
+                        uRadix( uRadix ),
+                        uAlign( a ),
+                        bPlus( bPlus ),
+                        bCaps( bCaps ),
+                        bTokenize( true )
+                {
+                }
+
+                static Fmt hex( unsigned int uWidth=0, bool bCaps=true )
+                {
+                        return Fmt( uWidth, 16, Right, false, bCaps, '0' );
+                }
+                
+                static Fmt oct( unsigned int uWidth=0 )
+                {
+                        return Fmt( uWidth, 8, Right, false, false, '0' );
+                }
+
+                static Fmt bin( unsigned int uWidth=0 )
+                {
+                        return Fmt( uWidth, 1, Right, false, false, '0' );
+                }
+
+                static Fmt ptr( bool bCaps=true )
+                {
+                        return Fmt( sizeof(ptrdiff_t)*2, 16, Right, false, bCaps, '0' );
+                }
+
+                Fmt &width( unsigned int uWidth );
+                Fmt &fill( char cFill='0' );
+                Fmt &radix( unsigned int uRadix );
+                Fmt &align( Alignment eAlign );
+                Fmt &plus( bool bPlus=true );
+                Fmt &caps( bool bCaps=true );
+                Fmt &tokenize( bool bTokenize=true );
+
+                Fmt &left();
+                Fmt &right();
+                Fmt &center();
+
+                unsigned char uMinWidth;
+                char cFillChar;
+                unsigned short uRadix : 6;
+                unsigned short uAlign : 2;
+                unsigned short bPlus : 1;
+                unsigned short bCaps : 1;
+                unsigned short bTokenize : 1;
+        } Fmt;
+};
+
+#endif
diff --git a/src/stable/formatter.cpp b/src/stable/formatter.cpp
new file mode 100644
index 0000000..f275d71
--- /dev/null
+++ b/src/stable/formatter.cpp
@@ -0,0 +1,547 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/formatter.h"
+
+#include "bu/stream.h"
+#include <string.h>
+
+template<> float Bu::tlog( float x )
+{
+        return logf( x );
+}
+
+template<> double Bu::tlog( double x )
+{
+        return log( x );
+}
+
+template<> long double Bu::tlog( long double x )
+{
+        return logl( x );
+}
+
+template<> float Bu::tfloor( float x )
+{
+        return floorf( x );
+}
+
+template<> double Bu::tfloor( double x )
+{
+        return floor( x );
+}
+
+template<> long double Bu::tfloor( long double x )
+{
+        return floorl( x );
+}
+
+template<> float Bu::tpow( float x, float y )
+{
+        return powf( x, y );
+}
+
+template<> double Bu::tpow( double x, double y )
+{
+        return pow( x, y );
+}
+
+template<> long double Bu::tpow( long double x, long double y )
+{
+        return powl( x, y );
+}
+
+Bu::Formatter::Formatter( Stream &rStream ) :
+        rStream( rStream ),
+        bTempFmt( false ),
+        uIndent( 0 ),
+        cIndent( '\t' )
+{
+}
+
+Bu::Formatter::~Formatter()
+{
+}
+
+void Bu::Formatter::write( const Bu::String &sStr )
+{
+        rStream.write( sStr );
+}
+
+void Bu::Formatter::write( const void *sStr, int iLen )
+{
+        rStream.write( sStr, iLen );
+}
+
+void Bu::Formatter::writeAligned( const Bu::String &sStr )
+{
+        int iLen = sStr.getSize();
+        if( iLen > fLast.uMinWidth )
+        {
+                write( sStr );
+        }
+        else
+        {
+                int iRem = fLast.uMinWidth - iLen;
+                switch( fLast.uAlign )
+                {
+                        case Fmt::Right:
+                                for( int k = 0; k < iRem; k++ )
+                                        write( &fLast.cFillChar, 1 );
+                                write( sStr );
+                                break;
+                        
+                        case Fmt::Center:
+                                {
+                                        int iHlf = iRem/2;
+                                        for( int k = 0; k < iHlf; k++ )
+                                                write( &fLast.cFillChar, 1 );
+                                        write( sStr );
+                                        iHlf = iRem-iHlf;;
+                                        for( int k = 0; k < iHlf; k++ )
+                                                write( &fLast.cFillChar, 1 );
+                                }
+                                break;
+                        
+                        case Fmt::Left:
+                                write( sStr );
+                                for( int k = 0; k < iRem; k++ )
+                                        write( &fLast.cFillChar, 1 );
+                                break;
+                }
+        }
+
+        usedFormat();
+}
+
+void Bu::Formatter::writeAligned( const char *sStr, int iLen )
+{
+        if( iLen > fLast.uMinWidth )
+        {
+                write( sStr, iLen );
+        }
+        else
+        {
+                int iRem = fLast.uMinWidth - iLen;
+                switch( fLast.uAlign )
+                {
+                        case Fmt::Right:
+                                for( int k = 0; k < iRem; k++ )
+                                        write( &fLast.cFillChar, 1 );
+                                write( sStr, iLen );
+                                break;
+                        
+                        case Fmt::Center:
+                                {
+                                        int iHlf = iRem/2;
+                                        for( int k = 0; k < iHlf; k++ )
+                                                write( &fLast.cFillChar, 1 );
+                                        write( sStr, iLen );
+                                        iHlf = iRem-iHlf;;
+                                        for( int k = 0; k < iHlf; k++ )
+                                                write( &fLast.cFillChar, 1 );
+                                }
+                                break;
+                        
+                        case Fmt::Left:
+                                write( sStr, iLen );
+                                for( int k = 0; k < iRem; k++ )
+                                        write( &fLast.cFillChar, 1 );
+                                break;
+                }
+        }
+
+        usedFormat();
+}
+
+void Bu::Formatter::read( void *sStr, int iLen )
+{
+        rStream.read( sStr, iLen );
+}
+
+Bu::String Bu::Formatter::readToken()
+{
+        Bu::String sRet;
+        if( fLast.bTokenize )
+        {
+                for(;;)
+                {
+                        char buf;
+                        int iRead = rStream.read( &buf, 1 );
+                        if( iRead == 0 )
+                                return sRet;
+                        if( buf == ' ' || buf == '\t' || buf == '\n' || buf == '\r' )
+                                continue;
+                        else
+                        {
+                                sRet += buf;
+                                break;
+                        }
+                }
+                for(;;)
+                {
+                        char buf;
+                        int iRead = rStream.read( &buf, 1 );
+                        if( iRead == 0 )
+                                return sRet;
+                        if( buf == ' ' || buf == '\t' || buf == '\n' || buf == '\r' )
+                                return sRet;
+                        else
+                                sRet += buf;
+                }
+        }
+        else
+        {
+                for(;;)
+                {
+                        char buf;
+                        int iRead = rStream.read( &buf, 1 );
+                        if( iRead == 0 )
+                                return sRet;
+                        else
+                                sRet += buf;
+                }
+        }
+}
+
+void Bu::Formatter::incIndent()
+{
+        if( uIndent < 0xFFU )
+                uIndent++;
+}
+
+void Bu::Formatter::decIndent()
+{
+        if( uIndent > 0 )
+                uIndent--;
+}
+
+void Bu::Formatter::setIndent( uint8_t uLevel )
+{
+        uIndent = uLevel;
+}
+
+void Bu::Formatter::clearIndent()
+{
+        uIndent = 0;
+}
+
+void Bu::Formatter::setIndentChar( char cIndent )
+{
+        this->cIndent = cIndent;
+}
+
+void Bu::Formatter::doFlush()
+{
+        rStream.flush();
+}
+
+Bu::Fmt &Bu::Fmt::width( unsigned int uWidth )
+{
+        this->uMinWidth = uWidth;
+        return *this;
+}
+
+Bu::Fmt &Bu::Fmt::fill( char cFill )
+{
+        this->cFillChar = (unsigned char)cFill;
+        return *this;
+}
+
+Bu::Fmt &Bu::Fmt::radix( unsigned int uRadix )
+{
+        this->uRadix = uRadix;
+        return *this;
+}
+
+Bu::Fmt &Bu::Fmt::align( Alignment eAlign )
+{
+        this->uAlign = eAlign;
+        return *this;
+}
+
+Bu::Fmt &Bu::Fmt::left()
+{
+        this->uAlign = Fmt::Left;
+        return *this;
+}
+
+Bu::Fmt &Bu::Fmt::center()
+{
+        this->uAlign = Fmt::Center;
+        return *this;
+}
+
+Bu::Fmt &Bu::Fmt::right()
+{
+        this->uAlign = Fmt::Right;
+        return *this;
+}
+
+Bu::Fmt &Bu::Fmt::plus( bool bPlus )
+{
+        this->bPlus = bPlus;
+        return *this;
+}
+
+Bu::Fmt &Bu::Fmt::caps( bool bCaps )
+{
+        this->bCaps = bCaps;
+        return *this;
+}
+
+Bu::Fmt &Bu::Fmt::tokenize( bool bTokenize )
+{
+        this->bTokenize = bTokenize;
+        return *this;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::Fmt &fmt )
+{
+        f.setTempFormat( fmt );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, Bu::Formatter::Special s )
+{
+        switch( s )
+        {
+                case Formatter::nl:
+                        {
+#ifdef WIN32
+                                f.write("\r\n", 2 );
+#else
+                                f.write("\n", 1 );
+#endif
+                                char ci = f.getIndentChar();
+                                for( int j = 0; j < f.getIndent(); j++ )
+                                        f.write( &ci, 1 );
+                                f.doFlush();
+                        }
+                        break;
+
+                case Formatter::flush:
+                        f.doFlush();
+                        break;
+        }
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const char *sStr )
+{
+        f.writeAligned( sStr, strlen( sStr ) );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, char *sStr )
+{
+        f.writeAligned( sStr, strlen( sStr ) );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::String &sStr )
+{
+        f.writeAligned( sStr );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed char c )
+{
+        f.ifmt<signed char>( c );
+        //f.write( (char *)&c, 1 );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, char c )
+{
+        f.write( (char *)&c, 1 );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned char c )
+{
+        f.ufmt<unsigned char>( c );
+        //f.write( (char *)&c, 1 );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed short i )
+{
+        f.ifmt<signed short>( i );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned short i )
+{
+        f.ufmt<unsigned short>( i );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed int i )
+{
+        f.ifmt<signed int>( i );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned int i )
+{
+        f.ufmt<unsigned int>( i );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed long i )
+{
+        f.ifmt<signed long>( i );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned long i )
+{
+        f.ufmt<unsigned long>( i );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed long long i )
+{
+        f.ifmt<signed long long>( i );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned long long i )
+{
+        f.ufmt<unsigned long long>( i );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, float flt )
+{
+        f.ffmt<float>( flt );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, double flt )
+{
+        f.ffmt<double>( flt );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, long double flt )
+{
+        f.ffmt<long double>( flt );
+        return f;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, bool b )
+{
+        f.writeAligned( b?("true"):("false") );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, Bu::String &sStr )
+{
+        sStr = f.readToken();
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed char &c )
+{
+        f.read( &c, 1 );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, char &c )
+{
+        f.read( &c, 1 );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned char &c )
+{
+        f.read( &c, 1 );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed short &i )
+{
+        f.iparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned short &i )
+{
+        f.uparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed int &i )
+{
+        f.iparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned int &i )
+{
+        f.uparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed long &i )
+{
+        f.iparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned long &i )
+{
+        f.uparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed long long &i )
+{
+        f.iparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned long long &i )
+{
+        f.uparse( i, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, float &flt )
+{
+        f.fparse( flt, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, double &flt )
+{
+        f.fparse( flt, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, long double &flt )
+{
+        f.fparse( flt, f.readToken() );
+        return f;
+}
+
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, bool &b )
+{
+        Bu::String sStr = f.readToken();
+        if( !sStr.isSet() )
+                return f;
+        char c = *sStr.begin();
+        if( c == 'y' || c == 'Y' || c == 't' || c == 'T' )
+                b = true;
+        else if( c == 'n' || c == 'N' || c == 'f' || c == 'F' )
+                b = false;
+
+        return f;
+}
+
diff --git a/src/stable/formatter.h b/src/stable/formatter.h
new file mode 100644
index 0000000..a440ec3
--- /dev/null
+++ b/src/stable/formatter.h
@@ -0,0 +1,303 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_FORMATTER_H
+#define BU_FORMATTER_H
+
+#include "bu/string.h"
+#include "bu/fmt.h"
+
+#include <math.h>
+
+namespace Bu
+{
+        class Stream;
+
+        template<typename t> t tlog( t x );
+        template<> float tlog( float x );
+        template<> double tlog( double x );
+        template<> long double tlog( long double x );
+
+        template<typename t> t tfloor( t x );
+        template<> float tfloor( float x );
+        template<> double tfloor( double x );
+        template<> long double tfloor( long double x );
+
+        template<typename t> t tpow( t x, t y );
+        template<> float tpow( float x, float y );
+        template<> double tpow( double x, double y );
+        template<> long double tpow( long double x, long double y );
+
+        class Formatter
+        {
+        public:
+                Formatter( Stream &rStream );
+                virtual ~Formatter();
+
+                void write( const Bu::String &sStr );
+                void write( const void *sStr, int iLen );
+                void writeAligned( const Bu::String &sStr );
+                void writeAligned( const char *sStr, int iLen );
+
+                void read( void *sStr, int iLen );
+                Bu::String readToken();
+
+                void incIndent();
+                void decIndent();
+                void setIndent( uint8_t uLevel );
+                void clearIndent();
+                uint8_t getIndent() const { return uIndent; }
+                void setIndentChar( char cIndent );
+                char getIndentChar() const { return cIndent; }
+
+                void setFormat( const Fmt &f )
+                {
+                        fLast = f;
+                        bTempFmt = false;
+                }
+
+                void setTempFormat( const Fmt &f )
+                {
+                        fLast = f;
+                        bTempFmt = true;
+                }
+
+                void usedFormat()
+                {
+                        if( bTempFmt )
+                                fLast = Fmt();
+                }
+
+                template<typename type>
+                void ifmt( type i )
+                {
+                        // This code is taken from Nango, hopefully we can make it better.
+                        bool bNeg = i<0;
+                        char cBase = fLast.bCaps?'A':'a';
+                        char buf[sizeof(type)*8+1];
+                        if( bNeg ) i = -i;
+                        if( fLast.uRadix < 2 || fLast.uRadix > 36 )
+                        {
+                                usedFormat();
+                                return;
+                        }
+
+                        for( int j = sizeof(type)*8; j >= 0; j-- )
+                        {
+                                int c = i%fLast.uRadix;
+                                i /= fLast.uRadix;
+                                buf[j] = (char)((c<10)?('0'+c):(cBase+c-10));
+                                if( i == 0 )
+                                {
+                                        if( bNeg ) buf[--j] = '-';
+                                        else if( fLast.bPlus ) buf[--j] = '+';
+                                        writeAligned( buf+j, sizeof(type)*8-j+1 );
+
+                                        return;
+                                }
+                        }
+                        usedFormat();
+                }
+
+                template<typename type>
+                void ufmt( type i )
+                {
+                        // This code is taken from Nango, hopefully we can make it better.
+                        char buf[sizeof(type)*8+1];
+                        char cBase = fLast.bCaps?'A':'a';
+                        if( fLast.uRadix < 2 || fLast.uRadix > 36 )
+                        {
+                                usedFormat();
+                                return;
+                        }
+
+                        for( int j = sizeof(type)*8; j >= 0; j-- )
+                        {
+                                int c = i%fLast.uRadix;
+                                i /= fLast.uRadix;
+                                buf[j] = (char)((c<10)?('0'+c):(cBase+c-10));
+                                if( i == 0 )
+                                {
+                                        if( fLast.bPlus ) buf[--j] = '+';
+                                        writeAligned( buf+j, sizeof(type)*8-j+1 );
+
+                                        return;
+                                }
+                        }
+                        usedFormat();
+                }
+
+                template<typename type>
+                void ffmt( type f )
+                {
+                        Bu::String fTmp;
+                        char cBase = fLast.bCaps?'A':'a';
+                        if( fLast.uRadix < 2 || fLast.uRadix > 36 )
+                        {
+                                usedFormat();
+                                return;
+                        }
+
+                        if( signbit(f) )
+                        {
+                                f = -f;
+                                fTmp += "-";
+                        }
+                        int iScale = tfloor(tlog( f ) / tlog( (type)fLast.uRadix ));
+                        f /= tpow( (type)fLast.uRadix, (type)iScale );
+
+                        if( iScale < 0 )
+                        {
+                                fTmp += "0.";
+                                for( int j = 1; j < -iScale; j++ )
+                                        fTmp += '0';
+                        }
+                        int c = f;
+                        fTmp += (char)((c<10)?('0'+c):(cBase+c-10));
+                        f -= (int)f;
+                        int j;
+                        for( j = 0; j < 8 && f; j++ )
+                        {
+                                if( iScale - j == 0 )
+                                        fTmp += '.';
+                                f = f*fLast.uRadix;
+                                int c = f;
+                                fTmp += (char)((c<10)?('0'+c):(cBase+c-10));
+                                f -= (int)f;
+                        }
+                        if( iScale >= j )
+                        {
+                                for( int k = j; k < iScale; k++ )
+                                        fTmp += '0';
+                                fTmp += ".0";
+                        }
+
+                        writeAligned( fTmp );
+                        usedFormat();
+                }
+                
+                template<typename type>
+                void iparse( type &i, const Bu::String &sBuf )
+                {
+                        if( !sBuf.isSet() )
+                                return;
+                        if( sBuf[0] != '+' && sBuf[0] != '-' &&
+                                (sBuf[0] < '0' && sBuf[0] > '9') )
+                                return;
+                        int j = 1;
+                        int iMax = sBuf.getSize();
+                        for(; j < iMax && (sBuf[j] >= '0' && sBuf[j] <= '9'); j++ ) { }
+                        i = 0;
+                        type iPos = 1;
+                        for(j--; j >= 0; j-- )
+                        {
+                                if( sBuf[j] == '+' || sBuf[j] == '-' )
+                                        continue;
+                                i += (sBuf[j]-'0')*iPos;
+                                iPos *= fLast.uRadix;
+                        }
+                        if( sBuf[0] == '-' )
+                                i = -i;
+
+                        usedFormat();
+                }
+                
+                template<typename type>
+                void uparse( type &i, const Bu::String &sBuf )
+                {
+                        if( !sBuf.isSet() )
+                                return;
+                        if( sBuf[0] != '+' &&
+                                (sBuf[0] < '0' && sBuf[0] > '9') )
+                                return;
+                        int j = 1;
+                        int iMax = sBuf.getSize();
+                        for(; j < iMax && (sBuf[j] >= '0' && sBuf[j] <= '9'); j++ ) { }
+                        i = 0;
+                        type iPos = 1;
+                        for(j--; j >= 0; j-- )
+                        {
+                                if( sBuf[j] == '+' )
+                                        continue;
+                                i += (sBuf[j]-'0')*iPos;
+                                iPos *= fLast.uRadix;
+                        }
+
+                        usedFormat();
+                }
+                
+                template<typename type>
+                void fparse( type &f, const Bu::String &sBuf )
+                {
+                        double fIn;
+                        sscanf( sBuf.getStr(), "%lf", &fIn );
+                        f = fIn;
+                        usedFormat();
+                }
+
+                enum Special
+                {
+                        nl,
+                        flush
+                };
+
+                void doFlush();
+
+        private:
+                Stream &rStream;
+                Fmt fLast;
+                bool bTempFmt;
+                uint8_t uIndent;
+                char cIndent;
+        };
+
+        Formatter &operator<<( Formatter &f, const Fmt &fmt );
+        Formatter &operator<<( Formatter &f, Formatter::Special s );
+        Formatter &operator<<( Formatter &f, const char *sStr );
+        Formatter &operator<<( Formatter &f, char *sStr );
+        Formatter &operator<<( Formatter &f, const Bu::String &sStr );
+        Formatter &operator<<( Formatter &f, signed char c );
+        Formatter &operator<<( Formatter &f, char c );
+        Formatter &operator<<( Formatter &f, unsigned char c );
+        Formatter &operator<<( Formatter &f, signed short i );
+        Formatter &operator<<( Formatter &f, unsigned short i );
+        Formatter &operator<<( Formatter &f, signed int i );
+        Formatter &operator<<( Formatter &f, unsigned int i );
+        Formatter &operator<<( Formatter &f, signed long i );
+        Formatter &operator<<( Formatter &f, unsigned long i );
+        Formatter &operator<<( Formatter &f, signed long long i );
+        Formatter &operator<<( Formatter &f, unsigned long long i );
+        Formatter &operator<<( Formatter &f, float flt );
+        Formatter &operator<<( Formatter &f, double flt );
+        Formatter &operator<<( Formatter &f, long double flt );
+        Formatter &operator<<( Formatter &f, bool b );
+
+        Formatter &operator>>( Formatter &f, Bu::String &sStr );
+        Formatter &operator>>( Formatter &f, signed char &c );
+        Formatter &operator>>( Formatter &f, char &c );
+        Formatter &operator>>( Formatter &f, unsigned char &c );
+        Formatter &operator>>( Formatter &f, signed short &i );
+        Formatter &operator>>( Formatter &f, unsigned short &i );
+        Formatter &operator>>( Formatter &f, signed int &i );
+        Formatter &operator>>( Formatter &f, unsigned int &i );
+        Formatter &operator>>( Formatter &f, signed long &i );
+        Formatter &operator>>( Formatter &f, unsigned long &i );
+        Formatter &operator>>( Formatter &f, signed long long &i );
+        Formatter &operator>>( Formatter &f, unsigned long long &i );
+        Formatter &operator>>( Formatter &f, float &flt );
+        Formatter &operator>>( Formatter &f, double &flt );
+        Formatter &operator>>( Formatter &f, long double &flt );
+        Formatter &operator>>( Formatter &f, bool &b );
+
+        template<typename type>
+        Formatter &operator<<( Formatter &f, const type *p )
+        {
+                return f << "0x" << Fmt::hex(sizeof(ptrdiff_t)*2) << (ptrdiff_t)(p);
+        }
+};
+
+#endif
diff --git a/src/stable/formula.cpp b/src/stable/formula.cpp
new file mode 100644
index 0000000..ac435ed
--- /dev/null
+++ b/src/stable/formula.cpp
@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/formula.h"
+
+namespace Bu
+{
+        subExceptionDef( FormulaException );
+}
+
diff --git a/src/stable/formula.h b/src/stable/formula.h
new file mode 100644
index 0000000..687e6c3
--- /dev/null
+++ b/src/stable/formula.h
@@ -0,0 +1,430 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef FORMULA_H
+#define FORMULA_H
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <math.h>
+//#include "sbuffer.h"
+
+#include "bu/stack.h"
+#include "bu/exceptionbase.h"
+#include "bu/hash.h"
+#include "bu/string.h"
+
+namespace Bu
+{
+        subExceptionDecl( FormulaException );
+        /**
+         * Implements a very simple formula parser that allows use of variables and
+         * custom functions.  This is based on a simple calculator-type parser that
+         * executes as it processes, accounting for operator precedence and
+         * grouping.
+         *
+         * prec = precision, a type to use for all math (except binary ops)
+         * bin = binary type, a type to hard cast all data to for binary ops
+         */
+        template<typename prec, typename bin=uint32_t>
+        class Formula
+        {
+        public:
+                class Func
+                {
+                public:
+                        virtual prec operator()( prec )=0;
+                };
+
+                typedef Hash<Bu::String, prec> varHash;
+                typedef Hash<Bu::String, Func *> funcHash;
+
+                Formula()
+                {
+                }
+
+                virtual ~Formula()
+                {
+                        for( typename funcHash::iterator i = hFunc.begin();
+                                 i != hFunc.end(); i++ )
+                        {
+                                delete (*i);
+                        }
+                }
+
+                prec run( const Bu::String &sFormulaSrc )
+                {
+                        if( sFormulaSrc.isEmpty() )
+                                throw FormulaException("Empty formula, nothing to do.");
+                        try
+                        {
+                                const char *sFormula = sFormulaSrc.getStr();
+                                for(;;)
+                                {
+                                        uint8_t tNum = nextToken( &sFormula );
+                                        if( tNum == symSubtract )
+                                        {
+                                                sOper.push( symNegate );
+                                                continue;
+                                        }
+                                        else if( tNum == symNot )
+                                        {
+                                                sOper.push( symNot );
+                                                continue;
+                                        }
+                                        else if( tNum == symOpenParen )
+                                        {
+                                                sOper.push( tNum );
+                                                continue;
+                                        }
+                                        else if( tNum == symFunction )
+                                        {
+                                                sOper.push( symFunction );
+                                                continue;
+                                        }
+                                        else if( tNum == symEOS )
+                                        {
+                                                throw Bu::FormulaException(
+                                                        "Cannot end with an operator.");
+                                        }
+
+                        oppart: uint8_t tOpr = nextToken( &sFormula );
+                                        if( tOpr == symEOS )
+                                        {
+                                                reduce();
+                                                prec ret = sValue.top();
+                                                sValue.clear();
+                                                sFunc.clear();
+                                                sOper.clear();
+                                                return ret;
+                                        }
+                                        if( !sOper.isEmpty() && getPrec( sOper.top() ) >
+                                                getPrec( tOpr ) )
+                                        {
+                                                reduce();
+                                        }
+                                        if( tOpr != symCloseParen )
+                                        {
+                                                sOper.push( tOpr );
+                                        }
+                                        else
+                                        {
+                                                reduce( true );
+                                                goto oppart;
+                                        }
+                                }
+                        }
+                        catch( ... )
+                        {
+                                sValue.clear();
+                                sFunc.clear();
+                                sOper.clear();
+                                throw;
+                        }
+                }
+
+                varHash hVars;
+                funcHash hFunc;
+
+        private:
+                enum
+                {
+                        symEOS,
+                        symAdd,
+                        symSubtract,
+                        symMultiply,
+                        symDivide,
+                        symOpenParen,
+                        symCloseParen,
+                        symNumber,
+                        symVariable,
+                        symFunction,
+                        symExponent,
+                        symNegate,
+                        symModulus,
+
+                        symAnd,
+                        symOr,
+                        symXor,
+                        symNot
+                };
+
+                typedef uint8_t symType;
+
+                Bu::Stack<symType> sOper;
+                Bu::Stack<prec> sValue;
+                Bu::Stack<Bu::String> sFunc;
+
+        private:
+                symType getPrec( symType nOper )
+                {
+                        switch( nOper )
+                        {
+                                case symNumber:
+                                case symVariable:
+                                case symOpenParen:
+                                case symCloseParen:
+                                        return 0;
+
+                                case symAdd:
+                                case symSubtract:
+                                        return 1;
+
+                                case symMultiply:
+                                case symDivide:
+                                case symModulus:
+                                        return 2;
+
+                                case symAnd:
+                                case symOr:
+                                case symXor:
+                                        return 2;
+
+                                case symExponent:
+                                case symNot:
+                                case symNegate:
+                                case symFunction:
+                                        return 3;
+
+                                default:
+                                        return 0;
+                        }
+                }
+
+                symType nextToken( const char **sBuf )
+                {
+                        for(;;)
+                        {
+                                char cbuf = **sBuf;
+                                ++(*sBuf);
+                                switch( cbuf )
+                                {
+                                        case '+':
+                                                return symAdd;
+
+                                        case '-':
+                                                return symSubtract;
+
+                                        case '*':
+                                                return symMultiply;
+
+                                        case '/':
+                                                return symDivide;
+
+                                        case '^':
+                                                return symExponent;
+
+                                        case '%':
+                                                return symModulus;
+
+                                        case '(':
+                                                return symOpenParen;
+
+                                        case ')':
+                                                return symCloseParen;
+
+                                        case '|':
+                                                return symOr;
+
+                                        case '&':
+                                                return symAnd;
+
+                                        case '#':
+                                                return symXor;
+
+                                        case '~':
+                                                return symNot;
+
+                                        case ' ':
+                                        case '\t':
+                                        case '\n':
+                                        case '\r':
+                                                break;
+
+                                        case '\0':
+                                                return symEOS;
+
+                                        default:
+                                                if( cbuf == '.' || (cbuf >= '0' && cbuf <= '9') )
+                                                {
+                                                        char num[50]={cbuf};
+                                                        int nPos = 1;
+                                                        bool bDot = false;
+
+                                                        for(;;)
+                                                        {
+                                                                cbuf = **sBuf;
+                                                                if( cbuf == '.' )
+                                                                {
+                                                                        if( bDot == false )
+                                                                                bDot = true;
+                                                                        else
+                                                                                throw FormulaException(
+                                                                                        "Numbers cannot have more than one "
+                                                                                        ". in them."
+                                                                                        );
+                                                                }
+                                                                if( cbuf == '.' ||
+                                                                        (cbuf >= '0' && cbuf <= '9') )
+                                                                {
+                                                                        num[nPos++] = cbuf;
+                                                                }
+                                                                else
+                                                                {
+                                                                        num[nPos] = '\0';
+                                                                        sValue.push(
+                                                                                static_cast<prec>(
+                                                                                        strtod( num, NULL )
+                                                                                        )
+                                                                                );
+                                                                        return symNumber;
+                                                                }
+                                                                ++(*sBuf);
+                                                        }
+                                                }
+                                                else if( (cbuf >= 'a' && cbuf <= 'z') || 
+                                                                 (cbuf >= 'A' && cbuf <= 'Z') ||
+                                                                 (cbuf == '_') )
+                                                {
+                                                        char tok[50]={cbuf};
+                                                        int nPos = 1;
+
+                                                        for(;;)
+                                                        {
+                                                                cbuf = **sBuf;
+                                                                if( (cbuf >= 'a' && cbuf <= 'z') || 
+                                                                        (cbuf >= 'A' && cbuf <= 'Z') ||
+                                                                        (cbuf >= '0' && cbuf <= '9') ||
+                                                                        cbuf == '_' || cbuf == '.' || cbuf == ':' )
+                                                                {
+                                                                        tok[nPos++] = cbuf;
+                                                                }
+                                                                else
+                                                                {
+                                                                        tok[nPos] = '\0';
+                                                                        if( hVars.has( tok ) )
+                                                                        {
+                                                                                sValue.push( hVars[tok] );
+                                                                                return symNumber;
+                                                                        }
+                                                                        else if( hFunc.has( tok ) )
+                                                                        {
+                                                                                sFunc.push( tok );
+                                                                                return symFunction;
+                                                                        }
+                                                                        else
+                                                                        {
+                                                                                throw FormulaException(
+                                                                                        "No variable or function named "
+                                                                                        "\"%s\" exists.",
+                                                                                        tok
+                                                                                        );
+                                                                        }
+                                                                }
+                                                                ++(*sBuf);
+                                                        }
+                                                }
+                                                break;
+                                }
+                        }
+                }
+
+                void reduce( bool bCloseParen = false )
+                {
+                        while( !sOper.isEmpty() )
+                        {
+                                uint8_t nOpr = sOper.top();
+                                if( nOpr == symOpenParen )
+                                {
+                                        if( bCloseParen == true )
+                                                sOper.pop();
+                                        return;
+                                }
+                                sOper.pop();
+
+                                prec dTop = sValue.top();
+                                sValue.pop();
+
+                                switch( nOpr )
+                                {
+                                        case symAdd:
+                                                sValue.top() += dTop;
+                                                break;
+
+                                        case symSubtract:
+                                                sValue.top() -= dTop;
+                                                break;
+
+                                        case symMultiply:
+                                                sValue.top() *= dTop;
+                                                break;
+
+                                        case symDivide:
+                                                sValue.top() /= dTop;
+                                                break;
+
+                                        case symExponent:
+                                                sValue.top() = static_cast<prec>(
+                                                                pow( sValue.top(), dTop )
+                                                        );
+                                                break;
+
+                                        case symModulus:
+                                                sValue.top() = static_cast<prec>(
+                                                                fmod( sValue.top(), dTop )
+                                                        );
+                                                break;
+
+                                        case symOr:
+                                                sValue.top() = static_cast<prec>(
+                                                                static_cast<bin>(sValue.top()) |
+                                                                static_cast<bin>(dTop)
+                                                        );
+                                                break;
+                                        
+                                        case symAnd:
+                                                sValue.top() = static_cast<prec>(
+                                                                static_cast<bin>(sValue.top()) &
+                                                                static_cast<bin>(dTop)
+                                                        );
+                                                break;
+                                        
+                                        case symXor:
+                                                sValue.top() = static_cast<prec>(
+                                                                static_cast<bin>(sValue.top()) ^
+                                                                static_cast<bin>(dTop)
+                                                        );
+                                                break;
+
+                                        case symFunction:
+                                                sValue.push( (*hFunc.get( sFunc.pop() ))( dTop ) );
+                                                break;
+
+                                        case symNegate:
+                                                sValue.push( -dTop );
+                                                break;
+
+                                        case symNot:
+                                                sValue.push( static_cast<prec>(
+                                                                ~static_cast<bin>(dTop)
+                                                        ) );
+                                                break;
+                                }
+                        }
+
+                        if( bCloseParen == true )
+                        {
+                                throw FormulaException(
+                                        "Close-paren found without matching open-paren."
+                                        );
+                        }
+                }
+        };
+}
+
+#endif
diff --git a/src/stable/hash.cpp b/src/stable/hash.cpp
new file mode 100644
index 0000000..59572ec
--- /dev/null
+++ b/src/stable/hash.cpp
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/hash.h"
+
+namespace Bu { subExceptionDef( HashException ) }
+
+template<>
+uint32_t Bu::__calcHashCode<const char *>( const char * const &k )
+{
+        if (k == NULL)
+        {
+                return 0;
+        }
+        
+        unsigned long int nPos = 0;
+        for( const char *s = k; *s; s++ )
+        {
+                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
+        }
+
+        return nPos;
+}
+
+template<> bool Bu::__cmpHashKeys<const char *>( const char * const &a, const char * const &b )
+{
+        if( a == b )
+                return true;
+
+        for(int j=0; a[j] == b[j]; j++ )
+                if( a[j] == '\0' )
+                        return true;
+
+        return false;
+}
+
+template<>
+uint32_t Bu::__calcHashCode<char *>( char * const &k )
+{
+        if (k == NULL)
+        {
+                return 0;
+        }
+        
+        unsigned long int nPos = 0;
+        for( const char *s = k; *s; s++ )
+        {
+                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
+        }
+
+        return nPos;
+}
+
+template<> bool Bu::__cmpHashKeys<char *>( char * const &a, char * const &b )
+{
+        if( a == b )
+                return true;
+
+        for(int j=0; a[j] == b[j]; j++ )
+                if( a[j] == '\0' )
+                        return true;
+
+        return false;
+}
+
diff --git a/src/stable/hash.h b/src/stable/hash.h
new file mode 100644
index 0000000..71aec73
--- /dev/null
+++ b/src/stable/hash.h
@@ -0,0 +1,1306 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_HASH_H
+#define BU_HASH_H
+
+#include <memory>
+#include "bu/exceptionbase.h"
+#include "bu/list.h"
+#include "bu/util.h"
+#include "bu/archivebase.h"
+#include "bu/sharedcore.h"
+
+namespace Bu
+{
+        subExceptionDecl( HashException )
+
+        enum eHashException
+        {
+                excodeNotFilled
+        };
+
+        template<typename T>
+        uint32_t __calcHashCode( const T &k );
+
+        template<typename T>
+        bool __cmpHashKeys( const T &a, const T &b );
+
+        /**
+         * Default functor used to compute the size of hash tables.  This version
+         * effectively doubles the size of the table when space is low, ensuring
+         * that you always wind up with an odd number for the table size.  A
+         * better but slower option is to always find the next prime number that's
+         * above double your current table size, but that has the potential to be
+         * slower.
+         */
+        struct __calcNextTSize_fast
+        {
+                uint32_t operator()( uint32_t nCapacity, uint32_t nFilled,
+                                uint32_t nDeleted ) const
+                {
+                        // This frist case will allow hashtables that are mostly deleted
+                        // items to reset to small allocations
+                        if( nFilled-nDeleted <= nCapacity/4 )
+                        {
+                                nCapacity = 11;
+                                while( nCapacity < nFilled*5/4 )
+                                        nCapacity = nCapacity*2+1;
+                                return nCapacity;
+                        }
+                        // This will hopefully prevent hash tables from growing needlessly
+                        if( nFilled-nDeleted <= nCapacity/2 )
+                                return nCapacity;
+                        // Otherwise, just increase the capacity
+                        return nCapacity*2+1;
+                }
+        };
+
+        template<typename totype>
+        int bitsTo( int iCount )
+        {
+                return ( (iCount/(sizeof(totype)*8))
+                                + (iCount%(sizeof(totype)*8)>0 ? 1 : 0));
+        }
+
+        template<typename key, typename value, typename sizecalc, typename keyalloc,
+                typename valuealloc, typename challoc>
+        class Hash;
+
+        /** @cond DEVEL */
+        template<typename key, typename value, typename sizecalc, typename keyalloc,
+                typename valuealloc, typename challoc >
+        class HashCore
+        {
+        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+        friend class SharedCore<
+                Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>,
+                HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc>
+                >;
+        private:
+                HashCore() :
+                        nCapacity( 0 ),
+                        nFilled( 0 ),
+                        nDeleted( 0 ),
+                        bFilled( NULL ),
+                        bDeleted( NULL ),
+                        aKeys( NULL ),
+                        aValues( NULL ),
+                        aHashCodes( NULL )
+                {
+                }
+
+                virtual ~HashCore()
+                {
+                        clear();
+                }
+
+                void init()
+                {
+                        if( nCapacity > 0 )
+                                return;
+
+                        nCapacity = 11;
+                        nKeysSize = bitsTo<uint32_t>( nCapacity );
+                        bFilled = ca.allocate( nKeysSize );
+                        bDeleted = ca.allocate( nKeysSize );
+                        clearBits();
+
+                        aHashCodes = ca.allocate( nCapacity );
+                        aKeys = ka.allocate( nCapacity );
+                        aValues = va.allocate( nCapacity );
+                }
+
+                void clearBits()
+                {
+                        if( nCapacity == 0 )
+                                return;
+
+                        for( uint32_t j = 0; j < nKeysSize; j++ )
+                        {
+                                bFilled[j] = bDeleted[j] = 0;
+                        }
+                }
+
+                void fill( uint32_t loc, const key &k, const value &v, uint32_t hash )
+                {
+                        init();
+
+                        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 );
+                }
+
+                void _erase( uint32_t loc )
+                {
+                        if( nCapacity == 0 )
+                                return;
+
+                        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 );
+                }
+
+                key &getKeyAtPos( uint32_t nPos )
+                {
+                        if( nPos >= nCapacity )
+                                throw HashException("Referenced position invalid.");
+                        return aKeys[nPos];
+                }
+                
+                const key &getKeyAtPos( uint32_t nPos ) const
+                {
+                        if( nPos >= nCapacity )
+                                throw HashException("Referenced position invalid.");
+                        return aKeys[nPos];
+                }
+                
+                value &getValueAtPos( uint32_t nPos )
+                {
+                        if( nPos >= nCapacity )
+                                throw HashException("Referenced position invalid.");
+                        return aValues[nPos];
+                }
+                
+                const value &getValueAtPos( uint32_t nPos ) const
+                {
+                        if( nPos >= nCapacity )
+                                throw HashException("Referenced position invalid.");
+                        return aValues[nPos];
+                }
+
+                uint32_t getFirstPos( bool &bFinished ) const
+                {
+                        for( uint32_t j = 0; j < nCapacity; j++ )
+                        {
+                                if( isFilled( j ) )
+                                        if( !isDeleted( j ) )
+                                                return j;
+                        }
+
+                        bFinished = true;
+                        return 0;
+                }
+
+                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;
+                        }
+
+                        bFinished = true;
+                        return 0;
+                }
+
+                uint32_t probe( uint32_t hash, const key &k, bool &bFill, bool rehash=true )
+                {
+                        init();
+
+                        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
+                        int8_t j;
+                        for( 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;
+                                        }
+                                }
+                        }
+
+                        // This is our insurance, if the table is full, then go ahead and
+                        // rehash, then try again.
+                        if( (isFilled( nCur ) || j == 32) && rehash == true )
+                        {
+                                reHash( szCalc( nCapacity, nFilled, nDeleted ) );
+
+                                // This is potentially dangerous, and could cause an infinite loop.
+                                // Be careful writing probe, eh?
+                                return probe( hash, k, bFill );
+                        }
+
+                        bFill = false;
+                        return nCur;
+                }
+                
+                uint32_t probe( uint32_t hash, key k, bool &bFill ) const
+                {
+                        if( nCapacity == 0 )
+                                throw Bu::ExceptionBase("Probe in empty hash table.");
+
+                        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;
+                                        }
+                                }
+                        }
+
+                        bFill = false;
+                        return nCur;
+                }
+                
+                void insert( const key &k, const value &v )
+                {
+                        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 );
+                        }
+                        else
+                        {
+                                fill( nPos, k, v, hash );
+                        }
+                }
+
+                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 = bitsTo<uint32_t>( nCapacity );
+                
+                        // Allocate new memory + prep
+                        bFilled = ca.allocate( nKeysSize );
+                        bDeleted = ca.allocate( nKeysSize );
+                        clearBits();
+
+                        aHashCodes = ca.allocate( nCapacity );
+                        aKeys = ka.allocate( nCapacity );
+                        aValues = va.allocate( nCapacity );
+
+                        nDeleted = nFilled = 0;
+
+                        // 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] );
+                                }
+                        }
+
+                        // Delete all of the old data
+                        for( uint32_t j = 0; j < nOldCapacity; j++ )
+                        {
+                                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
+                                        (bOldDeleted[j/32]&(1<<(j%32)))==0 )
+                                {
+                                        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 );
+                }
+
+                bool isFilled( uint32_t loc ) const
+                {
+                        if( loc >= nCapacity )
+                                throw HashException("Referenced position invalid.");
+                        return (bFilled[loc/32]&(1<<(loc%32)))!=0;
+                }
+
+                bool isDeleted( uint32_t loc ) const
+                {
+                        if( loc >= nCapacity )
+                                throw HashException("Referenced position invalid.");
+                        return (bDeleted[loc/32]&(1<<(loc%32)))!=0;
+                }
+
+                void clear()
+                {
+                        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 );
+                        
+                        bFilled = NULL;
+                        bDeleted = NULL;
+                        aKeys = NULL;
+                        aValues = NULL;
+                        aHashCodes = NULL;
+                        
+                        nCapacity = 0;
+                        nFilled = 0;
+                        nDeleted = 0;
+                }
+
+                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;
+        };
+        /** @endcond */
+
+        /**
+         * Libbu++ Template Hash Table.  This is your average hash table, that uses
+         * template functions in order to do fast, efficient, generalized hashing.
+         * It's pretty easy to use, and works well with all other libbu++ types so
+         * far.
+         *
+         * In order to use it, I recommend the following for all basic usage:
+         *@code
+         // Define a Hash typedef with strings as keys and ints as values.
+         typedef Bu::Hash<Bu::String, int> StrIntHash;
+
+         // Create one
+         StrIntHash hInts;
+
+         // Insert some integers
+         hInts["one"] = 1;
+         hInts["forty-two"] = 42;
+         hInts.insert("forty two", 42 );
+
+         // Get values out of the hash, the last two options are the most explicit,
+         // and must be used if the hash's value type does not match what you're
+         // comparing to exactly.
+         if( hInts["one"] == 1 ) doSomething();
+         if( hInts["forty-two"].value() == 42 ) doSomething();
+         if( hInts.get("forty two") == 42 ) doSomething();
+
+         // Iterate through the Hash
+         for( StrIntHash::iterator i = hInts.begin(); i != hInts.end(); i++ )
+         {
+                // i.getValue() works too
+                print("'%s' = %d\n", i.getKey().getStr(), (*i) );
+         }
+                                                                                                        
+         @endcode
+         *@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
+         *@ingroup Containers
+         */
+        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 SharedCore<
+                                 Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>,
+                                 HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc>
+                                 >
+        {
+        private:
+                typedef class HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc> Core;
+                typedef class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> MyType;
+        protected:
+                using SharedCore<MyType, Core>::core;
+                using SharedCore<MyType, Core>::_hardCopy;
+                using SharedCore<MyType, Core>::_resetCore;
+                using SharedCore<MyType, Core>::_allocateCore;
+        
+        public:
+                Hash()
+                {
+                }
+
+                Hash( const MyType &src ) :
+                        SharedCore<MyType, Core >( src )
+                {
+                }
+
+                virtual ~Hash()
+                {
+                }
+
+                /**
+                 * Get the current hash table capacity. (Changes at re-hash)
+                 *@returns (uint32_t) The current capacity.
+                 */
+                uint32_t getCapacity() const
+                {
+                        return core->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() const
+                {
+                        return core->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 getSize() const
+                {
+                        return core->nFilled-core->nDeleted;
+                }
+
+                bool isEmpty() const
+                {
+                        return (core->nFilled-core->nDeleted) == 0;
+                }
+
+                /**
+                 * 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() const
+                {
+                        return core->nDeleted;
+                }
+
+                struct HashProxy
+                {
+                friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+                private:
+                        HashProxy( MyType &h, const key *k, uint32_t nPos, uint32_t hash ) :
+                                hsh( h ),
+                                pKey( k ),
+                                nPos( nPos ),
+                                hash( hash ),
+                                bFilled( false )
+                        {
+                        }
+
+                        HashProxy( MyType &h, uint32_t nPos, value *pValue ) :
+                                hsh( h ),
+                                nPos( nPos ),
+                                pValue( pValue ),
+                                bFilled( true )
+                        {
+                        }
+
+                        MyType &hsh;
+                        const key *pKey;
+                        uint32_t nPos;
+                        value *pValue;
+                        uint32_t hash;
+                        bool bFilled;
+
+                public:
+                        /**
+                         * Cast operator for HashProxy.
+                         *@returns (value_type &) The value the HashProxy is pointing to.
+                         */
+                        operator value &()
+                        {
+                                if( bFilled == false )
+                                        throw HashException(
+                                                        excodeNotFilled,
+                                                        "No data assosiated with that key."
+                                                        );
+                                return *pValue;
+                        }
+
+                        /**
+                         * Direct function for retrieving a value out of the HashProxy.
+                         *@returns (value_type &) The value pointed to by this HashProxy.
+                         */
+                        value &getValue()
+                        {
+                                if( bFilled == false )
+                                        throw HashException(
+                                                        excodeNotFilled,
+                                                        "No data assosiated with that key."
+                                                        );
+                                return *pValue;
+                        }
+
+                        /**
+                         * Whether this HashProxy points to something real or not.
+                         */
+                        bool isFilled()
+                        {
+                                return bFilled;
+                        }
+
+                        /**
+                         * Erase the data pointed to by this HashProxy.
+                         */
+                        void erase()
+                        {
+                                if( bFilled )
+                                {
+                                        hsh.core->_erase( nPos );
+                                }
+                        }
+
+                        /**
+                         * Assign data to this point in the hash table.
+                         *@param nval (value_type) the data to assign.
+                         */
+                        value operator=( value nval )
+                        {
+                                if( bFilled )
+                                {
+                                        hsh.core->va.destroy( &hsh.core->aValues[nPos] );
+                                        hsh.core->va.construct( &hsh.core->aValues[nPos], nval );
+                                }
+                                else
+                                {
+                                        hsh.core->fill( nPos, *pKey, nval, hash ); 
+                                }
+
+                                return nval;
+                        }
+
+                        /**
+                         * 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;
+                        }
+                };
+
+                /**
+                 * Hash table index operator
+                 *@param k (key_type) Key of data to be retrieved.
+                 *@returns (HashProxy) Proxy pointing to the data.
+                 */
+                HashProxy operator[]( const key &k )
+                {
+                        _hardCopy();
+
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = core->probe( hash, k, bFill );
+
+                        if( bFill )
+                        {
+                                return HashProxy( *this, nPos, &core->aValues[nPos] );
+                        }
+                        else
+                        {
+                                return HashProxy( *this, &k, nPos, hash );
+                        }
+                }
+
+                /**
+                 * 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.
+                 */
+                void insert( const key &k, const value &v )
+                {
+                        _hardCopy();
+
+                        core->insert( k, v );
+                }
+
+                /**
+                 * Remove a value from the hash table.
+                 *@param k (key_type) The data under this key will be erased.
+                 */
+                void erase( const key &k )
+                {
+                        _hardCopy();
+
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = core->probe( hash, k, bFill );
+
+                        if( bFill )
+                        {
+                                core->_erase( nPos );
+                        }
+                }
+
+                struct iterator;
+
+                /**
+                 * Remove a value from the hash pointed to from an iterator.
+                 *@param i (iterator &) The data to be erased.
+                 */
+                void erase( struct iterator &i )
+                {
+                        if( this != i.hsh )
+                                throw HashException("This iterator didn't come from this Hash.");
+                        
+                        _hardCopy();
+
+                        if( core->isFilled( i.nPos ) && !core->isDeleted( i.nPos ) )
+                        {
+                                core->_erase( i.nPos );
+                        }
+                }
+
+                /**
+                 * Remove all data from the hash table.
+                 */
+                virtual void clear()
+                {
+                        _resetCore();
+                }
+
+                /**
+                 * 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).
+                 */
+                value &get( const key &k )
+                {
+                        _hardCopy();
+
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = core->probe( hash, k, bFill, false );
+
+                        if( bFill )
+                        {
+                                return core->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).
+                 */
+                const value &get( const key &k ) const
+                {
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = core->probe( hash, k, bFill );
+
+                        if( bFill )
+                        {
+                                return core->aValues[nPos];
+                        }
+                        else
+                        {
+                                throw HashException(
+                                                excodeNotFilled,
+                                                "No data assosiated with that key."
+                                                );
+                        }
+                }
+
+                /**
+                 * 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).
+                 */
+                bool has( const key &k ) const
+                {
+                        bool bFill;
+                        core->probe( __calcHashCode( k ), k, bFill );
+
+                        return bFill;
+                }
+
+                /**
+                 * Iteration structure for iterating through the hash.
+                 */
+                typedef struct iterator
+                {
+                        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+                private:
+                        iterator( MyType *hsh ) :
+                                hsh( hsh ),
+                                nPos( 0 ),
+                                bFinished( false )
+                        {
+                                nPos = hsh->core->getFirstPos( bFinished );
+                        }
+                        
+                        iterator( MyType *hsh, bool bDone ) :
+                                hsh( hsh ),
+                                nPos( 0 ),
+                                bFinished( bDone )
+                        {
+                        }
+
+                        MyType *hsh;
+                        uint32_t nPos;
+                        bool bFinished;
+
+                public:
+                        iterator( const iterator &i ) :
+                                hsh( i.hsh ),
+                                nPos( i.nPos ),
+                                bFinished( i.bFinished )
+                        {
+                        }
+
+                        iterator() :
+                                hsh( NULL ),
+                                nPos( NULL ),
+                                bFinished( true )
+                        {
+                        }
+
+                        bool isValid() const
+                        {
+                                return !bFinished;
+                        }
+
+                        operator bool() const
+                        {
+                                return !bFinished;
+                        }
+
+                        /**
+                         * Iterator incrementation operator. Move the iterator forward.
+                         */
+                        iterator operator++( int )
+                        {
+                                if( bFinished == false )
+                                        nPos = hsh->core->getNextPos( nPos, bFinished );
+
+                                return *this;
+                        }
+                        
+                        /**
+                         * Iterator incrementation operator. Move the iterator forward.
+                         */
+                        iterator operator++()
+                        {
+                                if( bFinished == false )
+                                        nPos = hsh->core->getNextPos( nPos, bFinished );
+
+                                return *this;
+                        }
+
+                        /**
+                         * Iterator equality comparison operator. Iterators the same?
+                         */
+                        bool operator==( const iterator &oth ) const
+                        {
+                                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 iterator &oth ) const
+                        {
+                                return !(*this == oth );
+                        }
+
+                        /**
+                         * Iterator assignment operator.
+                         */
+                        iterator operator=( const iterator &oth )
+                        {
+                                hsh = oth.hsh;
+                                nPos = oth.nPos;
+                                bFinished = oth.bFinished;
+                                return *this;
+                        }
+
+                        /**
+                         * Iterator dereference operator... err.. get the value
+                         *@returns (value_type &) The value behind this iterator.
+                         */
+                        value &operator *()
+                        {
+                                hsh->_hardCopy();
+                                return hsh->core->getValueAtPos( nPos );
+                        }
+
+                        const value &operator *() const
+                        {
+                                return hsh->core->getValueAtPos( nPos );
+                        }
+                        
+                        /**
+                         * Get the key behind this iterator.
+                         *@returns (key_type &) The key behind this iterator.
+                         */
+                        const key &getKey() const
+                        {
+                                return hsh->core->getKeyAtPos( nPos );
+                        }
+
+                        /**
+                         * Get the value behind this iterator.
+                         *@returns (value_type &) The value behind this iterator.
+                         */
+                        value &getValue()
+                        {
+                                hsh->_hardCopy();
+                                return hsh->core->getValueAtPos( nPos );
+                        }
+
+                        /**
+                         * Get the value behind this iterator.
+                         *@returns (value_type &) The value behind this iterator.
+                         */
+                        const value &getValue() const
+                        {
+                                return hsh->core->getValueAtPos( nPos );
+                        }
+                } iterator;
+                
+                /**
+                 * Iteration structure for iterating through the hash (const).
+                 */
+                typedef struct const_iterator
+                {
+                        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+                private:
+                        const_iterator( const MyType *hsh ) :
+                                hsh( hsh ),
+                                nPos( 0 ),
+                                bFinished( false )
+                        {
+                                nPos = hsh->core->getFirstPos( bFinished );
+                        }
+                        
+                        const_iterator( const MyType *hsh, bool bDone ) :
+                                hsh( hsh ),
+                                nPos( 0 ),
+                                bFinished( bDone )
+                        {
+                        }
+
+                        const MyType *hsh;
+                        uint32_t nPos;
+                        bool bFinished;
+
+                public:
+                        const_iterator() :
+                                hsh( NULL ),
+                                nPos( 0 ),
+                                bFinished( true )
+                        {
+                        }
+
+                        const_iterator( const const_iterator &src ) :
+                                hsh( src.hsh ),
+                                nPos( src.nPos ),
+                                bFinished( src.bFinished )
+                        {
+                        }
+
+                        const_iterator( const iterator &src ) :
+                                hsh( src.hsh ),
+                                nPos( src.nPos ),
+                                bFinished( src.bFinished )
+                        {
+                        }
+
+                        bool isValid() const
+                        {
+                                return !bFinished;
+                        }
+
+                        operator bool() const
+                        {
+                                return !bFinished;
+                        }
+
+                        /**
+                         * Iterator incrementation operator. Move the iterator forward.
+                         */
+                        const_iterator operator++( int )
+                        {
+                                if( bFinished == false )
+                                        nPos = hsh->core->getNextPos( nPos, bFinished );
+
+                                return *this;
+                        }
+                        
+                        /**
+                         * Iterator incrementation operator. Move the iterator forward.
+                         */
+                        const_iterator operator++()
+                        {
+                                if( bFinished == false )
+                                        nPos = hsh->core->getNextPos( nPos, bFinished );
+
+                                return *this;
+                        }
+
+                        /**
+                         * Iterator equality comparison operator. Iterators the same?
+                         */
+                        bool operator==( const const_iterator &oth ) const
+                        {
+                                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 ) const
+                        {
+                                return !(*this == oth );
+                        }
+
+                        /**
+                         * Iterator assignment operator.
+                         */
+                        const_iterator operator=( const const_iterator &oth )
+                        {
+                                hsh = oth.hsh;
+                                nPos = oth.nPos;
+                                bFinished = oth.bFinished;
+                                return *this;
+                        }
+
+                        /**
+                         * Iterator dereference operator... err.. get the value
+                         *@returns (value_type &) The value behind this iterator.
+                         */
+                        const value &operator *() const
+                        {
+                                return hsh->core->getValueAtPos( nPos );
+                        }
+                        
+                        /**
+                         * Get the key behind this iterator.
+                         *@returns (key_type &) The key behind this iterator.
+                         */
+                        const key &getKey() const
+                        {
+                                return hsh->core->getKeyAtPos( nPos );
+                        }
+
+                        /**
+                         * Get the value behind this iterator.
+                         *@returns (value_type &) The value behind this iterator.
+                         */
+                        const value &getValue() const
+                        {
+                                return hsh->core->getValueAtPos( nPos );
+                        }
+                } const_iterator;
+
+                /**
+                 * 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()
+                {
+                        return iterator( this );
+                }
+                
+                const_iterator begin() const
+                {
+                        return const_iterator( this );
+                }
+                
+                /**
+                 * 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()
+                {
+                        return iterator( this, true );
+                }
+                
+                const_iterator end() const
+                {
+                        return const_iterator( this, true );
+                }
+
+                /**
+                 * 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
+                {
+                        Bu::List<key> lKeys;
+
+                        for( uint32_t j = 0; j < core->nCapacity; j++ )
+                        {
+                                if( core->isFilled( j ) )
+                                {
+                                        if( !core->isDeleted( j ) )
+                                        {
+                                                lKeys.append( core->aKeys[j] );
+                                        }
+                                }
+                        }
+
+                        return lKeys;
+                }
+                
+                Bu::List<value> getValues() const
+                {
+                        Bu::List<value> lValues;
+
+                        for( uint32_t j = 0; j < core->nCapacity; j++ )
+                        {
+                                if( core->isFilled( j ) )
+                                {
+                                        if( !core->isDeleted( j ) )
+                                        {
+                                                lValues.append( core->aValues[j] );
+                                        }
+                                }
+                        }
+
+                        return lValues;
+                }
+
+                bool operator==( const MyType &rhs ) const
+                {
+                        if( this == &rhs )
+                                return true;
+                        if( core == rhs.core )
+                                return true;
+                        if( core == NULL || rhs.core == NULL )
+                                return false;
+                        if( getSize() != rhs.getSize() )
+                                return false;
+
+                        for( uint32_t j = 0; j < core->nCapacity; j++ )
+                        {
+                                if( core->isFilled( j ) )
+                                {
+                                        if( !core->isDeleted( j ) )
+                                        {
+                                                // Check to see if this key is in the other hash
+                                                if( rhs.has( core->aKeys[j] ) )
+                                                {
+                                                        if( !(core->aValues[j] == rhs.get( core->aKeys[j]) ) )
+                                                        {
+                                                                return false;
+                                                        }
+                                                }
+                                                else
+                                                {
+                                                        return false;
+                                                }
+                                        }
+                                }
+                        }
+
+                        return true;
+                }
+
+                bool operator!=( const MyType &rhs ) const
+                {
+                        return !(*this == rhs);
+                }
+
+        protected:
+                virtual Core *_copyCore( Core *src )
+                {
+                        Core *pRet = _allocateCore();
+
+                        pRet->nFilled = 0;
+                        pRet->nDeleted = 0;
+                        pRet->nCapacity = src->nCapacity;
+                        pRet->nKeysSize = bitsTo<uint32_t>( pRet->nCapacity );
+                        pRet->bFilled = pRet->ca.allocate( pRet->nKeysSize );
+                        pRet->bDeleted = pRet->ca.allocate( pRet->nKeysSize );
+                        pRet->clearBits();
+
+                        pRet->aHashCodes = pRet->ca.allocate( pRet->nCapacity );
+                        pRet->aKeys = pRet->ka.allocate( pRet->nCapacity );
+                        pRet->aValues = pRet->va.allocate( pRet->nCapacity );
+
+                        for( uint32_t j = 0; j < src->nCapacity; j++ )
+                        {
+                                if( src->isFilled( j ) && !src->isDeleted( j ) )
+                                {
+                                        pRet->insert( src->aKeys[j], src->aValues[j] );
+                                }
+                        }
+
+                        return pRet;
+                }
+        };
+        
+        template<typename T> uint32_t __calcHashCode( const T &k )
+        {
+                return static_cast<uint32_t>( k );
+        }
+
+        template<typename T> bool __cmpHashKeys( const T &a, const T &b )
+        {
+                return (a == 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 );
+
+        class Formatter;
+        Formatter &operator<<( Formatter &rOut, char *sStr );
+        Formatter &operator<<( Formatter &rOut, signed char c );
+        template<typename key, typename value>
+        Formatter &operator<<( Formatter &f, const Bu::Hash<key, value> &l )
+        {
+                f << '{';
+                for( typename Bu::Hash<key,value>::const_iterator i = l.begin(); i; i++ )
+                {
+                        if( i != l.begin() )
+                                f << ", ";
+                        f << i.getKey() << ": " << i.getValue();
+                }
+                f << '}';
+
+                return f;
+        }
+
+        template<typename key, typename value, typename a, typename b,
+                typename c, typename d>
+        ArchiveBase &operator<<( ArchiveBase &ar, const Hash<key,value,a,b,c,d> &h )
+        {
+                long iSize = h.getSize();
+                ar << iSize;
+                for( typename Hash<key,value,a,b,c,d>::const_iterator i = h.begin(); i != h.end(); i++ )
+                {
+                        ar << (i.getKey());
+                        ar << (i.getValue());
+                }
+
+                return ar;
+        }
+
+        template<typename key, typename value, typename a, typename b,
+                typename c, typename d>
+        ArchiveBase &operator>>( ArchiveBase &ar, Hash<key,value,a,b,c,d> &h )
+        {
+                h.clear();
+                long nSize;
+                ar >> nSize;
+
+                for( long j = 0; j < nSize; j++ )
+                {
+                        key k; value v;
+                        ar >> k >> v;
+                        h.insert( k, v );
+                }
+
+                return ar;
+        }
+}
+
+#endif
diff --git a/src/stable/heap.cpp b/src/stable/heap.cpp
new file mode 100644
index 0000000..a2ffac2
--- /dev/null
+++ b/src/stable/heap.cpp
@@ -0,0 +1,10 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/heap.h"
+
+namespace Bu { subExceptionDef( HeapException ) }
diff --git a/src/stable/heap.h b/src/stable/heap.h
new file mode 100644
index 0000000..afe8be6
--- /dev/null
+++ b/src/stable/heap.h
@@ -0,0 +1,612 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_HEAP_H
+#define BU_HEAP_H
+
+#include <stddef.h>
+#include <memory>
+#include "bu/exceptionbase.h"
+#include "bu/util.h"
+#include "bu/queue.h"
+#include "bu/sharedcore.h"
+
+namespace Bu
+{
+        subExceptionDecl( HeapException );
+
+        template<typename item, typename cmpfunc, typename itemalloc>
+        class Heap;
+
+        /** @cond DEVEL */
+        template<typename item, typename cmpfunc, typename itemalloc>
+        class HeapCore
+        {
+        friend class Heap<item, cmpfunc, itemalloc>;
+        friend class SharedCore<
+                Heap<item, cmpfunc, itemalloc>, HeapCore<item, cmpfunc, itemalloc>
+                >;
+        private:
+                HeapCore() :
+                        iSize( 0 ),
+                        iFill( 0 ),
+                        aItem( NULL )
+                {
+                }
+
+                virtual ~HeapCore()
+                {
+                        clear();
+                }
+
+                void init()
+                {
+                        if( iSize > 0 )
+                                return;
+
+                        iSize = 7;
+                        iFill = 0;
+                        aItem = ia.allocate( iSize );
+                }
+
+                void init( int iCap )
+                {
+                        if( iSize > 0 )
+                                return;
+
+                        for( iSize = 1; iSize < iCap; iSize=iSize*2+1 ) { }
+                        iFill = 0;
+                        aItem = ia.allocate( iSize );
+                }
+
+                void clear()
+                {
+                        if( iSize == 0 )
+                                return;
+
+                        for( int j = 0; j < iFill; j++ )
+                                ia.destroy( &aItem[j] );
+                        ia.deallocate( aItem, iSize );
+                        aItem = NULL;
+                        iSize = 0;
+                        iFill = 0;
+                }
+                
+                void upSize()
+                {
+                        if( iSize == 0 )
+                        {
+                                init();
+                                return;
+                        }
+
+                        item *aNewItems = ia.allocate( iSize*2+1 );
+                        //
+                        // We cannot use a memcopy here because we don't know what kind
+                        // of datastructures are being used, we have to copy them one at
+                        // a time.
+                        //
+                        for( int j = 0; j < iFill; j++ )
+                        {
+                                ia.construct( &aNewItems[j], aItem[j] );
+                                ia.destroy( &aItem[j] );
+                        }
+                        ia.deallocate( aItem, iSize );
+                        aItem = aNewItems;
+                        iSize = iSize*2+1;
+                }
+                
+                virtual void enqueue( const item &it )
+                {
+                        item i = it; // TODO: This is a silly workaround, put the i item
+                                                 // at the end.
+                        if( iFill+1 >= iSize )
+                                upSize();
+
+                        for( int j = 0; j < iFill; )
+                        {
+                                if( cmp( i, aItem[j] ) )
+                                {
+                                        Bu::swap( i, aItem[j] );
+                                }
+
+                                if( j*2+1 >= iFill )
+                                        break;
+                                if( cmp( i, aItem[j*2+1] ) )
+                                {
+                                        j = j*2+1;
+                                }
+                                else
+                                {
+                                        j = j*2+2;
+                                }
+                        }
+                        ia.construct( &aItem[iFill], i );
+                        if( iFill > 0 )
+                        {
+                                for( int j = iFill; j >= 0; )
+                                {
+                                        int k = (j-1)/2;
+                                        if( j == k )
+                                                break;
+                                        if( cmp( aItem[k], aItem[j] ) )
+                                                break;
+
+                                        Bu::swap( aItem[k], aItem[j] );
+                                        j = k;
+                                }
+                        }
+                        iFill++;
+                }
+
+                virtual item dequeue()
+                {
+                        if( iFill == 0 )
+                                throw HeapException("Heap empty.");
+                        item iRet = aItem[0];
+                        int j;
+                        for( j = 0; j < iFill; )
+                        {
+                                int k = j*2+1;
+                                if( k+1 < iFill && cmp( aItem[k+1], aItem[k] ) )
+                                {
+                                        if( k+1 < iFill-1 && cmp( aItem[iFill-1], aItem[k+1] ) )
+                                                break;
+                                        aItem[j] = aItem[k+1];
+                                        j = k+1;
+                                }
+                                else if( k < iFill )
+                                {
+                                        if( k < iFill-1 && cmp( aItem[iFill-1], aItem[k] ) )
+                                                break;
+                                        aItem[j] = aItem[k];
+                                        j = k;
+                                }
+                                else
+                                        break;
+                        }
+                        if( j < iFill-1 )
+                                aItem[j] = aItem[iFill-1];
+                        ia.destroy( &aItem[iFill-1] );
+                        iFill--;
+
+                        return iRet;
+                }
+
+        private:
+                int iSize;
+                int iFill;
+                item *aItem;
+                cmpfunc cmp;
+                itemalloc ia;
+        };
+        /** @endcond */
+
+        /**
+         * A priority queue that allows for an unlimited number of priorities.  All
+         * objects enqueued must support less-than-comparison.  Then every time an
+         * item is dequeued it is always the least item in the heap.  The heap
+         * operates using a binary tree for storage, which allows most operations
+         * to be very fast.  Enqueueing and dequeueing are both O(log(N)) operatoins
+         * whereas peeking is constant time.
+         *
+         * This heap implementation allows iterating, however please note that any
+         * enqueue or dequeue operation will invalidate the iterator and make it
+         * unusable (if it still works, you shouldn't trust the results).  Also,
+         * the items are not stored in memory in order, they are optomized into a
+         * tree.  This means that the items will be in effectively random order
+         * while iterating through them, and the order cannot be trusted.  Also,
+         * modifying an item in the heap will not cause that item to be re-sorted.
+         * If you want to change the position of an item in the heap you will have
+         * to dequeue every item before it, dequeue that item, change it, and
+         * re-enqueue all of the items removed.
+         */
+        template<typename item, typename cmpfunc=__basicLTCmp<item>, typename itemalloc=std::allocator<item> >
+        class Heap : public Queue<item>, public SharedCore<
+                                 Heap<item, cmpfunc, itemalloc>,
+                                 HeapCore<item, cmpfunc, itemalloc>
+                                 >
+        {
+        private:
+                typedef class Heap<item,cmpfunc,itemalloc> MyType;
+                typedef class HeapCore<item,cmpfunc,itemalloc> Core;
+
+        protected:
+                using SharedCore<MyType, Core>::core;
+                using SharedCore<MyType, Core>::_hardCopy;
+                using SharedCore<MyType, Core>::_resetCore;
+                using SharedCore<MyType, Core>::_allocateCore;
+
+        public:
+                Heap()
+                {
+                }
+                
+                Heap( cmpfunc cmpin )
+                {
+                        core->cmp = cmpin;
+                }
+
+                Heap( int iInitialCapacity )
+                {
+                        core->init( iInitialCapacity );
+                }
+                
+                Heap( cmpfunc cmpin, int iInitialCapacity )
+                {
+                        core->cmp = cmpin;
+                        core->init( iInitialCapacity );
+                }
+
+                Heap( const MyType &rSrc ) :
+                        SharedCore<MyType, Core>( rSrc )
+                {
+                }
+
+                virtual ~Heap()
+                {
+                }
+
+                virtual void enqueue( const item &it )
+                {
+                        _hardCopy();
+
+                        core->enqueue( it );
+                }
+
+                virtual item &peek()
+                {
+                        _hardCopy();
+
+                        if( core->iFill == 0 )
+                                throw HeapException("Heap empty.");
+                        return core->aItem[0];
+                }
+
+                virtual const item &peek() const
+                {
+                        if( core->iFill == 0 )
+                                throw HeapException("Heap empty.");
+                        return core->aItem[0];
+                }
+
+                virtual item dequeue()
+                {
+                        _hardCopy();
+
+                        return core->dequeue();
+                }
+
+                virtual bool isEmpty() const
+                {
+                        return (core->iFill==0);
+                }
+
+                virtual int getSize() const
+                {
+                        return core->iFill;
+                }
+
+                class iterator
+                {
+                        friend class const_iterator;
+                        friend class Heap<item, cmpfunc, itemalloc>;
+                private:
+                        Heap<item, cmpfunc, itemalloc> *pHeap;
+                        int iIndex;
+
+                        iterator( Heap<item, cmpfunc, itemalloc> *pHeap, int iIndex ) :
+                                pHeap( pHeap ), iIndex( iIndex )
+                        {
+                        }
+
+                        void checkValid()
+                        {
+                                if( pHeap == NULL )
+                                        throw Bu::ExceptionBase("Iterator not initialized.");
+                                if( iIndex < 0 || iIndex >= pHeap->core->iFill )
+                                        throw Bu::ExceptionBase("Iterator out of bounds.");
+                        }
+
+                public:
+                        iterator() :
+                                pHeap( NULL ),
+                                iIndex( -1 )
+                        {
+                        }
+
+                        iterator( const iterator &i ) :
+                                pHeap( i.pHeap ),
+                                iIndex( i.iIndex )
+                        {
+                        }
+
+                        bool operator==( const iterator &oth ) const
+                        {
+                                return (oth.pHeap == pHeap) && (oth.iIndex == iIndex);
+                        }
+
+                        bool operator!=( const iterator &oth ) const
+                        {
+                                return (oth.pHeap != pHeap) || (oth.iIndex != iIndex);
+                        }
+
+                        item &operator*()
+                        {
+                                pHeap->_hardCopy();
+
+                                return pHeap->core->aItem[iIndex];
+                        }
+
+                        item *operator->()
+                        {
+                                pHeap->_hardCopy();
+
+                                return &(pHeap->core->aItem[iIndex]);
+                        }
+
+                        iterator &operator++()
+                        {
+                                checkValid();
+                                iIndex++;
+                                if( iIndex >= pHeap->iFill )
+                                        iIndex = -1;
+
+                                return *this;
+                        }
+
+                        iterator &operator--()
+                        {
+                                checkValid();
+                                iIndex--;
+
+                                return *this;
+                        }
+                        
+                        iterator &operator++( int )
+                        {
+                                checkValid();
+                                iIndex++;
+                                if( iIndex >= pHeap->core->iFill )
+                                        iIndex = -1;
+
+                                return *this;
+                        }
+
+                        iterator &operator--( int )
+                        {
+                                checkValid();
+                                iIndex--;
+
+                                return *this;
+                        }
+
+                        iterator operator+( int iDelta )
+                        {
+                                checkValid();
+                                iterator ret( *this );
+                                ret.iIndex += iDelta;
+                                if( ret.iIndex >= pHeap->core->iFill )
+                                        ret.iIndex = -1;
+                                return ret;
+                        }
+
+                        iterator operator-( int iDelta )
+                        {
+                                checkValid();
+                                iterator ret( *this );
+                                ret.iIndex -= iDelta;
+                                if( ret.iIndex < 0 )
+                                        ret.iIndex = -1;
+                                return ret;
+                        }
+
+                        operator bool() const
+                        {
+                                return iIndex != -1;
+                        }
+
+                        bool isValid() const
+                        {
+                                return iIndex != -1;
+                        }
+
+                        iterator &operator=( const iterator &oth )
+                        {
+                                pHeap = oth.pHeap;
+                                iIndex = oth.iIndex;
+                        }
+                };
+                
+                class const_iterator
+                {
+                        friend class Heap<item, cmpfunc, itemalloc>;
+                private:
+                        Heap<item, cmpfunc, itemalloc> *pHeap;
+                        int iIndex;
+
+                        const_iterator( Heap<item, cmpfunc, itemalloc> *pHeap,
+                                        int iIndex ) :
+                                pHeap( pHeap ), iIndex( iIndex )
+                        {
+                        }
+
+                        void checkValid()
+                        {
+                                if( pHeap == NULL )
+                                        throw Bu::ExceptionBase("Iterator not initialized.");
+                                if( iIndex < 0 || iIndex >= pHeap->core->iFill )
+                                        throw Bu::ExceptionBase("Iterator out of bounds.");
+                        }
+
+                public:
+                        const_iterator() :
+                                pHeap( NULL ),
+                                iIndex( -1 )
+                        {
+                        }
+                        
+                        const_iterator( const const_iterator &i ) :
+                                pHeap( i.pHeap ),
+                                iIndex( i.iIndex )
+                        {
+                        }
+                        
+                        const_iterator( const iterator &i ) :
+                                pHeap( i.pHeap ),
+                                iIndex( i.iIndex )
+                        {
+                        }
+
+                        bool operator==( const const_iterator &oth ) const
+                        {
+                                return (oth.pHeap == pHeap) && (oth.iIndex == iIndex);
+                        }
+
+                        bool operator!=( const const_iterator &oth ) const
+                        {
+                                return (oth.pHeap != pHeap) || (oth.iIndex != iIndex);
+                        }
+
+                        const item &operator*()
+                        {
+                                pHeap->_hardCopy();
+
+                                return pHeap->core->aItem[iIndex];
+                        }
+
+                        const item *operator->()
+                        {
+                                pHeap->_hardCopy();
+
+                                return &(pHeap->core->aItem[iIndex]);
+                        }
+
+                        const_iterator &operator++()
+                        {
+                                checkValid();
+                                iIndex++;
+                                if( iIndex >= pHeap->core->iFill )
+                                        iIndex = -1;
+
+                                return *this;
+                        }
+
+                        const_iterator &operator--()
+                        {
+                                checkValid();
+                                iIndex--;
+
+                                return *this;
+                        }
+                        
+                        const_iterator &operator++( int )
+                        {
+                                checkValid();
+                                iIndex++;
+                                if( iIndex >= pHeap->core->iFill )
+                                        iIndex = -1;
+
+                                return *this;
+                        }
+
+                        const_iterator &operator--( int )
+                        {
+                                checkValid();
+                                iIndex--;
+
+                                return *this;
+                        }
+
+                        const_iterator operator+( int iDelta )
+                        {
+                                checkValid();
+                                const_iterator ret( *this );
+                                ret.iIndex += iDelta;
+                                if( ret.iIndex >= pHeap->iFill )
+                                        ret.iIndex = -1;
+                                return ret;
+                        }
+
+                        const_iterator operator-( int iDelta )
+                        {
+                                checkValid();
+                                const_iterator ret( *this );
+                                ret.iIndex -= iDelta;
+                                if( ret.iIndex < 0 )
+                                        ret.iIndex = -1;
+                                return ret;
+                        }
+
+                        operator bool() const
+                        {
+                                return iIndex != -1;
+                        }
+
+                        bool isValid() const
+                        {
+                                return iIndex != -1;
+                        }
+
+                        const_iterator &operator=( const const_iterator &oth )
+                        {
+                                pHeap = oth.pHeap;
+                                iIndex = oth.iIndex;
+                        }
+
+                        const_iterator &operator=( const iterator &oth )
+                        {
+                                pHeap = oth.pHeap;
+                                iIndex = oth.iIndex;
+                        }
+                };
+
+                iterator begin()
+                {
+                        if( core->iFill == 0 )
+                                return end();
+                        return iterator( this, 0 );
+                }
+
+                const_iterator begin() const
+                {
+                        if( core->iFill == 0 )
+                                return end();
+                        return const_iterator( this, 0 );
+                }
+
+                iterator end()
+                {
+                        return iterator( this, -1 );
+                }
+
+                const_iterator end() const
+                {
+                        return const_iterator( this, -1 );
+                }
+
+
+        protected:
+                virtual Core *_copyCore( Core *src )
+                {
+                        Core *pRet = _allocateCore();
+
+                        pRet->iSize = src->iSize;
+                        pRet->iFill = src->iFill;
+                        pRet->cmp = src->cmp;
+                        pRet->aItem = pRet->ia.allocate( pRet->iSize );
+                        for( int j = 0; j < pRet->iFill; j++ )
+                        {
+                                pRet->ia.construct( &pRet->aItem[j], src->aItem[j] );
+                        }
+
+                        return pRet;
+                }
+        };
+};
+
+#endif
diff --git a/src/stable/hex.cpp b/src/stable/hex.cpp
new file mode 100644
index 0000000..2a04c6f
--- /dev/null
+++ b/src/stable/hex.cpp
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/hex.h"
+
+Bu::Hex::Hex( Bu::Stream &rNext, bool bUpperCase, int iChunk ) :
+        Bu::Filter( rNext ),
+        iChunk( iChunk ),
+        iPos( 0 ),
+        iIn( 0 ),
+        sChrs(bUpperCase?"0123456789ABCDEF":"0123456789abcdef")
+{
+}
+
+Bu::Hex::~Hex()
+{
+}
+
+void Bu::Hex::start()
+{
+        iPos = iIn = 0;
+}
+
+Bu::size Bu::Hex::stop()
+{
+        return iPos;
+}
+
+Bu::size Bu::Hex::read( void *pBuf, Bu::size iBytes )
+{
+        Bu::size j;
+        uint8_t *puBuf = (uint8_t *)pBuf;
+        for( j = 0; j < iBytes; j++ )
+        {
+                for(; iIn < 2; iIn++ )
+                {
+                        if( rNext.read( &cIn[iIn], 1 ) == 0 )
+                                return j;
+                        if( cIn[iIn] == ' ' || cIn[iIn] == '\t' ||
+                                cIn[iIn] == '\n' || cIn[iIn] == '\r' )
+                                iIn--;
+                }
+#define chr2nibble( c ) ((c>='0'&&c<='9')?(c-'0'):((c|0x60)-'a'+10))
+                puBuf[j] = ((chr2nibble(cIn[0])<<4)|chr2nibble(cIn[1]));
+                iIn = 0;
+        }
+        return j;
+}
+
+Bu::size Bu::Hex::write( const void *pBuf, Bu::size iBytes )
+{
+        char cOut[2];
+        uint8_t *puBuf = (uint8_t *)pBuf;
+        for( Bu::size j = 0; j < iBytes; j++ )
+        {
+                cOut[0] = sChrs[(puBuf[j]&0xf0)>>4];
+                cOut[1] = sChrs[(puBuf[j]&0x0f)];
+                if( iChunk > 0 && iPos%iChunk == 0 && iPos>0 )
+                        rNext.write(" ", 1 );
+                rNext.write( cOut, 2 );
+                iPos++;
+        }
+        return iBytes;
+}
+
diff --git a/src/stable/hex.h b/src/stable/hex.h
new file mode 100644
index 0000000..3595fae
--- /dev/null
+++ b/src/stable/hex.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_HEX_H
+#define BU_HEX_H
+
+#include "bu/filter.h"
+
+namespace Bu
+{
+        /**
+         * This very simple filter encodes to/decodes from hex encoded string data.
+         * The primary use of this filter is in debugging, use it with
+         * Bu::encodeStr to easily create hex dumps of string data, even other raw
+         * structures.
+         *
+         *@code
+         Bu::println("Hexdump: " + Bu::encodeStr<Bu::Hex>("Test data ;)") );
+         @endcode
+         * Or...
+         *@code
+         complex_struct data;
+         ...
+         Bu::println("Hexdump: " +
+                Bu::encodeStr<Bu::Hex>(
+                        Bu::String( &data, sizeof(data) )
+                        )
+                );
+         @endcode
+         **/
+        class Hex : public Bu::Filter
+        {
+        public:
+                Hex( Bu::Stream &rNext, bool bUpperCase=false, int iChunk=-1 );
+                virtual ~Hex();
+
+                virtual void start();
+                virtual Bu::size stop();
+
+                virtual Bu::size read( void *pBuf, Bu::size iBytes );
+                virtual Bu::size write( const void *pBuf, Bu::size iBytes );
+                using Bu::Stream::write;
+
+        private:
+                int iChunk;
+                Bu::size iPos;
+                char cIn[2];
+                int iIn;
+                const char *sChrs;
+        };
+};
+
+#endif
diff --git a/src/stable/list.cpp b/src/stable/list.cpp
new file mode 100644
index 0000000..e05765e
--- /dev/null
+++ b/src/stable/list.cpp
@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/list.h"
+
diff --git a/src/stable/list.h b/src/stable/list.h
new file mode 100644
index 0000000..21ba0b5
--- /dev/null
+++ b/src/stable/list.h
@@ -0,0 +1,1014 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_LIST_H
+#define BU_LIST_H
+
+#include <memory>
+#include "bu/exceptionbase.h"
+#include "bu/sharedcore.h"
+#include "bu/archivebase.h"
+#include "bu/heap.h"
+
+namespace Bu
+{
+        /** @cond DEVEL */
+        template<typename value>
+        struct ListLink
+        {
+                value *pValue;
+                ListLink *pNext;
+                ListLink *pPrev;
+        };
+
+        template<typename value, typename valuealloc, typename linkalloc>
+        class List;
+
+        template<typename value, typename valuealloc, typename linkalloc>
+        struct ListCore
+        {
+        friend class List<value, valuealloc, linkalloc>;
+        friend class SharedCore<
+                List<value, valuealloc, linkalloc>,
+                ListCore<value, valuealloc, linkalloc>
+                >;
+        private:
+                typedef struct ListLink<value> Link;
+                ListCore() :
+                        pFirst( NULL ),
+                        pLast( NULL ),
+                        nSize( 0 )
+                { }
+
+                virtual ~ListCore()
+                {
+                        clear();
+                }
+
+                Link *pFirst;
+                Link *pLast;
+                long nSize;
+                linkalloc la;
+                valuealloc va;
+                
+                /**
+                 * Append a value to the list.
+                 *@param v (const value_type &) The value to append.
+                 */
+                Link *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;
+                        }
+                        return pNew;
+                }
+                
+                /**
+                 * Prepend a value to the list.
+                 *@param v (const value_type &) The value to prepend.
+                 */
+                Link *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;
+                        }
+                        return pNew;
+                }
+                
+                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;
+                }
+                
+                Link *insert( Link *pLink, const value &v )
+                {
+                        Link *pAfter = pLink;
+                        if( pAfter == NULL )
+                        {
+                                return append( v );
+                        }
+                        Link *pPrev = pAfter->pPrev;
+                        if( pPrev == NULL )
+                        {
+                                return prepend( v );
+                        }
+
+                        Link *pNew = la.allocate( 1 );
+                        pNew->pValue = va.allocate( 1 );
+                        va.construct( pNew->pValue, v );
+                        nSize++;
+                
+                        pNew->pNext = pAfter;
+                        pNew->pPrev = pPrev;
+                        pAfter->pPrev = pNew;
+                        pPrev->pNext = pNew;
+
+                        return pNew;
+                }
+
+                /**
+                 * Erase an item from the list.
+                 *@param i (iterator) The item to erase.
+                 */
+                void erase( Link *pLink )
+                {
+                        Link *pCur = pLink;
+                        if( pCur == NULL ) return;
+                        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;
+                                else
+                                        pFirst->pPrev = NULL;
+                                nSize--;
+                        }
+                        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;
+                                else
+                                        pLast = pPrev;
+                                nSize--;
+                        }
+                }
+        };
+        /** @endcond */
+
+        /**
+         * Linked list template container.  This class is similar to the stl list
+         * class except for a few minor changes.  First, when const, all
+         * members are only accessable const.  Second, erasing a location does not
+         * invalidate the iterator used, it simply points to the next valid
+         * location, or end() if there are no more.  Other iterators pointing to
+         * the deleted record will, of course, no longer be valid.
+         *
+         *@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.
+         *@extends SharedCore
+         *@ingroup Containers
+         */
+        template<typename value, typename valuealloc=std::allocator<value>,
+                typename linkalloc=std::allocator<struct ListLink<value> > >
+        class List /** @cond */ : public SharedCore<
+                                 List<value, valuealloc, linkalloc>,
+                                 ListCore<value, valuealloc, linkalloc>
+                                 > /** @endcond */
+        {
+        private:
+                typedef struct ListLink<value> Link;
+                typedef class List<value, valuealloc, linkalloc> MyType;
+                typedef struct ListCore<value, valuealloc, linkalloc> Core;
+
+        protected:
+                using SharedCore<MyType, Core>::core;
+                using SharedCore<MyType, Core>::_hardCopy;
+                using SharedCore<MyType, Core>::_allocateCore;
+
+        public:
+                struct const_iterator;
+                struct iterator;
+
+                List()
+                {
+                }
+
+                List( const MyType &src ) :
+                        SharedCore<MyType, Core >( src )
+                {
+                }
+                
+                List( const value &v )
+                {
+                        append( v );
+                }
+
+                ~List()
+                {
+                }
+
+                MyType &operator+=( const value &v )
+                {
+                        _hardCopy();
+                        append( v );
+                        return *this;
+                }
+
+                MyType &operator+=( const MyType &src )
+                {
+                        _hardCopy();
+                        append( src );
+                        return *this;
+                }
+                
+                MyType operator+( const MyType &src )
+                {
+                        MyType lNew( *this );
+                        lNew += src;
+                        return lNew;
+                }
+
+                bool operator==( const MyType &rhs ) const
+                {
+                        if( getSize() != rhs.getSize() )
+                                return false;
+
+                        for( typename MyType::const_iterator a = begin(), b = rhs.begin();
+                                 a; a++, b++ )
+                        {
+                                if( *a != *b )
+                                        return false;
+                        }
+
+                        return true;
+                }
+
+                bool operator!=( const MyType &rhs ) const
+                {
+                        return !(*this == rhs);
+                }
+
+                /**
+                 * Clear the data from the list.
+                 */
+                void clear()
+                {
+                        _hardCopy();
+                        core->clear();
+                }
+
+                MyType &enqueue( const value &v )
+                {
+                        _hardCopy();
+                        append( v );
+
+                        return *this;
+                }
+
+                value dequeue()
+                {
+                        // _hardCopy();  erase will call this for me
+                        value v = *core->pFirst->pValue;
+
+                        erase( begin() );
+
+                        return v;
+                }
+
+                MyType &push( const value &v )
+                {
+                        _hardCopy();
+                        prepend( v );
+
+                        return *this;
+                }
+
+                MyType &pop()
+                {
+                        _hardCopy();
+                        erase( begin() );
+
+                        return *this;
+                }
+
+                value peekPop()
+                {
+                        value v = first();
+                        pop();
+                        return v;
+                }
+
+                value &peek()
+                {
+                        return first();
+                }
+
+                /**
+                 * Append a value to the list.
+                 *@param v (const value_type &) The value to append.
+                 */
+                MyType &append( const value &v )
+                {
+                        _hardCopy();
+                        core->append( v );
+
+                        return *this;
+                }
+
+                MyType &append( const MyType &rSrc )
+                {
+                        _hardCopy();
+                        for( typename MyType::const_iterator i = rSrc.begin();
+                                 i != rSrc.end(); i++ )
+                        {
+                                core->append( *i );
+                        }
+
+                        return *this;
+                }
+
+                /**
+                 * Prepend a value to the list.
+                 *@param v (const value_type &) The value to prepend.
+                 */
+                MyType &prepend( const value &v )
+                {
+                        _hardCopy();
+                        core->prepend( v );
+
+                        return *this;
+                }
+
+                /**
+                 * Prepend another list to the front of this one.  This will prepend
+                 * the rSrc list in reverse order...I may fix that later.
+                 */
+                MyType &prepend( const MyType &rSrc )
+                {
+                        _hardCopy();
+                        for( typename MyType::const_iterator i = rSrc.begin();
+                                 i != rSrc.end(); i++ )
+                        {
+                                core->prepend( *i );
+                        }
+
+                        return *this;
+                }
+
+                MyType &insert( MyType::iterator &i, const value &v )
+                {
+                        _hardCopy();
+
+                        core->insert( i.pLink, v );
+
+                        return *this;
+                }
+
+                template<typename cmptype>
+                void sort( cmptype cmp )
+                {
+                        Heap<value, cmptype, valuealloc> hSort( cmp, getSize() );
+                        for( typename MyType::iterator i = begin(); i; i++ )
+                        {
+                                hSort.enqueue( *i );
+                        }
+                        clear();
+                        while( !hSort.isEmpty() )
+                        {
+                                append( hSort.dequeue() );
+                        }
+                }
+
+                void sort()
+                {
+                        sort<__basicLTCmp<value> >();
+                }
+
+                template<typename cmptype>
+                void sort()
+                {
+                        Heap<value, cmptype, valuealloc> hSort( getSize() );
+                        for( typename MyType::iterator i = begin(); i; i++ )
+                        {
+                                hSort.enqueue( *i );
+                        }
+                        clear();
+                        while( !hSort.isEmpty() )
+                        {
+                                append( hSort.dequeue() );
+                        }
+                }
+
+                /**
+                 * Insert a new item in sort order by searching for the first item that
+                 * is larger and inserting this before it, or at the end if none are
+                 * larger.  If this is the only function used to insert data in the
+                 * List all items will be sorted.  To use this, the value type must
+                 * support the > operator.
+                 */
+                template<typename cmptype>
+                iterator insertSorted( cmptype cmp, const value &v )
+                {
+                        _hardCopy();
+                        if( core->pFirst == NULL )
+                        {
+                                // Empty list
+                                return iterator( core->append( v ) );
+                        }
+                        else
+                        {
+                                Link *pCur = core->pFirst;
+                                for(;;)
+                                {
+                                        if( cmp( v, *(pCur->pValue)) )
+                                        {
+                                                return iterator( core->insert( pCur, v ) );
+                                        }
+                                        pCur = pCur->pNext;
+                                        if( pCur == NULL )
+                                        {
+                                                return iterator( core->append( v ) );
+                                        }
+                                }
+                        }
+                }
+                
+                iterator insertSorted( const value &v )
+                {
+                        return insertSorted<__basicLTCmp<value> >( v );
+                }
+
+                template<typename cmptype>
+                iterator insertSorted( const value &v )
+                {
+                        cmptype cmp;
+                        return insertSorted( cmp, v );
+                }
+
+                /**
+                 * An iterator to iterate through your list.
+                 */
+                typedef struct iterator
+                {
+                        friend struct const_iterator;
+                        friend class List<value, valuealloc, linkalloc>;
+                private:
+                        Link *pLink;
+
+                        iterator( Link *pLink ) :
+                                pLink( pLink )
+                        {
+                        }
+
+                public:
+                        iterator() :
+                                pLink( NULL )
+                        {
+                        }
+
+                        iterator( const iterator &i ) :
+                                pLink( i.pLink )
+                        {
+                        }
+
+                        /**
+                         * 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;
+                        }
+
+                        iterator &operator++()
+                        {
+                                if( pLink == NULL )
+                                        throw Bu::ExceptionBase(
+                                                "Attempt to iterate past end of list.");
+                                pLink = pLink->pNext;
+                                return *this;
+                        }
+
+                        iterator &operator--()
+                        {
+                                if( pLink == NULL )
+                                        throw Bu::ExceptionBase(
+                                                "Attempt to iterate past begining of list.");
+                                pLink = pLink->pPrev;
+                                return *this;
+                        }
+                        
+                        iterator &operator++( int )
+                        {
+                                if( pLink == NULL )
+                                        throw Bu::ExceptionBase(
+                                                "Attempt to iterate past end of list.");
+                                pLink = pLink->pNext;
+                                return *this;
+                        }
+
+                        iterator &operator--( int )
+                        {
+                                if( pLink == NULL )
+                                        throw Bu::ExceptionBase(
+                                                "Attempt to iterate past begining of list.");
+                                pLink = pLink->pPrev;
+                                return *this;
+                        }
+
+                        iterator operator+( int iDelta )
+                        {
+                                iterator ret( *this );
+                                for( int j = 0; j < iDelta; j++ )
+                                {
+                                        if( ret.pLink == NULL )
+                                                throw Bu::ExceptionBase(
+                                                        "Attempt to iterate past begining of list.");
+                                        ret.pLink = ret.pLink->pNext;
+                                }
+                                return ret;
+                        }
+
+                        iterator operator-( int iDelta )
+                        {
+                                iterator ret( *this );
+                                for( int j = 0; j < iDelta; j++ )
+                                {
+                                        if( ret.pLink == NULL )
+                                                throw Bu::ExceptionBase(
+                                                        "Attempt to iterate past begining of list.");
+                                        ret.pLink = ret.pLink->pPrev;
+                                }
+                                return ret;
+                        }
+
+                        operator bool()
+                        {
+                                return pLink != NULL;
+                        }
+
+                        bool isValid()
+                        {
+                                return pLink != NULL;
+                        }
+
+                        /**
+                         * Assignment operator.
+                         *@param oth (const iterator &) The other iterator to set this
+                         *              one to.
+                         */
+                        iterator &operator=( const iterator &oth )
+                        {
+                                pLink = oth.pLink;
+                                return *this;
+                        }
+                } iterator;
+                
+                /**
+                 *@see iterator
+                 */
+                typedef struct const_iterator
+                {
+                        friend class List<value, valuealloc, linkalloc>;
+                private:
+                        Link *pLink;
+
+                        const_iterator( Link *pLink ) :
+                                pLink( pLink )
+                        {
+                        }
+
+                public:
+                        const_iterator() :
+                                pLink( NULL )
+                        {
+                        }
+
+                        const_iterator( const iterator &i ) :
+                                pLink( i.pLink )
+                        {
+                        }
+
+                        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 )
+                                        throw Bu::ExceptionBase(
+                                                "Attempt to iterate past end of list.");
+                                pLink = pLink->pNext;
+                                return *this;
+                        }
+
+                        const_iterator &operator--()
+                        {
+                                if( pLink == NULL )
+                                        throw Bu::ExceptionBase(
+                                                "Attempt to iterate past begining of list.");
+                                pLink = pLink->pPrev;
+                                return *this;
+                        }
+                        
+                        const_iterator &operator++( int )
+                        {
+                                if( pLink == NULL )
+                                        throw Bu::ExceptionBase(
+                                                "Attempt to iterate past end of list.");
+                                pLink = pLink->pNext;
+                                return *this;
+                        }
+
+                        const_iterator &operator--( int )
+                        {
+                                if( pLink == NULL )
+                                        throw Bu::ExceptionBase(
+                                                "Attempt to iterate past begining of list.");
+                                pLink = pLink->pPrev;
+                                return *this;
+                        }
+
+                        const_iterator operator+( int iDelta )
+                        {
+                                const_iterator ret( *this );
+                                for( int j = 0; j < iDelta; j++ )
+                                {
+                                        if( ret.pLink == NULL )
+                                                throw Bu::ExceptionBase(
+                                                        "Attempt to iterate past begining of list.");
+                                        ret.pLink = ret.pLink->pNext;
+                                }
+                                return ret;
+                        }
+
+                        const_iterator operator-( int iDelta )
+                        {
+                                const_iterator ret( *this );
+                                for( int j = 0; j < iDelta; j++ )
+                                {
+                                        if( ret.pLink == NULL )
+                                                throw Bu::ExceptionBase(
+                                                        "Attempt to iterate past begining of list.");
+                                        ret.pLink = ret.pLink->pPrev;
+                                }
+                                return ret;
+                        }
+
+                        const_iterator &operator=( const iterator &oth )
+                        {
+                                pLink = oth.pLink;
+                                return *this;
+                        }
+
+                        const_iterator &operator=( const const_iterator &oth )
+                        {
+                                pLink = oth.pLink;
+                                return *this;
+                        }
+
+                        operator bool()
+                        {
+                                return pLink != NULL;
+                        }
+
+                        bool isValid()
+                        {
+                                return pLink != NULL;
+                        }
+                } const_iterator;
+
+                /**
+                 * Get an iterator pointing to the first item in the list.
+                 *@returns (iterator)
+                 */
+                iterator begin()
+                {
+                        _hardCopy();
+                        return iterator( core->pFirst );
+                }
+
+                /**
+                 * Get a const iterator pointing to the first item in the list.
+                 *@returns (const const_iterator)
+                 */
+                const_iterator begin() const
+                {
+                        return const_iterator( core->pFirst );
+                }
+
+                /**
+                 * Get an iterator pointing to a place just past the last item in
+                 *              the list.
+                 *@returns (const Link *)
+                 */
+                const iterator end()
+                {
+                        return iterator( NULL );
+                }
+
+                /**
+                 * Get an iterator pointing to a place just past the last item in
+                 *              the list.
+                 *@returns (const Link *)
+                 */
+                const const_iterator end() const
+                {
+                        return const_iterator( NULL );
+                }
+
+                /**
+                 * Erase an item from the list.
+                 *@param i (iterator) The item to erase.
+                 */
+                MyType &erase( iterator i )
+                {
+                        _hardCopy();
+                        core->erase( i.pLink );
+
+                        return *this;
+                }
+
+                /**
+                 * Erase an item from the list.
+                 *@param i (iterator) The item to erase.
+                 */
+                MyType &erase( const_iterator i )
+                {
+                        _hardCopy();
+                        core->erase( i.pLink );
+
+                        return *this;
+                }
+
+                /**
+                 * Erase an item from the list if you already know the item.
+                 *@param v The item to find and erase.
+                 */
+                MyType &erase( const value &v )
+                {
+                        for( const_iterator i = begin(); i != end(); i++ )
+                        {
+                                if( (*i) == v )
+                                {
+                                        erase( i );
+                                        return *this;
+                                }
+                        }
+
+                        return *this;
+                }
+
+                iterator find( const value &v )
+                {
+                        for( iterator i = begin(); i; i++ )
+                        {
+                                if( (*i) == v )
+                                        return i;
+                        }
+
+                        return end();
+                }
+
+                const_iterator find( const value &v ) const
+                {
+                        for( const_iterator i = begin(); i; i++ )
+                        {
+                                if( (*i) == v )
+                                        return i;
+                        }
+
+                        return end();
+                }
+
+                /**
+                 * Get the current size of the list.
+                 *@returns (int) The current size of the list.
+                 */
+                long getSize() const
+                {
+                        return core->nSize;
+                }
+
+                /**
+                 * Get the first item in the list.
+                 *@returns (value_type &) The first item in the list.
+                 */
+                value &first()
+                {
+                        if( core->pFirst->pValue == NULL )
+                                throw Bu::ExceptionBase("Attempt to read first element from empty list.");
+                        _hardCopy();
+                        return *core->pFirst->pValue;
+                }
+                
+                /**
+                 * Get the first item in the list.
+                 *@returns (const value_type &) The first item in the list.
+                 */
+                const value &first() const
+                {
+                        if( core->pFirst->pValue == NULL )
+                                throw Bu::ExceptionBase("Attempt to read first element from empty list.");
+                        return *core->pFirst->pValue;
+                }
+                
+                /**
+                 * Get the last item in the list.
+                 *@returns (value_type &) The last item in the list.
+                 */
+                value &last()
+                {
+                        _hardCopy();
+                        return *core->pLast->pValue;
+                }
+                
+                /**
+                 * Get the last item in the list.
+                 *@returns (const value_type &) The last item in the list.
+                 */
+                const value &last() const
+                {
+                        return *core->pLast->pValue;
+                }
+
+                bool isEmpty() const
+                {
+                        return (core->nSize == 0);
+                }
+        
+        protected:
+                virtual Core *_copyCore( Core *src )
+                {
+                        Core *pRet = _allocateCore();
+                        for( Link *pCur = src->pFirst; pCur; pCur = pCur->pNext )
+                        {
+                                pRet->append( *pCur->pValue );
+                        }
+                        return pRet;
+                }
+
+        private:
+        };
+
+        class Formatter;
+        Formatter &operator<<( Formatter &rOut, char *sStr );
+        Formatter &operator<<( Formatter &rOut, signed char c );
+        template<typename a, typename b, typename c>
+        Formatter &operator<<( Formatter &f, const Bu::List<a,b,c> &l )
+        {
+                f << '[';
+                for( typename Bu::List<a,b,c>::const_iterator i = l.begin(); i; i++ )
+                {
+                        if( i != l.begin() )
+                                f << ", ";
+                        f << *i;
+                }
+                f << ']';
+
+                return f;
+        }
+
+        template<typename value, typename a, typename b>
+        ArchiveBase &operator<<( ArchiveBase &ar, const List<value,a,b> &h )
+        {
+                ar << h.getSize();
+                for( typename List<value>::const_iterator i = h.begin(); i != h.end(); i++ )
+                {
+                        ar << (*i);
+                }
+
+                return ar;
+        }
+
+        template<typename value, typename a, typename b>
+        ArchiveBase &operator>>( ArchiveBase &ar, List<value,a,b> &h )
+        {
+                h.clear();
+                long nSize;
+                ar >> nSize;
+
+                for( long j = 0; j < nSize; j++ )
+                {
+                        value v;
+                        ar >> v;
+                        h.append( v );
+                }
+
+                return ar;
+        }
+
+}
+
+#endif
diff --git a/src/stable/logger.cpp b/src/stable/logger.cpp
new file mode 100644
index 0000000..8e46390
--- /dev/null
+++ b/src/stable/logger.cpp
@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/logger.h"
+#include <stdarg.h>
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+Bu::Logger::Logger()
+{
+        setFormat("%t");
+}
+
+Bu::Logger::~Logger()
+{
+}
+
+void Bu::Logger::log( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...)
+{
+#ifndef WIN32
+        if( (nLevel&nLevelMask) == 0 )
+                return;
+
+        va_list ap;
+        va_start( ap, sFormat );
+        char *text;
+        if( vasprintf( &text, sFormat, ap ) < 0 )
+        {
+                printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! WTF?\n");
+                return;
+        }
+        va_end(ap);
+        
+        time_t t = time(NULL);
+        
+        char *line = NULL;
+        struct tm *pTime;
+        pTime = localtime( &t );
+        if ( 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
+                ) < 0 )
+        {
+                //printf("LOGGER: ERROR ALLOCATING STRING:  %s\n", strerror( errno ) );
+                return;
+        }
+        write( fileno(stdout), line, strlen(line) );
+        free( text );
+        free( line );
+#else
+        #warning Bu::Logger::log IS A STUB for WIN32!!!!        
+#endif
+}
+
+void Bu::Logger::setFormat( const Bu::String &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::String 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( uint32_t n )
+{
+        nLevelMask = n;
+}
+
+uint32_t Bu::Logger::getMask()
+{
+        return nLevelMask;
+}
+
+void Bu::Logger::setLevel( uint32_t n )
+{
+        int j;
+        for( j = 31; j > 0; j-- )
+        {
+                if( (n&(1<<j)) )
+                {
+                        for(; j >= 0; j-- )
+                        {
+                                n |= (1<<j);
+                        }
+                        nLevelMask = n;
+                        return;
+                }
+        }
+}
+
+void Bu::Logger::hexDump( uint32_t nLevel, const char *sFile,
+                const char *sFunction, int nLine, const void *pDataV, long nDataLen,
+                const char *lpName )
+{
+        if( (nLevel&nLevelMask) == 0 )
+                return;
+
+        log( nLevel, sFile, sFunction, nLine, "Displaying %ld bytes of %s.", nDataLen, lpName );
+        const unsigned char *pData = (const unsigned char *)pDataV;
+        int j = 0;
+        Bu::String sBorder;
+        for( int l = 0; l < 8*3+2*8+2+5; l++ ) sBorder += ((l!=11&&l!=37)?("-"):("+"));
+        log( nLevel, sFile, sFunction, nLine, sBorder.getStr() );
+        Bu::String sLine;
+        for(;;)
+        {
+                {
+                        char buf[16];
+                        sprintf( buf, "%010d | ", j );
+                        sLine += buf;
+                }
+                int kmax = 8;
+                if( nDataLen-j < 8 ) kmax = nDataLen-j;
+                for(int k = 0; k < 8; k++ )
+                {
+                        if( k < kmax )
+                        {
+                                char buf[4];
+                                sprintf( buf, "%02X ", (int)((unsigned char)pData[j+k]) );
+                                sLine += buf;
+                        }
+                        else
+                        {
+                                sLine += "-- ";
+                        }
+                }
+                sLine += "| ";
+                for(int k = 0; k < kmax; k++ )
+                {
+                        char buf[3];
+                        sprintf( buf, "%c", (pData[j+k]>32 && pData[j+k]<=128)?(pData[j+k]):('.') );
+                        sLine += buf;
+                }
+                log( nLevel, sFile, sFunction, nLine, sLine.getStr() );
+                sLine = "";
+                j += kmax;
+                if( j >= nDataLen ) break;
+        }
+        log( nLevel, sFile, sFunction, nLine, sBorder.getStr() );
+}
+
diff --git a/src/stable/logger.h b/src/stable/logger.h
new file mode 100644
index 0000000..5c1352b
--- /dev/null
+++ b/src/stable/logger.h
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_LOGGER_H
+#define BU_LOGGER_H
+
+#include "bu/singleton.h"
+#include "bu/string.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( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...);
+
+                void setFormat( const Bu::String &str );
+                void setMask( uint32_t n );
+                void setLevel( uint32_t n );
+                uint32_t getMask();
+
+                void hexDump( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const void *pData, long nDataLen, const char *lpName );
+
+        private:
+                Bu::String sLogFormat;
+                uint32_t 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__ ) 
+
+#define logHexDump( nLevel, pData, iSize, sName ) \
+        Bu::Logger::getInstance().hexDump( nLevel, __FILE__, __PRETTY_FUNCTION__, __LINE__, pData, iSize, sName ) 
+
+/**
+ * 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/stable/lzma.cpp b/src/stable/lzma.cpp
new file mode 100644
index 0000000..6ed0806
--- /dev/null
+++ b/src/stable/lzma.cpp
@@ -0,0 +1,248 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/lzma.h"
+#include "bu/trace.h"
+
+#include <lzma.h>
+
+#define pState ((lzma_stream *)prState)
+
+using namespace Bu;
+
+Bu::Lzma::Lzma( Bu::Stream &rNext, int nCompression, Format eFmt ) :
+        Bu::Filter( rNext ),
+        prState( NULL ),
+        nCompression( nCompression ),
+        sTotalOut( 0 ),
+        eFmt( eFmt ),
+        bEos( false )
+{
+        TRACE( nCompression );
+        start();
+}
+
+Bu::Lzma::~Lzma()
+{
+        TRACE();
+        stop();
+}
+
+void Bu::Lzma::start()
+{
+        TRACE();
+        nBufSize = 64*1024;
+        pBuf = new char[nBufSize];
+}
+
+Bu::size Bu::Lzma::stop()
+{
+        TRACE();
+        if( pState )
+        {
+                if( bReading )
+                {
+                        lzma_end( pState );
+                        delete[] pBuf;
+                        pBuf = NULL;
+                        delete pState;
+                        prState = NULL;
+                        return 0;
+                }
+                else
+                {
+                        for(;;)
+                        {
+                                pState->next_in = NULL;
+                                pState->avail_in = 0;
+                                pState->avail_out = nBufSize;
+                                pState->next_out = (uint8_t *)pBuf;
+                                int res = lzma_code( pState, LZMA_FINISH );
+                                if( pState->avail_out < nBufSize )
+                                {
+                                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+                                }
+                                if( res == LZMA_STREAM_END )
+                                        break;
+                        }
+                        lzma_end( pState );
+                        delete[] pBuf;
+                        pBuf = NULL;
+                        delete pState;
+                        prState = NULL;
+                        return sTotalOut;
+                }
+        }
+        return 0;
+}
+
+void Bu::Lzma::lzmaError( int code )
+{
+        TRACE( code );
+        switch( code )
+        {
+                case LZMA_OK:
+                case LZMA_STREAM_END:
+                case LZMA_NO_CHECK:
+                case LZMA_UNSUPPORTED_CHECK:
+                        break;
+
+                case LZMA_MEM_ERROR:
+                        throw ExceptionBase("Lzma: Memory allocation error.");
+
+                case LZMA_MEMLIMIT_ERROR:
+                        throw ExceptionBase("Lzma: Memory usage limit was reached.");
+
+                case LZMA_FORMAT_ERROR:
+                        throw ExceptionBase("Lzma: File format not recognized.");
+
+                case LZMA_OPTIONS_ERROR:
+                        throw ExceptionBase("Lzma: Invalid or unsupported options.");
+
+                case LZMA_DATA_ERROR:
+                        throw ExceptionBase("Lzma: Data is corrupt.");
+
+                case LZMA_BUF_ERROR:
+                        throw ExceptionBase("Lzma: No progress is possible.");
+
+                case LZMA_PROG_ERROR:
+                        throw ExceptionBase("Lzma: Programming error.");
+
+                default:
+                        throw ExceptionBase("Lzma: Unknown error encountered." );
+        }
+}
+
+Bu::size Bu::Lzma::read( void *pData, Bu::size nBytes )
+{
+        TRACE( pData, nBytes );
+        if( !pState )
+        {
+                prState = new ::lzma_stream;
+                lzma_stream zEmpty = LZMA_STREAM_INIT;
+                Bu::memcpy( prState, &zEmpty, sizeof(lzma_stream) );
+
+                bReading = true;
+                lzmaError( lzma_auto_decoder( pState, UINT64_MAX, 0 ) );
+                pState->next_in = (uint8_t *)pBuf;
+                pState->avail_in = 0;
+        }
+        if( bReading == false )
+                throw ExceptionBase("This lzma filter is in writing mode, you can't read.");
+
+        int nRead = 0;
+        int nReadTotal = pState->total_out;
+        pState->next_out = (uint8_t *)pData;
+        pState->avail_out = nBytes;
+        for(;;)
+        {
+                int ret = lzma_code( pState, LZMA_RUN );
+                printf("inflate returned %d; avail in=%d, out=%d\n", ret,
+                                pState->avail_in, pState->avail_out );
+        
+                nReadTotal += nRead-pState->avail_out;
+
+                if( ret == LZMA_STREAM_END )
+                {
+                        bEos = true;
+                        if( pState->avail_in > 0 )
+                        {
+                                if( rNext.isSeekable() )
+                                {
+                                        rNext.seek( -pState->avail_in );
+                                }
+                        }
+                        return nBytes-pState->avail_out;
+                }
+//              if( ret != LZMA_BUF_ERROR )
+                        lzmaError( ret );
+
+                if( pState->avail_out )
+                {
+                        if( pState->avail_in == 0 )
+                        {
+                                nRead = rNext.read( pBuf, nBufSize );
+                                if( nRead == 0 && rNext.isEos() )
+                                {
+                                        throw Bu::ExceptionBase("Premature end of underlying "
+                                                        "stream found reading deflate stream.");
+                                }
+                                pState->next_in = (uint8_t *)pBuf;
+                                pState->avail_in = nRead;
+                        }
+                }
+                else
+                {
+                        return nBytes-pState->avail_out;
+                }
+        }
+        return 0;
+}
+
+Bu::size Bu::Lzma::write( const void *pData, Bu::size nBytes )
+{
+        TRACE( pData, nBytes );
+        if( !pState )
+        {
+                prState = new ::lzma_stream;
+                lzma_stream zEmpty = LZMA_STREAM_INIT;
+                Bu::memcpy( prState, &zEmpty, sizeof(lzma_stream) );
+
+                bReading = false;
+                if( eFmt == Xz )
+                        lzmaError(
+                                lzma_easy_encoder( pState, nCompression, LZMA_CHECK_CRC64 )
+                                );
+                else if( eFmt == LzmaAlone )
+                {
+                        lzma_options_lzma opt;
+                        lzma_lzma_preset( &opt, nCompression );
+                        lzmaError( lzma_alone_encoder( pState, &opt ) );
+                }
+                else
+                        throw Bu::ExceptionBase("Invalid format for lzma.");
+        }
+        if( bReading == true )
+                throw ExceptionBase("This lzma filter is in reading mode, you can't write.");
+
+        pState->next_in = (uint8_t *)pData;
+        pState->avail_in = nBytes;
+        for(;;)
+        {
+                pState->avail_out = nBufSize;
+                pState->next_out = (uint8_t *)pBuf;
+
+                lzmaError( lzma_code( pState, LZMA_RUN ) );
+
+                if( pState->avail_out < nBufSize )
+                {
+                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+                }
+                if( pState->avail_in == 0 )
+                        break;
+        }
+
+        return nBytes;
+}
+
+bool Bu::Lzma::isOpen()
+{
+        TRACE();
+        return (pState != NULL);
+}
+
+bool Bu::Lzma::isEos()
+{
+        TRACE();
+        return bEos;
+}
+
+Bu::size Bu::Lzma::getCompressedSize()
+{
+        return sTotalOut;
+}
+
diff --git a/src/stable/lzma.h b/src/stable/lzma.h
new file mode 100644
index 0000000..090da8d
--- /dev/null
+++ b/src/stable/lzma.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_LZMA_H
+#define BU_LZMA_H
+
+#include <stdint.h>
+
+#include "bu/filter.h"
+
+namespace Bu
+{
+        /**
+         * Provides XZ compression and decompression, both LZMA1 (LzmaAlone) as
+         * well as the newer LZMA2 (xz) format.  This uses .xz by default.
+         *
+         *@ingroup Streams
+         *@ingroup Compression
+         */
+        class Lzma : public Bu::Filter
+        {
+        public:
+                enum Format
+                {
+                        Xz                      = 0x01,
+                        LzmaAlone       = 0x02,
+                };
+
+                Lzma( Bu::Stream &rNext, int nCompression=6, Format eFmt=Xz );
+                virtual ~Lzma();
+
+                virtual void start();
+                virtual Bu::size stop();
+                virtual Bu::size read( void *pBuf, Bu::size nBytes );
+                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+
+                virtual bool isOpen();
+                virtual bool isEos();
+
+                Bu::size getCompressedSize();
+
+        private:
+                void lzmaError( int code );
+                void *prState;
+                bool bReading;
+                int nCompression;
+                char *pBuf;
+                uint32_t nBufSize;
+                Bu::size sTotalOut;
+                Format eFmt;
+                bool bEos;
+        };
+}
+
+#endif
diff --git a/src/stable/md5.cpp b/src/stable/md5.cpp
new file mode 100644
index 0000000..15cba17
--- /dev/null
+++ b/src/stable/md5.cpp
@@ -0,0 +1,246 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "bu/md5.h"
+#include "bu/stream.h"
+
+#ifdef SYSTEM_BIG_ENDIAN
+# define toLittleEndian( a, b ) _toLittleEndian( a, b )
+#else
+# define toLittleEndian( a, b ) (void)0
+#endif
+
+Bu::Md5::Md5()
+{
+        reset();
+}
+
+Bu::Md5::~Md5()
+{
+}
+
+void Bu::Md5::reset()
+{
+        // These are the magic seed numbers...
+
+        sum[0] = 0x67452301U;
+        sum[1] = 0xEFCDAB89U;
+        sum[2] = 0x98BADCFEU;
+        sum[3] = 0x10325476U;
+
+        uBits[0] = 0;
+        uBits[1] = 0;
+}
+
+void Bu::Md5::setSalt( const Bu::String & /*sSalt*/ )
+{
+}
+
+void Bu::Md5::addData( const void *sVData, int iSize )
+{
+        const char *sData = (const char *)sVData;
+        uint32_t t;
+
+        t = uBits[0];
+        if( (uBits[0] = t + ((uint32_t)iSize << 3)) < t )
+                uBits[1]++;
+        uBits[1] += iSize >> 29;
+
+        t = (t >> 3) & 0x3f;    /* How many bytes we have buffered */
+
+        /* Handle any leading odd-sized chunks */
+        if( t )
+        {
+                unsigned char *p = (unsigned char *) inbuf + t;
+
+                t = 64 - t;
+                if( (uint32_t)iSize < t ) {
+                        memcpy( p, sData, iSize );
+                        return;
+                }
+                memcpy( p, sData, t );
+                toLittleEndian( inbuf, 16 );
+                compBlock( sum, (uint32_t *)inbuf );
+                sData += t;
+                iSize -= t;
+        }
+
+        /* Process data in 64-byte chunks */
+        while( iSize >= 64 )
+        {
+                memcpy( inbuf, sData, 64 );
+                toLittleEndian( inbuf, 16 );
+                compBlock( sum, (uint32_t *)inbuf );
+                sData += 64;
+                iSize -= 64;
+        }
+
+        /* Handle any remaining bytes of data. */
+        memcpy( inbuf, sData, iSize );
+}
+
+Bu::String Bu::Md5::getResult()
+{
+        uint32_t lsum[4];
+        compCap( lsum );
+        return Bu::String( (const char *)lsum, 4*4 );
+}
+
+void Bu::Md5::writeResult( Bu::Stream &sOut )
+{
+        uint32_t lsum[4];
+        compCap( lsum );
+        sOut.write( lsum, 4*4 );
+}
+
+void Bu::Md5::compCap( uint32_t *sumout )
+{
+        uint8_t tmpbuf[64];
+        memcpy( sumout, sum, 4*4 );
+        memcpy( tmpbuf, inbuf, 64 );
+
+        uint32_t count;
+        uint8_t *p;
+
+        /* Compute number of bytes mod 64 */
+        count = (uBits[0] >> 3) & 0x3F;
+
+        /* Set the first char of padding to 0x80.  This is safe since there is
+           always at least one byte free */
+        p = tmpbuf + count;
+        *p++ = 0x80;
+
+        /* Bytes of padding needed to make 64 bytes */
+        count = 64 - 1 - count;
+
+        /* Pad out to 56 mod 64 */
+        if (count < 8) {
+                /* Two lots of padding:  Pad the first block to 64 bytes */
+                memset( p, 0, count );
+                toLittleEndian( tmpbuf, 16 );
+                compBlock( sumout, (uint32_t *)tmpbuf );
+
+                /* Now fill the next block with 56 bytes */
+                memset( tmpbuf, 0, 56);
+        } else {
+                /* Pad block to 56 bytes */
+                memset( p, 0, count - 8);
+        }
+        toLittleEndian( tmpbuf, 14 );
+
+        /* Append length in bits and transform */
+        ((uint32_t *) tmpbuf)[14] = uBits[0];
+        ((uint32_t *) tmpbuf)[15] = uBits[1];
+
+        compBlock( sumout, (uint32_t *)tmpbuf );
+        toLittleEndian((unsigned char *)sumout, 4);
+}
+
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+/* This is the central step in the MD5 algorithm. */
+#define MD5STEP(f, w, x, y, z, data, s) \
+        ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+
+void Bu::Md5::compBlock( uint32_t *lsum, uint32_t *x )
+{
+        register uint32_t a, b, c, d;
+        a = lsum[0];
+        b = lsum[1];
+        c = lsum[2];
+        d = lsum[3];
+
+    MD5STEP(F1, a, b, c, d, x[0] + 0xd76aa478, 7);
+    MD5STEP(F1, d, a, b, c, x[1] + 0xe8c7b756, 12);
+    MD5STEP(F1, c, d, a, b, x[2] + 0x242070db, 17);
+    MD5STEP(F1, b, c, d, a, x[3] + 0xc1bdceee, 22);
+    MD5STEP(F1, a, b, c, d, x[4] + 0xf57c0faf, 7);
+    MD5STEP(F1, d, a, b, c, x[5] + 0x4787c62a, 12);
+    MD5STEP(F1, c, d, a, b, x[6] + 0xa8304613, 17);
+    MD5STEP(F1, b, c, d, a, x[7] + 0xfd469501, 22);
+    MD5STEP(F1, a, b, c, d, x[8] + 0x698098d8, 7);
+    MD5STEP(F1, d, a, b, c, x[9] + 0x8b44f7af, 12);
+    MD5STEP(F1, c, d, a, b, x[10] + 0xffff5bb1, 17);
+    MD5STEP(F1, b, c, d, a, x[11] + 0x895cd7be, 22);
+    MD5STEP(F1, a, b, c, d, x[12] + 0x6b901122, 7);
+    MD5STEP(F1, d, a, b, c, x[13] + 0xfd987193, 12);
+    MD5STEP(F1, c, d, a, b, x[14] + 0xa679438e, 17);
+    MD5STEP(F1, b, c, d, a, x[15] + 0x49b40821, 22);
+
+    MD5STEP(F2, a, b, c, d, x[1] + 0xf61e2562, 5);
+    MD5STEP(F2, d, a, b, c, x[6] + 0xc040b340, 9);
+    MD5STEP(F2, c, d, a, b, x[11] + 0x265e5a51, 14);
+    MD5STEP(F2, b, c, d, a, x[0] + 0xe9b6c7aa, 20);
+    MD5STEP(F2, a, b, c, d, x[5] + 0xd62f105d, 5);
+    MD5STEP(F2, d, a, b, c, x[10] + 0x02441453, 9);
+    MD5STEP(F2, c, d, a, b, x[15] + 0xd8a1e681, 14);
+    MD5STEP(F2, b, c, d, a, x[4] + 0xe7d3fbc8, 20);
+    MD5STEP(F2, a, b, c, d, x[9] + 0x21e1cde6, 5);
+    MD5STEP(F2, d, a, b, c, x[14] + 0xc33707d6, 9);
+    MD5STEP(F2, c, d, a, b, x[3] + 0xf4d50d87, 14);
+    MD5STEP(F2, b, c, d, a, x[8] + 0x455a14ed, 20);
+    MD5STEP(F2, a, b, c, d, x[13] + 0xa9e3e905, 5);
+    MD5STEP(F2, d, a, b, c, x[2] + 0xfcefa3f8, 9);
+    MD5STEP(F2, c, d, a, b, x[7] + 0x676f02d9, 14);
+    MD5STEP(F2, b, c, d, a, x[12] + 0x8d2a4c8a, 20);
+
+    MD5STEP(F3, a, b, c, d, x[5] + 0xfffa3942, 4);
+    MD5STEP(F3, d, a, b, c, x[8] + 0x8771f681, 11);
+    MD5STEP(F3, c, d, a, b, x[11] + 0x6d9d6122, 16);
+    MD5STEP(F3, b, c, d, a, x[14] + 0xfde5380c, 23);
+    MD5STEP(F3, a, b, c, d, x[1] + 0xa4beea44, 4);
+    MD5STEP(F3, d, a, b, c, x[4] + 0x4bdecfa9, 11);
+    MD5STEP(F3, c, d, a, b, x[7] + 0xf6bb4b60, 16);
+    MD5STEP(F3, b, c, d, a, x[10] + 0xbebfbc70, 23);
+    MD5STEP(F3, a, b, c, d, x[13] + 0x289b7ec6, 4);
+    MD5STEP(F3, d, a, b, c, x[0] + 0xeaa127fa, 11);
+    MD5STEP(F3, c, d, a, b, x[3] + 0xd4ef3085, 16);
+    MD5STEP(F3, b, c, d, a, x[6] + 0x04881d05, 23);
+    MD5STEP(F3, a, b, c, d, x[9] + 0xd9d4d039, 4);
+    MD5STEP(F3, d, a, b, c, x[12] + 0xe6db99e5, 11);
+    MD5STEP(F3, c, d, a, b, x[15] + 0x1fa27cf8, 16);
+    MD5STEP(F3, b, c, d, a, x[2] + 0xc4ac5665, 23);
+
+    MD5STEP(F4, a, b, c, d, x[0] + 0xf4292244, 6);
+    MD5STEP(F4, d, a, b, c, x[7] + 0x432aff97, 10);
+    MD5STEP(F4, c, d, a, b, x[14] + 0xab9423a7, 15);
+    MD5STEP(F4, b, c, d, a, x[5] + 0xfc93a039, 21);
+    MD5STEP(F4, a, b, c, d, x[12] + 0x655b59c3, 6);
+    MD5STEP(F4, d, a, b, c, x[3] + 0x8f0ccc92, 10);
+    MD5STEP(F4, c, d, a, b, x[10] + 0xffeff47d, 15);
+    MD5STEP(F4, b, c, d, a, x[1] + 0x85845dd1, 21);
+    MD5STEP(F4, a, b, c, d, x[8] + 0x6fa87e4f, 6);
+    MD5STEP(F4, d, a, b, c, x[15] + 0xfe2ce6e0, 10);
+    MD5STEP(F4, c, d, a, b, x[6] + 0xa3014314, 15);
+    MD5STEP(F4, b, c, d, a, x[13] + 0x4e0811a1, 21);
+    MD5STEP(F4, a, b, c, d, x[4] + 0xf7537e82, 6);
+    MD5STEP(F4, d, a, b, c, x[11] + 0xbd3af235, 10);
+    MD5STEP(F4, c, d, a, b, x[2] + 0x2ad7d2bb, 15);
+    MD5STEP(F4, b, c, d, a, x[9] + 0xeb86d391, 21);
+
+        lsum[0] += a;
+        lsum[1] += b;
+        lsum[2] += c;
+        lsum[3] += d;
+}
+
+void Bu::Md5::_toLittleEndian( uint8_t *buf, uint32_t count )
+{
+        uint32_t t;
+        do {
+                t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
+                        ((unsigned) buf[1] << 8 | buf[0]);
+                *(uint32_t *) buf = t;
+                buf += 4;
+        } while( --count );
+}
diff --git a/src/stable/md5.h b/src/stable/md5.h
new file mode 100644
index 0000000..b7597fd
--- /dev/null
+++ b/src/stable/md5.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_MD5_H
+#define BU_MD5_H
+
+#include "bu/cryptohash.h"
+
+namespace Bu
+{
+        /**
+         * Class for easily calculating MD5 sums of just about any data.
+         * This code is based on some public domain code written by Colin Plumb in
+         * 1993.
+         *@author Mike Buland
+         */
+        class Md5 : public Bu::CryptoHash
+        {
+        public:
+                /** Build an MD5 sum builder. */
+                Md5();
+
+                /** Deconstruct */
+                virtual ~Md5();
+
+                virtual void reset();
+                virtual void setSalt( const Bu::String &sSalt );
+                virtual void addData( const void *sData, int iSize );
+                using Bu::CryptoHash::addData;
+                virtual String getResult();
+                virtual void writeResult( Bu::Stream &sOut );
+
+        private:
+                /**
+                 * Compute one block of input data.
+                 */
+                void compBlock( uint32_t *lsum, uint32_t *x );
+                void compCap( uint32_t *sumout );
+
+                void _addData( uint8_t *target, int &iCurFill, const void *sData,
+                                int iSize );
+                void _toLittleEndian( uint8_t *buf, uint32_t count );
+                
+                uint8_t inbuf[64];
+                uint32_t sum[4];
+                uint32_t uBits[2];
+        };
+};
+
+#endif
diff --git a/src/stable/membuf.cpp b/src/stable/membuf.cpp
new file mode 100644
index 0000000..14d0d58
--- /dev/null
+++ b/src/stable/membuf.cpp
@@ -0,0 +1,177 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/membuf.h"
+
+using namespace Bu;
+
+Bu::MemBuf::MemBuf() :
+        nPos( 0 )
+{
+}
+
+Bu::MemBuf::MemBuf( const Bu::String &str ) :
+        sBuf( str ),
+        nPos( 0 )
+{
+}
+
+Bu::MemBuf::~MemBuf()
+{
+}
+
+void Bu::MemBuf::close()
+{
+}
+
+size Bu::MemBuf::read( void *pBuf, size nBytes )
+{
+        if( (size)sBuf.getSize()-(size)nPos < nBytes )
+                nBytes = sBuf.getSize()-nPos;
+
+        memcpy( pBuf, sBuf.getStr()+nPos, nBytes );
+        nPos += nBytes;
+
+        return nBytes;
+}
+        
+size Bu::MemBuf::write( const void *pBuf, size nBytes )
+{
+        if( nPos == sBuf.getSize() )
+        {
+                // Easiest, just append the data.
+                sBuf.append( (const char *)pBuf, nBytes );
+                nPos += nBytes;
+                return nBytes;
+        }
+        else
+        {
+                // Trickier, we must do this in two parts, overwrite, then append
+                // Frist, overwrite.
+                size iOver = sBuf.getSize() - nPos;
+                if( iOver > nBytes )
+                        iOver = nBytes;
+                memcpy( sBuf.getStr()+nPos, pBuf, iOver );
+                // Then append
+                if( iOver < nBytes )
+                {
+                        sBuf.append( ((const char *)pBuf)+iOver, nBytes-iOver );
+                }
+                nPos += nBytes;
+                return nBytes;
+        }
+}
+
+size Bu::MemBuf::tell()
+{
+        return nPos;
+}
+
+void Bu::MemBuf::seek( size offset )
+{
+        nPos += offset;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+}
+
+void Bu::MemBuf::setPos( size pos )
+{
+        nPos = pos;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+}
+
+void Bu::MemBuf::setPosEnd( size 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 true;
+}
+
+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 )
+{
+}
+
+void Bu::MemBuf::setSize( size iSize )
+{
+        if( iSize < 0 )
+                iSize = 0;
+        sBuf.setSize( iSize );
+        if( nPos > iSize )
+                nPos = iSize;
+}
+
+Bu::size Bu::MemBuf::getSize() const
+{
+        return sBuf.getSize();
+}
+
+Bu::size Bu::MemBuf::getBlockSize() const
+{
+        return sBuf.getSize();
+}
+
+Bu::String Bu::MemBuf::getLocation() const
+{
+        return "";
+}
+
+Bu::String &Bu::MemBuf::getString()
+{
+        return sBuf;
+}
+
+void Bu::MemBuf::setString( const Bu::String &sNewData )
+{
+        sBuf = sNewData;
+        nPos = 0;
+}
+
diff --git a/src/stable/membuf.h b/src/stable/membuf.h
new file mode 100644
index 0000000..544dc83
--- /dev/null
+++ b/src/stable/membuf.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_MEM_BUF_H
+#define BU_MEM_BUF_H
+
+#include <stdint.h>
+
+#include "bu/config.h"
+#include "bu/stream.h"
+#include "bu/string.h"
+
+namespace Bu
+{
+        /**
+         * A memory buffer stream.  This provides a read/write stream in memory that
+         * works exactly like a file stream...only in memory.  You can seed the
+         * memory buffer with a Bu::String of your own, or start with an empty one.
+         * Due to Bu::String using Bu::SharedCore starting with a string will not
+         * necesarilly cause the MemBuf to make a copy of your memory, but if you're
+         * sure you're not going to need to change the stream then use StaticMemBuf.
+         *@ingroup Streams
+         */
+        class MemBuf : public Stream
+        {
+        public:
+                MemBuf();
+                MemBuf( const Bu::String &str );
+                virtual ~MemBuf();
+
+                virtual void close();
+                virtual size read( void *pBuf, size iBytes );
+
+                virtual size write( const void *pBuf, size iBytes );
+                using Stream::write;
+                virtual size tell();
+                virtual void seek( size offset );
+                virtual void setPos( size pos );
+                virtual void setPosEnd( size 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 );
+                virtual void setSize( size iSize );
+                virtual size getSize() const;
+                virtual size getBlockSize() const;
+                virtual Bu::String getLocation() const;
+
+                Bu::String &getString();
+                void setString( const Bu::String &sNewData );
+
+        private:
+                Bu::String sBuf;
+                size nPos;
+        };
+}
+
+#endif
diff --git a/src/stable/minicron.cpp b/src/stable/minicron.cpp
new file mode 100644
index 0000000..95cf66b
--- /dev/null
+++ b/src/stable/minicron.cpp
@@ -0,0 +1,477 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/minicron.h"
+
+#include <stdlib.h>
+#include <time.h>
+
+Bu::MiniCron::MiniCron() :
+        jidNext( 1 )
+{
+}
+
+Bu::MiniCron::~MiniCron()
+{
+        while( !hJobs.isEmpty() )
+        {
+                delete hJobs.dequeue();
+        }
+}
+
+bool Bu::MiniCron::hasJobs()
+{
+        return !hJobs.isEmpty();
+}
+
+time_t Bu::MiniCron::getNextRun()
+{
+        if( hasJobs() )
+                return hJobs.peek()->getNextRun();
+        return -1;
+}
+
+time_t Bu::MiniCron::getNextRun( Bu::MiniCron::JobId jid )
+{
+        for( JobHeap::iterator i = hJobs.begin(); i; i++ )
+        {
+                if( (*i)->getId() == jid )
+                {
+                        return (*i)->getNextRunTime();
+                }
+        }
+        return -1;
+}
+
+void Bu::MiniCron::poll()
+{
+        time_t tNow = time( NULL );
+
+        while( !hJobs.isEmpty() )
+        {
+                if( hJobs.peek()->getNextRun() <= tNow )
+                {
+                        Job *pJob = hJobs.dequeue();
+                        pJob->run();
+                        if( pJob->bContinue )
+                        {
+                                hJobs.enqueue( pJob );
+                        }
+                        else
+                        {
+                                delete pJob;
+                        }
+                }
+                else
+                {
+                        break;
+                }
+        }
+}
+
+Bu::MiniCron::JobId Bu::MiniCron::addJob( const Bu::String &sName,
+                Bu::MiniCron::CronSignal sigJob, const Bu::MiniCron::Timer &t )
+{
+        JobId jid = jidNext++;
+        Job *pJob = new Job( sName, jid );
+        pJob->sigJob = sigJob;
+        pJob->pTimer = t.clone();
+        pJob->tNextRun = pJob->pTimer->nextTime();
+        hJobs.enqueue( pJob );
+
+        return jid;
+}
+
+Bu::MiniCron::JobId Bu::MiniCron::addJobOnce( const Bu::String &sName,
+                Bu::MiniCron::CronSignal sigJob, const Bu::MiniCron::Timer &t )
+{
+        JobId jid = jidNext++;
+        Job *pJob = new Job( sName, jid, false );
+        pJob->sigJob = sigJob;
+        pJob->pTimer = t.clone();
+        pJob->tNextRun = pJob->pTimer->nextTime();
+        hJobs.enqueue( pJob );
+
+        return jid;
+}
+
+void Bu::MiniCron::removeJob( JobId jid )
+{
+        Bu::List<Job *> lJobs;
+        while( !hJobs.isEmpty() )
+        {
+                Job *pJob = hJobs.dequeue();
+                if( pJob->getId() == jid )
+                {
+                        delete pJob;
+                }
+                else
+                        lJobs.append( pJob );
+        }
+
+        for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
+        {
+                hJobs.enqueue( *i );
+        }
+}
+
+void Bu::MiniCron::runJob( JobId jid, bool bReschedule )
+{
+        Bu::List<Job *> lJobs;
+        while( !hJobs.isEmpty() )
+        {
+                Job *pJob = hJobs.dequeue();
+                if( pJob->getId() == jid )
+                {
+                        pJob->run( bReschedule );
+                        if( !pJob->bContinue )
+                        {
+                                delete pJob;
+                                break;
+                        }
+                        lJobs.append( pJob );
+                        break;
+                }
+                lJobs.append( pJob );
+        }
+
+        for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
+        {
+                hJobs.enqueue( *i );
+        }
+}
+
+void Bu::MiniCron::runJob( const Bu::String &sName, bool bReschedule )
+{
+        Bu::List<Job *> lJobs;
+        while( !hJobs.isEmpty() )
+        {
+                Job *pJob = hJobs.dequeue();
+                if( pJob->getName() == sName )
+                {
+                        pJob->run( bReschedule );
+                        if( !pJob->bContinue )
+                        {
+                                delete pJob;
+                                break;
+                        }
+                        lJobs.append( pJob );
+                        break;
+                }
+                lJobs.append( pJob );
+        }
+
+        for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
+        {
+                hJobs.enqueue( *i );
+        }
+}
+
+Bu::MiniCron::JobInfoList Bu::MiniCron::getJobInfo()
+{
+        JobInfoList lRet;
+        for( JobHeap::iterator i = hJobs.begin(); i; i++ )
+        {
+                lRet.append(
+                        JobInfo( (*i)->getName(), (*i)->getId(), (*i)->getNextRun() )
+                        );
+        }
+        lRet.sort();
+        return lRet;
+}
+
+Bu::MiniCron::Job::Job( const Bu::String &sName, JobId jid, bool bRepeat ) :
+        sName( sName ),
+        pTimer( NULL ),
+        bContinue( bRepeat ),
+        jid( jid ),
+        tAdded( time( NULL ) ),
+        iRunCount( 0 )
+{
+}
+
+Bu::MiniCron::Job::~Job()
+{
+        delete pTimer;
+        pTimer = NULL;
+}
+
+void Bu::MiniCron::Job::run( bool bReschedule )
+{
+        iRunCount++;
+        if( bReschedule )
+                tNextRun = pTimer->nextTime();
+        sigJob( *this );
+}
+
+time_t Bu::MiniCron::Job::getNextRun() const
+{
+        return tNextRun;
+}
+
+void Bu::MiniCron::Job::calcNextRun()
+{
+        if( pTimer )
+                tNextRun = pTimer->nextTime();
+}
+
+void Bu::MiniCron::Job::setTimer( const Timer &t )
+{
+        delete pTimer;
+        pTimer = t.clone();
+}
+
+void Bu::MiniCron::Job::stop()
+{
+        bContinue = false;
+}
+
+void Bu::MiniCron::Job::resume()
+{
+        bContinue = true;
+}
+
+Bu::MiniCron::JobId Bu::MiniCron::Job::getId() const
+{
+        return jid;
+}
+
+time_t Bu::MiniCron::Job::getTimeCreated() const
+{
+        return tAdded;
+}
+
+int Bu::MiniCron::Job::getRunCount() const
+{
+        return iRunCount;
+}
+
+time_t Bu::MiniCron::Job::getNextRunTime() const
+{
+        return tNextRun;
+}
+
+Bu::String Bu::MiniCron::Job::getName() const
+{
+        return sName;
+}
+
+Bu::MiniCron::JobInfo::JobInfo( const Bu::String &sName, JobId jid,
+                time_t tNext ) :
+        sName( sName ),
+        jid( jid ),
+        tNext( tNext )
+{
+}
+
+Bu::MiniCron::JobInfo::~JobInfo()
+{
+}
+
+bool Bu::MiniCron::JobInfo::operator<( const JobInfo &rhs ) const
+{
+        return jid < rhs.jid;
+}
+
+Bu::MiniCron::Timer::Timer()
+{
+}
+
+Bu::MiniCron::Timer::~Timer()
+{
+}
+
+Bu::MiniCron::TimerInterval::TimerInterval( time_t tFirst, time_t tInterval ) :
+        tNext( tFirst ),
+        tInterval( tInterval )
+{
+}
+
+Bu::MiniCron::TimerInterval::~TimerInterval()
+{
+}
+
+time_t Bu::MiniCron::TimerInterval::nextTime()
+{
+        time_t tRet = tNext;
+        tNext += tInterval;
+        return tRet;
+}
+
+Bu::MiniCron::TimerBasic::TimerBasic( const Bu::String &s ) :
+        tLast( -1 ),
+        sSpec( s )
+{
+}
+
+Bu::MiniCron::TimerBasic::~TimerBasic()
+{
+}
+
+time_t Bu::MiniCron::TimerBasic::nextTime()
+{
+        if( tLast == -1 )
+                tLast = time( NULL );
+
+        Bu::String::const_iterator i = sSpec.begin();
+        switch( lex( i ) )
+        {
+                case tokDaily:
+                        {
+                                int iHour = lexInt( i );
+                                int iMin = lexInt( i );
+
+                                struct tm t;
+                                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
+                                if( iHour < t.tm_hour ||
+                                        (iHour == t.tm_hour && iMin <= t.tm_min) )
+                                {
+                                        t.tm_mday++;
+                                }
+                                t.tm_hour = iHour;
+                                t.tm_min = iMin;
+                                t.tm_sec = 0;
+                                tLast = mktime( &t );
+                        }
+                        break;
+
+                case tokHourly:
+                        {
+                                int iMin = lexInt( i );
+
+                                struct tm t;
+                                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
+                                if( iMin <= t.tm_min )
+                                        t.tm_hour++;
+                                t.tm_min = iMin;
+                                t.tm_sec = 0;
+                                tLast = mktime( &t );
+                        }
+                        break;
+
+                case tokWeekly:
+                        {
+                                int iDay = lexInt( i );
+                                int iHour = lexInt( i );
+                                int iMin = lexInt( i );
+                                
+                                struct tm t;
+                                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
+                                if( iDay < t.tm_wday || 
+                                        (iDay == t.tm_wday && iHour < t.tm_hour) ||
+                                        (iDay == t.tm_wday && iHour == t.tm_hour
+                                         && iMin <= t.tm_min) )
+                                {
+                                        if( iDay <= t.tm_wday )
+                                                t.tm_mday += 7 - (t.tm_wday-iDay);
+                                        else
+                                                t.tm_mday += 7 - (iDay-t.tm_wday);
+                                }
+                                else
+                                {
+                                        t.tm_mday += (iDay-t.tm_wday);
+                                }
+                                t.tm_hour = iHour;
+                                t.tm_min = iMin;
+                                t.tm_sec = 0;
+                                tLast = mktime( &t );
+                        }
+                        break;
+
+                case tokMonthly:
+                        break;
+
+                case tokYearly:
+                        break;
+
+                default:
+                        break;
+        }
+
+        return tLast;
+}
+
+Bu::MiniCron::TimerBasic::Token Bu::MiniCron::TimerBasic::lex(
+                Bu::String::const_iterator &i )
+{
+        if( !i )
+        {
+                return tokEos;
+        }
+
+        Bu::String::const_iterator b = i;
+
+        for(; b && (*b == ' ' || *b == '\t'); b++ ) { i = b+1; }
+        for(; b && *b != ' ' && *b != '\t'; b++ ) { }
+
+        Bu::String sTok( i, b );
+        i = b;
+
+        if( sTok == "daily" )
+                return tokDaily;
+        else if( sTok == "hourly" )
+                return tokHourly;
+        else if( sTok == "weekly" )
+                return tokWeekly;
+        else if( sTok == "monthly" )
+                return tokMonthly;
+        else if( sTok == "yearly" )
+                return tokYearly;
+        else if( sTok == "sun" )
+        {
+                iVal = 0;
+                return valInt;
+        }
+        else if( sTok == "mon" )
+        {
+                iVal = 1;
+                return valInt;
+        }
+        else if( sTok == "tue" )
+        {
+                iVal = 2;
+                return valInt;
+        }
+        else if( sTok == "wed" )
+        {
+                iVal = 3;
+                return valInt;
+        }
+        else if( sTok == "thu" )
+        {
+                iVal = 4;
+                return valInt;
+        }
+        else if( sTok == "fri" )
+        {
+                iVal = 5;
+                return valInt;
+        }
+        else if( sTok == "sat" )
+        {
+                iVal = 6;
+                return valInt;
+        }
+        else if( sTok[0] >= '0' && sTok[0] <= '9' )
+        {
+                iVal = strtol( sTok.getStr(), NULL, 0 );
+                return valInt;
+        }
+
+        return tokErr;
+}
+
+int Bu::MiniCron::TimerBasic::lexInt( Bu::String::const_iterator &i )
+{
+        Token t = lex( i );
+        if( t == tokEos )
+                return 0;
+        if( t != valInt )
+                throw Bu::ExceptionBase("Expected int, got something else.");
+        return iVal;
+}
+
diff --git a/src/stable/minicron.h b/src/stable/minicron.h
new file mode 100644
index 0000000..0d1cb62
--- /dev/null
+++ b/src/stable/minicron.h
@@ -0,0 +1,336 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_MINICRON_H
+#define BU_MINICRON_H
+
+#include "bu/signals.h"
+#include "bu/heap.h"
+#include "bu/string.h"
+
+#include <time.h>
+
+namespace Bu
+{
+        /**
+         * A simple cron like system designed to be embedded in any program.  This
+         * class creates a simple cron system that can run any number of jobs at
+         * customizable intervals or schedules.  It does not support some of the
+         * more complex scheduling that some cron systems can do such as load
+         * balancing directly, but this could be done on the job side.
+         *
+         * This system is synchronous, it does not use any threads on it's own, but
+         * it is threadsafe, so a cron thread could be created if desired.
+         *
+         * The operation is fairly simple, jobs can be added at any time, and use
+         * any timer they would like, even custom timers.  When it is time for a
+         * job to be run it signals the slot provided when the job was added.  Every
+         * job slot recieves a handle to the job object so that it may control it's
+         * own lifetime and get information about itself.  In addition, every job
+         * is assigned a unique ID that can be used to control it's operation
+         * at any time.
+         *
+         * By default a job will continually reschedule itself after being run
+         * unless it calls stop() on it's job object, it is removed using
+         * removeJob() on the cron object, or it is added with addJobOnce.
+         *
+         *@todo A minor change to the job execution system could allow a Timer to
+         * defer or reschedule execution instead of the job executing.  This would,
+         * in effect, allow us to do every type of interesting scheduling that
+         * systems like fcron offer, including time constrained load-balanced
+         * execution.
+         */
+        class MiniCron
+        {
+        public:
+                class Job;
+                class Timer;
+                typedef Bu::Signal1<void, Bu::MiniCron::Job &> CronSignal;
+                typedef int JobId;
+
+                MiniCron();
+                virtual ~MiniCron();
+
+                /**
+                 * Tells you if there are jobs registered in the MiniCron.
+                 *@returns true if there are jobs, false otherwise.
+                 */
+                virtual bool hasJobs();
+
+                /**
+                 * If there are jobs, tells you the time the next one will execute.
+                 *@returns The timestamp that the next job will execute at.
+                 */
+                virtual time_t getNextRun();
+                
+                /**
+                 * Tells you the time the job matching jid will run next.
+                 *@returns The timestamp that the job jid will next run.
+                 */
+                virtual time_t getNextRun( JobId jid );
+
+                /**
+                 * Call this regularly to execute all jobs that should be executed.
+                 * This will loop until all jobs who's run time match the current time
+                 * or are below the current time (we've missed them).
+                 * If there is nothing to run, the runtime of this funcion is constant,
+                 * it is very fast.  Otherwise it executes at log(N) per job run,
+                 * O(N*log(N)).
+                 */
+                virtual void poll();
+
+                /**
+                 * Add a job for repeated scheduling.  Pass in a slot to signal, and a
+                 * Timer object to use to do the scheduling.  This function returns a
+                 * JobId which can be used at a later time to control the execution of
+                 * the job.
+                 */
+                virtual JobId addJob( const Bu::String &sName, CronSignal sigJob,
+                                const Timer &t );
+
+                /**
+                 * Add a job for one time scheduling.  Pass in a slot to signal, and a
+                 * Timer object to use to schodule the one run of this job.  This
+                 * function returns a JobId which can be used at a later time to control
+                 * the execution of the job.
+                 */
+                virtual JobId addJobOnce( const Bu::String &sName, CronSignal sigJob,
+                                const Timer &t );
+
+                /**
+                 * Remove a job, preventing all future runs of the job.  If there is no
+                 * job matching the given JobId then nothing will happen.  However, this
+                 * function is relatively expensive compared to the others in this class
+                 * and has a worse case runtime of 2*N*log(N), still not that bad, and
+                 * a O(N*log(N)).
+                 */
+                virtual void removeJob( JobId jid );
+
+                /**
+                 * Executes the job specified right now.  If bReschedule is true then
+                 * the job is then removed from the queue and rescheduled as though
+                 * it's time had come naturally to be run.  Otherwise, it's run without
+                 * interrupting the normal schedule.
+                 */
+                virtual void runJob( JobId jid, bool bReschedule=false );
+
+                /**
+                 * Executes the job specified right now.  If bReschedule is true then
+                 * the job is then removed from the queue and rescheduled as though
+                 * it's time had come naturally to be run.  Otherwise, it's run without
+                 * interrupting the normal schedule.
+                 */
+                virtual void runJob( const Bu::String &sName, bool bReschedule=false );
+
+                class JobInfo
+                {
+                public:
+                        JobInfo( const Bu::String &sName, JobId jid, time_t tNext );
+                        virtual ~JobInfo();
+                        
+                        bool operator<( const JobInfo &rhs ) const;
+
+                        Bu::String sName;
+                        JobId jid;
+                        time_t tNext;
+                };
+                typedef Bu::List<JobInfo> JobInfoList;
+
+                JobInfoList getJobInfo();
+
+                /**
+                 * The baseclass for timer/schedulers for MiniCron jobs.  Classes that
+                 * inherit from this are used to determine when jobs will run and at
+                 * what interval.
+                 */
+                class Timer
+                {
+                public:
+                        Timer();
+                        virtual ~Timer();
+
+                        /**
+                         * Called by MiniCron when each job is run to determine the next
+                         * time that a job should be run.  When a job is run, this function
+                         * is actually called before the job is executed again so that the
+                         * job can tell when the next time it will be run will be.
+                         */
+                        virtual time_t nextTime()=0;
+
+                        /**
+                         * This function should return a copy of the child class.
+                         */
+                        virtual Timer *clone() const = 0;
+                };
+
+                /**
+                 * Execute the job every tInterval seconds, also you can delay the
+                 * first run by a different amount of time from the job's creation.
+                 */
+                class TimerInterval : public Timer
+                {
+                public:
+                        TimerInterval( time_t tFirst, time_t tInterval );
+                        virtual ~TimerInterval();
+
+                        virtual time_t nextTime();
+                        virtual Timer *clone() const
+                                { return new TimerInterval( *this ); }
+                private:
+                        time_t tNext;
+                        time_t tInterval;
+                };
+
+                /**
+                 * A much more general timer class that can be used for much more
+                 * "cron-like" functionality.  The constructor takes a string that
+                 * describes the times that the job should be run.  At the moment the
+                 * following schemes are understood:
+                 *
+                 * "daily [hour] [minute]"
+                 * "hourly [minute]"
+                 * "weekly [day] [hour] [minute]"
+                 *
+                 * In these examples each word in [brackets] represents a number that
+                 * matches the data type in the brackets.  [day] is the number of days
+                 * since sunday, 0-6.  You can also use lowercase three character
+                 * abbreviations for the day names.
+                 *
+                 * Many more forms follow.
+                 */
+                class TimerBasic : public Timer
+                {
+                public:
+                        TimerBasic( const Bu::String &s );
+                        virtual ~TimerBasic();
+
+                        virtual time_t nextTime();
+                        virtual Timer *clone() const
+                                { return new TimerBasic( *this ); }
+
+                private:
+                        enum Token
+                        {
+                                tokDaily,
+                                tokHourly,
+                                tokWeekly,
+                                tokMonthly,
+                                tokYearly,
+                                valInt,
+                                tokErr,
+                                tokEos
+                        };
+                        Token lex( Bu::String::const_iterator &i );
+                        int lexInt( Bu::String::const_iterator &i );
+                        int iVal; //< A temp variable for parsing.
+                        time_t tLast;
+                        Bu::String sSpec;
+                };
+                
+                /**
+                 * Represents a MiniCron Job.  This class is used for both internal
+                 * job management as well as job slot interaction and control.  Objects
+                 * of this class are passed into the slots that are signaled when a job
+                 * is executed.
+                 */
+                class Job
+                {
+                        friend class Bu::MiniCron;
+                private:
+                        Job( const Bu::String &sName, JobId jid, bool bRepeat=true );
+                        virtual ~Job();
+
+                public:
+
+                        /**
+                         * Execute this job once, increment the runcount and schedule the
+                         * next occurance of it.
+                         */
+                        void run( bool bReschedule=true );
+
+                        /**
+                         * Get the time this job will next run.
+                         */
+                        time_t getNextRun() const;
+
+                        /**
+                         * Compute the time this job will next run.
+                         */
+                        void calcNextRun();
+
+                        /**
+                         * Replace the current job timer with a new one, this will trigger
+                         * a re-schedule.
+                         */
+                        void setTimer( const Timer &t );
+
+                        /**
+                         * Stop execution of this job, never execute this job again.
+                         */
+                        void stop();
+
+                        /**
+                         * Undo a previous stop.  This will cause a job that has been
+                         * stopped or even added with addJobOnce to be set for repeated
+                         * scheduling.
+                         */
+                        void resume();
+
+                        /**
+                         * Get the unique ID of this job.
+                         */
+                        JobId getId() const;
+
+                        /**
+                         * Get the timestamp this job was created.
+                         */
+                        time_t getTimeCreated() const;
+
+                        /**
+                         * Get the current run count of this job, how many times it has been
+                         * executed.  This is incremented before the slot is signaled.
+                         */
+                        int getRunCount() const;
+
+                        /**
+                         * Get the next time that this job will be run.  Certain timers may
+                         * have the ability to delay job executions, so this is the earliest
+                         * time that the job may run.
+                         */
+                        time_t getNextRunTime() const;
+
+                        /**
+                         * Gets the name that was set when the job was created.
+                         */
+                        Bu::String getName() const;
+
+                private:
+                        Bu::String sName;
+                        CronSignal sigJob;
+                        time_t tNextRun;
+                        Timer *pTimer;
+                        bool bContinue;
+                        JobId jid;
+                        time_t tAdded;
+                        int iRunCount;
+                };
+
+        private:
+                struct JobPtrCmp
+                {
+                        bool operator()( const Job *pLeft, const Job *pRight )
+                        {
+                                return pLeft->tNextRun < pRight->tNextRun;
+                        }
+                };
+                typedef Bu::Heap<Job *, JobPtrCmp> JobHeap;
+                JobHeap hJobs;
+                JobId jidNext;
+        };
+};
+
+#endif
diff --git a/src/stable/multiserver.cpp b/src/stable/multiserver.cpp
new file mode 100644
index 0000000..bd598ed
--- /dev/null
+++ b/src/stable/multiserver.cpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/multiserver.h"
+#include "bu/protocol.h"
+#include "bu/client.h"
+
+#include "bu/config.h"
+
+Bu::MultiServer::MultiServer()
+{
+}
+
+Bu::MultiServer::~MultiServer()
+{
+}
+
+void Bu::MultiServer::addProtocol( Bu::Protocol *(*proc)(), int iPort,
+        int nPoolSize )
+{
+        hProtos[iPort] = proc;
+        addPort( iPort, nPoolSize );
+}
+
+void Bu::MultiServer::addProtocol( Protocol *(*proc)(), const String &sAddr,
+        int iPort, int nPoolSize )
+{
+        hProtos[iPort] = proc;
+        addPort( sAddr, iPort, nPoolSize );
+}
+
+void Bu::MultiServer::onNewConnection( Bu::Client *pClient, int nPort )
+{
+        pClient->setProtocol( hProtos.get( nPort )() );
+}
+
+void Bu::MultiServer::onClosedConnection( Bu::Client *pClient )
+{
+        delete pClient->getProtocol();
+}
+
+void Bu::MultiServer::shutdown()
+{
+        Bu::Server::shutdown();
+}
+
+void Bu::MultiServer::tick()
+{
+        Bu::Server::tick();
+}
+
diff --git a/src/stable/multiserver.h b/src/stable/multiserver.h
new file mode 100644
index 0000000..e3b3ec3
--- /dev/null
+++ b/src/stable/multiserver.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_MULTI_SERVER_H
+#define BU_MULTI_SERVER_H
+
+#include "bu/server.h"
+#include "bu/hash.h"
+
+namespace Bu
+{
+        class Protocol;
+        class Client;
+
+        template<class T>
+        Protocol *genProtocol()
+        {
+                return new T;
+        }
+
+        class MultiServer : protected Server
+        {
+        public:
+                MultiServer();
+                virtual ~MultiServer();
+
+                void addProtocol( Protocol *(*proc)(), int iPort, int nPoolSize=40 );
+                void addProtocol( Protocol *(*proc)(), const String &sAddr, int iPort,
+                                int nPoolSize=40 );
+                
+                void scan()
+                {
+                        Server::scan();
+                }
+
+                void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 )
+                {
+                        Server::setTimeout( nTimeoutSec, nTimeoutUSec );
+                }
+
+                virtual void onNewConnection( Client *pClient, int nPort );
+                virtual void onClosedConnection( Client *pClient );
+
+                void shutdown();
+
+                void tick();
+
+        private:
+                Bu::Hash<int, Protocol *(*)()> hProtos;
+        };
+}
+
+#endif
diff --git a/src/stable/mutex.cpp b/src/stable/mutex.cpp
new file mode 100644
index 0000000..dbaaece
--- /dev/null
+++ b/src/stable/mutex.cpp
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/mutex.h"
+
+Bu::Mutex::Mutex()
+{
+        pthread_mutex_init( &mutex, NULL );
+}
+
+Bu::Mutex::~Mutex()
+{
+        pthread_mutex_destroy( &mutex );
+}
+
+int Bu::Mutex::lock()
+{
+        return pthread_mutex_lock( &mutex );
+}
+
+int Bu::Mutex::unlock()
+{
+        return pthread_mutex_unlock( &mutex );
+}
+
+int Bu::Mutex::trylock()
+{
+        return pthread_mutex_trylock( &mutex );
+}
+
diff --git a/src/stable/mutex.h b/src/stable/mutex.h
new file mode 100644
index 0000000..b5c8b7a
--- /dev/null
+++ b/src/stable/mutex.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_MUTEX_H
+#define BU_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.
+         *@ingroup Threading
+         */
+        class Mutex
+        {
+        public:
+                /**
+                 * Create an unlocked mutex.
+                 */
+                Mutex();
+                
+                /**
+                 * 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.
+                 */
+                ~Mutex();
+
+                /**
+                 * 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/stable/mutexlocker.cpp b/src/stable/mutexlocker.cpp
new file mode 100644
index 0000000..90b730e
--- /dev/null
+++ b/src/stable/mutexlocker.cpp
@@ -0,0 +1,24 @@
+#include "bu/mutexlocker.h"
+#include "bu/mutex.h"
+
+Bu::MutexLocker::MutexLocker( Bu::Mutex &mu ) :
+        mu( mu )
+{
+        mu.lock();
+}
+
+Bu::MutexLocker::~MutexLocker()
+{
+        mu.unlock();
+}
+
+void Bu::MutexLocker::unlock()
+{
+        mu.unlock();
+}
+
+void Bu::MutexLocker::relock()
+{
+        mu.lock();
+}
+
diff --git a/src/stable/mutexlocker.h b/src/stable/mutexlocker.h
new file mode 100644
index 0000000..7c3c97e
--- /dev/null
+++ b/src/stable/mutexlocker.h
@@ -0,0 +1,21 @@
+#ifndef BU_MUTEX_LOCKER_H
+#define BU_MUTEX_LOCKER_H
+
+namespace Bu
+{
+        class Mutex;
+        class MutexLocker
+        {
+        public:
+                MutexLocker( Mutex &mu );
+                virtual ~MutexLocker();
+
+                void unlock();
+                void relock();
+
+        private:
+                Mutex &mu;
+        };
+};
+
+#endif
diff --git a/src/stable/nullstream.cpp b/src/stable/nullstream.cpp
new file mode 100644
index 0000000..9552cc5
--- /dev/null
+++ b/src/stable/nullstream.cpp
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/nullstream.h"
+
+Bu::NullStream::NullStream() :
+        sRead( 0 ),
+        sWrote( 0 )
+{
+}
+
+Bu::NullStream::~NullStream()
+{
+}
+
+void Bu::NullStream::close()
+{
+        sRead = sWrote = 0;
+}
+
+Bu::size Bu::NullStream::read( void *pBuf, Bu::size nBytes )
+{
+        memset( pBuf, 0, nBytes );
+        sRead += nBytes;
+        return nBytes;
+}
+
+Bu::String Bu::NullStream::readLine()
+{
+        sRead++;
+        return Bu::String("\0", 1 );
+}
+
+Bu::size Bu::NullStream::write( const void *, Bu::size nBytes )
+{
+        sWrote += nBytes;
+        return nBytes;
+}
+
+Bu::size Bu::NullStream::tell()
+{
+        return sRead + sWrote;
+}
+
+void Bu::NullStream::seek( Bu::size )
+{
+}
+
+void Bu::NullStream::setPos( Bu::size )
+{
+}
+
+void Bu::NullStream::setPosEnd( Bu::size )
+{
+}
+
+bool Bu::NullStream::isEos()
+{
+        return false;
+}
+
+bool Bu::NullStream::isOpen()
+{
+        return true;
+}
+
+void Bu::NullStream::flush()
+{
+}
+
+bool Bu::NullStream::canRead()
+{
+        return true;
+}
+
+bool Bu::NullStream::canWrite()
+{
+        return true;
+}
+
+bool Bu::NullStream::isReadable()
+{
+        return true;
+}
+
+bool Bu::NullStream::isWritable()
+{
+        return true;
+}
+
+bool Bu::NullStream::isSeekable()
+{
+        return false;
+}
+
+bool Bu::NullStream::isBlocking()
+{
+        return true;
+}
+
+void Bu::NullStream::setBlocking( bool )
+{
+}
+
+void Bu::NullStream::setSize( Bu::size )
+{
+}
+
+Bu::size Bu::NullStream::getSize() const
+{
+        return 0;
+}
+
+Bu::size Bu::NullStream::getBlockSize() const
+{
+        return 0;
+}
+
+Bu::String Bu::NullStream::getLocation() const
+{
+        return "";
+}
+
diff --git a/src/stable/nullstream.h b/src/stable/nullstream.h
new file mode 100644
index 0000000..9b75332
--- /dev/null
+++ b/src/stable/nullstream.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_NULL_STREAM_H
+#define BU_NULL_STREAM_H
+
+#include "bu/stream.h"
+
+namespace Bu
+{
+        /**
+         * Works a lot like /dev/null on *nix style systems.  This class allows
+         * infinite reading and writing.  All operatorns "succeed" even if they
+         * don't seem to do anything.  This is great for testing writing code or
+         * doing dry runs.  When reading, it will produce NULL bytes, so any
+         * application that would like the ability to produce null streams as a
+         * snap-in replacement for any other Bu::Stream, this is the right option.
+         *
+         * As an added feature, the NullStream will track how many bytes it was
+         * asked to read and write, allowing you to use it to determine how many
+         * bytes a write opretion would use without actually writing anything.
+         */
+        class NullStream : public Bu::Stream
+        {
+        public:
+                NullStream();
+                virtual ~NullStream();
+
+                virtual void close();
+                virtual Bu::size read( void *pBuf, Bu::size nBytes );
+                virtual Bu::String readLine();
+                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+                using Bu::Stream::write;
+                virtual Bu::size tell();
+                virtual void seek( Bu::size offset );
+                virtual void setPos( Bu::size pos );
+                virtual void setPosEnd( Bu::size 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 );
+                virtual void setSize( Bu::size iSize );
+
+                virtual size getSize() const;
+                virtual size getBlockSize() const;
+                virtual Bu::String getLocation() const;
+
+                Bu::size getBytesRead() { return sRead; }
+                Bu::size getByetsWritten() { return sWrote; }
+
+        private:
+                Bu::size sRead;
+                Bu::size sWrote;
+        };
+};
+
+#endif
diff --git a/src/stable/optparser.cpp b/src/stable/optparser.cpp
new file mode 100644
index 0000000..050232c
--- /dev/null
+++ b/src/stable/optparser.cpp
@@ -0,0 +1,492 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/optparser.h"
+#include "bu/sio.h"
+using namespace Bu;
+
+#include <stdlib.h>
+
+Bu::OptParser::OptParser()
+{
+}
+
+Bu::OptParser::~OptParser()
+{
+}
+
+void Bu::OptParser::parse( int argc, char **argv )
+{
+        for( int j = 1; j < argc; j++ )
+        {
+                if( argv[j][0] == '-' )
+                {
+                        // Now we're on to something, which kind is it?
+                        if( argv[j][1] == '-' )
+                        {
+                                int iEPos;
+                                for( iEPos = 2; argv[j][iEPos] != '\0' &&
+                                         argv[j][iEPos] != '='; iEPos++ ) { }
+
+                                Bu::String sOpt;
+                                int iCount = argc-j;
+                                Bu::String sExtraParam;
+                                if( argv[j][iEPos] == '=' )
+                                {
+                                        sOpt.set( argv[j]+2, iEPos-2 );
+                                        iCount++;
+                                        sExtraParam.set( argv[j]+iEPos+1 );
+                                }
+                                else
+                                {
+                                        sOpt.set( argv[j]+2 );
+                                }
+                                if( !hlOption.has( sOpt ) )
+                                {
+                                        optionError( "--" + sOpt );
+                                }
+                                else
+                                {
+                                        // Long param, cool, that's easy, first search for =
+                                        Option *pOpt = hlOption.get( sOpt );
+                                        if( pOpt->sUsed )
+                                        {
+                                                Bu::StrArray aParams( iCount );
+                                                aParams.append( sOpt );
+                                                if( sExtraParam.isSet() )
+                                                {
+                                                        aParams.append( argv[j]+iEPos+1 );
+                                                }
+                                                for( int k = j+1; k < argc; k++ )
+                                                {
+                                                        aParams.append( argv[k] );
+                                                }
+                                                j += pOpt->sUsed( aParams );
+                                        }
+                                        else if( pOpt->pProxy )
+                                        {
+                                                if( pOpt->sOverride.isSet() )
+                                                {
+                                                        pOpt->pProxy->setValue( pOpt->sOverride );
+                                                }
+                                                else if( sExtraParam.isSet() )
+                                                {
+                                                        pOpt->pProxy->setValueFromStr( sExtraParam );
+                                                }
+                                                else if( argv[j+1] != '\0' )
+                                                {
+                                                        pOpt->pProxy->setValueFromStr( argv[j+1] );
+                                                        j++;
+                                                }
+                                        }
+                                }
+                        }
+                        else
+                        {
+                                int iCPos;
+                                for( iCPos = 1; argv[j][iCPos] != '\0'; iCPos++ )
+                                {
+                                        if( !hsOption.has( argv[j][iCPos] ) )
+                                        {
+                                                Bu::String sOpt("-");
+                                                sOpt += argv[j][iCPos];
+                                                optionError( sOpt );
+                                        }
+                                        else
+                                        {
+                                                Option *pOpt = hsOption.get( argv[j][iCPos] );
+                                                char buf[2] = {argv[j][iCPos], '\0'};
+                                                if( pOpt->sUsed )
+                                                {
+                                                        Bu::StrArray aParams( argc-j+1 );
+                                                        aParams.append( buf );
+                                                        int iMod = 0;
+                                                        if( argv[j][iCPos+1] != '\0' )
+                                                        {
+                                                                aParams.append( argv[j]+iCPos+1 );
+                                                                iMod = -1;
+                                                        }
+                                                        for( int k = j+1; k < argc; k++ )
+                                                        {
+                                                                aParams.append( argv[k] );
+                                                        }
+                                                        int iUsed = pOpt->sUsed( aParams );
+                                                        if( iUsed > 0 )
+                                                        {
+                                                                j += iUsed + iMod;
+                                                                break;
+                                                        }
+                                                }
+                                                else if( pOpt->pProxy )
+                                                {
+                                                        if( pOpt->sOverride.isSet() )
+                                                        {
+                                                                pOpt->pProxy->setValue( pOpt->sOverride );
+                                                        }
+                                                        else if( argv[j][iCPos+1] != '\0' )
+                                                        {
+                                                                pOpt->pProxy->setValueFromStr(
+                                                                        argv[j]+iCPos+1
+                                                                        );
+                                                                break;
+                                                        }
+                                                        else if( argv[j+1] )
+                                                        {
+                                                                pOpt->pProxy->setValueFromStr(
+                                                                        argv[j+1]
+                                                                        );
+                                                                j++;
+                                                                break;
+                                                        }
+                                                }
+                                        }
+                                }
+                        }
+                }
+                else
+                {
+                        if( !sNonOption )
+                        {
+                                optionError( argv[j] );
+                        }
+                        else
+                        {
+                                int iCount = argc-j;
+                                Bu::StrArray aParams( iCount );
+                                for( int k = j; k < argc; k++ )
+                                {
+                                        aParams.append( argv[k] );
+                                }
+                                j += sNonOption( aParams );
+                        }
+                }
+        }
+}
+
+void Bu::OptParser::parse( const Bu::String &sLine )
+{
+        Bu::String sCmd = sLine.clone();
+        int iParams = 0;
+        bool bInGap = true;
+        bool bInQuote = false;
+        for( Bu::String::iterator i = sCmd.begin(); i; i++ )
+        {
+                if( bInQuote == false && (*i == ' ' || *i == '\t') )
+                {
+                        if( bInGap == false )
+                        {
+                                bInGap = true;
+                        }
+                }
+                else if( *i == '"' )
+                {
+                        bInQuote = !bInQuote;
+                }
+                else
+                {
+                        if( bInGap )
+                        {
+                                iParams++;
+                                bInGap = false;
+                        }
+                }
+        }
+
+        bInQuote = false;
+        bInGap = true;
+        char **asParam = new char*[iParams];
+        iParams = 0;
+        for( char *i = sCmd.getStr(); *i; i++ )
+        {
+                if( bInQuote == false && (*i == ' ' || *i == '\t') )
+                {
+                        if( bInGap == false )
+                        {
+                                bInGap = true;
+                                *i = '\0';
+                        }
+                }
+                else if( *i == '"' )
+                {
+                        bInQuote = !bInQuote;
+                }
+                else
+                {
+                        if( bInGap )
+                        {
+                                asParam[iParams++] = i;
+                                bInGap = false;
+                        }
+                }
+        }
+
+        parse( iParams, asParam );
+
+        delete[] asParam;
+}
+
+void Bu::OptParser::addOption( const Option &opt )
+{
+        lOption.append( opt );
+        if( opt.cOpt != '\0' )
+                hsOption.insert( opt.cOpt, &lOption.last() );
+        if( opt.sOpt.isSet() )
+                hlOption.insert( opt.sOpt, &lOption.last() );
+}
+
+void Bu::OptParser::setOverride( char cOpt, const Bu::Variant &sOverride )
+{
+        hsOption.get( cOpt )->sOverride = sOverride;
+}
+
+void Bu::OptParser::setOverride( const Bu::String &sOpt, const Bu::Variant &sOverride )
+{
+        hlOption.get( sOpt )->sOverride = sOverride;
+}
+
+void Bu::OptParser::setHelpDefault( const Bu::String &sOpt, const Bu::String &sTxt )
+{
+        hlOption.get( sOpt )->sHelpDefault = sTxt;
+}
+
+void Bu::OptParser::addHelpOption( char c, const Bu::String &s, const Bu::String &sHelp )
+{
+        Option o;
+        o.sUsed = slot( this, &OptParser::optHelp );
+        o.cOpt = c;
+        o.sOpt = s;
+        o.sHelp = sHelp;
+        addOption( o );
+}
+
+void Bu::OptParser::addHelpBanner( const Bu::String &sText, bool bFormatted )
+{
+        Banner b;
+        b.sText = sText;
+        b.bFormatted = bFormatted;
+        if( lOption.getSize() > 0 )
+        {
+                for( b.iAfter = lOption.begin(); b.iAfter+1; b.iAfter++ ) { }
+        }
+        lBanner.append( b );
+}
+
+int Bu::OptParser::optHelp( StrArray /*aParams*/ )
+{
+        bool bHasShort = false;
+        int iMaxWidth = 0;
+        int iScrWidth = 80;
+        char *env = getenv("COLUMNS");
+        if( env )
+                iScrWidth = strtol( env, NULL, 10 );
+        for( OptionList::iterator i = lOption.begin(); i; i++ )
+        {
+                if( (*i).cOpt != '\0' )
+                        bHasShort = true;
+                int lOptSize = (*i).sOpt.getSize() + (*i).sHelpDefault.getSize();
+                if( (*i).sOpt.isSet() && iMaxWidth < lOptSize )
+                        iMaxWidth = lOptSize;
+        }
+        int iIndent = 4;
+        if( bHasShort )
+                iIndent += 4;
+        if( iMaxWidth > 0 )
+                iIndent += 4 + iMaxWidth;
+
+        BannerList::iterator iBanner;
+        for( iBanner = lBanner.begin(); iBanner; iBanner++ )
+        {
+                if( (*iBanner).iAfter )
+                        break;
+
+                if( (*iBanner).bFormatted )
+                        sio << format( (*iBanner).sText, iScrWidth-1, 0 );
+                else
+                        sio << (*iBanner).sText;
+                sio << sio.nl;
+        }
+        for( OptionList::iterator i = lOption.begin(); i; i++ )
+        {
+                sio << "    ";
+                if( bHasShort )
+                {
+                        if( (*i).cOpt == '\0' )
+                                sio << "  ";
+                        else
+                                sio << "-" << (*i).cOpt;
+                        sio << "  ";
+                }
+                if( iMaxWidth > 0 )
+                {
+                        if( (*i).sOpt.isSet() )
+                        {
+                                sio << "--" << Fmt(iMaxWidth, Fmt::Left)
+                                        << (*i).sOpt + (*i).sHelpDefault;
+                        }
+                        else
+                        {
+                                sio << "  " << Fmt(iMaxWidth) << "";
+                        }
+                        sio << "  ";
+                }
+                sio << format( (*i).sHelp, iScrWidth-iIndent-1, iIndent );
+                sio << sio.nl;
+        
+                for( ; iBanner; iBanner++ )
+                {
+                        if( (*iBanner).iAfter != i )
+                                break;
+                        
+                        if( (*iBanner).bFormatted )
+                                sio << format( (*iBanner).sText, iScrWidth-1, 0 );
+                        else
+                                sio << (*iBanner).sText;
+                        sio << sio.nl;
+                }
+        }
+        exit( 0 );
+        return 0;
+}
+
+void Bu::OptParser::optionError( const Bu::String &sOption )
+{
+        sio << "Unregcognized option discovered: " << sOption << sio.nl << sio.nl;
+        exit( 1 );
+}
+
+void Bu::OptParser::setNonOption( OptionSignal sSignal )
+{
+        sNonOption = sSignal;
+}
+
+Bu::String Bu::OptParser::format( const Bu::String &sIn, int iWidth,
+                int iIndent )
+{
+        Bu::String sOut;
+        Bu::String sIndent;
+        for( int j = 0; j < iIndent; j++ )
+                sIndent.append(" ", 1);
+        bool bFirst = true;
+        int iSpaceCount = 0;
+        bool bSpace = false;
+        int iPrevLineLen;
+        int iLineLen = 0;
+        Bu::String::const_iterator iLastSpace, iStart;
+        for( Bu::String::const_iterator i = iLastSpace = iStart = sIn.begin(); i; i++ )
+        {
+                if( *i == ' ' )
+                {
+                        if( bSpace == false )
+                        {
+                                iLastSpace = i;
+                                iSpaceCount++;
+                                bSpace = true;
+                                iPrevLineLen = iLineLen;
+                        }
+                }
+                else
+                {
+                        bSpace = false;
+                }
+                iLineLen++;
+
+                if( iLineLen >= iWidth )
+                {
+                        iSpaceCount--;
+                        if( bFirst == true )
+                                bFirst = false;
+                        else
+                                sOut += sIndent;
+                        int iExtraSpaces = iWidth-iPrevLineLen;
+                        bSpace = false;
+                        float fFill = 0.0;
+                        int iSubSpaceCount = 0;
+                        float fAdd = ((float)iExtraSpaces/(float)iSpaceCount);
+                        for( Bu::String::const_iterator k = iStart; k != iLastSpace; k++ )
+                        {
+                                sOut += *k;
+                                if( *k == ' ' )
+                                {
+                                        if( bSpace == false && iExtraSpaces > 0 )
+                                        {
+                                                bSpace = true;
+                                                fFill += fAdd;
+                                                iSubSpaceCount++;
+                                                for( int sp = 0; sp < (int)(fFill); sp++ )
+                                                {
+                                                        sOut += ' ';
+                                                        iExtraSpaces--;
+                                                }
+                                                fFill -= (int)fFill;
+                                                if( iSubSpaceCount == iSpaceCount && iExtraSpaces > 0 )
+                                                {
+                                                        for(; iExtraSpaces > 0; iExtraSpaces-- )
+                                                        {
+                                                                sOut += ' ';
+                                                        }
+                                                }
+                                        }
+                                }
+                                else
+                                        bSpace = false;
+                        }
+                        //sOut.append( iStart, iLastSpace );
+                        sOut.append("\n");
+                        for(; iLastSpace && *iLastSpace == ' '; iLastSpace++ ) { }
+                        iStart = i = iLastSpace;
+                        bSpace = false;
+                        iLineLen = 1;
+                        iSpaceCount = 0;
+                }
+        }
+        if( !bFirst )
+                sOut += sIndent;
+        sOut.append( iStart );
+        return sOut;
+}
+
+
+//
+// Code for Bu::OptParser::_ValueProxy
+//
+
+Bu::OptParser::_ValueProxy::_ValueProxy()
+{
+}
+
+Bu::OptParser::_ValueProxy::~_ValueProxy()
+{
+}
+
+//
+// Code for Bu::OptParser::Option
+//
+
+Bu::OptParser::Option::Option() :
+        cOpt( '\0' ),
+        pProxy( NULL )
+{
+}
+
+Bu::OptParser::Option::Option( const Option &rSrc ) :
+        cOpt( rSrc.cOpt ),
+        sOpt( rSrc.sOpt ),
+        sHelp( rSrc.sHelp ),
+        sUsed( rSrc.sUsed ),
+        pProxy( NULL ),
+        sOverride( rSrc.sOverride )
+{
+        if( rSrc.pProxy )
+                pProxy = rSrc.pProxy->clone();
+}
+
+Bu::OptParser::Option::~Option()
+{
+        delete pProxy;
+        pProxy = NULL;
+}
+
diff --git a/src/stable/optparser.h b/src/stable/optparser.h
new file mode 100644
index 0000000..f2fe531
--- /dev/null
+++ b/src/stable/optparser.h
@@ -0,0 +1,223 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_OPT_PARSER_H
+#define BU_OPT_PARSER_H
+
+#include "bu/string.h"
+#include "bu/list.h"
+#include "bu/hash.h"
+#include "bu/signals.h"
+#include "bu/array.h"
+#include "bu/membuf.h"
+#include "bu/formatter.h"
+#include "bu/variant.h"
+
+namespace Bu
+{
+        typedef Bu::Array<Bu::String> StrArray;
+
+        /**
+         * POSIX/Gnu style command line parser.  Handles long and short options in
+         * a variety of fun and useful ways, along with singal based callbacks and
+         * automatic variable setting.  It's pretty easy to use, and very flexible.
+         *
+         * OptParser supports it's own builtin help mechanism which automatically
+         * enumerates the available options and their help in a well formatted and
+         * easy to read way, automatically formatting your help text per option and
+         * allows for addition "help banners" which can be placed wherever you
+         * would like.
+         */
+        class OptParser
+        {
+        private:
+                class _ValueProxy
+                {
+                public:
+                        _ValueProxy();
+                        virtual ~_ValueProxy();
+
+                        virtual void setValueFromStr( const Bu::String & )=0;
+                        virtual void setValue( const Bu::Variant &vVar )=0;
+                        virtual _ValueProxy *clone()=0;
+                };
+
+                template<typename ptype>
+                class ValueProxy : public _ValueProxy
+                {
+                public:
+                        ValueProxy( ptype &v ) :
+                                v( v )
+                        {
+                        }
+
+                        virtual ~ValueProxy()
+                        {
+                        }
+
+                        virtual void setValueFromStr( const Bu::String &sVal )
+                        {
+                                Bu::MemBuf mb( sVal );
+                                Bu::Formatter f( mb );
+                                f << Bu::Fmt().tokenize( false );
+                                f >> v;
+                        }
+
+                        virtual void setValue( const Bu::Variant &vVar )
+                        {
+                                if( vVar.getType() == typeid(ptype) )
+                                {
+                                        v = vVar.get<ptype>();
+                                }
+                                else if( vVar.getType() == typeid(Bu::String) )
+                                {
+                                        setValueFromStr( vVar.get<Bu::String>() );
+                                }
+                                else
+                                {
+                                        Bu::MemBuf mb;
+                                        Bu::Formatter f( mb );
+//                                      f << vVar;
+                                        setValueFromStr( mb.getString() );
+                                }
+                        }
+                        
+                        virtual _ValueProxy *clone()
+                        {
+                                return new ValueProxy<ptype>( v );
+                        }
+
+                private:
+                        ptype &v;
+                };
+
+        public:
+                typedef Signal1<int, StrArray> OptionSignal;
+                class Option
+                {
+                public:
+                        Option();
+                        Option( const Option &rSrc );
+                        virtual ~Option();
+
+                        char cOpt;
+                        Bu::String sOpt;
+                        Bu::String sHelp;
+                        OptionSignal sUsed;
+                        _ValueProxy *pProxy;
+                        Bu::Variant sOverride;
+                        Bu::String sHelpDefault;
+                };
+        
+        private:
+                typedef Bu::List<Option> OptionList;
+                typedef Bu::Hash<char, Option *> ShortOptionHash;
+                typedef Bu::Hash<Bu::String, Option *> LongOptionHash;
+                
+                class Banner
+                {
+                public:
+                        Bu::String sText;
+                        bool bFormatted;
+                        OptionList::const_iterator iAfter;
+                };
+
+                typedef Bu::List<Banner> BannerList;
+
+        public:
+                OptParser();
+                virtual ~OptParser();
+
+                void parse( int argc, char **argv );
+                void parse( const Bu::String &sLine );
+
+                void addOption( const Option &opt );
+                
+                template<typename vtype>
+                void addOption( vtype &var, char cOpt, const Bu::String &sOpt,
+                                const Bu::String &sHelp )
+                {
+                        Option o;
+                        o.cOpt = cOpt;
+                        o.sOpt = sOpt;
+                        o.pProxy = new ValueProxy<vtype>( var );
+                        o.sHelp = sHelp;
+                        addOption( o );
+                }
+                
+                template<typename vtype>
+                void addOption( vtype &var, const Bu::String &sOpt,
+                                const Bu::String &sHelp )
+                {
+                        addOption( var, '\0', sOpt, sHelp );
+                }
+                
+                template<typename vtype>
+                void addOption( vtype &var, char cOpt, const Bu::String &sHelp )
+                {
+                        addOption( var, cOpt, "", sHelp );
+                }
+
+                void addOption( OptionSignal sUsed, char cOpt, const Bu::String &sOpt,
+                                const Bu::String &sHelp )
+                {
+                        Option o;
+                        o.cOpt = cOpt;
+                        o.sOpt = sOpt;
+                        o.sUsed = sUsed;
+                        o.sHelp = sHelp;
+                        addOption( o );
+                }
+                
+                void addOption( OptionSignal sUsed, const Bu::String &sOpt,
+                                const Bu::String &sHelp )
+                {
+                        addOption( sUsed, '\0', sOpt, sHelp );
+                }
+                
+                void addOption( OptionSignal sUsed, char cOpt,
+                                const Bu::String &sHelp )
+                {
+                        addOption( sUsed, cOpt, "", sHelp );
+                }
+
+                void setOverride( char cOpt, const Bu::Variant &sOverride );
+                void setOverride( const Bu::String &sOpt,
+                                const Bu::Variant &sOverride );
+
+                void setHelpDefault( const Bu::String &sOpt, const Bu::String &sTxt );
+                
+                void addHelpOption( char c='h', const Bu::String &s="help",
+                                const Bu::String &sHelp="This help." );
+                void addHelpBanner( const Bu::String &sText, bool bFormatted=true );
+
+                int optHelp( StrArray aParams );
+
+                /**
+                 * This function is called when an unrecognized option is found, the
+                 * default behaviour is to print an error to stdout and exit( 1 ), if
+                 * you want to do something different, just override this function.
+                 * This is also called by default when something is found that hasn't
+                 * been handled by an option, and isn't an option (starts with - or --).
+                 * To change this behaviour call 
+                 */
+                virtual void optionError( const Bu::String &sOption );
+
+                void setNonOption( OptionSignal sSignal );
+
+        private:
+                Bu::String format( const Bu::String &sIn, int iWidth, int iIndent );
+
+                OptionList lOption;
+                ShortOptionHash hsOption;
+                LongOptionHash hlOption;
+                BannerList lBanner;
+                OptionSignal sNonOption;
+        };
+};
+
+#endif
diff --git a/src/stable/pearsonhash.cpp b/src/stable/pearsonhash.cpp
new file mode 100644
index 0000000..d753d20
--- /dev/null
+++ b/src/stable/pearsonhash.cpp
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/pearsonhash.h"
+#include "bu/stream.h"
+
+uint8_t Bu::PearsonHash::aSBox[] = {
+        251, 175, 119, 215, 81, 14, 79, 191, 103, 49, 181, 143, 186, 157, 0,
+        232, 31, 32, 55, 60, 152, 58, 17, 237, 174, 70, 160, 144, 220, 90, 57,
+        223, 59, 3, 18, 140, 111, 166, 203, 196, 134, 243, 124, 95, 222, 179,
+        197, 65, 180, 48, 36, 15, 107, 46, 233, 130, 165, 30, 123, 161, 209, 23,
+        97, 16, 40, 91, 219, 61, 100, 10, 210, 109, 250, 127, 22, 138, 29, 108,
+        244, 67, 207, 9, 178, 204, 74, 98, 126, 249, 167, 116, 34, 77, 193,
+        200, 121, 5, 20, 113, 71, 35, 128, 13, 182, 94, 25, 226, 227, 199, 75,
+        27, 41, 245, 230, 224, 43, 225, 177, 26, 155, 150, 212, 142, 218, 115,
+        241, 73, 88, 105, 39, 114, 62, 255, 192, 201, 145, 214, 168, 158, 221,
+        148, 154, 122, 12, 84, 82, 163, 44, 139, 228, 236, 205, 242, 217, 11,
+        187, 146, 159, 64, 86, 239, 195, 42, 106, 198, 118, 112, 184, 172, 87,
+        2, 173, 117, 176, 229, 247, 253, 137, 185, 99, 164, 102, 147, 45, 66,
+        231, 52, 141, 211, 194, 206, 246, 238, 56, 110, 78, 248, 63, 240, 189,
+        93, 92, 51, 53, 183, 19, 171, 72, 50, 33, 104, 101, 69, 8, 252, 83, 120,
+        76, 135, 85, 54, 202, 125, 188, 213, 96, 235, 136, 208, 162, 129, 190,
+        132, 156, 38, 47, 1, 7, 254, 24, 4, 216, 131, 89, 21, 28, 133, 37, 153,
+        149, 80, 170, 68, 6, 169, 234, 151
+};
+
+Bu::PearsonHash::PearsonHash()
+{
+        reset();
+}
+
+Bu::PearsonHash::~PearsonHash()
+{
+}
+
+void Bu::PearsonHash::reset()
+{
+        iValue = 0;
+}
+
+void Bu::PearsonHash::setSalt( const Bu::String & /*sSalt*/ )
+{
+}
+
+void Bu::PearsonHash::addData( const void *sData, int iSize )
+{
+        for( int j = 0; j < iSize; j++ )
+        {
+                iValue = aSBox[ iValue^((unsigned char *)sData)[j] ];
+        }
+}
+
+Bu::String Bu::PearsonHash::getResult()
+{
+        return Bu::String((char)iValue);
+}
+
+void Bu::PearsonHash::writeResult( Stream &sOut )
+{
+        sOut.write( &iValue, 1 );
+}
+
diff --git a/src/stable/pearsonhash.h b/src/stable/pearsonhash.h
new file mode 100644
index 0000000..2a9cfa7
--- /dev/null
+++ b/src/stable/pearsonhash.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_PEARSON_HASH_H
+#define BU_PEARSON_HASH_H
+
+#include "bu/cryptohash.h"
+
+namespace Bu
+{
+        /**
+         * A pearson hash is a non-cryptographically secure hashing function that
+         * is very light on resources, very fast, and produces a single byte
+         * as it's output.  It is strongly dependant on every byte in the input,
+         * which means that it's a good choice for adding to short messages to
+         * ensure that the contents of the messages are unchanged.
+         *
+         * Pearson hash is named for it's inventor Peter K. Pearson who described
+         * it in his article "Fast hashing of variable-length text strings"
+         * published in 1990 by ACM.  I haven't read it, because you have to pay to
+         * get a copy :-P
+         */
+        class PearsonHash : public Bu::CryptoHash
+        {
+        public:
+                PearsonHash();
+                virtual ~PearsonHash();
+
+                virtual void reset();
+                virtual void setSalt( const Bu::String &sSalt );
+                virtual void addData( const void *sData, int iSize );
+                using Bu::CryptoHash::addData;
+                virtual String getResult();
+                virtual void writeResult( Stream &sOut );
+
+        private:
+                static uint8_t aSBox[256];
+                uint8_t iValue;
+        };
+};
+
+#endif
diff --git a/src/stable/plugger.cpp b/src/stable/plugger.cpp
new file mode 100644
index 0000000..fb6850a
--- /dev/null
+++ b/src/stable/plugger.cpp
@@ -0,0 +1,11 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/plugger.h"
+
+namespace Bu { subExceptionDef( PluginException ) }
+
diff --git a/src/stable/plugger.h b/src/stable/plugger.h
new file mode 100644
index 0000000..c22f964
--- /dev/null
+++ b/src/stable/plugger.h
@@ -0,0 +1,289 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_PLUGGER_H
+#define BU_PLUGGER_H
+
+#include "bu/hash.h"
+#include "bu/list.h"
+#include "bu/exceptionbase.h"
+#include "bu/string.h"
+#include <stddef.h>
+
+#include "bu/config.h"
+
+#ifdef WIN32
+# include <windows.h>
+#else
+# include <dlfcn.h>
+#endif
+
+namespace Bu
+{
+        subExceptionDecl( PluginException );
+
+        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;
+#ifdef WIN32
+                HMODULE dlHandle;
+#else
+                void *dlHandle;
+#endif
+                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;                                                                                                    \
+                }                                                                                                                                       \
+                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;                                                                                                    \
+                }                                                                                                                                       \
+                Bu::PluginInfo pluginname = {                                                                                   \
+                        #pluginname, name, ver, rev,                                                                    \
+                        (void *(*)())(create ##classname),                                                              \
+                        (void (*)( void * ))(destroy ##classname) };                                    \
+        }
+
+//
+// This is probably the main interface to use, I'll describe it some here...
+//   structname - The name of the structure, this is what you have to pass to
+//                register.  Depending on how you build your dll/so files this
+//                will need to be unique (generally not)
+//   pluginname - This is what will be used by the plugin system to refer to
+//                your plugin once it's loaded.  This should be unique, but not
+//                a string
+//   classname  - The name of the class that is the plugin
+//   baseclass  - The name of the base class that is the parent of the plugin
+//   name       - The name of the author of this class (or company)
+//   ver        - an integer version number for the plugin
+//   rev        - an integer revision number for the plugin
+//
+#define PluginInterface3( structname, pluginname, classname, baseclass, name, ver, rev ) \
+        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) };                                    \
+        }
+
+        /**
+         * A complete dynamic plugin manager system.  This will allow you to design
+         * and use plugins that are compiled into your program and dynamically
+         * linked to your program interchangably.  It works on windows and on *nix
+         * and bsd type systems (anything that supports dlopen).  Basically you
+         * create a base class that will be the basic interface of your plugins.
+         * Then you create some classes that inherit from it, and use the
+         * PluginInterface3 macro to create the required data structures for it.
+         *
+         * Once you have plugins you can create a Plugger, by passing in the base
+         * class as it's template parameter.  Once it's created, you can register
+         * plugins.  To register a plugin that is builtin, you just need to pass
+         * a pointer to it's interface structure to the registerBuiltinPlugin
+         * function.  To register a plugin that is in a shared object or dll file
+         * you just pass the filename (with path, probably), and the name of the
+         * structure to load and you're all set.
+         *
+         * To instantiate an object from a plugin simply call instantiate with the
+         * name of the plugin as specified in the interface macro.  To destroy an
+         * object crated with the plugger do not delete it, instead pass it into
+         * Plugger's destroy function.
+         *
+         * Any objects not destroyed when the plugger is deleted will be destroyed
+         * automatically.
+         *
+         * It is important to note that some systems (linux at least) partition off
+         * the memory allocated by objects linked in at run time into a seperate
+         * segment that, while it can be accessed by the main program, cannot be
+         * safely or reliably freed by the main program.  With that in mind it is
+         * a good idea to free all memory allocated by a plugin object in the plugin
+         * object and not allow the calling program to delete it.
+         */
+        template<class T>
+        class Plugger
+        {
+        public:
+                typedef Bu::Hash<Bu::String, PluginReg *> PluginHash;
+                typedef Bu::Hash<ptrdiff_t, void *> InstHash;
+
+        public:
+                Plugger()
+                {
+                }
+
+                virtual ~Plugger()
+                {
+                        for( InstHash::iterator i = hObj.begin(); i != hObj.end(); i++ )
+                        {
+                                T *pPlug = (T *)i.getKey();
+                                PluginReg *pReg = (PluginReg *)*i;
+                                pReg->pInfo->destroyPlugin( pPlug );
+                        }
+
+                        for( PluginHash::iterator i = hPlugin.begin();
+                                 i != hPlugin.end(); i++ )
+                        {
+                                if( (*i)->bBuiltin == false )
+                                {
+#ifdef WIN32
+                                        FreeLibrary( (*i)->dlHandle );
+#else
+                                        dlclose( (*i)->dlHandle );
+#endif
+                                }
+                                delete (*i);
+                        }
+                }
+
+                void registerBuiltinPlugin( PluginInfo *pInfo )
+                {
+                        PluginReg *pReg = new PluginReg;
+                        pReg->bBuiltin = true;
+                        pReg->pInfo = pInfo;
+                        hPlugin.insert( pInfo->sID, pReg );
+                }
+
+                void registerExternalPlugin( const Bu::String &sFName,
+                                const Bu::String &sPluginName )
+                {
+                        PluginReg *pReg;
+                        if( hPlugin.has( sPluginName ) )
+                                throw Bu::ExceptionBase("A plugin with name '%s' is already "
+                                        "loaded.", sPluginName.getStr() );
+
+                        pReg = new PluginReg;
+
+                        pReg->bBuiltin = false;
+#ifdef WIN32
+                        pReg->dlHandle = LoadLibrary( sFName.getStr() );
+                        if( pReg->dlHandle == NULL )
+                        {
+                                throw PluginException( 1, "Error opening %s: %s",
+                                        sFName.getStr(), Bu::getLastWinError().getStr() );
+                        }
+                        pReg->pInfo = (PluginInfo *)GetProcAddress( pReg->dlHandle,
+                                        sPluginName.getStr() );
+                        if( pReg->pInfo == NULL )
+                        {
+                                throw PluginException( 2, "Error mapping %s: %s",
+                                        sFName.getStr(), Bu::getLastWinError().getStr() );
+                        }
+#else
+                        pReg->dlHandle = dlopen( sFName.getStr(), RTLD_NOW );
+                        if( pReg->dlHandle == NULL )
+                        {
+                                throw PluginException( 1, "Error opening %s: %s",
+                                        sFName.getStr(), dlerror() );
+                        }
+                        pReg->pInfo = (PluginInfo *)dlsym( pReg->dlHandle,
+                                        sPluginName.getStr() );
+                        if( pReg->pInfo == NULL )
+                        {
+                                throw PluginException( 2, "Error mapping %s: %s",
+                                        sFName.getStr(), dlerror() );
+                        }
+#endif
+                        hPlugin.insert( pReg->pInfo->sID, pReg );
+                }
+
+                T *instantiate( const Bu::String &lpName )
+                {
+                        PluginReg *pReg = (PluginReg *)hPlugin[lpName];
+                        if( pReg == NULL )
+                                return NULL;
+
+                        T *p = (T *)pReg->pInfo->createPlugin();
+                        hObj.insert( (ptrdiff_t)p, pReg );
+                        //printf("pReg:  %08X, pPlug: %08X\n", pReg, p );
+                
+                        return p;
+                }
+
+                bool hasPlugin( const Bu::String &lpName )
+                {
+                        return hPlugin.has( lpName );
+                }
+
+                void destroy( T *pPlug )
+                {
+                        PluginReg *pReg = (PluginReg *)hObj.get((ptrdiff_t)pPlug);
+                        //printf("pReg:  %08X, pPlug: %08X\n", pReg, pPlug );
+                        if( pReg == NULL )
+                                return;
+
+                        pReg->pInfo->destroyPlugin( pPlug );
+
+                        hObj.erase( (ptrdiff_t)pPlug );
+                }
+
+                void unloadAll()
+                {
+                        for( PluginHash::iterator i = hPlugin.begin();
+                                 i != hPlugin.end(); i++ )
+                        {
+                                if( (*i)->bBuiltin == false )
+                                {
+#ifdef WIN32
+                                        FreeLibrary( (*i)->dlHandle );
+#else
+                                        dlclose( (*i)->dlHandle );
+#endif
+                                }
+                                delete (*i);
+                        }
+                        hPlugin.clear();
+                }
+
+                Bu::List<Bu::String> getPluginList()
+                {
+                        return hPlugin.getKeys();
+                }
+
+        private:
+                PluginHash hPlugin;
+                InstHash hObj;
+        };
+}
+
+#endif
diff --git a/src/stable/process.cpp b/src/stable/process.cpp
new file mode 100644
index 0000000..a98936e
--- /dev/null
+++ b/src/stable/process.cpp
@@ -0,0 +1,441 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/process.h"
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include <sys/select.h>
+
+#include "bu/config.h"
+
+Bu::Process::Process( Flags eFlags, const char *sName, char *const argv[] ) :
+        iStdIn( -1 ),
+        iStdOut( -1 ),
+        iStdErr( -1 ),
+        iPid( 0 ),
+        iProcStatus( 0 ),
+        bBlocking( true ),
+        bStdOutEos( true ),
+        bStdErrEos( true )
+{
+        gexec( eFlags, sName, argv );
+}
+
+Bu::Process::Process( Flags eFlags, const char *sName, const char *argv, ...) :
+        iStdIn( -1 ),
+        iStdOut( -1 ),
+        iStdErr( -1 ),
+        iPid( 0 ),
+        iProcStatus( 0 ),
+        bBlocking( true ),
+        bStdOutEos( true ),
+        bStdErrEos( true )
+{
+        int iCnt = 0;
+        va_list ap;
+        va_start( ap, argv );
+        for(; va_arg( ap, const char *); iCnt++ ) { }
+        va_end( ap );
+
+        char const **list = new char const *[iCnt+2];
+        va_start( ap, argv );
+        list[0] = argv;
+        for( int j = 1; j <= iCnt; j++ )
+        {
+                list[j] = va_arg( ap, const char *);
+        }
+        list[iCnt+1] = NULL;
+        va_end( ap );
+
+        gexec( eFlags, sName, (char *const *)list );
+        delete[] list;
+}
+
+Bu::Process::Process( Flags eFlags, const Bu::Process::Options &opt, const char *sName, char *const argv[] ) :
+        iStdIn( -1 ),
+        iStdOut( -1 ),
+        iStdErr( -1 ),
+        iPid( 0 ),
+        iProcStatus( 0 ),
+        bBlocking( true ),
+        bStdOutEos( true ),
+        bStdErrEos( true ),
+        opt( opt )
+{
+        gexec( eFlags, sName, argv );
+}
+
+Bu::Process::Process( Flags eFlags, const Bu::Process::Options &opt, const char *sName, const char *argv, ...) :
+        iStdIn( -1 ),
+        iStdOut( -1 ),
+        iStdErr( -1 ),
+        iPid( 0 ),
+        iProcStatus( 0 ),
+        bBlocking( true ),
+        bStdOutEos( true ),
+        bStdErrEos( true ),
+        opt( opt )
+{
+        int iCnt = 0;
+        va_list ap;
+        va_start( ap, argv );
+        for(; va_arg( ap, const char *); iCnt++ ) { }
+        va_end( ap );
+
+        char const **list = new char const *[iCnt+2];
+        va_start( ap, argv );
+        list[0] = argv;
+        for( int j = 1; j <= iCnt; j++ )
+        {
+                list[j] = va_arg( ap, const char *);
+        }
+        list[iCnt+1] = NULL;
+        va_end( ap );
+
+        gexec( eFlags, sName, (char *const *)list );
+        delete[] list;
+}
+
+Bu::Process::~Process()
+{
+        close();
+}
+
+void Bu::Process::wait()
+{
+        close();
+}
+
+void Bu::Process::gexec( Flags eFlags, const char *sName, char *const argv[] )
+{
+        int iaStdIn[2];
+        int iaStdOut[2];
+        int iaStdErr[2];
+        pipe( iaStdIn );
+        if( eFlags & StdOut )
+        {
+                pipe( iaStdOut );
+                iStdOut = iaStdOut[0];
+                bStdOutEos = false;
+        }
+        if( eFlags & StdErr )
+        {
+                pipe( iaStdErr );
+                iStdErr = iaStdErr[0];
+                bStdErrEos = false;
+        }
+
+        iStdIn = iaStdIn[1];
+
+//      fcntl( iStdOut, F_SETFL, fcntl( iStdOut, F_GETFL, 0 )|O_NONBLOCK );
+
+        iPid = fork();
+        if( iPid == 0 )
+        {
+                ::close( iaStdIn[1] );
+                dup2( iaStdIn[0], 0 );
+                if( eFlags & StdOut )
+                {
+                        ::close( iaStdOut[0] );
+                        dup2( iaStdOut[1], 1 );
+                }
+                if( eFlags & StdErr )
+                {
+                        ::close( iaStdErr[0] );
+                        dup2( iaStdErr[1], 2 );
+                }
+                if( (opt.eFlags&Options::SetGid) )
+                {
+                        setgid( opt.iGid );
+                }
+                if( (opt.eFlags&Options::SetUid) )
+                {
+                        setuid( opt.iUid );
+                }
+                execvp( sName, argv );
+                throw Bu::ExceptionBase("Hey, execvp failed!");
+        }
+        ::close( iaStdIn[0] );
+        if( eFlags & StdOut )
+                ::close( iaStdOut[1] );
+        if( eFlags & StdErr )
+                ::close( iaStdErr[1] );
+}
+
+void Bu::Process::close()
+{
+        if( iPid )
+        {
+                if( iStdIn > -1 )
+                        ::close( iStdIn );
+                if( iStdOut > -1 )
+                        ::close( iStdOut );
+                if( iStdErr > -1 )
+                        ::close( iStdErr );
+                waitpid( iPid, &iProcStatus, 0 );
+                iPid = 0;
+        }
+}
+
+void Bu::Process::closeStdIn()
+{
+        ::close( iStdIn );
+        iStdIn = -1;
+}
+
+void Bu::Process::closeStdOut()
+{
+        ::close( iStdOut );
+        iStdOut = -1;
+}
+
+Bu::size Bu::Process::read( void *pBuf, Bu::size nBytes )
+{
+        if( bStdOutEos )
+                return 0;
+        fd_set rfds;
+        FD_ZERO( &rfds );
+        FD_SET( iStdOut, &rfds );
+        struct timeval tv = {0, 0};
+        if( ::bu_select( iStdOut+1, &rfds, NULL, NULL, &tv ) < 0 )
+                throw Bu::ExceptionBase( strerror( errno ) );
+        if( FD_ISSET( iStdOut, &rfds ) || bBlocking )
+        {
+                Bu::size nRead = TEMP_FAILURE_RETRY( ::read( iStdOut, pBuf, nBytes ) );
+                if( nRead == 0 )
+                {
+                        bStdOutEos = true;
+                        checkClose();
+                        return 0;
+                }
+                if( nRead < 0 )
+                {
+                        if( errno == EAGAIN )
+                                return 0;
+                        throw Bu::ExceptionBase( strerror( errno ) );
+                }
+                return nRead;
+        }
+        return 0;
+}
+
+Bu::size Bu::Process::readErr( void *pBuf, Bu::size nBytes )
+{
+        if( bStdErrEos )
+                return 0;
+        fd_set rfds;
+        FD_ZERO( &rfds );
+        FD_SET( iStdErr, &rfds );
+        struct timeval tv = {0, 0};
+        if( ::bu_select( iStdErr+1, &rfds, NULL, NULL, &tv ) < 0 )
+                throw Bu::ExceptionBase( strerror( errno ) );
+        if( FD_ISSET( iStdErr, &rfds ) || bBlocking )
+        {
+                Bu::size nRead = TEMP_FAILURE_RETRY( ::read( iStdErr, pBuf, nBytes ) );
+                if( nRead == 0 )
+                {
+                        bStdErrEos = true;
+                        checkClose();
+                        return 0;
+                }
+                if( nRead < 0 )
+                {
+                        if( errno == EAGAIN )
+                                return 0;
+                        throw Bu::ExceptionBase( strerror( errno ) );
+                }
+                return nRead;
+        }
+        return 0;
+}
+
+Bu::size Bu::Process::write( const void *pBuf, Bu::size nBytes )
+{
+        return TEMP_FAILURE_RETRY( ::write( iStdIn, pBuf, nBytes ) );
+}
+
+Bu::size Bu::Process::tell()
+{
+        return 0;
+}
+
+void Bu::Process::seek( Bu::size )
+{
+}
+
+void Bu::Process::setPos( Bu::size )
+{
+}
+
+void Bu::Process::setPosEnd( Bu::size )
+{
+}
+
+bool Bu::Process::isEos()
+{
+        return (iPid == 0);
+}
+
+bool Bu::Process::isOpen()
+{
+        return (iPid != 0);
+}
+
+void Bu::Process::flush()
+{
+}
+
+bool Bu::Process::canRead()
+{
+        return true;
+}
+
+bool Bu::Process::canWrite()
+{
+        return true;
+}
+
+bool Bu::Process::isReadable()
+{
+        return true;
+}
+
+bool Bu::Process::isWritable()
+{
+        return true;
+}
+
+bool Bu::Process::isSeekable()
+{
+        return false;
+}
+
+bool Bu::Process::isBlocking()
+{
+        return true;
+}
+
+void Bu::Process::setBlocking( bool bBlocking )
+{
+        if( bBlocking )
+        {
+                if( !bStdOutEos )
+                        fcntl( iStdOut, F_SETFL, fcntl(iStdOut,F_GETFL,0 )&(~O_NONBLOCK) );
+                if( !bStdErrEos )
+                        fcntl( iStdErr, F_SETFL, fcntl(iStdErr,F_GETFL,0 )&(~O_NONBLOCK) );
+        }
+        else
+        {
+                if( !bStdOutEos )
+                        fcntl( iStdOut, F_SETFL, fcntl( iStdOut, F_GETFL, 0 )|O_NONBLOCK );
+                if( !bStdErrEos )
+                        fcntl( iStdErr, F_SETFL, fcntl( iStdErr, F_GETFL, 0 )|O_NONBLOCK );
+        }
+        this->bBlocking = bBlocking;
+}
+
+void Bu::Process::setSize( Bu::size )
+{
+}
+
+Bu::size Bu::Process::getBlockSize() const
+{
+        return 0;
+}
+
+Bu::size Bu::Process::getSize() const
+{
+        return 0;
+}
+
+Bu::String Bu::Process::getLocation() const
+{
+        return "";
+}
+
+void Bu::Process::select( bool &bStdOut, bool &bStdErr )
+{
+        fd_set rfds;
+        FD_ZERO( &rfds );
+        if( !bStdOutEos )
+                FD_SET( iStdOut, &rfds );
+        if( !bStdErrEos )
+                FD_SET( iStdErr, &rfds );
+        if( ::bu_select( iStdErr+1, &rfds, NULL, NULL, NULL ) < 0 )     
+                throw Bu::ExceptionBase( strerror( errno ) );
+
+        if( FD_ISSET( iStdOut, &rfds ) )
+                bStdOut = true;
+        else
+                bStdOut = false;
+
+        if( FD_ISSET( iStdErr, &rfds ) )
+                bStdErr = true;
+        else
+                bStdErr = false;
+}
+
+bool Bu::Process::isRunning()
+{
+        if( waitpid( iPid, NULL, WNOHANG ) == iPid )
+                checkClose();
+        return iPid != 0;
+}
+
+void Bu::Process::ignoreStdErr()
+{
+        if( iStdErr == -1 )
+                return;
+        ::close( iStdErr );
+        iStdErr = -1;
+        bStdErrEos = true;
+}
+
+pid_t Bu::Process::getPid()
+{
+        return iPid;
+}
+
+bool Bu::Process::childExited()
+{
+        return WIFEXITED( iProcStatus );
+}
+
+int Bu::Process::childExitStatus()
+{
+        return WEXITSTATUS( iProcStatus );
+}
+
+bool Bu::Process::childSignaled()
+{
+        return WIFSIGNALED( iProcStatus );
+}
+
+int Bu::Process::childSignal()
+{
+        return WTERMSIG( iProcStatus );
+}
+
+bool Bu::Process::childCoreDumped()
+{
+        return WCOREDUMP( iProcStatus );
+}
+
+void Bu::Process::checkClose()
+{
+        if( bStdOutEos && bStdErrEos )
+        {
+                close();
+        }
+}
+
diff --git a/src/stable/process.h b/src/stable/process.h
new file mode 100644
index 0000000..d6282e0
--- /dev/null
+++ b/src/stable/process.h
@@ -0,0 +1,153 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_PROCESS_H
+#define BU_PROCESS_H
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include "bu/stream.h"
+#include "bu/string.h"
+
+namespace Bu
+{
+        /**
+         * Runs a program and attaches streams to it's stdin, stdout, and stderr.
+         * Reading from a Bu::Process will read from the program's standard output,
+         * writing to a Bu::Process will write to the program's standard input.
+         */
+        class Process : public Bu::Stream
+        {
+        public:
+                enum Flags
+                {
+                        None    =       0x00,
+                        StdOut  =       0x01,
+                        StdErr  =       0x02,
+                        Both    =       0x03
+                };
+
+        public:
+                class Options
+                {
+                public:
+                        enum OptFlags
+                        {
+                                None    = 0x00,
+                                SetUid  = 0x01,
+                                SetGid  = 0x02,
+                        };
+
+                        Options() : eFlags( None ) {}
+
+                        int eFlags;
+                        int iUid;
+                        int iGid;
+                };
+
+                Process( Flags eFlags, const char *sName, char *const argv[] );
+                Process( Flags eFlags, const char *sName, const char *argv, ...);
+                Process( Flags eFlags, const Options &opt, const char *sName, char *const argv[] );
+                Process( Flags eFlags, const Options &opt, const char *sName, const char *argv, ...);
+                virtual ~Process();
+
+                /**
+                 * Waits until the process exits.  This blocks the caller until the
+                 * child process terminates.
+                 */
+                void wait();
+
+                virtual void close();
+                virtual void closeStdIn();
+                virtual void closeStdOut();
+                virtual Bu::size read( void *pBuf, Bu::size nBytes );
+                virtual Bu::size readErr( void *pBuf, Bu::size nBytes );
+                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+                using Stream::write;
+
+                virtual Bu::size tell();
+                virtual void seek( Bu::size offset );
+                virtual void setPos( Bu::size pos );
+                virtual void setPosEnd( Bu::size 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 );
+
+                virtual void setSize( Bu::size iSize );
+
+                virtual size getBlockSize() const;
+                virtual size getSize() const;
+                virtual Bu::String getLocation() const;
+
+                void select( bool &bStdOut, bool &bStdErr );
+
+                bool isRunning();
+                void ignoreStdErr();
+
+                /**
+                 * Returns the pid of the child process, or zero if there is no
+                 * currently running child.  Note that a read operation must be
+                 * performed in order to discover that the child has ended.
+                 */
+                pid_t getPid();
+
+                /**
+                 * Returns true if the child exited normally (by calling exit or
+                 * returning from main).
+                 */
+                bool childExited();
+
+                /**
+                 * Returns the 8 bit integer value returned from the child program if
+                 * childExited returned true.
+                 */
+                int childExitStatus();
+
+                /**
+                 * Returns true if the child exited because of a signal.
+                 */
+                bool childSignaled();
+
+                /**
+                 * Returns the signal ID if the childSignaled return true.
+                 */
+                int childSignal();
+
+                /**
+                 * Returns true if the child left a core dump behind when it exited.
+                 */
+                bool childCoreDumped();
+
+        private:
+                int iStdIn;
+                int iStdOut;
+                int iStdErr;
+                pid_t iPid;
+                int iProcStatus;
+                bool bBlocking;
+                bool bStdOutEos;
+                bool bStdErrEos;
+
+                void gexec( Flags eFlags, const char *sName, char *const argv[] );
+                void checkClose();
+                Options opt;
+        };
+}
+
+#endif
diff --git a/src/stable/protocol.cpp b/src/stable/protocol.cpp
new file mode 100644
index 0000000..2489d05
--- /dev/null
+++ b/src/stable/protocol.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/protocol.h"
+
+using namespace Bu;
+
+Bu::Protocol::Protocol()
+{
+}
+
+Bu::Protocol::~Protocol()
+{
+}
+
+void Bu::Protocol::onNewConnection( Bu::Client * )
+{
+}
+
+void Bu::Protocol::onNewData( Bu::Client * )
+{
+}
+
+void Bu::Protocol::onMessage( Bu::Client *, const Bu::String & )
+{
+}
+
+void Bu::Protocol::onTick( Bu::Client * )
+{
+}
+
diff --git a/src/stable/protocol.h b/src/stable/protocol.h
new file mode 100644
index 0000000..0058723
--- /dev/null
+++ b/src/stable/protocol.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_PROTOCOL_H
+#define BU_PROTOCOL_H
+
+#include <stdint.h>
+
+#include "bu/string.h"
+
+namespace Bu
+{
+        class Client;
+
+        /**
+         *@ingroup Serving
+         */
+        class Protocol
+        {
+        public:
+                Protocol();
+                virtual ~Protocol();
+
+                virtual void onNewConnection( Bu::Client *pClient );
+                virtual void onNewData( Bu::Client *pClient );
+                virtual void onMessage( Bu::Client *pClient, const Bu::String &sMsg );
+                virtual void onTick( Bu::Client *pClient );
+
+        private:
+
+        };
+}
+
+#endif
diff --git a/src/stable/protocolhttp.cpp b/src/stable/protocolhttp.cpp
new file mode 100644
index 0000000..eaee9d0
--- /dev/null
+++ b/src/stable/protocolhttp.cpp
@@ -0,0 +1,353 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include <dirent.h>
+
+#ifndef WIN32
+        #include <sys/wait.h>
+#endif 
+
+#include <errno.h>
+#include <stdlib.h>
+#include "bu/protocolhttp.h"
+#include "bu/logger.h"
+
+#define CRLF "\x0D\x0A"
+#define CR '\x0D'
+#define LF '\x0A'
+
+using namespace Bu;
+
+Bu::ProtocolHttp::ProtocolHttp()
+{
+}
+
+Bu::ProtocolHttp::~ProtocolHttp()
+{
+}
+
+void Bu::ProtocolHttp::onNewConnection( Bu::Client *pClient )
+{
+        this->pClient = pClient;
+
+        iState = 0;
+}
+
+#define SDB( i ) (void)0
+//#define SDB( i ) printf("state %d: %d, \"%s\"\n", i, tt, sToken.getStr() )
+
+void Bu::ProtocolHttp::onNewData( Bu::Client *pClient )
+{
+/*      logHexDump(
+                1,
+                pClient->getInput().getStr(),
+                pClient->getInput().getSize(),
+                "input"
+                );*/
+
+        for(;;)
+        {
+                Bu::String sToken;
+                TokenType tt = getToken( sToken );
+
+                if( tt == ttOutOfData )
+                        return;
+
+                switch( iState )
+                {
+                        case 0:         // Start token, should be "method" (get, put, etc)
+                                SDB( 0 );
+                                sMethod = sToken;
+                                iState = 1;
+                                break;
+
+                        case 1:         // The path requested
+                                SDB( 1 );
+                                sPath = sToken;
+                                iState = 2;
+                                break;
+
+                        case 2:         // The protocol name and version
+                                SDB( 2 );
+                                if( strncmp( sToken.getStr(), "HTTP/", 5 ) )
+                                {
+                                        pClient->disconnect();
+                                        return;
+                                }
+                                else
+                                {
+                                        char *s, *s2;
+                                        s = sToken.getStr()+5;
+                                        iMajor = strtol( s, &s2, 10 );
+                                        iMinor = strtol( s2+1, NULL, 10 );
+                                        iState = 3;
+                                }
+                                break;
+
+                        case 3:         // End of initial header, now comes mime-style blocks.
+                                SDB( 3 );
+                                if( tt == ttNewline )
+                                {
+                                        iState = 10;
+                                }
+                                else if( tt == ttDoubleNewline )
+                                {
+                                        earlyResponse();
+                                }
+                                else
+                                {
+                                        pClient->disconnect();
+                                        return;
+                                }
+                                break;
+
+                        case 10:                // HTTP-Message (skipped for now...)
+                                SDB( 10 );
+                                if( tt == ttString )
+                                {
+                                        iState = 11;
+                                }
+                                else
+                                {
+                                        pClient->disconnect();
+                                }
+                                break;
+
+                        case 11:                // Should be a colon...
+                                SDB( 11 );
+                                if( tt == ttSeperator && sToken == ":" )
+                                {
+                                        iState = 12;
+                                }
+                                else
+                                {
+                                        pClient->disconnect();
+                                }
+                                break;
+
+                        case 12:
+                                SDB( 12 );
+                                if( tt == ttNewline )
+                                {
+                                        iState = 10;
+                                }
+                                if( tt == ttDoubleNewline )
+                                {
+                                        earlyResponse();
+                                }
+                                break;
+
+                        case 20:
+                                SDB( 20 );
+                                break;
+                }
+        }
+}
+
+Bu::ProtocolHttp::TokenType Bu::ProtocolHttp::getToken( Bu::String &line )
+{
+        char s;
+        int jmax = pClient->getInputSize();
+        bool bNonWS = false;
+        
+        for( int j = 0; j < jmax; j++ )
+        {
+                pClient->peek( &s, 1, j );
+                if( iState > 2 && isSeperator( s ) )
+                {
+                        if( j == 0 )
+                        {
+                                line += s;
+                                pClient->seek( 1 );
+                                return ttSeperator;
+                        }
+                        else
+                        {
+                                pClient->seek( j );
+                                return ttString;
+                        }
+                }
+                else if( isWS( s ) )
+                {
+                        if( bNonWS )
+                        {
+                                pClient->seek( j );
+                                return ttString;
+                        }
+                }
+                else if( s == CR )
+                {
+                        if( pClient->getInputSize() < 4 )
+                                return ttOutOfData;
+                        
+                        char ss[3];
+                        pClient->peek( ss, 3, j+1 );
+                        if( ss[0] == LF && ss[1] != ' ' && ss[1] != '\t' )
+                        {
+                                if( bNonWS )
+                                {
+                                        pClient->seek( j );
+                                        return ttString;
+                                }
+                                else if( ss[1] == CR && ss[2] == LF )
+                                {
+                                        pClient->seek( 4 );
+                                        return ttDoubleNewline;
+                                }
+                                else
+                                {
+                                        pClient->seek( 2 );
+                                        return ttNewline;
+                                }
+                        }
+                        
+                        j += 2;
+                        if( bNonWS )
+                        {
+                                pClient->seek( j );
+                                return ttString;
+                        }
+                }
+                else
+                {
+                        line += s;
+                        bNonWS = true;
+                }
+        }
+
+        return ttOutOfData;
+}
+
+bool Bu::ProtocolHttp::isWS( char buf )
+{
+        return (buf == ' ' || buf == '\t');
+}
+
+bool Bu::ProtocolHttp::isSeperator( char buf )
+{
+        return (buf == '(' || buf == ')' || buf == '<' || buf == '>' ||
+                        buf == '@' || buf == ',' || buf == ';' || buf == ':' ||
+                        buf == '\\' || buf == '\"' || buf == '/' || buf == '[' ||
+                        buf == ']' || buf == '?' || buf == '=' || buf == '{' ||
+                        buf == '}' );
+}
+
+void Bu::ProtocolHttp::earlyResponse()
+{
+        if( sMethod == "GET" )
+        {
+                onRequest( sMethod, sPath );
+                iState = 0;
+        }
+        else
+        {
+                iState = 20;
+        }
+}
+
+void Bu::ProtocolHttp::lateResponse()
+{
+        onRequest( sMethod, sPath );
+}
+
+void Bu::ProtocolHttp::sendResponse( const Response &rRes )
+{
+        char buf[1024];
+        int iSize = sprintf( buf, "HTTP/1.1 %d ", rRes.iCode );
+
+        pClient->write( buf, iSize );
+        pClient->write( rRes.sReason );
+        pClient->write( CRLF, 2 );
+
+        for( Response::StringHash::const_iterator i = rRes.hHeaders.begin();
+                 i != rRes.hHeaders.end(); i++ )
+        {
+                pClient->write( i.getKey() );
+                pClient->write(": ", 2 );
+                pClient->write( i.getValue() );
+                pClient->write( CRLF, 2 );
+        }
+
+        iSize = sprintf( buf, "Content-Length: %ld" CRLF, rRes.sContent.getSize() );
+        pClient->write( buf, iSize );
+
+        pClient->write( CRLF, 2 );
+        pClient->write( rRes.sContent );
+}
+
+//
+// Bu::ProtocolHttp::Response
+//
+Bu::ProtocolHttp::Response::Response( int iCode ) :
+        iCode( iCode )
+{
+        switch( iCode )
+        {
+                case 100:       sReason = "Continue"; break;
+                case 101:       sReason = "Switching Protocols"; break;
+                case 200:       sReason = "OK"; break;
+                case 201:       sReason = "Created"; break;
+                case 202:       sReason = "Accepted"; break;
+                case 203:       sReason = "Non-Authoritative Information"; break;
+                case 204:       sReason = "No Content"; break;
+                case 205:       sReason = "Reset Content"; break;
+                case 206:       sReason = "Partial Content"; break;
+                case 300:       sReason = "Multiple Choices"; break;
+                case 301:       sReason = "Moved Permanently"; break;
+                case 302:       sReason = "Found"; break;
+                case 303:       sReason = "See Other"; break;
+                case 304:       sReason = "Not Modified"; break;
+                case 305:       sReason = "Use Proxy"; break;
+                case 307:       sReason = "Temporary Redirect"; break;
+                case 400:       sReason = "Bad Request"; break;
+                case 401:       sReason = "Unauthorized"; break;
+                case 402:       sReason = "Payment Required"; break;
+                case 403:       sReason = "Forbidden"; break;
+                case 404:       sReason = "Not Found"; break;
+                case 405:       sReason = "Method Not Allowed"; break;
+                case 406:       sReason = "Not Acceptable"; break;
+                case 407:       sReason = "Proxy Authentication Required"; break;
+                case 408:       sReason = "Request Time-out"; break;
+                case 409:       sReason = "Conflict"; break;
+                case 410:       sReason = "Gone"; break;
+                case 411:       sReason = "Length Required"; break;
+                case 412:       sReason = "Precondition Failed"; break;
+                case 413:       sReason = "Request Entity Too Large"; break;
+                case 414:       sReason = "Request-URI Too Large"; break;
+                case 415:       sReason = "Unsupported Media Type"; break;
+                case 416:       sReason = "Requested range not satisfiable"; break;
+                case 417:       sReason = "Expectation Failed"; break;
+                case 500:       sReason = "Internal Server Error"; break;
+                case 501:       sReason = "Not Implemented"; break;
+                case 502:       sReason = "Bad Gateway"; break;
+                case 503:       sReason = "Service Unavailable"; break;
+                case 504:       sReason = "Gateway Time-out"; break;
+                case 505:       sReason = "HTTP Version not supported"; break;
+        }
+}
+
+Bu::ProtocolHttp::Response::Response( int iCode, const Bu::String &sReason ) :
+        iCode( iCode ),
+        sReason( sReason )
+{
+}
+
+Bu::ProtocolHttp::Response::~Response()
+{
+}
+
+void Bu::ProtocolHttp::Response::setHeader(
+        const Bu::String &sKey, const Bu::String &sVal )
+{
+        hHeaders.insert( sKey, sVal );
+}
+
+void Bu::ProtocolHttp::Response::setContent( const Bu::String &sCont )
+{
+        sContent = sCont;
+}
+
diff --git a/src/stable/protocolhttp.h b/src/stable/protocolhttp.h
new file mode 100644
index 0000000..153a00d
--- /dev/null
+++ b/src/stable/protocolhttp.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_PROTOCOL_HTTP_H
+#define BU_PROTOCOL_HTTP_H
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include "bu/protocol.h"
+#include "bu/client.h"
+#include "bu/string.h"
+#include "bu/hash.h"
+
+namespace Bu
+{
+        /**
+         * An HTTP Protocol handler.  Yes, I know that HTTP stands for Hyper Text
+         * Transfer Protocol, and that the Protocol part is redundant, but in this
+         * case the word Protocol is refering to the Libbu++ construct Bu::Protocol,
+         * and not a means of encoding conversations.  Anyway, this class represents
+         * a general HTTP server processor.  Every time a request comes in it calls
+         * the onRequest function in a subclass with the method and URI that were
+         * requested.  The sub-class can then do whatever it needs to to send back
+         * a response.
+         *@ingroup Serving
+         */
+        class ProtocolHttp : public Protocol
+        {
+        public: /* Types */
+                typedef Bu::List<Bu::String> TokenList;
+
+        public: /* Interface */
+                ProtocolHttp();
+                virtual ~ProtocolHttp();
+
+                virtual void onNewConnection( Bu::Client *pClient );
+                virtual void onNewData( Bu::Client *pClient );
+
+                virtual void onRequest(
+                        const Bu::String &sMethod, const Bu::String &sPath )=0;
+
+                class Response
+                {
+                        friend class Bu::ProtocolHttp;
+                public:
+                        Response( int iCode );
+                        Response( int iCode, const Bu::String &sReason );
+                        virtual ~Response();
+
+                        void setHeader( const Bu::String &sKey, const Bu::String &sVal );
+                        void setContent( const Bu::String &sCont );
+
+                private:
+                        int iCode;
+                        Bu::String sReason;
+                        typedef Bu::Hash<Bu::String,Bu::String> StringHash;
+                        StringHash hHeaders;
+                        Bu::String sContent;
+                };
+                
+                void sendResponse( const Response &rRes );
+        
+        private:
+                enum TokenType
+                {
+                        ttOutOfData,
+                        ttString,
+                        ttNewline,
+                        ttDoubleNewline,
+                        ttSeperator
+                };
+                /**
+                 * Read an HTTP line, this is up to the first CRLF that isn't followed
+                 * by a continuation character, converting it to one line as it reads.
+                 *@param line All data read will be appended to line, even if no
+                 * end-of-line is read.
+                 *@returns True if an end-of-line is read and the line should be
+                 * processed, false if the end-of-line has not been reached, and more
+                 * data needs to be read before this operation can continue.
+                 */
+                TokenType getToken( Bu::String &line );
+                bool isWS( char buf );
+                bool isSeperator( char buf );
+
+                void earlyResponse();
+                void lateResponse();
+
+        private: /* state */
+                Bu::Client *pClient;
+                TokenList lTokens;
+
+                int iState;
+
+                Bu::String sMethod;
+                Bu::String sPath;
+                int iMajor;
+                int iMinor;
+        };
+}
+
+#endif
diff --git a/src/stable/protocoltelnet.cpp b/src/stable/protocoltelnet.cpp
new file mode 100644
index 0000000..7e37cca
--- /dev/null
+++ b/src/stable/protocoltelnet.cpp
@@ -0,0 +1,620 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/protocoltelnet.h"
+#include "bu/client.h"
+
+/* We apparently at least want defs for the lower 13, not sure we care about
+ * the rest of the chars, maybe escape.
+ */
+#define CH_NUL          '\x00'  /* NUL */
+#define CH_SOH          '\x01'  /* Start Of Heading */
+#define CH_STX          '\x02'  /* Start of Text */
+#define CH_ETX          '\x03'  /* End of Text */
+#define CH_EOT          '\x04'  /* End of transmission */
+#define CH_ENQ          '\x05'  /* Enquiery */
+#define CH_ACK          '\x06'  /* Acknowledge */
+#define CH_BEL          '\x07'  /* Bell */
+#define CH_BS           '\x08'  /* Backspace */
+#define CH_TAB          '\x09'  /* Horizontal Tab */
+#define CH_LF           '\x0A'  /* NL Line feed, new line */
+#define CH_VT           '\x0B'  /* Vertical Tab */
+#define CH_FF           '\x0C'  /* Form feed, new page */
+#define CH_CR           '\x0D'  /* Carriage return */
+#define CH_ESC          '\x1B'  /* Escape */
+#define CH_DEL          '\x7F'  /* Delete */
+
+#define CODE_SE         '\xf0'  /* End of subnegotiation params. */
+#define CODE_NOP        '\xf1'  /* No operation (keep-alive). */
+#define CODE_DM         '\xf2'  /* Datastream side of a Synch. */
+#define CODE_BRK        '\xf3'  /* Break character. */
+#define CODE_IP         '\xf4'  /* Interrupt Process character. */
+#define CODE_AO         '\xf5'  /* Abort Output character. */
+#define CODE_AYT        '\xf6'  /* Are You There? character. */
+#define CODE_EC         '\xf7'  /* Erase Character character. */
+#define CODE_EL         '\xf8'  /* Erase Line character. */
+#define CODE_GA         '\xf9'  /* Go Ahead signal. */
+#define CODE_SB         '\xfa'  /* Begin subnegotiation options. */
+#define CODE_WILL       '\xfb'  /* Desire to do something. */
+#define CODE_WONT       '\xfc'  /* Refuse to perform. */
+#define CODE_DO         '\xfd'  /* Request option. */
+#define CODE_DONT       '\xfe'  /* Demand a stop. */
+
+#define CODE_IAC        '\xff'  /* Interpret-As-Command. */
+
+#define OPT_BINARY      '\x00'  /* Binary mode (file transfers?). */
+#define OPT_ECHO        '\x01'  /* (local) Echo mode. */
+#define OPT_SUPGA       '\x03'  /* Suppress Go Ahead signals. */
+#define OPT_STATUS      '\x05'  /* Allow status messages. */
+#define OPT_TIMING      '\x06'  /* Place a timing mark in the code. */
+#define OPT_EXASCII     '\x11'  /* Extended ASCII. */
+#define OPT_LOGOUT      '\x12'  /* Logout. */
+#define OPT_TTYPE       '\x18'  /* Terminal Type. */
+#define OPT_NAWS        '\x1f'  /* Negotiate about window size. */
+#define OPT_TSPEED      '\x20'  /* Terminal Speed. */
+#define OPT_NEWENV      '\x27'  /* New Environment Option. */
+#define OPT_EXOPL       '\xff'  /* Can we, will we, handle extended options. */
+
+#ifndef __TELNET_DEBUG
+# define printCode( a ) (void)0
+# define printOpt( a ) (void)0
+#endif
+
+Bu::ProtocolTelnet::ProtocolTelnet() :
+        oBinary(        *this, OPT_BINARY ),
+        oEcho(          *this, OPT_ECHO ),
+        oNAWS(          *this, OPT_NAWS ),
+        oSuppressGA(*this, OPT_SUPGA ),
+        bCanonical( true ),
+        bSubOpt( false )
+{
+}
+
+Bu::ProtocolTelnet::~ProtocolTelnet()
+{
+}
+
+void Bu::ProtocolTelnet::onNewConnection( Bu::Client *pClient )
+{
+        this->pClient = pClient;
+}
+
+void Bu::ProtocolTelnet::onNewData( Bu::Client *pClient )
+{
+        char bc;
+        int iLeft;
+        while( (iLeft = pClient->getInputSize()) )
+        {
+                if( bSubOpt )
+                {
+                        pClient->peek( &bc, 1 );
+                        if( bc == CODE_IAC )
+                        {
+                                if( iLeft <= 1 ) return;
+                                char bc2;
+                                printCode( CODE_IAC );
+                                pClient->peek( &bc2, 1, 1 );
+                                printCode( bc2 );
+                                if( bc2 == CODE_SE )
+                                {
+                                        bSubOpt = false;
+                                        onSubOpt();
+                                }
+                                else if( bc2 == CODE_IAC )
+                                {
+                                        sSubBuf += CODE_IAC;
+                                }
+                                else
+                                {
+                                        // Error of some sort.
+                                }
+                                pClient->seek( 1 );
+                        }
+                        else
+                        {
+                                sSubBuf += bc;
+                        }
+                        pClient->seek( 1 );
+                }
+                else
+                {
+                        pClient->peek( &bc, 1 );
+                        if( bc == CODE_IAC )
+                        {
+                                if( iLeft <= 1 ) return;
+                                char bc2;
+                                pClient->peek( &bc2, 1, 1 );
+                                printCode( bc );
+                                printCode( bc2 );
+
+                                switch( bc2 )
+                                {
+                                        case CODE_WILL:
+                                                if( iLeft <= 2 ) return;
+                                                {
+                                                        char bc3;
+                                                        pClient->peek( &bc3, 1, 2 );
+                                                        pClient->seek( 1 );
+                                                        printOpt( bc3 );
+                                                        onWill( bc3 );
+                                                }
+                                                break;
+
+                                        case CODE_WONT:
+                                                if( iLeft <= 2 ) return;
+                                                {
+                                                        char bc3;
+                                                        pClient->peek( &bc3, 1, 2 );
+                                                        pClient->seek( 1 );
+                                                        printOpt( bc3 );
+                                                        onWont( bc3 );
+                                                }
+                                                break;
+
+                                        case CODE_DO:
+                                                if( iLeft <= 2 ) return;
+                                                {
+                                                        char bc3;
+                                                        pClient->peek( &bc3, 1, 2 );
+                                                        pClient->seek( 1 );
+                                                        printOpt( bc3 );
+                                                        onDo( bc3 );
+                                                }
+                                                break;
+
+                                        case CODE_DONT:
+                                                if( iLeft <= 2 ) return;
+                                                {
+                                                        char bc3;
+                                                        pClient->peek( &bc3, 1, 2 );
+                                                        pClient->seek( 1 );
+                                                        printOpt( bc3 );
+                                                        onDont( bc3 );
+                                                }
+                                                break;
+
+                                        case CODE_SB:
+                                                if( iLeft <= 2 ) return;
+                                                {
+                                                        pClient->peek( &cSubOpt, 1, 2 );
+                                                        pClient->seek( 1 );
+                                                        printOpt( cSubOpt );
+                                                        bSubOpt = true;
+                                                }
+                                                break;
+
+                                        case CODE_IAC:
+                                                sDataBuf += CODE_IAC;
+                                                printCode( CODE_IAC );
+                                                break;
+                                }
+                                pClient->seek( 1 );
+#ifdef __TELNET_DEBUG
+                                printf("\n");
+#endif
+                        }
+                        else if( bc == CODE_SB )
+                        {
+                        }
+                        else
+                        {
+                                // This is where control code handling goes
+                                // Also, possibly, character code conversion, although I'm not
+                                // sure that really matters anymore, go ASCII/UTF-8
+                                if( bCanonical )
+                                {
+                                        if( bc < 0x20 || bc >= CH_DEL )
+                                        {
+                                                if( bc == CH_CR )
+                                                {
+                                                        if( iLeft <= 1 ) return;
+                                                        char bc2;
+                                                        pClient->peek( &bc2, 1, 1 );
+                                                        if( bc2 == CH_NUL || bc2 == CH_LF )
+                                                        {
+                                                                onCtlChar( bc );
+                                                                gotLine( sDataBuf );
+                                                                sDataBuf.clear();
+                                                        }
+                                                        pClient->seek( 1 );
+                                                }
+                                                else
+                                                {
+                                                        onCtlChar( bc );
+                                                }
+                                        }
+                                        else
+                                        {
+                                                sDataBuf += bc;
+                                                if( oEcho.isLocalSet() )
+                                                {
+                                                        pClient->write( &bc, 1 );
+#ifdef __TELNET_DEBUG
+                                                        printf("%c", bc );
+                                                        fflush( stdout );
+#endif
+                                                }
+                                        }
+                                }
+                                else
+                                {
+                                        sDataBuf += bc;
+                                        if( oEcho.isLocalSet() )
+                                        {
+                                                pClient->write( &bc, 1 );
+                                        }
+                                }
+                        }
+                        pClient->seek( 1 );
+                }
+        }
+
+        // It's true, this code will not be executed if we only have half of an
+        // IAC code or multibyte escape sequence or something, but then again, it
+        // shouldn't be called then, and really, shouldn't be, it'll be called soon
+        // enough, when we get the rest of that code.
+        if( !bCanonical )
+        {
+                gotData( sDataBuf );
+        }
+}
+
+void Bu::ProtocolTelnet::setCanonical( bool bCon )
+{
+        bCanonical = bCon;
+}
+
+bool Bu::ProtocolTelnet::isCanonical()
+{
+        return bCanonical;
+}
+
+void Bu::ProtocolTelnet::write( const Bu::String &sData )
+{
+        write( sData.getStr(), sData.getSize() );
+}
+
+void Bu::ProtocolTelnet::write( const char *pData, int iSize )
+{
+        int iLast = 0, j;
+        for( j = iLast; j < iSize; j++ )
+        {
+                if( pData[j] == '\n' )
+                {
+                        if( j+1 >= iSize ||
+                                (pData[j+1] != '\r' && pData[j+1] != '\0') )
+                        {
+                                pClient->write( pData+iLast, j-iLast );
+                                pClient->write( "\n\r", 2 );
+                                iLast = j+1;
+                        }
+                        else
+                        {
+                                j++;
+                        }
+                }
+        }
+        if( j > iLast )
+        {
+                pClient->write( pData+iLast, iSize-iLast );
+        }
+        //pClient->write( pData, iSize );
+}
+
+void Bu::ProtocolTelnet::write( char cData )
+{
+        write( &cData, 1 );
+}
+
+void Bu::ProtocolTelnet::onWill( char cCode )
+{
+        try
+        {
+                Option *pOpt = hOpts[cCode];
+                if( pOpt->isRemoteEnabled() )
+                {
+                        pOpt->fOpts |= Option::fRemoteIs;
+                        char buf[3] = { CODE_IAC, CODE_DO, cCode };
+                        pClient->write( buf, 3 );
+                }
+                else
+                {
+                        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+                        pClient->write( buf, 3 );
+                }
+
+        }
+        catch( Bu::HashException &e )
+        {
+                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+                pClient->write( buf, 3 );
+        }
+}
+
+void Bu::ProtocolTelnet::onWont( char cCode )
+{
+        try
+        {
+                Option *pOpt = hOpts[cCode];
+
+                pOpt->fOpts &= ~Option::fRemoteIs;
+                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+                pClient->write( buf, 3 );
+        }
+        catch( Bu::HashException &e )
+        {
+                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+                pClient->write( buf, 3 );
+        }
+}
+
+void Bu::ProtocolTelnet::onDo( char cCode )
+{
+        try
+        {
+                Option *pOpt = hOpts[cCode];
+                if( pOpt->isLocalEnabled() )
+                {
+                        pOpt->fOpts |= Option::fLocalIs;
+                        char buf[3] = { CODE_IAC, CODE_WILL, cCode };
+                        pClient->write( buf, 3 );
+                }
+                else
+                {
+                        char buf[3] = { CODE_IAC, CODE_WONT, cCode };
+                        pClient->write( buf, 3 );
+                }
+
+        }
+        catch( Bu::HashException &e )
+        {
+                char buf[3] = { CODE_IAC, CODE_WONT, cCode };
+                pClient->write( buf, 3 );
+        }
+}
+
+void Bu::ProtocolTelnet::onDont( char cCode )
+{
+        try
+        {
+                Option *pOpt = hOpts[cCode];
+
+                pOpt->fOpts &= ~Option::fLocalIs;
+                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+                pClient->write( buf, 3 );
+        }
+        catch( Bu::HashException &e )
+        {
+                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+                pClient->write( buf, 3 );
+        }
+}
+
+void Bu::ProtocolTelnet::onSubOpt()
+{
+        switch( cSubOpt )
+        {
+                case OPT_NAWS:
+                        {
+                                uint16_t iWidth, iHeight;
+                                ((char *)&iWidth)[1] = sSubBuf[0];
+                                ((char *)&iWidth)[0] = sSubBuf[1];
+                                ((char *)&iHeight)[1] = sSubBuf[2];
+                                ((char *)&iHeight)[0] = sSubBuf[3];
+                                onSubNAWS( iWidth, iHeight );
+                        }
+                        break;
+
+                default:
+                        onSubUnknown( cSubOpt, sSubBuf );
+                        break;
+        }
+
+        sSubBuf.clear();
+}
+
+void Bu::ProtocolTelnet::onCtlChar( char cChr )
+{
+#ifdef __TELNET_DEBUG 
+        switch( cChr )
+        {
+                case CH_NUL:    printf("NUL "); break;
+                case CH_SOH:    printf("SOH "); break;
+                case CH_STX:    printf("STX "); break;
+                case CH_ETX:    printf("ETX "); break;
+                case CH_EOT:    printf("EOT "); break;
+                case CH_ENQ:    printf("ENQ "); break;
+                case CH_ACK:    printf("ACK "); break;
+                case CH_BEL:    printf("BEL "); break;
+                case CH_BS:             printf("BS ");  break;
+                case CH_TAB:    printf("TAB "); break;
+                case CH_LF:             printf("LF ");  break;
+                case CH_VT:             printf("VT ");  break;
+                case CH_FF:             printf("FF ");  break;
+                case CH_CR:             printf("CR ");  break;
+                case CH_ESC:    printf("ESC "); break;
+                case CH_DEL:    printf("DEL "); break;
+                default:                printf("!![%02x] ", cChr );     break;
+        }
+        fflush( stdout );
+#endif
+
+        switch( cChr )
+        {
+                case CH_DEL:
+                        {
+                                if( sDataBuf.getSize() > 0 )
+                                {
+                                        sDataBuf.resize( sDataBuf.getSize()-1 );
+                                        char buf[3] = { CH_BS, ' ', CH_BS };
+                                        pClient->write( buf, 3 );
+                                }
+                        }
+                        break;
+
+        }
+}
+
+#ifdef __TELNET_DEBUG
+void Bu::ProtocolTelnet::printCode( char cCode )
+{
+        switch( cCode )
+        {
+                case CODE_SE:           printf("SE ");          break;
+                case CODE_NOP:          printf("NOP ");         break;
+                case CODE_DM:           printf("DM ");          break;
+                case CODE_BRK:          printf("BRK ");         break;
+                case CODE_IP:           printf("IP ");          break;
+                case CODE_AO:           printf("AO ");          break;
+                case CODE_AYT:          printf("AYT ");         break;
+                case CODE_EC:           printf("EC ");          break;
+                case CODE_EL:           printf("EL ");          break;
+                case CODE_GA:           printf("GA ");          break;
+                case CODE_SB:           printf("SB ");          break;
+                case CODE_WILL:         printf("WILL ");        break;
+                case CODE_WONT:         printf("WONT ");        break;
+                case CODE_DO:           printf("DO ");          break;
+                case CODE_DONT:         printf("DONT ");        break;
+                case CODE_IAC:          printf("IAC ");         break;
+                default:                        printf("??%02x ", cCode );      break;
+        }
+        fflush( stdout );
+}
+
+void Bu::ProtocolTelnet::printOpt( char cOpt )
+{
+        switch( cOpt )
+        {
+                case OPT_BINARY:        printf("BINARY ");      break;
+                case OPT_ECHO:          printf("ECHO ");        break;
+                case OPT_SUPGA:         printf("SUPGA ");       break;
+                case OPT_STATUS:        printf("STATUS ");      break;
+                case OPT_TIMING:        printf("TIMING ");      break;
+                case OPT_EXASCII:       printf("EXASCII ");     break;
+                case OPT_LOGOUT:        printf("LOGOUT ");      break;
+                case OPT_TTYPE:         printf("TTYPE ");       break;
+                case OPT_NAWS:          printf("NAWS ");        break;
+                case OPT_TSPEED:        printf("TSPEED ");      break;
+                case OPT_NEWENV:        printf("NEWENV ");      break;
+                case OPT_EXOPL:         printf("EXOPL ");       break;
+                default:                        printf("??%02x ", cOpt);        break;
+        }
+        fflush( stdout );
+}
+#endif
+
+Bu::ProtocolTelnet::Option::Option( Bu::ProtocolTelnet &rPT, char cCode ) :
+        rPT( rPT ),
+        fOpts( 0 ),
+        cCode( cCode )
+{
+        rPT.hOpts.insert( cCode, this );
+}
+
+Bu::ProtocolTelnet::Option::~Option()
+{
+}
+
+void Bu::ProtocolTelnet::Option::localEnable( bool bSet )
+{
+        if( bSet == (bool)(!(fOpts&fLocalCant)) ) return;
+
+        if( bSet )
+                fOpts &= ~fLocalCant;
+        else
+                fOpts |= fLocalCant;
+}
+
+void Bu::ProtocolTelnet::Option::localSet( bool bSet )
+{
+        if( bSet == (bool)(fOpts&fLocalIs) ) return;
+
+        char buf[3] = { CODE_IAC, 0, cCode };
+
+        if( bSet )
+        {
+                buf[1] = CODE_WILL;
+                rPT.pClient->write( buf, 3 );
+#ifdef __TELNET_DEBUG
+                printf("<= ");
+                rPT.printCode( buf[0] );
+                rPT.printCode( buf[1] );
+                rPT.printOpt( buf[2] );
+                printf("\n");
+#endif
+        }
+        else
+        {
+                buf[1] = CODE_WONT;
+                rPT.pClient->write( buf, 3 );
+#ifdef __TELNET_DEBUG
+                printf("<= ");
+                rPT.printCode( buf[0] );
+                rPT.printCode( buf[1] );
+                rPT.printOpt( buf[2] );
+                printf("\n");
+#endif
+        }
+}
+
+bool Bu::ProtocolTelnet::Option::isLocalEnabled()
+{
+        return (bool)(!(fOpts&fLocalCant));
+}
+
+bool Bu::ProtocolTelnet::Option::isLocalSet()
+{
+        return (bool)(fOpts&fLocalIs);
+}
+
+void Bu::ProtocolTelnet::Option::remoteEnable( bool /*bSet*/ )
+{
+        return;
+}
+
+void Bu::ProtocolTelnet::Option::remoteSet( bool bSet )
+{
+        //if( bSet == (bool)(fOpts&fRemoteIs) ) return;
+
+        char buf[3] = { CODE_IAC, 0, cCode };
+
+        if( bSet )
+        {
+                buf[1] = CODE_DO;
+                rPT.pClient->write( buf, 3 );
+#ifdef __TELNET_DEBUG
+                printf("<= ");
+                rPT.printCode( buf[0] );
+                rPT.printCode( buf[1] );
+                rPT.printOpt( buf[2] );
+                printf("\n");
+#endif
+        }
+        else
+        {
+                buf[1] = CODE_DONT;
+                rPT.pClient->write( buf, 3 );
+#ifdef __TELNET_DEBUG
+                printf("<= ");
+                rPT.printCode( buf[0] );
+                rPT.printCode( buf[1] );
+                rPT.printOpt( buf[2] );
+                printf("\n");
+#endif
+        }
+}
+
+bool Bu::ProtocolTelnet::Option::isRemoteEnabled()
+{
+        return (bool)(!(fOpts&fRemoteCant));
+}
+
+bool Bu::ProtocolTelnet::Option::isRemoteSet()
+{
+        return (bool)(fOpts&fRemoteIs);
+}
+
diff --git a/src/stable/protocoltelnet.h b/src/stable/protocoltelnet.h
new file mode 100644
index 0000000..74d6478
--- /dev/null
+++ b/src/stable/protocoltelnet.h
@@ -0,0 +1,220 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_PROTOCOL_TELNET_H
+#define BU_PROTOCOL_TELNET_H
+
+#include "bu/protocol.h"
+#include "bu/hash.h"
+#include "bu/string.h"
+
+// #define __TELNET_DEBUG
+
+namespace Bu
+{
+        /**
+         * Telnet Protocol handler.  This attempts to provide useful and general
+         * support for most of the most commonly used Telnet extensions in a simple
+         * and easy to use way.  The Option variables control the settings that can
+         * be used on the line, and control which virtual "callbacks" will be called
+         * when different events happen.
+         *
+         * To setup initial values and to disable any options you wish override the
+         * onNewConnection function in your own class, like this:
+         *@code
+         class MyTelnet : public Bu::ProtocolTelnet
+         {
+         public:
+                ...
+
+                virtual void onNewConnection( class Bu::Client *pClient )
+                {
+                        // Call the parent class' onNewConnection to get everything all
+                        // set up.
+                        Bu::ProtocolTelnet::onNewConnection( pClient );
+
+                        // These functions disable the option to send files via telnet,
+                        // disabling the remote option means that we won't accept this
+                        // option (binary data being sent to us) from the client.
+                        //
+                        // Disabling the local option means that the client cannot ask us
+                        // to send them binary data.
+                        oBinary.enableRemote( false );
+                        oBinary.enableLocal( false );
+
+                        // This requests that the client send us window size updates
+                        // whenever the size of their window changes, and an initial set to
+                        // boot.
+                        //
+                        // To see if this option is set later, try oNAWS.isRemoteSet(), but
+                        // wait a little while, asking immediatly will always return false,
+                        // since the remote side has yet to receive our request.
+                        oNAWS.remoteSet();
+                }
+        }
+         @endcode
+         *
+         *@ingroup Serving
+         */
+        class ProtocolTelnet : public Protocol
+        {
+        public:
+                ProtocolTelnet();
+                virtual ~ProtocolTelnet();
+
+                /**
+                 * If you override this function in a child class, make sure to call
+                 * this version of it as the very first thing that you do, before you
+                 * set any options.  See the example in the class docs.
+                 */
+                virtual void onNewConnection( class Bu::Client *pClient );
+
+                /**
+                 * You should never override this function unless you really, really
+                 * know what you're doing.  If you want to get data after each line
+                 * entered (in canonical mode) or after any data arrives (non canonical
+                 * mode) then override the gotLine and gotData functions, respectively.
+                 */
+                virtual void onNewData( class Bu::Client *pClient );
+
+                /**
+                 * Override this function to be notified of lines being submitted by
+                 * the client.  This function is only called in canonical mode, after
+                 * all edits are performed on the data.  In this mode weather you use
+                 * the line or not, the data will be cleared from the buffer when this
+                 * function returns, any changes made to the buffer will be destroyed.
+                 */
+                virtual void gotLine( Bu::String & /*sLine*/ ){};
+
+                /**
+                 * Override this function to be notified of any new data that comes in
+                 * from the client.  This function is only called in non-canonical mode,
+                 * and includes all raw data minus telnet control codes and ansi
+                 * escape sequences.  In this mode control of the buffer is up to the
+                 * child class in this function, the buffer will never be cleared unless
+                 * it happens in this function's override.
+                 */
+                virtual void gotData( Bu::String & /*sData*/ ){};
+
+                /**
+                 * Using this function to enable or disable canonical mode only affects
+                 * the way the data is processed and which virtual functions are called
+                 * during processing.  It does not affect options set locally or
+                 * remotely.  Setting this to false will enable char-at-a-time mode,
+                 * effectively disabling internal line-editing code.  Characters
+                 * such as backspace that are detected will not be handled and will be
+                 * sent to the user override.  The subclass will also be notified every
+                 * time new data is available, not just whole lines.
+                 *
+                 * When set to true (the default), line editing control codes will be
+                 * interpreted and used, and the subclass will only be notified when
+                 * complete lines are available in the buffer.
+                 */
+                void setCanonical( bool bCon=true );
+                bool isCanonical();
+
+                void write( const Bu::String &sData );
+                void write( const char *pData, int iSize );
+                void write( char cData );
+
+                const Bu::String &getBuffer() { return sDataBuf; }
+
+        public:
+                /**
+                 * If you wish to know the current dimensions of the client window,
+                 * override this function, it will be called whenever the size changes.
+                 */
+                virtual void onSubNAWS( uint16_t /*iWidth*/, uint16_t /*iHeight*/ ){};
+
+                /**
+                 * This function is called whenever an unknown sub negotiation option is
+                 * sent over the line.  This doesn't mean that it's malformatted, it
+                 * just means that this class doesn't support that option yet, but you
+                 * can handle it yourself if you'd like.  Feel free to change the
+                 * sSubBuf, it will be cleared as soon as this function returns anyway.
+                 */
+                virtual void onSubUnknown( char /*cSubOpt*/,
+                        Bu::String & /*sSubBuf*/ ){};
+
+        private:
+                /**
+                 * Represents a basic telnet option, either on or off, no parameters.
+                 * Each Option can negotiate effectively on it's own, and has two
+                 * parameters in each of two classes.  Both local and remote can be
+                 * enabled/disabled and set/unset.  Enabled represents the ability to
+                 * set the option, disabling an option should also unset it.  Set or
+                 * unset represent wether the option is being used, if it is allowed.
+                 */
+                class Option
+                {
+                        friend class Bu::ProtocolTelnet;
+                private:
+                        Option( ProtocolTelnet &rPT, char cCode );
+                        virtual ~Option();
+
+                public:
+                        void localEnable( bool bSet=true );
+                        void localSet( bool bSet=true );
+                        
+                        bool isLocalEnabled();
+                        bool isLocalSet();
+                        
+                        void remoteEnable( bool bSet=true );
+                        void remoteSet( bool bSet=true );
+
+                        bool isRemoteEnabled();
+                        bool isRemoteSet();
+
+                private:
+                        enum
+                        {
+                                fLocalCant      = 0x01, /**< Local can't/won't allow option. */
+                                fLocalIs        = 0x02, /**< Local is using option. */
+                                fRemoteCant     = 0x04, /**< Remote can't/won't allow option. */
+                                fRemoteIs       = 0x08  /**< Remote is using option. */
+                        };
+
+                        ProtocolTelnet &rPT;
+                        char fOpts;
+                        char cCode;
+                };
+                friend class Bu::ProtocolTelnet::Option;
+
+                Hash<char, Option *> hOpts;
+
+        public:
+                Option oBinary;
+                Option oEcho;
+                Option oNAWS;
+                Option oSuppressGA;
+
+        private:
+                void onWill( char cCode );
+                void onWont( char cCode );
+                void onDo( char cCode );
+                void onDont( char cCode );
+                void onSubOpt();
+                void onCtlChar( char cChr );
+
+#ifdef __TELNET_DEBUG
+                void printCode( char cCode );
+                void printOpt( char cOpt );
+#endif
+
+        private:
+                Client *pClient;
+
+                Bu::String sDataBuf;    /**< Buffer for regular line data. */
+                Bu::String sSubBuf;     /**< Buffer for subnegotiation data. */
+                char cSubOpt;   /**< Which suboption are we processing. */
+
+                bool bCanonical;        /**< Are we canonicalizing incoming data? */
+                bool bSubOpt;           /**< Are we processing a suboption right now? */
+        };
+}
+
+#endif
diff --git a/src/stable/queue.cpp b/src/stable/queue.cpp
new file mode 100644
index 0000000..9d6edac
--- /dev/null
+++ b/src/stable/queue.cpp
@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/queue.h"
diff --git a/src/stable/queue.h b/src/stable/queue.h
new file mode 100644
index 0000000..e5d9b5f
--- /dev/null
+++ b/src/stable/queue.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_QUEUE_H
+#define BU_QUEUE_H
+
+namespace Bu
+{
+        /**
+         * Queue abstract baseclass
+         */
+        template<typename value>
+        class Queue
+        {
+        public:
+                Queue()
+                {
+                }
+
+                virtual ~Queue()
+                {
+                }
+
+                virtual void enqueue( const value &i )=0;
+                virtual value dequeue()=0;
+                virtual value &peek()=0;
+                virtual const value &peek() const=0;
+                virtual bool isEmpty() const=0;
+                virtual int getSize() const=0;
+
+        private:
+
+        };
+}
+
+#endif
diff --git a/src/stable/queuebuf.cpp b/src/stable/queuebuf.cpp
new file mode 100644
index 0000000..98d8ee0
--- /dev/null
+++ b/src/stable/queuebuf.cpp
@@ -0,0 +1,278 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/queuebuf.h"
+
+#include "bu/sio.h"
+using Bu::sio;
+
+Bu::QueueBuf::QueueBuf( int iBlockSize /*=256*/ ) :
+        iBlockSize( iBlockSize ),
+        iReadOffset( 0 ),
+        iWriteOffset( 0 ),
+        iTotalSize( 0 )
+{
+}
+
+Bu::QueueBuf::~QueueBuf()
+{
+        for( BlockList::iterator i = lBlocks.begin(); i; i++ )
+                delete[] *i;
+}
+
+void Bu::QueueBuf::close()
+{
+        for( BlockList::iterator i = lBlocks.begin(); i; i++ )
+                delete[] *i;
+        lBlocks.clear();
+        iReadOffset = iWriteOffset = iTotalSize = 0;
+}
+
+Bu::size Bu::QueueBuf::read( void *pRawBuf, Bu::size nBytes )
+{
+        if( nBytes <= 0 )
+                return 0;
+
+        if( lBlocks.isEmpty() )
+                return 0;
+
+        Bu::size iLeft = nBytes;
+        char *pBuf = (char *)pRawBuf;
+
+        while( iLeft > 0 && iTotalSize > 0 )
+        {
+                if( iReadOffset == iBlockSize )
+                {
+                        removeBlock();
+                        if( lBlocks.isEmpty() )
+                        {
+                                return nBytes-iLeft;
+                        }
+                        iReadOffset = 0;
+                }
+                char *pBlock = lBlocks.first();
+                Bu::size iCopy = iBlockSize-iReadOffset;
+                if( iLeft < iCopy )
+                        iCopy = iLeft;
+                if( iTotalSize < iCopy )
+                        iCopy = iTotalSize;
+                memcpy( pBuf, pBlock+iReadOffset, iCopy );
+                iReadOffset += iCopy;
+                iLeft -= iCopy;
+                pBuf += iCopy;
+                iTotalSize -= iCopy;
+//              sio << "Read " << iCopy << " bytes, new size: " << iTotalSize << sio.nl;
+        }
+
+        return nBytes - iLeft;
+}
+
+Bu::size Bu::QueueBuf::peek( void *pBuf, Bu::size nBytes )
+{
+        return peek( pBuf, nBytes, 0 );
+}
+
+Bu::size Bu::QueueBuf::peek( void *pRawBuf, Bu::size nBytes, Bu::size nSkip )
+{
+        if( nBytes <= 0 )
+                return 0;
+
+        if( lBlocks.isEmpty() )
+                return 0;
+
+        Bu::size iLeft = nBytes;
+        char *pBuf = (char *)pRawBuf;
+
+        int iTmpReadOffset = iReadOffset + nSkip;
+        Bu::size iTmpRemSize = iTotalSize;
+        BlockList::iterator iBlock = lBlocks.begin();
+        while( iTmpReadOffset > iBlockSize )
+        {
+                iTmpReadOffset -= iBlockSize;
+                iBlock++;
+        }
+        while( iLeft > 0 && iTmpRemSize > 0 )
+        {
+                if( iTmpReadOffset == iBlockSize )
+                {
+                        iBlock++;
+                        if( iBlock == lBlocks.end() )
+                        {
+                                return nBytes-iLeft;
+                        }
+                        iTmpReadOffset = 0;
+                }
+                char *pBlock = *iBlock;
+                Bu::size iCopy = iBlockSize-iTmpReadOffset;
+                if( iLeft < iCopy )
+                        iCopy = iLeft;
+                if( iTmpRemSize < iCopy )
+                        iCopy = iTmpRemSize;
+                memcpy( pBuf, pBlock+iTmpReadOffset, iCopy );
+                iTmpReadOffset += iCopy;
+                iLeft -= iCopy;
+                pBuf += iCopy;
+                iTmpRemSize -= iCopy;
+//              sio << "Read (peek) " << iCopy << " bytes, new temp size: "
+//                      << iTmpRemSize << sio.nl;
+        }
+
+        return nBytes - iLeft;
+}
+
+Bu::size Bu::QueueBuf::write( const void *pRawBuf, Bu::size nBytes )
+{
+        if( nBytes <= 0 )
+                return 0;
+
+        if( lBlocks.isEmpty() )
+        {
+                addBlock();
+                iWriteOffset = 0;
+        }
+        Bu::size iLeft = nBytes;
+        const char *pBuf = (const char *)pRawBuf;
+
+        while( iLeft > 0 )
+        {
+                if( iWriteOffset == iBlockSize )
+                {
+                        addBlock();
+                        iWriteOffset = 0;
+                }
+                char *pBlock = lBlocks.last();
+                Bu::size iCopy = iBlockSize-iWriteOffset;
+                if( iLeft < iCopy )
+                        iCopy = iLeft;
+                memcpy( pBlock+iWriteOffset, pBuf, iCopy );
+                iWriteOffset += iCopy;
+                iLeft -= iCopy;
+                pBuf += iCopy;
+                iTotalSize += iCopy;
+//              sio << "Wrote " << iCopy << " bytes, new size: " << iTotalSize
+//                      << sio.nl;
+        }
+
+        return nBytes;
+}
+
+Bu::size Bu::QueueBuf::tell()
+{
+        return -1;
+}
+
+void Bu::QueueBuf::seek( Bu::size iAmnt )
+{
+        if( iAmnt <= 0 )
+                return;
+
+        if( (Bu::size)iAmnt >= iTotalSize )
+        {
+//              sio << "seek: clear all data (" << iAmnt << ">=" << iTotalSize
+//                      << ")." << sio.nl;
+                close();
+                return;
+        }
+
+        iReadOffset += iAmnt;
+        iTotalSize -= iAmnt;
+        while( iReadOffset >= iBlockSize )
+        {
+                removeBlock();
+                iReadOffset -= iBlockSize;
+//              sio << "seek: removal step (" << iReadOffset << ")" << sio.nl;
+        }
+}
+
+void Bu::QueueBuf::setPos( Bu::size )
+{
+}
+
+void Bu::QueueBuf::setPosEnd( Bu::size )
+{
+}
+
+bool Bu::QueueBuf::isEos()
+{
+        return iTotalSize == 0;
+}
+
+bool Bu::QueueBuf::isOpen()
+{
+        return true;
+}
+
+void Bu::QueueBuf::flush()
+{
+}
+
+bool Bu::QueueBuf::canRead()
+{
+        return iTotalSize > 0;
+}
+
+bool Bu::QueueBuf::canWrite()
+{
+        return true;
+}
+
+bool Bu::QueueBuf::isReadable()
+{
+        return true;
+}
+
+bool Bu::QueueBuf::isWritable()
+{
+        return true;
+}
+
+bool Bu::QueueBuf::isSeekable()
+{
+        return false;
+}
+
+bool Bu::QueueBuf::isBlocking()
+{
+        return false;
+}
+
+void Bu::QueueBuf::setBlocking( bool )
+{
+}
+
+void Bu::QueueBuf::setSize( Bu::size )
+{
+}
+
+Bu::size Bu::QueueBuf::getSize() const
+{
+        return iTotalSize;
+}
+
+Bu::size Bu::QueueBuf::getBlockSize() const
+{
+        return iBlockSize;
+}
+
+Bu::String Bu::QueueBuf::getLocation() const
+{
+        return "";
+}
+
+void Bu::QueueBuf::addBlock()
+{
+        lBlocks.append( new char[iBlockSize] );
+//      sio << "Added new block." << sio.nl;
+}
+
+void Bu::QueueBuf::removeBlock()
+{
+        delete[] lBlocks.first();
+        lBlocks.erase( lBlocks.begin() );
+//      sio << "Removed block." << sio.nl;
+}
+
diff --git a/src/stable/queuebuf.h b/src/stable/queuebuf.h
new file mode 100644
index 0000000..929ca35
--- /dev/null
+++ b/src/stable/queuebuf.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_QUEUE_BUF_H
+#define BU_QUEUE_BUF_H
+
+#include "bu/stream.h"
+
+namespace Bu
+{
+        /**
+         * A queuing buffer stream class.  All data written to this class is
+         * appended to it, there is no stored position.  All data read is read
+         * from the begining and then thrown away.  It operates by using a linked
+         * list of small buffers, and deallocating or reusing them when it can.
+         */
+        class QueueBuf : public Bu::Stream
+        {
+        public:
+                QueueBuf( int iBlockSize=256 );
+                virtual ~QueueBuf();
+
+                virtual void close();
+                virtual Bu::size read( void *pBuf, Bu::size nBytes );
+                virtual Bu::size peek( void *pBuf, Bu::size nBytes );
+                virtual Bu::size peek( void *pBuf, Bu::size nBytes, Bu::size nSkip );
+                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+                virtual Bu::size tell();
+                virtual void seek( Bu::size offset );
+                virtual void setPos( Bu::size pos );
+                virtual void setPosEnd( Bu::size 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 );
+                virtual void setSize( Bu::size iSize );
+
+                virtual size getSize() const;
+                virtual size getBlockSize() const;
+                virtual Bu::String getLocation() const;
+
+        private:
+                void addBlock();
+                void removeBlock();
+
+        private:
+                int iBlockSize;
+                int iReadOffset;
+                int iWriteOffset;
+                Bu::size iTotalSize;
+                typedef Bu::List<char *> BlockList;
+                BlockList lBlocks;
+        };
+};
+
+#endif
diff --git a/src/stable/ringbuffer.cpp b/src/stable/ringbuffer.cpp
new file mode 100644
index 0000000..99b1b1c
--- /dev/null
+++ b/src/stable/ringbuffer.cpp
@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/ringbuffer.h"
+
diff --git a/src/stable/ringbuffer.h b/src/stable/ringbuffer.h
new file mode 100644
index 0000000..f43773d
--- /dev/null
+++ b/src/stable/ringbuffer.h
@@ -0,0 +1,228 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_RING_BUFFER_H
+#define BU_RING_BUFFER_H
+
+#include <memory>
+#include "bu/exceptionbase.h"
+#include "bu/queue.h"
+#include "bu/sharedcore.h"
+
+namespace Bu
+{
+        template<typename value, typename valuealloc> class RingBuffer;
+
+        /** @cond DEVEL */
+        template<typename value, typename valuealloc>
+        class RingBufferCore
+        {
+        friend class RingBuffer<value, valuealloc>;
+        friend class SharedCore<RingBuffer<value, valuealloc>,
+                   RingBufferCore<value, valuealloc> >;
+        private:
+                RingBufferCore() :
+                        iCapacity( 0 ),
+                        iStart( -1 ),
+                        iEnd( -2 ),
+                        aData( NULL )
+                {
+                }
+
+                virtual ~RingBufferCore()
+                {
+                        clear();
+                }
+
+                void init( int iNewCapacity )
+                {
+                        if( iCapacity > 0 )
+                                return;
+
+                        iCapacity = iNewCapacity;
+                        iStart = -1;
+                        iEnd = -2;
+                        aData = va.allocate( iCapacity );
+                }
+
+                void clear()
+                {
+                        for( int j = iStart; j < iEnd; j=(j+1%iCapacity) )
+                        {
+                                va.destroy( &aData[j] );
+                        }
+                        va.deallocate( aData, iCapacity );
+                        aData = NULL;
+                        iCapacity = 0;
+                }
+                
+                void enqueue( const value &v )
+                {
+                        if( iStart == -1 )
+                        {
+                                iStart = 0;
+                                iEnd = 1;
+                                va.construct( &aData[0], v );
+                        }
+                        else if( iStart == iEnd )
+                        {
+                                throw ExceptionBase("Hey, it's full!");
+                        }
+                        else
+                        {
+                                va.construct( &aData[iEnd], v );
+                                iEnd = (iEnd+1)%iCapacity;
+                        }
+                }
+
+                value dequeue()
+                {
+                        if( iStart == -1 )
+                        {
+                                throw ExceptionBase("No data");
+                        }
+                        else
+                        {
+                                value &v = aData[iStart];
+                                va.destroy( &aData[iStart] );
+                                iStart = (iStart+1)%iCapacity;
+                                if( iStart == iEnd )
+                                {
+                                        iStart = -1;
+                                        iEnd = -2;
+                                }
+                                return v;
+                        }
+                }
+
+                value &get( int iIndex )
+                {
+                        return aData[(iIndex+iStart)%iCapacity];
+                }
+
+                int getSize()
+                {
+                        if( iStart < 0 )
+                                return 0;
+                        if( iEnd == iStart )
+                                return iCapacity;
+                        if( iEnd < iStart )
+                                return iEnd-iStart;
+                        return iCapacity-(iEnd-iStart);
+                }
+
+                int iCapacity;
+                int iStart, iEnd;
+                value *aData;
+                valuealloc va;
+        };
+        /** @endcond */
+
+        /**
+         *@ingroup Containers
+         */
+        template<typename value, typename valuealloc=std::allocator<value> >
+        class RingBuffer : public Queue<value>, public SharedCore<
+                                           RingBuffer<value, valuealloc>,
+                                           RingBufferCore<value, valuealloc>
+                                           >
+        {
+        private:
+                typedef RingBuffer<value, valuealloc> MyType;
+                typedef RingBufferCore<value, valuealloc> Core;
+
+        protected:
+                using SharedCore<MyType, Core>::core;
+                using SharedCore<MyType, Core>::_hardCopy;
+                using SharedCore<MyType, Core>::_allocateCore;
+
+        public:
+                RingBuffer( int iCapacity )
+                {
+                        core->init( iCapacity );
+                }
+
+                RingBuffer( const RingBuffer &rSrc ) :
+                        SharedCore<MyType, Core>( rSrc )
+                {
+                }
+
+                virtual ~RingBuffer()
+                {
+                }
+
+                int getCapacity() const
+                {
+                        return core->iCapacity;
+                }
+
+                bool isFilled() const
+                {
+                        return (core->iStart == core->iEnd);
+                }
+
+                bool isEmpty() const
+                {
+                        return (core->iStart == -1);
+                }
+
+                virtual void enqueue( const value &v )
+                {
+                        _hardCopy();
+
+                        core->enqueue( v );
+                }
+
+                virtual value dequeue()
+                {
+                        _hardCopy();
+
+                        return core->dequeue();
+                }
+
+                virtual int getSize() const
+                {
+                        return core->getSize();
+                }
+
+                virtual value &peek()
+                {
+                        _hardCopy();
+
+                        return core->get( 0 );
+                }
+
+                virtual const value &peek() const
+                {
+                        return core->get( 0 );
+                }
+
+                value &operator[]( int iIndex )
+                {
+                        _hardCopy();
+
+                        return core->get( iIndex );
+                }
+
+        protected:
+                virtual Core *_copyCore( Core *src )
+                {
+                        Core *pRet = _allocateCore();
+
+                        pRet->init( src->iCapacity );
+                        int iSize = src->getSize();
+                        for( int j = 0; j < iSize; j++ )
+                        {
+                                pRet->enqueue( src->get( j ) );
+                        }
+
+                        return pRet;
+                }
+        };
+}
+
+#endif
diff --git a/src/stable/server.cpp b/src/stable/server.cpp
new file mode 100644
index 0000000..1972a3f
--- /dev/null
+++ b/src/stable/server.cpp
@@ -0,0 +1,214 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/server.h"
+#include <errno.h>
+#include <unistd.h>
+#include "bu/tcpserversocket.h"
+#include "bu/client.h"
+#include "bu/tcpsocket.h"
+#include "bu/config.h"
+
+Bu::Server::Server() :
+        nTimeoutSec( 0 ),
+        nTimeoutUSec( 0 ),
+        bAutoTick( false )
+{
+        FD_ZERO( &fdActive );
+}
+
+Bu::Server::~Server()
+{
+        shutdown();
+}
+
+void Bu::Server::addPort( int nPort, int nPoolSize )
+{
+        TcpServerSocket *s = new TcpServerSocket( nPort, nPoolSize );
+        int nSocket = s->getSocket();
+        FD_SET( nSocket, &fdActive );
+        hServers.insert( nSocket, s );
+}
+
+void Bu::Server::addPort( const String &sAddr, int nPort, int nPoolSize )
+{
+        TcpServerSocket *s = new TcpServerSocket( 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;
+
+        FD_ZERO( &fdWrite );
+        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+        {
+                if( (*i)->hasOutput() )
+                        FD_SET( i.getKey(), &fdWrite );
+        }
+
+        if( TEMP_FAILURE_RETRY( select( FD_SETSIZE,
+                        &fdRead, &fdWrite, &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 ) )
+                        {
+                                TcpServerSocket *pSrv = hServers.get( j );
+                                addClient( pSrv->accept(), pSrv->getPort() );
+                        }
+                        else
+                        {
+                                Client *pClient = hClients.get( j );
+                                pClient->processInput();
+                                if( !pClient->isOpen() )
+                                {
+                                        closeClient( j );
+                                }
+                        }
+                }
+                if( FD_ISSET( j, &fdWrite ) )
+                {
+                        try
+                        {
+                                Client *pClient = hClients.get( j );
+                                try
+                                {
+                                        pClient->processOutput();
+                                }
+                                catch( Bu::TcpSocketException &e )
+                                {
+                                        closeClient( j );
+                                }
+                        }
+                        catch( Bu::HashException &e )
+                        {
+                                // Do nothing, I guess, the client is already dead...
+                                // TODO:  Someday, we may want to handle this more graceully.
+                        }
+                }
+        }
+
+        Bu::List<int> lDelete;
+        // 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++ )
+        {
+                if( (*i)->wantsDisconnect() && !(*i)->hasOutput() )
+                {
+                        lDelete.append( i.getKey() );
+                }
+        }
+
+        for( Bu::List<int>::iterator i = lDelete.begin(); i != lDelete.end(); i++ )
+        {
+                closeClient( *i );
+        }
+
+        if( bAutoTick )
+                tick();
+}
+
+void Bu::Server::addClient( int nSocket, int nPort )
+{
+        FD_SET( nSocket, &fdActive );
+
+        Client *c = new Client(
+                new Bu::TcpSocket( nSocket ),
+                new SrvClientLinkFactory()
+                );
+        hClients.insert( nSocket, c );
+
+        onNewConnection( c, nPort );
+}
+
+Bu::Server::SrvClientLink::SrvClientLink( Bu::Client *pClient ) :
+        pClient( pClient )
+{
+}
+
+Bu::Server::SrvClientLink::~SrvClientLink()
+{
+}
+
+void Bu::Server::SrvClientLink::sendMessage( const Bu::String &sMsg )
+{
+        pClient->onMessage( sMsg );
+}
+
+Bu::Server::SrvClientLinkFactory::SrvClientLinkFactory()
+{
+}
+
+Bu::Server::SrvClientLinkFactory::~SrvClientLinkFactory()
+{
+}
+
+Bu::ClientLink *Bu::Server::SrvClientLinkFactory::createLink(
+                Bu::Client *pClient )
+{
+        return new SrvClientLink( pClient );
+}
+
+void Bu::Server::setAutoTick( bool bEnable )
+{
+        bAutoTick = bEnable;
+}
+
+void Bu::Server::tick()
+{
+        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+        {
+                (*i)->tick();
+        }
+}
+
+void Bu::Server::shutdown()
+{
+        for( SrvHash::iterator i = hServers.begin(); i != hServers.end(); i++ )
+        {
+                delete *i;
+        }
+
+        hServers.clear();
+
+        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+        {
+                closeClient( i.getKey() );
+        }
+
+        hClients.clear();
+}
+
+void Bu::Server::closeClient( int iSocket )
+{
+        Bu::Client *pClient = hClients.get( iSocket );
+        onClosedConnection( pClient );
+        pClient->close();
+        hClients.erase( iSocket );
+        FD_CLR( iSocket, &fdActive );
+        delete pClient;
+}
+
diff --git a/src/stable/server.h b/src/stable/server.h
new file mode 100644
index 0000000..c59543a
--- /dev/null
+++ b/src/stable/server.h
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_SERVER_H
+#define BU_SERVER_H
+
+#include <stdint.h>
+
+#ifndef WIN32
+        #include <sys/select.h>
+#endif
+
+#include "bu/string.h"
+#include "bu/list.h"
+
+#include "bu/clientlink.h"
+#include "bu/clientlinkfactory.h"
+#include "bu/hash.h"
+
+#include "bu/config.h"
+
+namespace Bu
+{
+        class TcpServerSocket;
+        class TcpSocket;
+        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.
+         *@ingroup Serving
+         */
+        class Server
+        {
+        public:
+                Server();
+                virtual ~Server();
+
+                void addPort( int nPort, int nPoolSize=40 );
+                void addPort( const String &sAddr, int nPort, int nPoolSize=40 );
+
+                virtual void scan();
+                void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 );
+
+                void addClient( int nSocket, int nPort );
+
+                void setAutoTick( bool bEnable=true );
+                void tick();
+
+                virtual void onNewConnection( Client *pClient, int nPort )=0;
+                virtual void onClosedConnection( Client *pClient )=0;
+
+                void shutdown();
+
+        private:
+                void closeClient( int iSocket );
+                class SrvClientLink : public Bu::ClientLink
+                {
+                public:
+                        SrvClientLink( Bu::Client *pClient );
+                        virtual ~SrvClientLink();
+
+                        virtual void sendMessage( const Bu::String &sMsg );
+
+                private:
+                        Bu::Client *pClient;
+                };
+
+                class SrvClientLinkFactory : public Bu::ClientLinkFactory
+                {
+                public:
+                        SrvClientLinkFactory();
+                        virtual ~SrvClientLinkFactory();
+
+                        virtual Bu::ClientLink *createLink( Bu::Client *pClient );
+                };
+
+                int nTimeoutSec;
+                int nTimeoutUSec;
+                fd_set fdActive;
+                typedef Hash<int,TcpServerSocket *> SrvHash;
+                SrvHash hServers;
+                typedef Hash<int,Client *> ClientHash;
+                ClientHash hClients;
+                bool bAutoTick;
+        };
+}
+
+#endif
diff --git a/src/stable/sha1.cpp b/src/stable/sha1.cpp
new file mode 100644
index 0000000..bfe4c5a
--- /dev/null
+++ b/src/stable/sha1.cpp
@@ -0,0 +1,194 @@
+/*

+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.

+ *

+ * This file is part of the libbu++ library and is released under the

+ * terms of the license contained in the file LICENSE.

+ */

+

+#include <string.h>

+

+#include "bu/stream.h"

+

+#include "bu/sha1.h"

+

+Bu::Sha1::Sha1() :

+        uH0( 0x67452301 ),

+        uH1( 0xefcdab89 ),

+        uH2( 0x98badcfe ),

+        uH3( 0x10325476 ),

+        uH4( 0xc3d2e1f0 ),

+        iUnprocessedBytes( 0 ),

+        uTotalBytes( 0 )

+{

+        reset();

+}

+

+Bu::Sha1::~Sha1()

+{

+}

+

+void Bu::Sha1::reset()

+{

+        uH0 = 0x67452301;

+        uH1 = 0xefcdab89;

+        uH2 = 0x98badcfe;

+        uH3 = 0x10325476;

+        uH4 = 0xc3d2e1f0;

+        iUnprocessedBytes = 0;

+        uTotalBytes = 0;

+}

+

+void Bu::Sha1::setSalt( const Bu::String & /*sSalt*/ )

+{

+}

+

+void Bu::Sha1::addData( const void *sDataRaw, int iSize )

+{

+        const unsigned char *sData = (const unsigned char *)sDataRaw;

+        // add these bytes to the running total

+        uTotalBytes += iSize;

+

+        // repeat until all data is processed

+        while( iSize > 0 )

+        {

+                // number of bytes required to complete block

+                int iNeeded = 64 - iUnprocessedBytes;

+

+                // number of bytes to copy (use smaller of two)

+                int iToCopy = (iSize < iNeeded) ? iSize : iNeeded;

+

+                // Copy the bytes

+                memcpy( uBytes + iUnprocessedBytes, sData, iToCopy );

+

+                // Bytes have been copied

+                iSize -= iToCopy;

+                sData += iToCopy;

+                iUnprocessedBytes += iToCopy;

+                

+                // there is a full block

+                if( iUnprocessedBytes == 64 )

+                {

+                        process();

+                }

+        }

+}

+

+Bu::String Bu::Sha1::getResult()

+{

+        // save the message size

+        uint32_t totalBitsL = uTotalBytes << 3;

+        uint32_t totalBitsH = uTotalBytes >> 29;

+

+        // add 0x80 to the message

+        addData( "\x80", 1 );

+        

+        unsigned char footer[64] = {

+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

+

+        // block has no room for 8-byte filesize, so finish it

+        if( iUnprocessedBytes > 56 )

+                addData( (char*)footer, 64 - iUnprocessedBytes);

+

+        // how many zeros do we need

+        int iNeededZeros = 56 - iUnprocessedBytes;

+

+        // store file size (in bits) in big-endian format

+        toBigEndian( totalBitsH, footer + iNeededZeros );

+        toBigEndian( totalBitsL, footer + iNeededZeros + 4 );

+

+        // finish the final block

+        addData( (char*)footer, iNeededZeros + 8 );

+

+        Bu::String sRet( 20 );

+

+        unsigned char *digest = (unsigned char *)sRet.getStr();

+

+        // copy the digest bytes

+        toBigEndian( uH0, digest );

+        toBigEndian( uH1, digest + 4 );

+        toBigEndian( uH2, digest + 8 );

+        toBigEndian( uH3, digest + 12 );

+        toBigEndian( uH4, digest + 16 );

+

+        // return the digest

+        return sRet;

+}

+

+void Bu::Sha1::writeResult( Bu::Stream &sOut )

+{

+        sOut.write( getResult() );

+}

+

+void Bu::Sha1::process()

+{

+        int t;

+        uint32_t a, b, c, d, e, K, f, W[80];

+

+        // starting values

+        a = uH0;

+        b = uH1;

+        c = uH2;

+        d = uH3;

+        e = uH4;

+

+        // copy and expand the message block

+        for( t = 0; t < 16; t++ ) W[t] = (uBytes[t*4] << 24)

+                                                                        +(uBytes[t*4 + 1] << 16)

+                                                                        +(uBytes[t*4 + 2] << 8)

+                                                                        + uBytes[t*4 + 3];

+        for(; t< 80; t++ ) W[t] = lrot( W[t-3]^W[t-8]^W[t-14]^W[t-16], 1 );

+        

+        /* main loop */

+        uint32_t temp;

+        for( t = 0; t < 80; t++ )

+        {

+                if( t < 20 ) {

+                        K = 0x5a827999;

+                        f = (b & c) | ((~b) & d);

+                } else if( t < 40 ) {

+                        K = 0x6ed9eba1;

+                        f = b ^ c ^ d;

+                } else if( t < 60 ) {

+                        K = 0x8f1bbcdc;

+                        f = (b & c) | (b & d) | (c & d);

+                } else {

+                        K = 0xca62c1d6;

+                        f = b ^ c ^ d;

+                }

+                temp = lrot(a,5) + f + e + W[t] + K;

+                e = d;

+                d = c;

+                c = lrot(b,30);

+                b = a;

+                a = temp;

+                //printf( "t=%d %08x %08x %08x %08x %08x\n",t,a,b,c,d,e );

+        }

+

+        /* add variables */

+        uH0 += a;

+        uH1 += b;

+        uH2 += c;

+        uH3 += d;

+        uH4 += e;

+

+        //printf( "Current: %08x %08x %08x %08x %08x\n",H0,H1,H2,H3,H4 );

+        /* all bytes have been processed */

+        iUnprocessedBytes = 0;

+}

+

+uint32_t Bu::Sha1::lrot( uint32_t x, int bits )

+{

+        return (x<<bits) | (x>>(32 - bits));

+}

+

+void Bu::Sha1::toBigEndian( uint32_t num, unsigned char* byte )

+{

+        byte[0] = (unsigned char)(num>>24);

+        byte[1] = (unsigned char)(num>>16);

+        byte[2] = (unsigned char)(num>>8);

+        byte[3] = (unsigned char)num;

+}

+

diff --git a/src/stable/sha1.h b/src/stable/sha1.h
new file mode 100644
index 0000000..1b7f6df
--- /dev/null
+++ b/src/stable/sha1.h
@@ -0,0 +1,53 @@
+/*

+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.

+ *

+ * This file is part of the libbu++ library and is released under the

+ * terms of the license contained in the file LICENSE.

+ */

+

+#ifndef SHA1_H

+#define SHA1_H

+

+#include <stdint.h>

+#include "bu/cryptohash.h"

+

+namespace Bu

+{

+        /**

+         * Calculates SHA-1 sums.  This is based strongly on code from Michael D.

+         * Leonhard who released his code under the terms of the MIT license,

+         * thank you!  Check out his website http://tamale.net he has a lot of

+         * cool stuff there.

+         */

+        class Sha1 : public CryptoHash

+        {

+        public:

+                Sha1();

+                virtual ~Sha1();

+

+                virtual void reset();

+                virtual void setSalt( const Bu::String &sSalt );

+                virtual void addData( const void *sData, int iSize );

+                using CryptoHash::addData;

+                virtual String getResult();

+                virtual void writeResult( Stream &sOut );

+

+                void update( const char* data, int num );

+                unsigned char* getDigest();

+

+                // utility methods

+

+        private:

+                static uint32_t lrot( uint32_t x, int bits );

+                static void toBigEndian( uint32_t in, unsigned char* out );

+                void process();

+        

+        private:

+                uint32_t uH0, uH1, uH2, uH3, uH4;

+                unsigned char uBytes[64];

+                int iUnprocessedBytes;

+                uint32_t uTotalBytes;

+        };

+};

+

+#endif

diff --git a/src/stable/sharedcore.cpp b/src/stable/sharedcore.cpp
new file mode 100644
index 0000000..75f92eb
--- /dev/null
+++ b/src/stable/sharedcore.cpp
@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/sharedcore.h"
+
diff --git a/src/stable/sharedcore.h b/src/stable/sharedcore.h
new file mode 100644
index 0000000..bf9395c
--- /dev/null
+++ b/src/stable/sharedcore.h
@@ -0,0 +1,193 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_SHARED_CORE_H
+#define BU_SHARED_CORE_H
+
+#include "bu/util.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+
+namespace Bu
+{
+        /**
+         * A mechanism for creating classes that perform lazy copies.  The concept
+         * behind this is that instead of copying a large object when it is assigned
+         * or passed into a copy constructor we simply copy a pointer internally.
+         * The assumption is that many times when an object is passed by value we
+         * don't really want to keep the object around, we want the recipient to
+         * take ownership without allocating a new object.  This allows that to
+         * happen.
+         *
+         * When used properly this makes object copying essentially free (O(1),
+         * that is) and performs the actual copy when a user tries to modify the
+         * object.
+         *
+         * For example, lets look at something like the getKeys function in
+         * Bu::Hash.  When this function is called it creates a Bu::List of
+         * appropriate type, fills it with keys, and returns it.  This is a good
+         * way for this function to behave, there may be additional issues if the
+         * List object were allocated with new and not on the stack.  However,
+         * returning the List at the end of the function could potentially take
+         * a very long time depending on the size of the list and the type of the
+         * key.  In this case the getKeys function doesn't want ownership of the
+         * List object, and when it returns it, it's local copy will be destroyed.
+         *
+         * However, List inherits from SharedCore, which means that when it is
+         * returned all we do is copy a pointer to the "core" of the list, which
+         * is a very fast operatorion.  For a brief moment, before anyone can do
+         * anything else, there are two objects referencing the core of that single
+         * list.  However, the getKeys() function will destroy it's local copy
+         * before the calling function can use it's new copy.  That means that by
+         * the time the calling function can use it's new List of keys it is the
+         * only one with a reference to the core, and no copy will need to happen.
+         *
+         * Using SharedCore on your own classes is fairly straight forward.  There
+         * are only a couple of steps.  First, break the class into two classes.
+         * Move every variable from the original class (generally everything that's
+         * private) into the new class.  Then make the original class inherit from
+         * SharedCore.  The SharedCore template takes 2 parameters, first is the
+         * class it's inheriting from, second is the new core class.  Now, in your
+         * original class you will have one class variable, a pointer named core.
+         * All of your original variables will be accessable through core.  The next
+         * step is to access everything you used to through core, and to find 
+         * every function that may change data in the core.  At the top of every
+         * function that may change data you want to call _hardCopy().
+         *
+         * That's more or less it.  A more detailed guide will be written soon.
+         * @todo Write a guide for this.
+         */
+        template<typename Shell, typename Core>
+        class SharedCore
+        {
+                typedef class SharedCore<Shell, Core> _SharedType;
+        public:
+                SharedCore() :
+                        core( NULL ),
+                        iRefCount( NULL )
+                {
+                        core = _allocateCore();
+                        iRefCount = new int(1);
+                }
+
+                SharedCore( const _SharedType &rSrc ) :
+                        core( NULL ),
+                        iRefCount( NULL )
+                {
+                        _softCopy( rSrc );
+                }
+
+                virtual ~SharedCore()
+                {
+                        _deref();
+                }
+
+                SharedCore &operator=( const SharedCore &rhs )
+                {
+                        if( core == rhs.core )
+                                return *this;
+
+                        _softCopy( rhs );
+                        return *this;
+                }
+
+                int getRefCount() const
+                {
+                        return *iRefCount;
+                }
+
+                Shell clone() const
+                {
+                        Shell s( dynamic_cast<const Shell &>(*this) );
+                        s._hardCopy();
+                        return s;
+                }
+
+                bool isCoreShared( const Shell &rOther ) const
+                {
+                        return rOther.core == core;
+                }
+
+        protected:
+                Core *core;
+                void _hardCopy()
+                {
+                        if( !core || !iRefCount )
+                                return;
+                        if( (*iRefCount) == 1 )
+                                return;
+                        Core *copy = _copyCore( core );
+                        _deref();
+                        core = copy;
+                        iRefCount = new int( 1 );
+                }
+
+                /**
+                 * Reset core acts like a hard copy, except instead of providing a
+                 * standalone copy of the shared core, it provides a brand new core.
+                 *
+                 * Very useful in functions used to reset the state of an object.
+                 */
+                void _resetCore()
+                {
+                        if( core )
+                                _deref();
+                        core = _allocateCore();
+                        iRefCount = new int( 1 );
+                }
+
+                virtual Core *_allocateCore()
+                {
+                        return new Core();
+                }
+
+                virtual Core *_copyCore( Core *pSrc )
+                {
+                        return new Core( *pSrc );
+                }
+
+                virtual void _deallocateCore( Core *pSrc )
+                {
+                        delete pSrc;
+                }
+
+        private:
+                void _deref()
+                {
+                        if( (--(*iRefCount)) == 0 )
+                        {
+                                _deallocateCore( core );
+                                delete iRefCount;
+                        }
+                        core = NULL;
+                        iRefCount = NULL;
+                }
+
+                void _incRefCount()
+                {
+                        if( iRefCount && core )
+                                ++(*iRefCount);
+                }
+
+                void _softCopy( const _SharedType &rSrc )
+                {
+                        if( core )
+                                _deref();
+                        core = rSrc.core;
+                        iRefCount = rSrc.iRefCount;
+                        _incRefCount();
+                }
+
+                int *iRefCount;
+        };
+};
+
+#undef fin
+#undef fout
+
+#endif
diff --git a/src/stable/signals.cpp b/src/stable/signals.cpp
new file mode 100644
index 0000000..ffbc7ba
--- /dev/null
+++ b/src/stable/signals.cpp
@@ -0,0 +1,10 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/signals.h"
+
+namespace Bu { subExceptionDef( SignalException ) }
diff --git a/src/stable/singleton.h b/src/stable/singleton.h
new file mode 100644
index 0000000..13db01b
--- /dev/null
+++ b/src/stable/singleton.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_SINGLETON_H
+#define BU_SINGLETON_H
+
+#include <stdio.h>
+
+namespace Bu
+{
+        /**
+         * 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).
+         */
+        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& );
+
+        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/stable/sio.cpp b/src/stable/sio.cpp
new file mode 100644
index 0000000..5f8e234
--- /dev/null
+++ b/src/stable/sio.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/sio.h"
+
+Bu::StdStream Bu::sioRaw;
+Bu::Formatter Bu::sio( Bu::sioRaw );
+
+Bu::size Bu::print( Bu::Stream &s, const Bu::String &str )
+{
+        return s.write( str.getStr(), str.getSize() );
+}
+
+Bu::size Bu::print( const Bu::String &str )
+{
+        return print( sioRaw, str );
+}
+
+Bu::size Bu::println( Bu::Stream &s, const Bu::String &str )
+{
+        Bu::size sRet = s.write( str.getStr(), str.getSize() );
+        sRet += s.write("\n", 1 );
+        s.flush();
+        return sRet;
+}
+
+Bu::size Bu::println( const Bu::String &str )
+{
+        return println( sioRaw, str );
+}
+
diff --git a/src/stable/sio.h b/src/stable/sio.h
new file mode 100644
index 0000000..9f2cd05
--- /dev/null
+++ b/src/stable/sio.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_SIO_H
+#define BU_SIO_H
+
+#include "bu/stdstream.h"
+#include "bu/formatter.h"
+
+namespace Bu
+{
+        extern Bu::StdStream sioRaw;
+        extern Bu::Formatter sio;
+
+        Bu::size print( Bu::Stream &s, const Bu::String &str );
+        Bu::size print( const Bu::String &str );
+
+        Bu::size println( Bu::Stream &s, const Bu::String &str );
+        Bu::size println( const Bu::String &str );
+};
+
+#endif
diff --git a/src/stable/sptr.cpp b/src/stable/sptr.cpp
new file mode 100644
index 0000000..ea21e3b
--- /dev/null
+++ b/src/stable/sptr.cpp
@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/sptr.h"
diff --git a/src/stable/sptr.h b/src/stable/sptr.h
new file mode 100644
index 0000000..4eb5a52
--- /dev/null
+++ b/src/stable/sptr.h
@@ -0,0 +1,229 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_SPTR_H
+#define BU_SPTR_H
+
+#include <stdint.h>
+#include <stdio.h>
+
+namespace Bu
+{
+        template<typename T> class SPtr;
+        template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src );
+
+        /**
+         *@ingroup Containers
+         */
+        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( const SPtr<T> &src ) :
+                        pRefCnt( src.pRefCnt ),
+                        pData( src.pData )
+                {
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
+                }
+
+                SPtr( T *pSrc ) :
+                        pRefCnt( NULL ),
+                        pData( pSrc )
+                {
+                        if( pData )
+                        {
+                                pRefCnt = new int32_t;
+                                (*pRefCnt) = 1;
+                        }
+                }
+
+                /**
+                 * Get the number of references to this pointer.
+                 *@returns (int32_t) The number of references to this pointer.
+                 */
+                int32_t getRefCount() const
+                {
+                        return *pRefCnt;
+                }
+
+                void clear()
+                {
+                        decCount();
+                        pRefCnt = NULL;
+                        pData = NULL;
+                }
+
+                /**
+                 * Pointer access operator.
+                 *@returns (const T *)
+                 */
+                const T *operator->() const
+                {
+                        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;
+                }
+
+                /**
+                 * Dereference operator.
+                 *@returns (T &) The value at the end of the pointer.
+                 */
+                T &operator*()
+                {
+                        return *pData;
+                }
+
+                /**
+                 * 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;
+                }
+
+                /**
+                 * 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;
+                }
+
+                /**
+                 * 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;
+                }
+
+                /**
+                 * 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;
+                }
+                
+                /**
+                 * Not 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);
+                }
+
+                /**
+                 * Not 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);
+                }
+
+                /**
+                 * Boolean cast operator. Do we have a pointer?
+                 */
+                operator bool() 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 )
+                        {
+                                (*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;
+        };
+
+        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/stable/stack.cpp b/src/stable/stack.cpp
new file mode 100644
index 0000000..73352d3
--- /dev/null
+++ b/src/stable/stack.cpp
@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/stack.h"
diff --git a/src/stable/stack.h b/src/stable/stack.h
new file mode 100644
index 0000000..0d1ed3c
--- /dev/null
+++ b/src/stable/stack.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_STACK_H
+#define BU_STACK_H
+
+#include <memory>
+#include "bu/config.h"
+
+namespace Bu
+{
+        template<typename value, typename valuealloc=std::allocator<value> >
+        class Stack
+        {
+        private:
+                typedef struct Chunk
+                {
+                        value *pValue;
+                        Chunk *pPrev;
+                } Chunk;
+        public:
+                Stack() :
+                        pTop( NULL )
+                {
+                }
+
+                virtual ~Stack()
+                {
+                }
+
+                void push( const value &v )
+                {
+                        Chunk *pChnk = new Chunk;
+                        pChnk->pValue = va.allocate( 1 );
+                        va.construct( pChnk->pValue, v );
+                        pChnk->pPrev = pTop;
+                        pTop = pChnk;
+                }
+
+                value &peek()
+                {
+                        return *pTop->pValue;
+                }
+                
+                value &top()
+                {
+                        return *pTop->pValue;
+                }
+
+                value pop()
+                {
+                        value ret( *pTop->pValue );
+                        
+                        Chunk *pChnk = pTop;
+                        pTop = pTop->pPrev;
+
+                        va.destroy( pChnk->pValue );
+                        va.deallocate( pChnk->pValue, 1 );
+                        delete pChnk;
+
+                        return ret;
+                }
+
+                void clear()
+                {
+                        while( !isEmpty() )
+                                pop();
+                }
+
+                bool isEmpty()
+                {
+                        return pTop == NULL;
+                }
+
+        private:
+                Chunk *pTop;
+                valuealloc va;
+        };
+}
+
+#endif
diff --git a/src/stable/staticmembuf.cpp b/src/stable/staticmembuf.cpp
new file mode 100644
index 0000000..74fae31
--- /dev/null
+++ b/src/stable/staticmembuf.cpp
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/staticmembuf.h"
+
+using namespace Bu;
+
+Bu::StaticMemBuf::StaticMemBuf( const void *pData, size iSize ) :
+        pData( pData ),
+        iSize( iSize ),
+        nPos( 0 )
+{
+}
+
+Bu::StaticMemBuf::~StaticMemBuf()
+{
+}
+
+void Bu::StaticMemBuf::close()
+{
+}
+
+size Bu::StaticMemBuf::read( void *pBuf, size nBytes )
+{
+        if( iSize-nPos < nBytes )
+                nBytes = iSize-nPos;
+
+        memcpy( pBuf, ((char *)pData)+nPos, nBytes );
+        nPos += nBytes;
+
+        return nBytes;
+}
+        
+size Bu::StaticMemBuf::write( const void *, size )
+{
+        return -1;
+}
+
+size Bu::StaticMemBuf::tell()
+{
+        return nPos;
+}
+
+void Bu::StaticMemBuf::seek( size offset )
+{
+        nPos += offset;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > iSize ) nPos = iSize;
+}
+
+void Bu::StaticMemBuf::setPos( size pos )
+{
+        nPos = pos;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > iSize ) nPos = iSize;
+}
+
+void Bu::StaticMemBuf::setPosEnd( size pos )
+{
+        nPos = iSize-pos;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > iSize ) nPos = iSize;
+}
+
+bool Bu::StaticMemBuf::isEos()
+{
+        return (nPos == iSize);
+}
+
+bool Bu::StaticMemBuf::isOpen()
+{
+        return true;
+}
+
+void Bu::StaticMemBuf::flush()
+{
+}
+
+bool Bu::StaticMemBuf::canRead()
+{
+        return !isEos();
+}
+
+bool Bu::StaticMemBuf::canWrite()
+{
+        return false;
+}
+
+bool Bu::StaticMemBuf::isReadable()
+{
+        return true;
+}
+
+bool Bu::StaticMemBuf::isWritable()
+{
+        return false;
+}
+
+bool Bu::StaticMemBuf::isSeekable()
+{
+        return true;
+}
+
+bool Bu::StaticMemBuf::isBlocking()
+{
+        return true;
+}
+
+void Bu::StaticMemBuf::setBlocking( bool )
+{
+}
+
+void Bu::StaticMemBuf::setSize( size )
+{
+}
+
+Bu::size Bu::StaticMemBuf::getSize() const
+{
+        return iSize;
+}
+
+Bu::size Bu::StaticMemBuf::getBlockSize() const
+{
+        return iSize;
+}
+
+Bu::String Bu::StaticMemBuf::getLocation() const
+{
+        return "";
+}
+
diff --git a/src/stable/staticmembuf.h b/src/stable/staticmembuf.h
new file mode 100644
index 0000000..f168de3
--- /dev/null
+++ b/src/stable/staticmembuf.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_STATIC_MEM_BUF_H
+#define BU_STATIC_MEM_BUF_H
+
+#include <stdint.h>
+
+#include "bu/config.h"
+#include "bu/stream.h"
+
+namespace Bu
+{
+        /**
+         * An immutable, read-only memory buffer.  Construct this buffer around a
+         * block of raw memory, provide the length of the block, and you can read
+         * from that block via this class as though it were a normal stream.
+         *
+         * Use this class instead of MemBuf when you have a string already, and
+         * don't need to change it.  MemBuf will make a copy of your string for
+         * it's own use (often) and this will not (ever).
+         *@ingroup Streams
+         */
+        class StaticMemBuf : public Stream
+        {
+        public:
+                StaticMemBuf( const void *pData, size iSize );
+                virtual ~StaticMemBuf();
+
+                virtual void close();
+                virtual size read( void *pBuf, size iBytes );
+
+                virtual size write( const void *pBuf, size iBytes );
+                using Stream::write;
+                virtual size tell();
+                virtual void seek( size offset );
+                virtual void setPos( size pos );
+                virtual void setPosEnd( size 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 );
+                virtual void setSize( size iSize );
+                virtual size getSize() const;
+                virtual size getBlockSize() const;
+                virtual Bu::String getLocation() const;
+
+        private:
+                const void *pData;
+                size iSize;
+                size nPos;
+        };
+}
+
+#endif
diff --git a/src/stable/stdstream.cpp b/src/stable/stdstream.cpp
new file mode 100644
index 0000000..b1d5d61
--- /dev/null
+++ b/src/stable/stdstream.cpp
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include <stdio.h>
+#include "bu/stdstream.h"
+
+Bu::StdStream::StdStream()
+{
+}
+
+Bu::StdStream::~StdStream()
+{
+}
+
+void Bu::StdStream::close()
+{
+}
+
+Bu::size Bu::StdStream::read( void *pBuf, Bu::size nBytes )
+{
+        return fread( pBuf, 1, nBytes, stdin );
+}
+
+Bu::size Bu::StdStream::write( const void *pBuf, Bu::size nBytes )
+{
+        return fwrite( pBuf, 1, nBytes, stdout );
+}
+
+Bu::size Bu::StdStream::tell()
+{
+        return 0;
+}
+
+void Bu::StdStream::seek( Bu::size )
+{
+}
+
+void Bu::StdStream::setPos( Bu::size )
+{
+}
+
+void Bu::StdStream::setPosEnd( Bu::size )
+{
+}
+
+bool Bu::StdStream::isEos()
+{
+        return false;
+}
+
+bool Bu::StdStream::isOpen()
+{
+        return true;
+}
+
+void Bu::StdStream::flush()
+{
+        fflush( stdout );
+}
+
+bool Bu::StdStream::canRead()
+{
+        return true;
+}
+
+bool Bu::StdStream::canWrite()
+{
+        return true;
+}
+
+bool Bu::StdStream::isReadable()
+{
+        return true;
+}
+
+bool Bu::StdStream::isWritable()
+{
+        return true;
+}
+
+bool Bu::StdStream::isSeekable()
+{
+        return false;
+}
+
+bool Bu::StdStream::isBlocking()
+{
+        return true;
+}
+
+void Bu::StdStream::setBlocking( bool )
+{
+}
+
+void Bu::StdStream::setSize( Bu::size )
+{
+}
+
+Bu::size Bu::StdStream::getSize() const
+{
+        return 0;
+}
+
+Bu::size Bu::StdStream::getBlockSize() const
+{
+        return 0;
+}
+
+Bu::String Bu::StdStream::getLocation() const
+{
+        return "";
+}
+
diff --git a/src/stable/stdstream.h b/src/stable/stdstream.h
new file mode 100644
index 0000000..ff6c774
--- /dev/null
+++ b/src/stable/stdstream.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_STD_STREAM_H
+#define BU_STD_STREAM_H
+
+#include <stdint.h>
+#include "stream.h"
+
+namespace Bu
+{
+        /**
+         *@ingroup Streams
+         */
+        class StdStream : public Stream
+        {
+        public:
+                StdStream();
+                virtual ~StdStream();
+
+                virtual void close();
+                virtual size read( void *pBuf, size nBytes );
+                virtual size write( const void *pBuf, size nBytes );
+                using Stream::write;
+                virtual size tell();
+                virtual void seek( size offset );
+                virtual void setPos( size pos );
+                virtual void setPosEnd( size 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 );
+                virtual void setSize( size iSize );
+                virtual size getSize() const;
+                virtual size getBlockSize() const;
+                virtual Bu::String getLocation() const;         
+        };
+}
+
+#endif
diff --git a/src/stable/stream.cpp b/src/stable/stream.cpp
new file mode 100644
index 0000000..58641cc
--- /dev/null
+++ b/src/stable/stream.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/stream.h"
+
+Bu::Stream::Stream()
+{
+}
+
+Bu::Stream::~Stream()
+{
+}
+
+Bu::String Bu::Stream::readLine()
+{
+        Bu::String sRet;
+        
+        for(;;)
+        {
+                char s;
+                if( read( &s, 1 ) == 0 )
+                        return sRet;
+                if( s == '\n' || s == '\r' )
+                        return sRet;
+                sRet.append( s );
+        }
+}
+
+Bu::String Bu::Stream::readAll()
+{
+        Bu::String sRet;
+        char buf[4096];
+
+        while( !isEos() )
+        {
+                int iRead = read( buf, 4096 );
+                if( iRead == 0 )
+                        return sRet;
+                sRet.append( buf, iRead );
+        }
+
+        return sRet;
+}
+
+Bu::size Bu::Stream::write( const Bu::String &sBuf )
+{
+        return write( sBuf.getStr(), sBuf.getSize() );
+}
+
diff --git a/src/stable/stream.h b/src/stable/stream.h
new file mode 100644
index 0000000..b35f6ee
--- /dev/null
+++ b/src/stable/stream.h
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_STREAM_H
+#define BU_STREAM_H
+
+#include "bu/config.h"
+
+#include <stdint.h>
+#include <stdio.h>
+
+#include "bu/string.h"
+
+namespace Bu
+{
+        /**
+         * 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.
+         *@ingroup Streams
+         */
+        class Stream
+        {
+        public:
+                Stream();
+                virtual ~Stream();
+
+                /**
+                 * Close the stream.
+                 */
+                virtual void close() = 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 read( void *pBuf, size iBytes ) = 0;
+
+                /**
+                 * Attempts to read a complete line from the stream.  This will stop
+                 * reading when it has reached the end of the stream, or runs out of
+                 * data in a non-blocking stream.
+                 *@returns The line read, not including newline character.
+                 */
+                virtual Bu::String readLine();
+
+                /**
+                 * Reads all data from the current position onward until isEos returns
+                 * true and returns it as a Bu::String.  This will also return if no
+                 * data is available and the stream is in non-blocking mode.  This
+                 * function is intended for very particular circumstances and is often
+                 * not the most efficient way to access the data that you would like.
+                 *@returns The entire stream contents.
+                 */
+                virtual Bu::String readAll();
+
+                /**
+                 * 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 write( const void *pBuf, size iBytes ) = 0;
+
+                virtual size write( const Bu::String &sBuf );
+
+                /**
+                 * Get the current position in the stream.
+                 *@returns (long) The current position in the stream.
+                 */
+                virtual size 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( size offset ) = 0;
+
+                /**
+                 * Set position in the stream relative to the start of the stream.
+                 *@param pos (long) The position.
+                 */
+                virtual void setPos( size pos ) = 0;
+
+                /**
+                 * Set position in the stream relative to the end of the stream.
+                 *@param pos (long) The position.
+                 */
+                virtual void setPosEnd( size 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
+                 * actually write one or more bytes.  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;
+
+                /**
+                 * Set the size of the stream, this does not apply to many types of
+                 * streams.  For those that it does apply to, data will be added or
+                 * removed from the end of the stream, but the content of the added
+                 * data is undefined.
+                 */
+                virtual void setSize( size iSize ) = 0;
+
+                /**
+                 * Returns the size of the stream if the stream can have a size.  For
+                 * streams that do not (sockets, pipes, etc.) this should throw an
+                 * unsupported exception.
+                 */
+                virtual size getSize() const = 0;
+
+                /**
+                 * Returns the block-size of the stream, if it has one.  This should
+                 * throw an unsupported exception.  In some cases the block size
+                 * returned will not represent quite the same thing, for example,
+                 * sockets will return their MTU, while files will return the
+                 * filesystem's block size, and memory buffers will throw an exception.
+                 */
+                virtual size getBlockSize() const = 0;
+
+                /**
+                 * If possible, this returns a string that can be used to describe how
+                 * to access the open stream.  Not all streams support this, such as
+                 * MemBuf, but for files it may give you a path to a file, for a socket
+                 * it may give you an ip address, etc.  If it isn't supported, an empty
+                 * string may be returned.
+                 */
+                virtual Bu::String getLocation() const = 0;
+
+        private:
+
+        };
+}
+
+#endif
diff --git a/src/stable/streamstack.cpp b/src/stable/streamstack.cpp
new file mode 100644
index 0000000..d45306d
--- /dev/null
+++ b/src/stable/streamstack.cpp
@@ -0,0 +1,234 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/streamstack.h"
+
+Bu::StreamStack::StreamStack()
+{
+}
+
+Bu::StreamStack::StreamStack( Bu::Stream *pStream )
+{
+        lFilts.prepend( pStream );
+}
+
+Bu::StreamStack::~StreamStack()
+{
+        clear();
+}
+
+bool Bu::StreamStack::isEmpty()
+{
+        return lFilts.isEmpty();
+}
+
+bool Bu::StreamStack::hasStream()
+{
+        return !lFilts.isEmpty();
+}
+
+void Bu::StreamStack::setStream( Bu::Stream *pStream )
+{
+        if( !lFilts.isEmpty() )
+                throw Bu::ExceptionBase("There is already a stream set.");
+
+        lFilts.prepend( pStream );
+}
+
+void Bu::StreamStack::clear()
+{
+        for( FilterList::iterator i = lFilts.begin(); i; i++ )
+        {
+                delete *i;
+        }
+
+        lFilts.clear();
+}
+
+void Bu::StreamStack::popFilter()
+{
+        if( lFilts.isEmpty() )
+                return;
+
+        delete lFilts.first();
+        lFilts.erase( lFilts.begin() );
+}
+
+Bu::Stream *Bu::StreamStack::getTop()
+{
+        checkStack();
+
+        return lFilts.first();
+}
+
+Bu::Stream *Bu::StreamStack::getStream()
+{
+        checkStack();
+
+        return lFilts.last();
+}
+
+void Bu::StreamStack::close()
+{
+        checkStack();
+
+        lFilts.first()->close();
+}
+
+Bu::size Bu::StreamStack::read( void *pBuf, Bu::size nBytes )
+{
+        checkStack();
+
+        return lFilts.first()->read( pBuf, nBytes );
+}
+
+Bu::size Bu::StreamStack::write( const void *pBuf, Bu::size nBytes )
+{
+        checkStack();
+
+        return lFilts.first()->write( pBuf, nBytes );
+}
+
+Bu::size Bu::StreamStack::write( const Bu::String &sBuf )
+{
+        checkStack();
+
+        return lFilts.first()->write( sBuf );
+}
+
+Bu::size Bu::StreamStack::tell()
+{
+        checkStack();
+
+        return lFilts.first()->tell();
+}
+
+void Bu::StreamStack::seek( Bu::size offset )
+{
+        checkStack();
+
+        lFilts.first()->seek( offset );
+}
+
+void Bu::StreamStack::setPos( Bu::size pos )
+{
+        checkStack();
+
+        lFilts.first()->setPos( pos );
+}
+
+void Bu::StreamStack::setPosEnd( Bu::size pos )
+{
+        checkStack();
+
+        lFilts.first()->setPosEnd( pos );
+}
+
+bool Bu::StreamStack::isEos()
+{
+        checkStack();
+
+        return lFilts.first()->isEos();
+}
+
+bool Bu::StreamStack::isOpen()
+{
+        checkStack();
+
+        return lFilts.first()->isOpen();
+}
+
+void Bu::StreamStack::flush()
+{
+        checkStack();
+
+        lFilts.first()->flush();
+}
+
+bool Bu::StreamStack::canRead()
+{
+        checkStack();
+
+        return lFilts.first()->canRead();
+}
+
+bool Bu::StreamStack::canWrite()
+{
+        checkStack();
+
+        return lFilts.first()->canWrite();
+}
+
+bool Bu::StreamStack::isReadable()
+{
+        checkStack();
+
+        return lFilts.first()->isReadable();
+}
+
+bool Bu::StreamStack::isWritable()
+{
+        checkStack();
+
+        return lFilts.first()->isWritable();
+}
+
+bool Bu::StreamStack::isSeekable()
+{
+        checkStack();
+
+        return lFilts.first()->isSeekable();
+}
+
+bool Bu::StreamStack::isBlocking()
+{
+        checkStack();
+
+        return lFilts.first()->isBlocking();
+}
+
+void Bu::StreamStack::setBlocking( bool bBlocking )
+{
+        checkStack();
+
+        lFilts.first()->setBlocking( bBlocking );
+}
+
+void Bu::StreamStack::setSize( Bu::size iSize )
+{
+        checkStack();
+
+        lFilts.first()->setSize( iSize );
+}
+
+Bu::size Bu::StreamStack::getSize() const
+{
+        checkStack();
+        
+        return lFilts.first()->getSize();
+}
+
+Bu::size Bu::StreamStack::getBlockSize() const
+{
+        checkStack();
+
+        return lFilts.first()->getBlockSize();
+}
+
+Bu::String Bu::StreamStack::getLocation() const
+{
+        checkStack();
+
+        return lFilts.first()->getLocation();
+}
+
+inline void Bu::StreamStack::checkStack() const
+{
+        if( lFilts.isEmpty() )
+                throw Bu::ExceptionBase("StreamStack is empty.");
+}
+
diff --git a/src/stable/streamstack.h b/src/stable/streamstack.h
new file mode 100644
index 0000000..846935b
--- /dev/null
+++ b/src/stable/streamstack.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_STREAM_STACK_H
+#define BU_STREAM_STACK_H
+
+#include "bu/stream.h"
+
+#include <typeinfo>
+
+namespace Bu
+{
+        class StreamStack : public Bu::Stream
+        {
+        private:
+                typedef Bu::List<Bu::Stream *> FilterList;
+
+        public:
+                StreamStack();
+                StreamStack( Bu::Stream *pStream );
+                virtual ~StreamStack();
+
+                bool isEmpty();
+                bool hasStream();
+                void setStream( Bu::Stream *pStream );
+
+                void clear();
+                void popFilter();
+                Bu::Stream *getTop();
+
+                Bu::Stream *getStream();
+
+                template<typename filter>
+                Bu::Stream *findFilter()
+                {
+                        for( FilterList::iterator i = lFilts.begin(); i; i++ )
+                        {
+                                if( typeid(**i) == typeid( filter ) )
+                                {
+                                        return *i;
+                                }
+                        }
+
+                        throw Bu::ExceptionBase("Filter not found.");
+                }
+
+                template<typename filter>
+                void pushFilter()
+                {
+                        checkStack();
+
+                        filter *pFlt = new filter( *lFilts.first() );
+                        lFilts.prepend( pFlt );
+                }
+
+                template<typename filter, typename p1t>
+                void pushFilter( p1t p1 )
+                {
+                        checkStack();
+
+                        filter *pFlt = new filter( *lFilts.first(), p1 );
+                        lFilts.prepend( pFlt );
+                }
+
+                template<typename filter, typename p1t, typename p2t>
+                void pushFilter( p1t p1, p2t p2 )
+                {
+                        checkStack();
+
+                        filter *pFlt = new filter( *lFilts.first(), p1, p2 );
+                        lFilts.prepend( pFlt );
+                }
+
+                template<typename filter, typename p1t, typename p2t, typename p3t>
+                void pushFilter( p1t p1, p2t p2, p3t p3 )
+                {
+                        checkStack();
+
+                        filter *pFlt = new filter( *lFilts.first(), p1, p2, p3 );
+                        lFilts.prepend( pFlt );
+                }
+
+                template<typename filter, typename p1t, typename p2t, typename p3t,
+                        typename p4t>
+                void pushFilter( p1t p1, p2t p2, p3t p3, p4t p4 )
+                {
+                        checkStack();
+
+                        filter *pFlt = new filter( *lFilts.first(), p1, p2, p3, p4 );
+                        lFilts.prepend( pFlt );
+                }
+
+                template<typename filter, typename p1t, typename p2t, typename p3t,
+                        typename p4t, typename p5t>
+                void pushFilter( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
+                {
+                        checkStack();
+
+                        filter *pFlt = new filter( *lFilts.first(), p1, p2, p3, p4, p5 );
+                        lFilts.prepend( pFlt );
+                }
+
+                //
+                // Everything below here merely passes on the call to the top of the
+                // stream stack.
+                //
+
+                virtual void close();
+                virtual Bu::size read( void *pBuf, Bu::size nBytes );
+                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+
+                virtual Bu::size write( const Bu::String &sBuf );
+                virtual Bu::size tell();
+                virtual void seek( Bu::size offset );
+                virtual void setPos( Bu::size pos );
+                virtual void setPosEnd( Bu::size 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 );
+                virtual void setSize( Bu::size iSize );
+                virtual size getSize() const;
+                virtual size getBlockSize() const;
+                virtual Bu::String getLocation() const;
+
+        private:
+                void checkStack() const;
+
+        private:
+                FilterList lFilts;
+        };
+};
+
+#endif
diff --git a/src/stable/strfilter.h b/src/stable/strfilter.h
new file mode 100644
index 0000000..8da0a3f
--- /dev/null
+++ b/src/stable/strfilter.h
@@ -0,0 +1,124 @@
+#ifndef STR_FILTER_H
+#define STR_FILTER_H
+
+#include "bu/string.h"
+#include "bu/membuf.h"
+
+namespace Bu
+{
+        //
+        // Encoders
+        //
+        template<typename tFilter>
+        Bu::String encodeStr( const Bu::String &sIn )
+        {
+                Bu::MemBuf mb;
+                {
+                        tFilter fEnc( mb );
+                        fEnc.write( sIn.getStr(), sIn.getSize() );
+                }
+                return mb.getString();
+        }
+
+        template<typename tFilter, typename p1t>
+        Bu::String encodeStr( const Bu::String &sIn, p1t p1 )
+        {
+                Bu::MemBuf mb;
+                {
+                        tFilter fEnc( mb, p1 );
+                        fEnc.write( sIn.getStr(), sIn.getSize() );
+                }
+                return mb.getString();
+        }
+
+        template<typename tFilter, typename p1t, typename p2t>
+        Bu::String encodeStr( const Bu::String &sIn, p1t p1, p2t p2 )
+        {
+                Bu::MemBuf mb;
+                {
+                        tFilter fEnc( mb, p1, p2 );
+                        fEnc.write( sIn.getStr(), sIn.getSize() );
+                }
+                return mb.getString();
+        }
+
+        template<typename tFilter, typename p1t, typename p2t, typename p3t>
+        Bu::String encodeStr( const Bu::String &sIn, p1t p1, p2t p2, p3t p3 )
+        {
+                Bu::MemBuf mb;
+                {
+                        tFilter fEnc( mb, p1, p2 );
+                        fEnc.write( sIn.getStr(), sIn.getSize() );
+                }
+                return mb.getString();
+        }
+
+        //
+        // Decoders
+        //
+        template<typename tFilter>
+        Bu::String decodeStr( const Bu::String &sIn )
+        {
+                Bu::MemBuf mb( sIn );
+                tFilter fDec( mb );
+                char buf[1024];
+                String sRet;
+                for(;;)
+                {
+                        int iRead = fDec.read( buf, 1024 );
+                        if( iRead == 0 )
+                                return sRet;
+                        sRet.append( buf, iRead );
+                }
+        }
+        
+        template<typename tFilter, typename p1t>
+        Bu::String decodeStr( const Bu::String &sIn, p1t p1 )
+        {
+                Bu::MemBuf mb( sIn );
+                tFilter fDec( mb, p1 );
+                char buf[1024];
+                String sRet;
+                for(;;)
+                {
+                        int iRead = fDec.read( buf, 1024 );
+                        if( iRead == 0 )
+                                return sRet;
+                        sRet.append( buf, iRead );
+                }
+        }
+        
+        template<typename tFilter, typename p1t, typename p2t>
+        Bu::String decodeStr( const Bu::String &sIn, p1t p1, p2t p2 )
+        {
+                Bu::MemBuf mb( sIn );
+                tFilter fDec( mb, p1, p2 );
+                char buf[1024];
+                String sRet;
+                for(;;)
+                {
+                        int iRead = fDec.read( buf, 1024 );
+                        if( iRead == 0 )
+                                return sRet;
+                        sRet.append( buf, iRead );
+                }
+        }
+        
+        template<typename tFilter, typename p1t, typename p2t, typename p3t>
+        Bu::String decodeStr( const Bu::String &sIn, p1t p1, p2t p2, p3t p3 )
+        {
+                Bu::MemBuf mb( sIn );
+                tFilter fDec( mb, p1, p2, p3 );
+                char buf[1024];
+                String sRet;
+                for(;;)
+                {
+                        int iRead = fDec.read( buf, 1024 );
+                        if( iRead == 0 )
+                                return sRet;
+                        sRet.append( buf, iRead );
+                }
+        }
+};
+
+#endif
diff --git a/src/stable/string.cpp b/src/stable/string.cpp
new file mode 100644
index 0000000..1a9018b
--- /dev/null
+++ b/src/stable/string.cpp
@@ -0,0 +1,1470 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#define BU_TRACE
+#include "bu/trace.h"
+
+#include "bu/string.h"
+#include "bu/hash.h"
+#include "bu/membuf.h"
+#include "bu/formatter.h"
+#include <stdlib.h>
+
+#define nMinSize        (256)
+
+Bu::StringCore::StringCore() :
+        nLength( 0 ),
+        pFirst( NULL ),
+        pLast( NULL )
+{
+}
+
+Bu::StringCore::StringCore( const StringCore &rSrc ) :
+        nLength( rSrc.nLength ),
+        pFirst( NULL ),
+        pLast( NULL )
+{
+        if( rSrc.pFirst == NULL || rSrc.nLength == 0 )
+        {
+                pFirst = pLast = NULL;
+        }
+        else
+        {
+                pFirst = pLast = newChunk( nLength );
+                Chunk *pLink = rSrc.pFirst;
+                int iPos = 0;
+                while( pLink != NULL )
+                {
+                        memcpy( pFirst->pData+iPos, pLink->pData, pLink->nLength );
+                        iPos += pLink->nLength;
+                        pLink = pLink->pNext;
+                }
+        }
+}
+
+Bu::StringCore::~StringCore()
+{
+        clear();
+}
+
+void Bu::StringCore::clear() const
+{
+        if( pFirst == NULL )
+                return;
+
+        Chunk *i = pFirst;
+        for(;;)
+        {
+                Chunk *n = i->pNext;
+                delete[] i->pData;
+                delete i;
+                if( n == NULL )
+                        break;
+                i = n;
+        }
+        pFirst = pLast = NULL;
+        nLength = 0;
+}       
+
+Bu::StringCore::Chunk *Bu::StringCore::newChunk() const
+{
+        Chunk *pNew = new Chunk;
+        pNew->pNext = NULL;
+        return pNew;
+}
+
+Bu::StringCore::Chunk *Bu::StringCore::newChunk( long nLen ) const
+{
+        Chunk *pNew = new Chunk;
+        pNew->pNext = NULL;
+        pNew->nLength = nLen;
+        pNew->pData = new char[(nLen<nMinSize)?(nMinSize):(nLen)+1];
+        pNew->pData[nLen] = (char)0;
+        return pNew;
+}
+
+Bu::StringCore::Chunk *Bu::StringCore::copyChunk(
+                Bu::StringCore::Chunk *pSrc ) const
+{
+        Chunk *pNew = new Chunk;
+        pNew->pNext = pSrc->pNext;
+        pNew->nLength = pSrc->nLength;
+        pNew->pData = new char[
+                (pNew->nLength<nMinSize)?(nMinSize):(pNew->nLength)+1
+                ];
+        memcpy( pNew->pData, pSrc->pData, pSrc->nLength );
+        pNew->pData[pNew->nLength] = (char)0;
+        return pNew;
+}
+
+void Bu::StringCore::appendChunk( Bu::StringCore::Chunk *pNewChunk )
+{
+        if( pFirst == NULL )
+                pLast = pFirst = pNewChunk;
+        else
+        {
+                pLast->pNext = pNewChunk;
+                pLast = pNewChunk;
+        }
+
+        nLength += pNewChunk->nLength;
+}
+
+void Bu::StringCore::prependChunk( Bu::StringCore::Chunk *pNewChunk )
+{
+        if( pFirst == NULL )
+                pLast = pFirst = pNewChunk;
+        else
+        {
+                pNewChunk->pNext = pFirst;
+                pFirst = pNewChunk;
+        }
+
+        nLength += pNewChunk->nLength;
+}
+
+Bu::String::String()
+{
+}
+
+Bu::String::String( const char *pData )
+{
+        append( pData );
+}
+
+Bu::String::String( const char *pData, long nLength )
+{
+        append( pData, nLength );
+}
+
+Bu::String::String( const Bu::String &rSrc ) :
+        Bu::SharedCore<Bu::String, Bu::StringCore>( rSrc )
+{
+}
+
+Bu::String::String( const Bu::String &rSrc, long nLength )
+{
+        append( rSrc, nLength );
+}
+
+Bu::String::String( const Bu::String &rSrc, long nStart, long nLength )
+{
+        append( rSrc, nStart, nLength );
+}
+
+Bu::String::String( long nSize )
+{
+        core->pFirst = core->pLast = core->newChunk( nSize );
+        core->nLength = nSize;
+}
+
+Bu::String::String( const Bu::String::const_iterator &s )
+{
+        append( s );
+}
+
+Bu::String::String( const Bu::String::const_iterator &s,
+                const Bu::String::const_iterator &e )
+{
+        append( s, e );
+}
+
+Bu::String::~String()
+{
+}
+
+void Bu::String::append( const char *pData )
+{
+        if( !pData ) return;
+        long nLen;
+        for( nLen = 0; pData[nLen] != (char)0; nLen++ ) { }
+
+        append( pData, 0, nLen );
+}
+
+void Bu::String::append( const char *pData, long nLen )
+{
+        append( pData, 0, nLen );
+}
+
+void Bu::String::append( const char *pData, long nStart, long nLen )
+{
+        if( !pData ) return;
+        if( nLen <= 0 )
+                return;
+
+        pData += nStart;
+
+        _hardCopy();
+
+        if( core->pLast && core->pLast->nLength < nMinSize )
+        {
+                int nAmnt = nMinSize - core->pLast->nLength;
+                if( nAmnt > nLen )
+                        nAmnt = nLen;
+                memcpy(
+                        core->pLast->pData+core->pLast->nLength,
+                        pData,
+                        nAmnt
+                   );
+                pData += nAmnt;
+                core->pLast->nLength += nAmnt;
+                nLen -= nAmnt;
+                core->nLength += nAmnt;
+        }
+
+        if( nLen > 0 )
+        {
+                Chunk *pNew = core->newChunk( nLen );
+                memcpy( pNew->pData, pData, nLen );
+                core->appendChunk( pNew );
+//                              core->nLength += nLen;
+        }
+}
+
+void Bu::String::append( const char &cData )
+{
+        if( core->pLast && core->pLast->nLength < nMinSize )
+        {
+                _hardCopy();
+                core->pLast->pData[core->pLast->nLength] = cData;
+                ++core->pLast->nLength; ++core->nLength;
+//              pLast->pData[pLast->nLength] = (char)0;
+        }
+        else
+        {
+                append( &cData, 1 );
+        }
+}
+
+void Bu::String::append( const String & sData )
+{
+        append( sData.getStr(), 0, sData.getSize() );
+}
+
+void Bu::String::append( const String & sData, long nLen )
+{
+        append( sData.getStr(), 0, nLen );
+}
+
+void Bu::String::append( const String & sData, long nStart, long nLen )
+{
+        if( nLen < 0 )
+                nLen = sData.getSize() - nStart;
+        append( sData.getStr(), nStart, nLen );
+}
+
+void Bu::String::append( const const_iterator &s )
+{
+        if( !s.isValid() )
+                return;
+        Chunk *pSrc = s.pChunk;
+
+        Chunk *pNew = core->newChunk( pSrc->nLength-s.iPos );
+        memcpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
+
+        _hardCopy();
+        core->appendChunk( pNew );
+
+        while( (pSrc = pSrc->pNext) )
+        {
+                core->appendChunk( core->copyChunk( pSrc ) );
+        }
+}
+
+void Bu::String::append( const iterator &s )
+{
+        append( const_iterator( s ) );
+}
+
+void Bu::String::append( const const_iterator &s, const const_iterator &e )
+{
+        if( !s.isValid() )
+                return;
+        if( !e.isValid() )
+        {
+                append( s );
+                return;
+        }
+        _hardCopy();
+        if( s.pChunk == e.pChunk )
+        {
+                // Simple case, they're the same chunk
+                Chunk *pNew = core->newChunk( e.iPos-s.iPos );
+                memcpy( pNew->pData, s.pChunk->pData+s.iPos, e.iPos-s.iPos );
+                core->appendChunk( pNew );
+        }
+        else
+        {
+                // A little trickier, scan the blocks...
+                Chunk *pSrc = s.pChunk;
+                Chunk *pNew = core->newChunk( pSrc->nLength-s.iPos );
+                memcpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
+                core->appendChunk( pNew );
+
+                while( (pSrc = pSrc->pNext) != e.pChunk )
+                {
+                        core->appendChunk( core->copyChunk( pSrc ) );
+                }
+
+                pNew = core->newChunk( e.iPos );
+                memcpy( pNew->pData, pSrc->pData, e.iPos );
+                core->appendChunk( pNew );
+        }
+}
+
+void Bu::String::prepend( const String & sData )
+{
+        prepend( sData.getStr(), sData.getSize() );
+}
+
+void Bu::String::prepend( const char *pData )
+{
+        if( pData == NULL )
+                return;
+
+        _hardCopy();
+        long nLen;
+        for( nLen = 0; pData[nLen] != (char)0; nLen++ ) { }
+        
+        Chunk *pNew = core->newChunk( nLen );
+        memcpy( pNew->pData, pData, nLen );
+
+        core->prependChunk( pNew );
+}
+
+void Bu::String::prepend( const char *pData, long nLen )
+{
+        Chunk *pNew = core->newChunk( nLen );
+        
+        memcpy( pNew->pData, pData, nLen );
+
+        _hardCopy();
+        core->prependChunk( pNew );
+}
+
+void Bu::String::prepend( const char c )
+{
+        prepend( &c, 1 );
+}
+
+void Bu::String::insert( long nPos, const char *pData, long nLen )
+{
+        if( nLen <= 0 )
+                return;
+        if( nPos <= 0 )
+        {
+                prepend( pData, nLen );
+        }
+        else if( nPos >= core->nLength )
+        {
+                append( pData, nLen );
+        }
+        else
+        {
+                // If we're going to flatten anyway, might as well for everyone
+                flatten();
+                _hardCopy();
+                Chunk *p1 = core->newChunk( nPos );
+                Chunk *p2 = core->newChunk( nLen );
+                Chunk *p3 = core->newChunk( core->nLength-nPos );
+                memcpy( p1->pData, core->pFirst->pData, nPos );
+                memcpy( p2->pData, pData, nLen );
+                memcpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
+                core->clear();
+                core->appendChunk( p1 );
+                core->appendChunk( p2 );
+                core->appendChunk( p3 );
+        }
+}
+
+void Bu::String::insert( long nPos, const String &str )
+{
+        if( nPos <= 0 )
+        {
+                prepend( str );
+        }
+        else if( nPos >= core->nLength )
+        {
+                append( str );
+        }
+        else
+        {
+                flatten();
+                _hardCopy();
+                Chunk *p1 = core->newChunk( nPos );
+                Chunk *p3 = core->newChunk( core->nLength-nPos );
+                memcpy( p1->pData, core->pFirst->pData, nPos );
+                memcpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
+                core->clear();
+                core->appendChunk( p1 );
+                for( Chunk *pChnk = str.core->pFirst; pChnk;
+                         pChnk = pChnk->pNext )
+                {
+                        core->appendChunk( core->copyChunk( pChnk ) );
+                }
+
+                core->appendChunk( p3 );
+        }
+}
+
+void Bu::String::insert( long nPos, const char *pData )
+{
+        insert( nPos, pData, strlen( pData ) );
+}
+
+void Bu::String::remove( long nPos, long nLen )
+{
+        if( nLen <= 0 || nPos < 0 || nPos >= core->nLength )
+                return;
+        if( nLen > core->nLength-nPos )
+                nLen = core->nLength-nPos;
+        flatten();
+        _hardCopy();
+        memmove( core->pFirst->pData+nPos, core->pFirst->pData+nPos+nLen, core->nLength-nPos-nLen+1 );
+        core->nLength -= nLen;
+        core->pFirst->nLength -= nLen;
+}
+
+void Bu::String::clear()
+{
+        _hardCopy();
+        core->clear();
+}
+
+Bu::String Bu::String::replace( const Bu::String &fnd,
+                const Bu::String &rep ) const
+{
+        String out;
+        const_iterator o = begin();
+        while( true )
+        {
+                const_iterator i = o.find( fnd, fnd.getSize() );
+                if( !i )
+                {
+                        out.append( o );
+                        return out;
+                }
+                else
+                {
+                        out.append( o, i );
+                        out.append( rep );
+                        o = i;
+                        o += fnd.getSize();
+                }
+        }
+}
+
+void Bu::String::resize( long nNewSize )
+{
+        if( core->nLength == nNewSize )
+                return;
+        if( nNewSize < 0 )
+                nNewSize = 0;
+
+        flatten();
+        _hardCopy();
+
+        // TODO:  This is bad
+
+        Chunk *pNew = core->newChunk( nNewSize );
+        long nNewLen = (nNewSize<core->nLength)?(nNewSize):(core->nLength);
+        if( core->nLength > 0 )
+        {
+                memcpy( pNew->pData, core->pFirst->pData, nNewLen );
+                delete[] core->pFirst->pData;
+                delete core->pFirst;
+        }
+        pNew->pData[nNewLen] = (char)0;
+        core->pFirst = core->pLast = pNew;
+        core->nLength = nNewSize;
+}
+
+long Bu::String::getSize() const
+{
+        return core->nLength;
+}
+
+char *Bu::String::getStr()
+{
+        if( core->pFirst == NULL || core->nLength == 0 )
+                return (char *)"";
+
+        flatten();
+        _hardCopy();
+        core->pFirst->pData[core->nLength] = (char)0;
+        return core->pFirst->pData;
+}
+
+const char *Bu::String::getStr() const
+{
+        if( core->pFirst == NULL || core->nLength == 0 )
+                return (char *)"";
+
+        flatten();
+        core->pFirst->pData[core->nLength] = (char)0;
+        return core->pFirst->pData;
+}
+
+const char *Bu::String::getConstStr() const
+{
+        return getStr();
+}
+
+Bu::String Bu::String::getSubStrIdx( long iStart, long iSize ) const
+{
+        if( iStart < 0 )
+                iStart = 0;
+        if( iStart >= core->nLength )
+                return (const char[]){(char)0};
+        if( iSize < 0 )
+                iSize = core->nLength;
+        if( iStart+iSize > core->nLength )
+                iSize = core->nLength-iStart;
+        if( iSize == 0 )
+                return (const char[]){(char)0};
+
+        flatten();
+        String ret( core->pFirst->pData+iStart, iSize );
+        return ret;
+}
+
+Bu::String Bu::String::getSubStr( const_iterator iBegin,
+                const_iterator iEnd ) const
+{
+        if( !iBegin.isValid() )
+                return String();
+        if( iBegin.pChunk == iEnd.pChunk )
+        {
+                return String( iBegin.pChunk->pData+iBegin.iPos,
+                        iEnd.iPos-iBegin.iPos );
+        }
+        else if( !iEnd.isValid() )
+        {
+                String ret;
+                ret.append(
+                        iBegin.pChunk->pData+iBegin.iPos,
+                        iBegin.pChunk->nLength-iBegin.iPos
+                        );
+                for( Chunk *pCur = iBegin.pChunk->pNext;
+                         pCur; pCur = pCur->pNext )
+                {
+                        ret.append( pCur->pData, pCur->nLength );
+                }
+                return ret;
+        }
+        else
+        {
+                String ret;
+                ret.append(
+                        iBegin.pChunk->pData+iBegin.iPos,
+                        iBegin.pChunk->nLength-iBegin.iPos
+                        );
+                for( Chunk *pCur = iBegin.pChunk->pNext;
+                         pCur != iEnd.pChunk; pCur = pCur->pNext )
+                {
+                        ret.append( pCur->pData, pCur->nLength );
+                }
+                ret.append(
+                        iEnd.pChunk->pData,
+                        iEnd.iPos
+                        );
+                return ret;
+        }
+}
+
+Bu::StringList Bu::String::split( const char c ) const
+{
+        Bu::StringList ret;
+        const_iterator l, r;
+        l = begin();
+        for(r=l; l;)
+        {
+                for( r = l; r && r != c; r++ ) { }
+                ret.append( String( l, r ) );
+                l = r;
+                l++;
+        }
+        return ret;
+}
+
+Bu::String &Bu::String::operator+=( const char *pData )
+{
+        append( pData );
+
+        return (*this);
+}
+
+Bu::String &Bu::String::operator+=( const Bu::String &rSrc )
+{
+        append( rSrc );
+
+        return (*this);
+}
+
+Bu::String &Bu::String::operator+=( const Bu::String::const_iterator &i )
+{
+        append( i, i+1 );
+
+        return (*this);
+}
+
+Bu::String &Bu::String::operator+=( const char cData )
+{
+        if( core->pLast && core->pLast->nLength < nMinSize )
+        {
+                _hardCopy();
+                core->pLast->pData[core->pLast->nLength] = cData;
+                ++core->pLast->nLength; ++core->nLength;
+//              pLast->pData[pLast->nLength] = (char)0;
+        }
+        else
+        {
+                append( &cData, 1 );
+        }
+        //append( pData );
+
+        return (*this);
+}
+
+Bu::String &Bu::String::operator=( const char *pData )
+{
+        set( pData );
+
+        return (*this);
+}
+
+Bu::String Bu::String::operator+( const Bu::String &rRight ) const
+{
+        String ret( *this );
+        ret.append( rRight );
+        return ret;
+}
+
+Bu::String Bu::String::operator+( const char *pRight ) const
+{
+        String ret( *this );
+        ret.append( pRight );
+        return ret;
+}
+
+Bu::String Bu::String::operator+( char *pRight ) const
+{
+        String ret( *this );
+        ret.append( pRight );
+        return ret;
+}
+
+void Bu::String::set( const char *pData )
+{
+        clear();
+        append( pData );
+}
+
+void Bu::String::set( const char *pData, long nSize )
+{
+        clear();
+        append( pData, nSize );
+}
+
+void Bu::String::set( const char *pData, long nStart, long nSize )
+{
+        clear();
+        append( pData, nStart, nSize );
+}
+
+void Bu::String::set( const String &rData )
+{
+        clear();
+        append( rData );
+}
+
+void Bu::String::set( const String &rData, long nSize )
+{
+        clear();
+        append( rData, nSize );
+}
+
+void Bu::String::set( const String &rData, long nStart, long nSize )
+{
+        clear();
+        append( rData, nStart, nSize );
+}
+
+void Bu::String::set( const_iterator s )
+{
+        clear();
+        append( s );
+}
+
+void Bu::String::set( const_iterator s, const_iterator e )
+{
+        clear();
+        append( s, e );
+}
+
+void Bu::String::setSize( long iSize )
+{
+        _hardCopy();
+        core->clear();
+        core->appendChunk( core->newChunk( iSize ) );
+}
+
+bool Bu::String::operator==( const char *pData ) const
+{
+        if( core->pFirst == NULL || core->nLength == 0 ) {
+                if( pData == NULL )
+                        return true;
+                if( pData[0] == (char)0 )
+                        return true;
+                return false;
+        }
+
+        flatten();
+        core->pFirst->pData[core->nLength] = (char)0;
+        const char *a = pData;
+        char *b = core->pFirst->pData;
+        for( long j = 0; *a!=(char)0 || *b!=(char)0; j++, a++, b++ )
+        {
+                if( *a != *b )
+                        return false;
+                if( *a == (char)0 && j < core->nLength )
+                        return false;
+        }
+
+        return true;
+}
+
+bool Bu::String::operator==( const String &pData ) const
+{
+        if( core == pData.core )
+                return true;
+        if( core->pFirst == pData.core->pFirst )
+                return true;
+        if( (core->nLength == 0 && pData.core->nLength == 0) ) 
+                return true;
+        if( core->nLength != pData.core->nLength )
+                return false;
+        if( pData.core->pFirst == NULL || core->pFirst == NULL )
+                return false;
+
+        flatten();
+        pData.flatten();
+        const char *a = pData.core->pFirst->pData;
+        char *b = core->pFirst->pData;
+        for( long j = 0; j < core->nLength; j++, a++, b++ )
+        {
+                if( *a != *b )
+                        return false;
+        }
+
+        return true;
+}
+
+bool Bu::String::operator!=(const char *pData ) const
+{
+        return !(*this == pData);
+}
+
+bool Bu::String::operator!=(const String &pData ) const
+{
+        return !(*this == pData);
+}
+
+bool Bu::String::operator<(const String &pData ) const
+{
+        flatten();
+        pData.flatten();
+
+        const char *a = core->pFirst->pData;
+        char *b = pData.core->pFirst->pData;
+        for( long j = 0; j < core->nLength; j++, a++, b++ )
+        {
+                if( *a != *b )
+                        return *a < *b;
+        }
+
+        return false;
+}
+
+bool Bu::String::operator<=(const String &pData ) const
+{
+        flatten();
+        pData.flatten();
+
+        const char *a = core->pFirst->pData;
+        char *b = pData.core->pFirst->pData;
+        for( long j = 0; j < core->nLength; j++, a++, b++ )
+        {
+                if( *a != *b )
+                        return *a < *b;
+        }
+
+        return true;
+}
+
+bool Bu::String::operator>(const String &pData ) const
+{
+        flatten();
+        pData.flatten();
+
+        const char *a = core->pFirst->pData;
+        char *b = pData.core->pFirst->pData;
+        for( long j = 0; j < core->nLength; j++, a++, b++ )
+        {
+                if( *a != *b )
+                        return *a > *b;
+        }
+
+        return false;
+}
+
+bool Bu::String::operator>=(const String &pData ) const
+{
+        flatten();
+        pData.flatten();
+
+        const char *a = core->pFirst->pData;
+        char *b = pData.core->pFirst->pData;
+        for( long j = 0; j < core->nLength; j++, a++, b++ )
+        {
+                if( *a != *b )
+                        return *a > *b;
+        }
+
+        return true;
+}
+
+char &Bu::String::operator[]( long nIndex )
+{
+        if( nIndex < 0 || nIndex >= core->nLength )
+                throw Bu::ExceptionBase("Index out of range.");
+        flatten();
+        _hardCopy();
+
+        return core->pFirst->pData[nIndex];
+}
+
+const char &Bu::String::operator[]( long nIndex ) const
+{
+        if( nIndex < 0 || nIndex >= core->nLength )
+                throw Bu::ExceptionBase("Index out of range.");
+        flatten();
+
+        return core->pFirst->pData[nIndex];
+}
+
+bool Bu::String::isSet() const
+{
+        return (core->pFirst != NULL);
+}
+
+bool Bu::String::compareSub( const char *pData, long nIndex, long nLen ) const
+{
+        if( core->pFirst == NULL || core->nLength == 0 ) {
+                if( pData == NULL )
+                        return true;
+                if( nLen == 0 )
+                        return true;
+                if( pData[0] == (char)0 )
+                        return true;
+                return false;
+        }
+        if( nIndex+nLen > core->nLength )
+                return false;
+
+        flatten();
+        core->pFirst->pData[core->nLength] = (char)0;
+        const char *a = pData;
+        char *b = core->pFirst->pData+nIndex;
+        for( long j = 0; j < nLen; j++, a++, b++ )
+        {
+                if( *a != *b )
+                        return false;
+                if( *a == (char)0 && j < core->nLength )
+                        return false;
+        }
+
+        return true;
+}
+
+bool Bu::String::compareSub( const String &rData, long nIndex, long nLen ) const
+{
+        if( core->pFirst == NULL || core->nLength == 0 || rData.core->pFirst == NULL || rData.core->nLength == 0 ) 
+                return false;
+        if( nLen < 0 )
+                nLen = rData.core->nLength;
+        if( nIndex+nLen > core->nLength )
+                return false;
+
+        flatten();
+        rData.flatten();
+        const char *a = rData.core->pFirst->pData;
+        char *b = core->pFirst->pData + nIndex;
+        for( long j = 0; j < nLen; j++, a++, b++ )
+        {
+                if( *a != *b )
+                        return false;
+        }
+
+        return true;
+}
+
+bool Bu::String::isWS( long nIndex ) const
+{
+        flatten();
+
+        return core->pFirst->pData[nIndex]==' ' || core->pFirst->pData[nIndex]=='\t'
+                || core->pFirst->pData[nIndex]=='\r' || core->pFirst->pData[nIndex]=='\n';
+}
+
+bool Bu::String::isAlpha( long nIndex ) const
+{
+        flatten();
+
+        return (core->pFirst->pData[nIndex] >= 'a' && core->pFirst->pData[nIndex] <= 'z')
+                || (core->pFirst->pData[nIndex] >= 'A' && core->pFirst->pData[nIndex] <= 'Z');
+}
+
+Bu::String Bu::String::toLower() const
+{
+        Bu::String sRet = *this;
+
+        sRet.flatten();
+        sRet._hardCopy();
+
+        for( long j = 0; j < sRet.core->nLength; j++ )
+        {
+                if( sRet.core->pFirst->pData[j] >= 'A' &&
+                        sRet.core->pFirst->pData[j] <= 'Z' )
+                        sRet.core->pFirst->pData[j] -= 'A'-'a';
+        }
+
+        return sRet;
+}
+
+Bu::String Bu::String::toUpper() const
+{
+        Bu::String sRet = *this;
+
+        sRet.flatten();
+        sRet._hardCopy();
+
+        for( long j = 0; j < sRet.core->nLength; j++ )
+        {
+                if( sRet.core->pFirst->pData[j] >= 'a' &&
+                        sRet.core->pFirst->pData[j] <= 'z' )
+                        sRet.core->pFirst->pData[j] += 'A'-'a';
+        }
+        
+        return sRet;
+}
+
+Bu::String::const_iterator Bu::String::find( const char cChar,
+                Bu::String::const_iterator iStart ) const
+{
+        if( !iStart ) iStart = begin();
+        for( ; iStart; iStart++ )
+        {
+                if( cChar == *iStart )
+                        return iStart;
+        }
+        return end();
+}
+
+Bu::String::const_iterator Bu::String::find( const char *sText, int nLen,
+                Bu::String::const_iterator iStart ) const
+{
+        if( !iStart ) iStart = begin();
+        for( ; iStart; iStart++ )
+        {
+                if( iStart.compare( sText, nLen ) )
+                        return iStart;
+        }
+        return end();
+}
+
+Bu::String::const_iterator Bu::String::find( const String &rStr,
+                Bu::String::const_iterator iStart ) const
+{
+        if( !iStart ) iStart = begin();
+        for( ; iStart; iStart++ )
+        {
+                if( iStart.compare( rStr ) )
+                        return iStart;
+        }
+        return end();
+}
+
+Bu::String::const_iterator Bu::String::find( const String &rStr, int nLen,
+                Bu::String::const_iterator iStart ) const
+{
+        if( !iStart ) iStart = begin();
+        for( ; iStart; iStart++ )
+        {
+                if( iStart.compare( rStr, nLen ) )
+                        return iStart;
+        }
+        return end();
+}
+
+Bu::String::iterator Bu::String::find( const char cChar,
+                Bu::String::const_iterator iStart )
+{
+        if( !iStart ) iStart = begin();
+        for( ; iStart; iStart++ )
+        {
+                if( cChar == *iStart )
+                        return iterator( iStart.pChunk, iStart.iPos );
+        }
+        return end();
+}
+
+Bu::String::iterator Bu::String::find( const char *sText, int nLen,
+                Bu::String::const_iterator iStart )
+{
+        if( !iStart ) iStart = begin();
+        for( ; iStart; iStart++ )
+        {
+                if( iStart.compare( sText, nLen ) )
+                        return iterator( iStart.pChunk, iStart.iPos );
+        }
+        return end();
+}
+
+Bu::String::iterator Bu::String::find( const String &rStr,
+                Bu::String::const_iterator iStart )
+{
+        if( !iStart ) iStart = begin();
+        for( ; iStart; iStart++ )
+        {
+                if( iStart.compare( rStr ) )
+                        return iterator( iStart.pChunk, iStart.iPos );
+        }
+        return end();
+}
+
+Bu::String::iterator Bu::String::find( const String &rStr, int nLen,
+                Bu::String::const_iterator iStart )
+{
+        if( !iStart ) iStart = begin();
+        for( ; iStart; iStart++ )
+        {
+                if( iStart.compare( rStr, nLen ) )
+                        return iterator( iStart.pChunk, iStart.iPos );
+        }
+        return end();
+}
+
+long Bu::String::findIdx( const char cChar, long iStart ) const
+{
+        flatten();
+        for( long j = iStart; j < core->pFirst->nLength; j++ )
+        {
+                if( core->pFirst->pData[j] == cChar )
+                        return j;
+        }
+        return -1;
+}
+
+long Bu::String::findIdx( const char *sText, long iStart ) const
+{
+        long nTLen = strlen( sText );
+        flatten();
+        for( long j = iStart; j < core->pFirst->nLength-nTLen; j++ )
+        {
+                if( !strncmp( sText, core->pFirst->pData+j, nTLen ) )
+                        return j;
+        }
+        return -1;
+}
+
+long Bu::String::rfindIdx( const char *sText ) const
+{
+        long nTLen = strlen( sText );
+        flatten();
+        for( long j = core->pFirst->nLength-nTLen-1; j >= 0; j-- )
+        {
+                if( !strncmp( sText, core->pFirst->pData+j, nTLen ) )
+                        return j;
+        }
+        return -1;
+}
+
+void Bu::String::trimFront( long nAmnt )
+{
+        long nNewLen = core->nLength - nAmnt;
+        flatten();
+        Chunk *pNew = core->newChunk( nNewLen );
+        memcpy( pNew->pData, core->pFirst->pData+nAmnt, nNewLen );
+        _hardCopy();
+        core->clear();
+        core->appendChunk( pNew );
+}
+/*
+void Bu::String::trimBack( char c )
+{
+        if( core->pFirst == NULL || core->nLength == 0 )
+                return;
+        flatten();
+        for( ; core->pFirst->nLength > 0 &&
+                core->pFirst->pData[core->pFirst->nLength-1] == c;
+                core->pFirst->nLength--, core->nLength-- ) { }
+}
+*/
+void Bu::String::trimBack( long iAmnt )
+{
+        if( iAmnt < 0 )
+                return;
+        if( core->nLength - iAmnt < 0 )
+        {
+                clear();
+                return;
+        }
+        if( core->pFirst == NULL || core->nLength == 0 )
+                return;
+
+        flatten();
+        core->pFirst->nLength -= iAmnt;
+        core->nLength -= iAmnt;
+}
+
+Bu::String Bu::String::trimWhitespace() const
+{
+        if( core->nLength == 0 )
+                return "";
+        const_iterator i = begin();
+        for( ; i && (*i == ' ' || *i == '\t' || *i == '\n' || *i == '\r'); i++ ) { }
+        if( !i )
+                return "";
+
+        const_iterator e = i;
+        for( ; e; e++ )
+        {
+                if( *e == ' ' || *e == '\t' || *e == '\n' || *e == '\r' )
+                {
+                        const_iterator t = e;
+                        for( ; t && (*t == ' ' || *t == '\t' || *t == '\n' || *t == '\r'); t++ ) { }
+                        if( t )
+                        {
+                                e = t;
+                        }
+                        else
+                        {
+                                break;
+                        }
+                }
+        }
+
+        return Bu::String( i, e );
+}
+
+Bu::String::iterator Bu::String::begin()
+{
+        if( core->nLength == 0 )
+                return iterator( NULL, 0 );
+        return iterator( core->pFirst, 0 );
+}
+
+Bu::String::const_iterator Bu::String::begin() const
+{
+        if( core->nLength == 0 )
+                return const_iterator( NULL, 0 );
+        return iterator( core->pFirst, 0 );
+}
+
+Bu::String::iterator Bu::String::end()
+{
+        return iterator( NULL, 0 );
+}
+
+Bu::String::const_iterator Bu::String::end() const
+{
+        return const_iterator( NULL, 0 );
+}
+
+bool Bu::String::isEmpty() const
+{
+        if( core->nLength == 0 )
+                return true;
+        return false;
+}
+
+void Bu::String::flatten() const
+{
+        if( isFlat() )
+                return;
+
+        if( core->pFirst == NULL || core->nLength == 0 )
+                return;
+
+        Chunk *pNew = core->newChunk( core->nLength );
+        char *pos = pNew->pData;
+        Chunk *i = core->pFirst;
+        for(;;)
+        {
+                memcpy( pos, i->pData, i->nLength );
+                pos += i->nLength;
+                i = i->pNext;
+                if( i == NULL )
+                        break;
+        }
+        core->clear();
+
+        core->pLast = core->pFirst = pNew;
+        core->nLength = pNew->nLength;
+}
+
+bool Bu::String::isFlat() const
+{
+        return (core->pFirst == core->pLast);
+}
+
+//
+// Sub-class Bu::String::FormatProxy
+//
+
+Bu::String::FormatProxy::FormatProxy( const String &rFmt ) :
+        rFmt( rFmt )
+{
+}
+
+Bu::String::FormatProxy::~FormatProxy()
+{
+}
+
+Bu::String::FormatProxy::operator Bu::String() const
+{
+        int iCount = lArgs.getSize();
+        ArgList::const_iterator *aArg =
+                new ArgList::const_iterator[iCount];
+        {
+                int j = 0;
+                for( ArgList::const_iterator i = lArgs.begin();
+                         i; i++, j++ )
+                {
+                        aArg[j] = i;
+                }
+        }
+        Bu::MemBuf mbOut;
+        Bu::Formatter f( mbOut );
+        for( String::const_iterator s = rFmt.begin(); s; s++ )
+        {
+                if( *s == '%' )
+                {
+                        s++;
+                        if( *s == '%' )
+                                f << *s;
+                        else
+                        {
+                                String sNum;
+                                while( s && *s >= '0' && *s <= '9' )
+                                {
+                                        sNum += *s;
+                                        s++;
+                                }
+                                int iIndex = strtol( sNum.getStr(), 0, 10 )-1;
+                                if( iIndex < 0 || iIndex >= iCount )
+                                {
+                                        delete[] aArg;
+                                        throw Bu::ExceptionBase(
+                                                "Argument index %d is outside of "
+                                                "valid range (1-%d).", iIndex+1, iCount
+                                                );
+                                }
+
+                                f << (*aArg[iIndex]).format << (*aArg[iIndex]).value;
+                                if( s )
+                                        f << *s;
+                        }
+                }
+                else
+                {
+                        f << *s;
+                }
+        }
+
+        delete[] aArg;
+        return mbOut.getString();
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+template<> uint32_t Bu::__calcHashCode<Bu::String>( const Bu::String &k )
+{
+        long j, sz = k.getSize();
+        const char *s = k.getStr();
+
+        long nPos = 0;
+        for( j = 0; j < sz; j++, s++ )
+        {
+                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
+        }
+
+        return nPos;
+}
+
+template<> bool Bu::__cmpHashKeys<Bu::String>(
+                const Bu::String &a, const Bu::String &b )
+{
+        return a == b;
+}
+
+template<> void Bu::__tracer_format<Bu::String>( const Bu::String &v )
+{
+        printf("(%ld)\"%s\"", v.getSize(), v.getStr() );
+}
+
+bool &Bu::operator<<( bool &dst, const Bu::String &sIn )
+{
+        if( sIn == "true" || sIn == "yes" || sIn == "t" )
+                dst = true;
+        else
+                dst = false;
+
+        return dst;
+}
+
+uint8_t &Bu::operator<<( uint8_t &dst, const Bu::String &sIn )
+{
+        sscanf( sIn.getStr(), "%hhu", &dst );
+        return dst;
+}
+
+int8_t &Bu::operator<<( int8_t &dst, const Bu::String &sIn )
+{
+        sscanf( sIn.getStr(), "%hhd", &dst );
+        return dst;
+}
+
+char &Bu::operator<<( char &dst, const Bu::String &sIn )
+{
+        sscanf( sIn.getStr(), "%hhd", &dst );
+        return dst;
+}
+
+uint16_t &Bu::operator<<( uint16_t &dst, const Bu::String &sIn )
+{
+        sscanf( sIn.getStr(), "%hu", &dst );
+        return dst;
+}
+
+int16_t &Bu::operator<<( int16_t &dst, const Bu::String &sIn )
+{
+        sscanf( sIn.getStr(), "%hd", &dst );
+        return dst;
+}
+
+uint32_t &Bu::operator<<( uint32_t &dst, const Bu::String &sIn )
+{
+        sscanf( sIn.getStr(), "%u", &dst );
+        return dst;
+}
+
+int32_t &Bu::operator<<( int32_t &dst, const Bu::String &sIn )
+{
+        sscanf( sIn.getStr(), "%d", &dst );
+        return dst;
+}
+
+uint64_t &Bu::operator<<( uint64_t &dst, const Bu::String &sIn )
+{
+        sscanf( sIn.getStr(), "%llu", &dst );
+        return dst;
+}
+
+int64_t &Bu::operator<<( int64_t &dst, const Bu::String &sIn )
+{
+        sscanf( sIn.getStr(), "%lld", &dst );
+        return dst;
+}
+
+float &Bu::operator<<( float &dst, const Bu::String &sIn )
+{
+        sscanf( sIn.getStr(), "%f", &dst );
+        return dst;
+}
+
+double &Bu::operator<<( double &dst, const Bu::String &sIn )
+{
+        sscanf( sIn.getStr(), "%lf", &dst );
+        return dst;
+}
+
+long double &Bu::operator<<( long double &dst, const Bu::String &sIn )
+{
+        sscanf( sIn.getStr(), "%Lf", &dst );
+        return dst;
+}
+
+Bu::String &Bu::operator<<( Bu::String &dst, const Bu::String &sIn )
+{
+        dst = sIn;
+        return dst;
+}
+
+Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, const Bu::String &s )
+{
+        long n = s.getSize();
+        ar << n;
+        ar.write( s.getConstStr(), n );
+        return ar;
+}
+
+Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, Bu::String &s )
+{
+        long n;
+        ar >> n;
+        s.setSize( n );
+        ar.read( s.getStr(), n );
+        return ar;
+}
+
diff --git a/src/stable/string.h b/src/stable/string.h
new file mode 100644
index 0000000..a9006d1
--- /dev/null
+++ b/src/stable/string.h
@@ -0,0 +1,1053 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_STRING_H
+#define BU_STRING_H
+
+#include <stdint.h>
+#include <memory>
+
+#include "bu/util.h"
+#include "bu/sharedcore.h"
+#include "bu/exceptionbase.h"
+#include "bu/archivebase.h"
+#include "bu/list.h"
+#include "bu/fmt.h"
+#include "bu/variant.h"
+#include <string.h>
+
+namespace Bu
+{
+        class String;
+        class MemBuf;
+
+        /** @cond DEVEL */
+        class StringCore
+        {
+        friend class String;
+        friend class SharedCore<String, StringCore>;
+        private:
+                struct Chunk
+                {
+                        long nLength;
+                        char *pData;
+                        Chunk *pNext;
+                };
+
+                StringCore();
+                StringCore( const StringCore &rSrc );
+                virtual ~StringCore();
+
+                mutable long nLength;
+                mutable Chunk *pFirst;
+                mutable Chunk *pLast;
+
+                void clear() const;
+                Chunk *newChunk() const;
+                Chunk *newChunk( long nLen ) const;
+                Chunk *copyChunk( Chunk *pSrc ) const;
+                void appendChunk( Chunk *pNewChunk );
+                void prependChunk( Chunk *pNewChunk );
+        };
+        /** @endcond */
+
+        /**
+         */
+        class String : public SharedCore<String, StringCore>
+        {
+        protected:
+                using SharedCore<String, StringCore >::core;
+                using SharedCore<String, StringCore >::_hardCopy;
+
+        private:
+                typedef StringCore::Chunk Chunk;
+
+        public: // Iterators
+                struct iterator;
+                typedef struct const_iterator
+                {
+                        friend class String;
+                        friend struct iterator;
+                private:
+                        const_iterator( Chunk *pChunk, int iPos ) :
+                                pChunk( pChunk ),
+                                iPos( iPos )
+                        {
+                        }
+
+                        Chunk *pChunk;
+                        int iPos;
+
+                public:
+                        const_iterator( const const_iterator &i ) :
+                                pChunk( i.pChunk ),
+                                iPos( i.iPos )
+                        {
+                        }
+                        
+                        const_iterator( const struct iterator &i ) :
+                                pChunk( i.pChunk ),
+                                iPos( i.iPos )
+                        {
+                        }
+
+                        const_iterator() :
+                                pChunk( NULL ),
+                                iPos( 0 )
+                        {
+                        }
+
+                        bool operator==( const const_iterator &i ) const
+                        {
+                                return pChunk == i.pChunk && iPos == i.iPos;
+                        }
+
+                        bool operator!=( const const_iterator &i ) const
+                        {
+                                return !(*this == i);
+                        }
+
+                        const_iterator &operator=( const const_iterator &i )
+                        {
+                                pChunk = i.pChunk;
+                                iPos = i.iPos;
+                                return *this;
+                        }
+                        
+                        const_iterator &operator=( const iterator &i )
+                        {
+                                pChunk = i.pChunk;
+                                iPos = i.iPos;
+                                return *this;
+                        }
+
+                        const_iterator &operator++()
+                        {
+                                if( !pChunk ) return *this;
+                                iPos++;
+                                if( iPos >= pChunk->nLength )
+                                {
+                                        iPos = 0;
+                                        pChunk = pChunk->pNext;
+                                }
+                                return *this;
+                        }
+
+                        const_iterator &operator++( int )
+                        {
+                                if( !pChunk ) return *this;
+                                iPos++;
+                                if( iPos >= pChunk->nLength )
+                                {
+                                        iPos = 0;
+                                        pChunk = pChunk->pNext;
+                                }
+                                return *this;
+                        }
+
+                        const_iterator &operator+=( int iAmnt )
+                        {
+                                if( !pChunk ) return *this;
+                                iPos += iAmnt;
+                                while( iPos >= pChunk->nLength )
+                                {
+                                        iPos -= pChunk->nLength;
+                                        pChunk = pChunk->pNext;
+                                        if( pChunk == NULL )
+                                                break;
+                                }
+                                return *this;
+                        }
+
+                        const_iterator operator+( int iAmnt ) const
+                        {
+                                if( !pChunk ) return *this;
+                                const_iterator ret( *this );
+                                ret += iAmnt;
+                                return ret;
+                        }
+
+                        const char &operator *() const
+                        {
+                                if( !pChunk ) throw Bu::ExceptionBase("Not a valid const_iterator.");
+                                return pChunk->pData[iPos];
+                        }
+
+                        bool operator==( const char &c ) const
+                        {
+                                if( !pChunk ) return false;
+                                return pChunk->pData[iPos] == c;
+                        }
+
+                        bool operator!=( const char &c ) const
+                        {
+                                if( !pChunk ) return false;
+                                return pChunk->pData[iPos] != c;
+                        }
+                        
+                        operator bool() const
+                        {
+                                return pChunk != NULL;
+                        }
+
+                        bool isValid() const
+                        {
+                                return pChunk != NULL;
+                        }
+
+                        bool compare( const const_iterator &c ) const
+                        {
+                                const_iterator a = *this;
+                                const_iterator b = c;
+                                if( a == b )
+                                        return true;
+                                for(; a && b; a++, b++ )
+                                {
+                                        if( *a != *b )
+                                                return false;
+                                }
+                                if( (bool)a != (bool)b )
+                                        return false;
+                                return true;
+                        }
+
+                        bool compare( const const_iterator &c, int nLen ) const
+                        {
+                                const_iterator a = *this;
+                                const_iterator b = c;
+                                if( a == b )
+                                        return true;
+                                for(int j = 0; j < nLen; a++, b++, j++ )
+                                {
+                                        if( !a || !b || *a != *b )
+                                                return false;
+                                }
+                                return true;
+                        }
+
+                        bool compare( const char *c ) const
+                        {
+                                if( !pChunk ) return false;
+                                const_iterator a = *this;
+                                for(; a && *c; a++, c++ )
+                                {
+                                        if( *a != *c )
+                                                return false;
+                                }
+                                if( a.isValid() != (*c!=(char)0) )
+                                        return false;
+                                return true;
+                        }
+
+                        bool compare( const char *c, int nLen ) const
+                        {
+                                if( !pChunk ) return false;
+                                const_iterator a = *this;
+                                int j = 0;
+                                for(; a && j < nLen; a++, c++, j++ )
+                                {
+                                        if( *a != *c )
+                                                return false;
+                                }
+                                if( j < nLen )
+                                        return false;
+                                return true;
+                        }
+
+                        bool compare( const String &s ) const
+                        {
+                                if( !pChunk ) return false;
+                                return compare( s.begin() );
+                        }
+
+                        bool compare( const String &s, int nLen ) const
+                        {
+                                if( !pChunk ) return false;
+                                return compare( s.begin(), nLen );
+                        }
+
+                        const_iterator find( const char c ) const
+                        {
+                                for( const_iterator i = *this; i; i++ )
+                                {
+                                        if( *i == c )
+                                                return i;
+                                }
+                                return const_iterator( NULL, 0 );
+                        }
+
+                        const_iterator find( const char *pStr, int nLen ) const
+                        {
+                                for( const_iterator i = *this; i; i++ )
+                                {
+                                        if( i.compare( pStr, nLen ) )
+                                                return i;
+                                }
+                                return const_iterator( NULL, 0 );
+                        }
+
+                        const_iterator find( const String &s ) const
+                        {
+                                for( const_iterator i = *this; i; i++ )
+                                {
+                                        if( i.compare( s ) )
+                                                return i;
+                                }
+                                return const_iterator( NULL, 0 );
+                        }
+
+                        const_iterator find( const String &s, int nLen ) const
+                        {
+                                for( const_iterator i = *this; i; i++ )
+                                {
+                                        if( i.compare( s, nLen ) )
+                                                return i;
+                                }
+                                return const_iterator( NULL, 0 );
+                        }
+                } const_iterator;
+                
+                typedef struct iterator
+                {
+                        friend class String;
+                        friend struct const_iterator;
+                private:
+                        iterator( Chunk *pChunk, int iPos ) :
+                                pChunk( pChunk ),
+                                iPos( iPos )
+                        {
+                        }
+
+                        Chunk *pChunk;
+                        int iPos;
+
+                public:
+                        iterator( const iterator &i ) :
+                                pChunk( i.pChunk ),
+                                iPos( i.iPos )
+                        {
+                        }
+
+                        iterator() :
+                                pChunk( NULL ),
+                                iPos( 0 )
+                        {
+                        }
+
+                        operator const_iterator() const
+                        {
+                                return const_iterator( pChunk, iPos );
+                        }
+
+                        bool operator==( const iterator &i ) const
+                        {
+                                return pChunk == i.pChunk && iPos == i.iPos;
+                        }
+
+                        bool operator!=( const iterator &i ) const
+                        {
+                                return !(*this == i);
+                        }
+
+                        iterator &operator=( const iterator &i )
+                        {
+                                pChunk = i.pChunk;
+                                iPos = i.iPos;
+                                return *this;
+                        }
+
+                        iterator &operator++()
+                        {
+                                if( !pChunk ) return *this;
+                                iPos++;
+                                if( iPos >= pChunk->nLength )
+                                {
+                                        iPos = 0;
+                                        pChunk = pChunk->pNext;
+                                }
+                                return *this;
+                        }
+
+                        iterator &operator++( int )
+                        {
+                                if( !pChunk ) return *this;
+                                iPos++;
+                                if( iPos >= pChunk->nLength )
+                                {
+                                        iPos = 0;
+                                        pChunk = pChunk->pNext;
+                                }
+                                return *this;
+                        }
+
+                        iterator &operator+=( int iAmnt )
+                        {
+                                if( !pChunk ) return *this;
+                                iPos += iAmnt;
+                                while( iPos >= pChunk->nLength )
+                                {
+                                        iPos -= pChunk->nLength;
+                                        pChunk = pChunk->pNext;
+                                        if( pChunk == NULL )
+                                                break;
+                                }
+                                return *this;
+                        }
+
+                        iterator operator+( int iAmnt ) const
+                        {
+                                if( !pChunk ) return *this;
+                                iterator ret( *this );
+                                ret += iAmnt;
+                                return ret;
+                        }
+
+                        char &operator*()
+                        {
+                                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
+                                return pChunk->pData[iPos];
+                        }
+
+                        const char &operator*() const
+                        {
+                                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
+                                return pChunk->pData[iPos];
+                        }
+
+                        bool operator==( const char &c ) const
+                        {
+                                if( !pChunk ) return false;
+                                return pChunk->pData[iPos] == c;
+                        }
+
+                        bool operator!=( const char &c ) const
+                        {
+                                if( !pChunk ) return false;
+                                return pChunk->pData[iPos] != c;
+                        }
+
+                        iterator &operator=( const char &c )
+                        {
+                                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
+                                pChunk->pData[iPos] = c;
+                                return *this;
+                        }
+
+                        operator bool() const
+                        {
+                                return pChunk != NULL;
+                        }
+
+                        bool isValid() const
+                        {
+                                return pChunk != NULL;
+                        }
+
+                        bool compare( const const_iterator &c ) const
+                        {
+                                const_iterator a( *this );
+                                const_iterator b = c;
+                                if( a == b )
+                                        return true;
+                                for(; a && b; a++, b++ )
+                                {
+                                        if( *a != *b )
+                                                return false;
+                                }
+                                if( (bool)a != (bool)b )
+                                        return false;
+                                return true;
+                        }
+
+                        bool compare( const const_iterator &c, int nLen ) const
+                        {
+                                const_iterator a( *this );
+                                const_iterator b = c;
+                                if( a == b )
+                                        return true;
+                                for(int j = 0; j < nLen; a++, b++, j++ )
+                                {
+                                        if( !a || !b || *a != *b )
+                                                return false;
+                                }
+                                return true;
+                        }
+
+                        bool compare( const char *c ) const
+                        {
+                                if( !pChunk ) return false;
+                                iterator a = *this;
+                                for(; a && *c; a++, c++ )
+                                {
+                                        if( *a != *c )
+                                                return false;
+                                }
+                                if( a.isValid() != (*c!=(char)0) )
+                                        return false;
+                                return true;
+                        }
+
+                        bool compare( const char *c, int nLen ) const
+                        {
+                                if( !pChunk ) return false;
+                                iterator a = *this;
+                                int j = 0;
+                                for(; a && j < nLen; a++, c++, j++ )
+                                {
+                                        if( *a != *c )
+                                                return false;
+                                }
+                                if( j < nLen )
+                                        return false;
+                                return true;
+                        }
+
+                        bool compare( const String &s ) const
+                        {
+                                if( !pChunk ) return false;
+                                return compare( s.begin() );
+                        }
+
+                        bool compare( const String &s, int nLen ) const
+                        {
+                                if( !pChunk ) return false;
+                                return compare( s.begin(), nLen );
+                        }
+
+                        iterator find( const char c ) const
+                        {
+                                for( iterator i = *this; i; i++ )
+                                {
+                                        if( *i == c )
+                                                return i;
+                                }
+                                return iterator( NULL, 0 );
+                        }
+
+                        iterator find( const char *pStr, int nLen ) const
+                        {
+                                for( iterator i = *this; i; i++ )
+                                {
+                                        if( i.compare( pStr, nLen ) )
+                                                return i;
+                                }
+                                return iterator( NULL, 0 );
+                        }
+
+                        iterator find( const String &s ) const
+                        {
+                                for( iterator i = *this; i; i++ )
+                                {
+                                        if( i.compare( s ) )
+                                                return i;
+                                }
+                                return iterator( NULL, 0 );
+                        }
+
+                        iterator find( const String &s, int nLen ) const
+                        {
+                                for( iterator i = *this; i; i++ )
+                                {
+                                        if( i.compare( s, nLen ) )
+                                                return i;
+                                }
+                                return iterator( NULL, 0 );
+                        }
+                } iterator;
+
+        public:
+                String();
+                String( const char *pData );
+                String( const char *pData, long nLength );
+                String( const String &rSrc );
+                String( const String &rSrc, long nLength );
+                String( const String &rSrc, long nStart, long nLength );
+                String( long nSize );
+                String( const const_iterator &s );
+                String( const const_iterator &s, const const_iterator &e );
+                virtual ~String();
+
+                /**
+                 * Append data to your string.
+                 *@param pData (const char *) The data to append.
+                 */
+                void append( const char *pData );
+
+                /**
+                 * Append data to your string.
+                 *@param pData (const char *) The data to append.
+                 *@param nLen (long) The length of the data to append.
+                 */
+                void append( const char *pData, long nLen );
+                
+                /**
+                 * Append data to your string.
+                 *@param pData (const char *) The data to append.
+                 *@param nStart (long) The start position to copy from.
+                 *@param nLen (long) The length of the data to append.
+                 */
+                void append( const char *pData, long nStart, long nLen );
+
+                /**
+                 * Append a single char to your string.
+                 *@param cData (const char &) The character to append.
+                 */
+                void append( const char &cData );
+
+                /**
+                 * Append another String to this one.
+                 *@param sData (String &) The String to append.
+                 *@todo This function can be made much faster by not using getStr()
+                 */
+                void append( const String & sData );
+                
+                /**
+                 * Append another String to this one.
+                 *@param sData (String &) The String to append.
+                 *@param nLen How much data to append.
+                 *@todo This function can be made much faster by not using getStr()
+                 */
+                void append( const String & sData, long nLen );
+                
+                /**
+                 * Append another String to this one.
+                 *@param sData (String &) The String to append.
+                 *@param nStart Start position in sData to start copying from.
+                 *@param nLen How much data to append.
+                 *@todo This function can be made much faster by not using getStr()
+                 */
+                void append( const String & sData, long nStart, long nLen );
+                
+                /**
+                 * Append data to this String using the passed in iterator as a base.
+                 * The iterator is const, it is not changed.
+                 *@param s Iterator from any compatible String to copy data from.
+                 */
+                void append( const const_iterator &s );
+
+                /**
+                 * Append data to this String using the passed in iterator as a base.
+                 * The iterator is const, it is not changed.
+                 *@param s Iterator from any compatible String to copy data from.
+                 */
+                void append( const iterator &s );
+
+                /**
+                 * Append data to this String using the passed in iterator as a base,
+                 * and copy data until the ending iterator is reached.  The character
+                 * at the ending iterator is not copied.
+                 * The iterators are const, they are not changed.
+                 *@param s Iterator from any compatible String to copy data from.
+                 *@param e Iterator to stop copying at.
+                 */
+                void append( const const_iterator &s, const const_iterator &e );
+                
+                /**
+                 * Prepend another String to this one.
+                 *@param sData (String &) The String to prepend.
+                 *@todo This function can be made much faster by not using getStr()
+                 */
+                void prepend( const String & sData );
+
+                /**
+                 * Prepend data to your string.
+                 *@param pData (const char *) The data to prepend.
+                 */
+                void prepend( const char *pData );
+
+                /**
+                 * Prepend data to your string.
+                 *@param pData (const char *) The data to prepend.
+                 *@param nLen (long) The length of the data to prepend.
+                 */
+                void prepend( const char *pData, long nLen );
+
+                void prepend( const char c );
+
+                /**
+                 * Insert pData before byte nPos, that is, the first byte of pData will
+                 * start at nPos.  This could probably be made faster by avoiding
+                 * flattening.
+                 */
+                void insert( long nPos, const char *pData, long nLen );
+
+                void insert( long nPos, const String &str );
+
+                /**
+                 *@todo This function shouldn't use strlen, we should add our own to
+                 * this class, one that can be overridden in a specific implementation.
+                 */
+                void insert( long nPos, const char *pData );
+
+                void remove( long nPos, long nLen );
+
+                /**
+                 * Clear all data from the string.
+                 */
+                void clear();
+
+                String replace( const String &fnd, const String &rep ) const;
+
+                /**
+                 * Force the string to resize
+                 *@param nNewSize (long) The new size of the string.
+                 */
+                void resize( long nNewSize );
+
+                /**
+                 * Get the current size of the string.
+                 *@returns (long) The current size of the string.
+                 */
+                long getSize() const;
+                
+                /**
+                 * Get a pointer to the string array.
+                 *@returns (char *) The string data.
+                 */
+                char *getStr();
+                
+                /**
+                 * Get a const pointer to the string array.
+                 *@returns (const char *) The string data.
+                 */
+                const char *getStr() const;
+
+                /**
+                 * A convinience function, this one won't cause as much work as the
+                 * non-const getStr, so if you're not changing the data, consider it.
+                 */
+                const char *getConstStr() const;
+
+                String getSubStrIdx( long iStart, long iSize=-1 ) const;
+
+                String getSubStr( const_iterator iBegin,
+                                const_iterator iEnd=String::const_iterator() ) const;
+
+                Bu::List<String> split( const char c ) const;
+
+                /**
+                 * Plus equals operator for String.
+                 *@param pData (const char *) The data to append to your String.
+                 */
+                String &operator+=( const char *pData );
+                
+                /**
+                 * Plus equals operator for String.
+                 *@param rSrc (const String &) The String to append to your String.
+                 */
+                String &operator+=( const String &rSrc );
+
+                String &operator+=( const String::const_iterator &i );
+
+                /**
+                 * Plus equals operator for String.
+                 *@param cData (const char) The character to append to your String.
+                 */
+                String &operator+=( const char cData );
+
+                /**
+                 * Assignment operator.
+                 *@param pData (const char *) The character array to append to your
+                 *              String.
+                 */
+                String &operator=( const char *pData );
+
+                String operator+( const String &rRight ) const;
+
+                String operator+( const char *pRight ) const;
+
+                String operator+( char *pRight ) const;
+
+                /**
+                 * Reset your String to this character array.
+                 *@param pData (const char *) The character array to set your String to.
+                 */
+                void set( const char *pData );
+
+                /**
+                 * Reset your String to this character array.
+                 *@param pData (const char *) The character array to set your String to.
+                 *@param nSize (long) The length of the inputted character array.
+                 */
+                void set( const char *pData, long nSize );
+
+                void set( const char *pData, long nStart, long nSize );
+                
+                void set( const String &rData );
+
+                void set( const String &rData, long nSize );
+
+                void set( const String &rData, long nStart, long nSize );
+
+                void set( const_iterator s );
+
+                void set( const_iterator s, const_iterator e );
+
+                /**
+                 * Resize the string, possibly to make room for a copy.  At the moment
+                 * this operation *is* destructive.  What was in the string will in no
+                 * way be preserved.  This is, however, very fast.  If you want to
+                 * keep your data check out resize.
+                 *@param iSize the new size in bytes.  The string is guranteed to have
+                 * at least this much contiguous space available when done.
+                 */
+                void setSize( long iSize );
+
+                /**
+                 * Equals comparison operator.
+                 *@param pData (const char *) The character array to compare your String
+                 *              to.
+                 */
+                bool operator==( const char *pData ) const;
+                
+                /**
+                 * Equals comparison operator.
+                 *@param pData (const String &) The String to compare your String to.
+                 */
+                bool operator==( const String &pData ) const;
+
+                /**
+                 * Not equals comparison operator.
+                 *@param pData (const char *) The character array to compare your String
+                 *              to.
+                 */
+                bool operator!=(const char *pData ) const;
+                
+                /**
+                 * Not equals comparison operator.
+                 *@param pData (const String &) The String to compare your String to.
+                 */
+                bool operator!=(const String &pData ) const;
+
+                bool operator<(const String &pData ) const;
+                
+                bool operator<=(const String &pData ) const;
+
+                bool operator>(const String &pData ) const;
+
+                bool operator>=(const String &pData ) const;
+
+                /**
+                 * Indexing operator
+                 *@param nIndex (long) The index of the character you want.
+                 *@returns (char &) The character at position (nIndex).
+                 */
+                char &operator[]( long nIndex );
+                
+                /**
+                 * Const indexing operator
+                 *@param nIndex (long) The index of the character you want.
+                 *@returns (const char &) The character at position (nIndex).
+                 */
+                const char &operator[]( long nIndex ) const;
+
+                bool isSet() const;
+
+                bool compareSub( const char *pData, long nIndex, long nLen ) const;
+
+                bool compareSub( const String &rData, long nIndex, long nLen ) const;
+                
+                /**
+                 * 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;
+
+                /**
+                 * 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;
+
+                /**
+                 * Convert your alpha characters to lower case.
+                 */
+                String toLower() const;
+
+                /**
+                 * Convert your alpha characters to upper case.
+                 */
+                String toUpper() const;
+
+                const_iterator find( const char cChar,
+                                const_iterator iStart=const_iterator() ) const;
+
+                const_iterator find( const char *sText, int nLen,
+                                const_iterator iStart=const_iterator() ) const;
+
+                const_iterator find( const String &rStr,
+                                const_iterator iStart=const_iterator() ) const;
+
+                const_iterator find( const String &rStr, int nLen,
+                                const_iterator iStart=const_iterator() ) const;
+
+                iterator find( const char cChar,
+                                const_iterator iStart=const_iterator() );
+
+                iterator find( const char *sText, int nLen,
+                                const_iterator iStart=const_iterator() );
+
+                iterator find( const String &rStr,
+                                const_iterator iStart=const_iterator() );
+
+                iterator find( const String &rStr, int nLen,
+                                const_iterator iStart=const_iterator() );
+
+                /**
+                 * Find the index of the first occurrance of cChar
+                 *@param cChar The character to search for.
+                 *@param iStart The position in the string to start searching from.
+                 *@returns (long) The index of the first occurrance. -1 for not found.
+                 */
+                long findIdx( const char cChar, long iStart=0 ) const;
+                
+                /**
+                 * Find the index of the first occurrance of sText
+                 *@param sText The null-terminated string to search for.
+                 *@param iStart The position in the string to start searching from.
+                 *@returns The index of the first occurrance. -1 for not found.
+                 */
+                long findIdx( const char *sText, long iStart=0 ) const;
+
+                /**
+                 * 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 rfindIdx( const char *sText ) const;
+
+                /**
+                 * 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 );
+
+                void trimBack( long iAmnt );
+
+                Bu::String trimWhitespace() const;
+                
+                iterator begin();
+
+                const_iterator begin() const;
+
+                iterator end();
+
+                const_iterator end() const;
+
+                bool isEmpty() const;
+
+        private:
+                void flatten() const;
+                bool isFlat() const;
+
+                class FormatProxy
+                {
+                public:
+                        FormatProxy( const String &rFmt );
+                        virtual ~FormatProxy();
+
+                        template<typename T>
+                        FormatProxy &arg( const T &x )
+                        {
+                                lArgs.append( Arg( x ) );
+
+                                return *this;
+                        }
+
+                        template<typename T>
+                        FormatProxy &arg( const T &x, const Bu::Fmt &f )
+                        {
+                                lArgs.append( Arg( x, f ) );
+
+                                return *this;
+                        }
+
+                        operator String() const;
+
+                private:
+                        const String &rFmt;
+                        class Arg
+                        {
+                        public:
+                                template<typename T>
+                                Arg( const T &v ) :
+                                        value( v )
+                                {
+                                }
+
+                                template<typename T>
+                                Arg( const T &v, const Bu::Fmt &f ) :
+                                        value( v ),
+                                        format( f )
+                                {
+                                }
+
+                                Bu::Variant value;
+                                Bu::Fmt format;
+                        };
+                        typedef Bu::List<Arg> ArgList;
+                        ArgList lArgs;
+                };
+
+        public:
+                template<typename ArgType>
+                FormatProxy arg( const ArgType &x )
+                {
+                        return FormatProxy( *this ).arg( x );
+                }
+
+                template<typename ArgType>
+                FormatProxy arg( const ArgType &x, const Bu::Fmt &f )
+                {
+                        return FormatProxy( *this ).arg( x, f );
+                }
+        };
+        
+        template<class T> String operator+( const T *pLeft, const String &rRight )
+        {
+                Bu::String ret( pLeft );
+                ret.append( rRight );
+                return ret;
+        }
+
+        ArchiveBase &operator<<( ArchiveBase &ar, const String &s );
+        ArchiveBase &operator>>( ArchiveBase &ar, String &s );
+
+        template<typename T>
+        uint32_t __calcHashCode( const T &k );
+
+        template<typename T>
+        bool __cmpHashKeys( const T &a, const T &b );
+
+        template<> uint32_t __calcHashCode<String>( const String &k );
+        template<> bool __cmpHashKeys<String>(
+                const String &a, const String &b );
+        
+        template<typename t> void __tracer_format( const t &v );
+        template<> void __tracer_format<String>( const String &v );
+
+        bool &operator<<( bool &dst, const String &sIn );
+        uint8_t &operator<<( uint8_t &dst, const String &sIn );
+        int8_t &operator<<( int8_t &dst, const String &sIn );
+        char &operator<<( char &dst, const String &sIn );
+        uint16_t &operator<<( uint16_t &dst, const String &sIn );
+        int16_t &operator<<( int16_t &dst, const String &sIn );
+        uint32_t &operator<<( uint32_t &dst, const String &sIn );
+        int32_t &operator<<( int32_t &dst, const String &sIn );
+        uint64_t &operator<<( uint64_t &dst, const String &sIn );
+        int64_t &operator<<( int64_t &dst, const String &sIn );
+        float &operator<<( float &dst, const String &sIn );
+        double &operator<<( double &dst, const String &sIn );
+        long double &operator<<( long double &dst, const String &sIn );
+        Bu::String &operator<<( Bu::String &dst, const String &sIn );
+
+        typedef Bu::List<String> StringList;
+};
+
+#endif
diff --git a/src/stable/substream.cpp b/src/stable/substream.cpp
new file mode 100644
index 0000000..c201752
--- /dev/null
+++ b/src/stable/substream.cpp
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/substream.h"
+
+Bu::SubStream::SubStream( Bu::Stream &rNext, Bu::size iSize ) :
+        Bu::Filter( rNext ),
+        iStart( 0 ),
+        iPos( 0 ),
+        iSize( iSize )
+{
+        iStart = rNext.tell();
+}
+
+Bu::SubStream::~SubStream()
+{
+}
+
+Bu::size Bu::SubStream::read( void *pBuf, Bu::size nBytes )
+{
+        if( (Bu::size)nBytes > iSize-iPos )
+                nBytes = iSize-iPos;
+        nBytes = rNext.read( pBuf, nBytes );
+        iPos += nBytes;
+        return nBytes;
+}
+
+Bu::size Bu::SubStream::write( const void *pBuf, Bu::size nBytes )
+{
+        if( (Bu::size)nBytes > iSize-iPos )
+                nBytes = iSize-iPos;
+        nBytes = rNext.write( pBuf, nBytes );
+        iPos += nBytes;
+        return nBytes;
+}
+
+void Bu::SubStream::start()
+{
+        // doesn't mean anything...
+}
+
+Bu::size Bu::SubStream::stop()
+{
+        // doesn't mean anything...
+        return 0;
+}
+
+void Bu::SubStream::close()
+{
+        // don't do anything?  maybe...
+}
+
+Bu::size Bu::SubStream::tell()
+{
+        return iPos;
+}
+
+void Bu::SubStream::seek( Bu::size offset )
+{
+        if( iPos+offset < 0 )
+                offset = -iPos;
+        else if( iPos+offset > iSize )
+                offset = iSize-iPos;
+        rNext.seek( offset );
+        iPos += offset;
+}
+
+void Bu::SubStream::setPos( Bu::size pos )
+{
+        if( pos < 0 )
+                pos = 0;
+        else if( pos > iSize )
+                pos = iSize;
+        iPos = pos;
+        pos += iStart;
+        rNext.setPos( pos );
+}
+
+void Bu::SubStream::setPosEnd( Bu::size pos )
+{
+        if( iSize-pos < 0 )
+                pos = 0;
+        else if( iSize-pos > iSize )
+                pos = iSize;
+        else
+                pos = iSize-pos;
+        iPos = pos;
+        rNext.setPos( iStart+pos );
+}
+
+bool Bu::SubStream::isEos()
+{
+        return rNext.isEos() || iPos == iSize;
+}
+
+bool Bu::SubStream::canRead()
+{
+        return rNext.canRead() && (iPos < iSize);
+}
+
+bool Bu::SubStream::canWrite()
+{
+        return rNext.canWrite() && (iPos < iSize);
+}
+
diff --git a/src/stable/substream.h b/src/stable/substream.h
new file mode 100644
index 0000000..1db4d6c
--- /dev/null
+++ b/src/stable/substream.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_SUB_STREAM_H
+#define BU_SUB_STREAM_H
+
+#include "bu/filter.h"
+
+namespace Bu
+{
+        /**
+         * Creates a sub-stream of a given stream.  This allows you to read and
+         * write safely to a section of another stream, keeping all data within
+         * the given bounds.  The substream acts exactly like a top level stream
+         * when you reach the bounds of either the containing stream or the
+         * artificial bounds of the substream, except that unlike many stream types,
+         * when writing you cannot move beyond the bounds of the substream.  Reads,
+         * on the other hand, work exactly the same way, returning less data than
+         * requested when the end of the stream is reached.
+         *
+         * The substream always begins at the current position in the base stream,
+         * if you would like to skip some data first, simply seek.
+         *
+         * The substream class is safe to use with all blocking and non-blocking
+         * base streams, including sockets, however it can have unpredictable
+         * results when used on a buffering stream that may read more data than
+         * requested in order to complete a request such as the buffer or bzip2
+         * filters.
+         */
+        class SubStream : public Bu::Filter
+        {
+        public:
+                SubStream( Bu::Stream &rNext, Bu::size iSize );
+                virtual ~SubStream();
+
+                virtual Bu::size read( void *pBuf, Bu::size nBytes );
+                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+                using Bu::Stream::write;
+
+                virtual void start();
+                virtual Bu::size stop();
+                virtual void close();
+                virtual Bu::size tell();
+                virtual void seek( Bu::size offset );
+                virtual void setPos( Bu::size pos );
+                virtual void setPosEnd( Bu::size pos );
+                virtual bool isEos();
+
+                virtual bool canRead();
+                virtual bool canWrite();
+
+        protected:
+                Bu::size iStart;
+                Bu::size iPos;
+                Bu::size iSize;
+        };
+};
+
+#endif
diff --git a/src/stable/synchroatom.h b/src/stable/synchroatom.h
new file mode 100644
index 0000000..fb02054
--- /dev/null
+++ b/src/stable/synchroatom.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_SYNCHRO_ATOM_H
+#define BU_SYNCHRO_ATOM_H
+
+#include <pthread.h>
+
+#include "bu/mutex.h"
+
+namespace Bu
+{
+        /**
+         * A thread-safe wrapper class.
+         *@ingroup Threading
+         */
+        template <class T>
+        class SynchroAtom
+        {
+        public:
+                /**
+                 * Construct an empty queue.
+                 */
+                SynchroAtom()
+                {
+                }
+
+                SynchroAtom( const T &src ) :
+                        data( src )
+                {
+                }
+                
+                ~SynchroAtom()
+                {
+                }
+
+                T get()
+                {
+                        mOperate.lock();
+                        T ret = data;
+                        mOperate.unlock();
+                        return ret;
+                }
+
+                void set( const T &val )
+                {
+                        mOperate.lock();
+                        data = val;
+                        mOperate.unlock();
+                }
+
+        private:
+                T data;
+
+                Mutex mOperate; /**< The master mutex, used on all operations. */
+        };
+};
+
+#endif
diff --git a/src/stable/synchrocounter.cpp b/src/stable/synchrocounter.cpp
new file mode 100644
index 0000000..48bbe21
--- /dev/null
+++ b/src/stable/synchrocounter.cpp
@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/synchrocounter.h"
diff --git a/src/stable/synchrocounter.h b/src/stable/synchrocounter.h
new file mode 100644
index 0000000..d201bee
--- /dev/null
+++ b/src/stable/synchrocounter.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_SYNCHRO_COUNTER_H
+#define BU_SYNCHRO_COUNTER_H
+
+#include "bu/mutex.h"
+
+namespace Bu
+{
+        /**
+         * A simple thread-safe counter class.  This is handy for assigning unique
+         * IDs to objects that are being created in different threads.
+         *@ingroup Threading Containers
+         */
+        template <class T>
+        class SynchroCounter
+        {
+        public:
+                SynchroCounter() :
+                        tCounter( 0 )
+                {
+                }
+                
+                virtual ~SynchroCounter()
+                {
+                }
+
+                T next()
+                {
+                        mOperate.lock();
+                        T tRet = tCounter;
+                        tCounter++;
+                        mOperate.unlock();
+
+                        return tRet;
+                }
+
+        private:
+                T tCounter;                             /**< The counter itself. */
+                Mutex mOperate; /**< The master mutex, used on all operations. */
+        };
+}
+
+#endif
diff --git a/src/stable/synchroheap.cpp b/src/stable/synchroheap.cpp
new file mode 100644
index 0000000..5dcce33
--- /dev/null
+++ b/src/stable/synchroheap.cpp
@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/synchroheap.h"
+
diff --git a/src/stable/synchroheap.h b/src/stable/synchroheap.h
new file mode 100644
index 0000000..4dd898d
--- /dev/null
+++ b/src/stable/synchroheap.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_SYNCHRO_HEAP_H
+#define BU_SYNCHRO_HEAP_H
+
+#include "bu/heap.h"
+#include "bu/mutex.h"
+#include "bu/condition.h"
+
+namespace Bu
+{
+        template<typename item, typename cmpfunc=__basicLTCmp<item>,
+                typename itemalloc=std::allocator<item> >
+        class SynchroHeap
+        {
+        public:
+                SynchroHeap()
+                {
+                }
+
+                virtual ~SynchroHeap()
+                {
+                }
+
+                void enqueue( item i )
+                {
+                        imData.lock();
+                        hData.enqueue( i );
+                        icBlock.signal();
+                        imData.unlock();
+                }
+
+                item dequeue( bool bBlock=false )
+                {
+                        imData.lock();
+                        if( hData.isEmpty() )
+                        {
+                                imData.unlock();
+
+                                if( bBlock )
+                                {
+                                        icBlock.lock();
+
+                                        while( hData.isEmpty() )
+                                                icBlock.wait();
+
+                                        imData.lock();
+                                        try
+                                        {
+                                                item iRet = hData.dequeue();
+                                                imData.unlock();
+                                                icBlock.unlock();
+                                                return iRet;
+                                        }
+                                        catch(...)
+                                        {
+                                                imData.unlock();
+                                                icBlock.unlock();
+                                                throw;
+                                        }
+                                }
+                                throw HeapException("Heap empty.");
+                        }
+                        else
+                        {
+                                try
+                                {
+                                        item iRet = hData.dequeue();
+                                        imData.unlock();
+                                        return iRet;
+                                }
+                                catch(...)
+                                {
+                                        imData.unlock();
+                                        throw;
+                                }
+                        }
+                }
+
+                item dequeue( int iSec, int iUSec )
+                {
+                        imData.lock();
+                        if( hData.isEmpty() )
+                        {
+                                imData.unlock();
+
+                                icBlock.lock();
+
+                                icBlock.wait( iSec, iUSec );
+
+                                imData.lock();
+                                try
+                                {
+                                        item iRet = hData.dequeue();
+                                        imData.unlock();
+                                        icBlock.unlock();
+                                        return iRet;
+                                }
+                                catch(...)
+                                {
+                                        imData.unlock();
+                                        icBlock.unlock();
+                                        throw;
+                                }
+                        }
+                        else
+                        {
+                                try
+                                {
+                                        item iRet = hData.dequeue();
+                                        imData.unlock();
+                                        return iRet;
+                                }
+                                catch(...)
+                                {
+                                        imData.unlock();
+                                        throw;
+                                }
+                        }
+                }
+                
+                bool isEmpty()
+                {
+                        imData.lock();
+                        bool bRet = hData.isEmpty();
+                        imData.unlock();
+                        return bRet;
+                }
+
+                int getSize()
+                {
+                        imData.lock();
+                        int iRet = hData.getSize();
+                        imData.unlock();
+                        return iRet;
+                }
+
+        private:
+                Heap< item, cmpfunc, itemalloc > hData;
+                Mutex imData;
+                Condition icBlock;
+        };
+};
+
+#endif
+
diff --git a/src/stable/synchroqueue.h b/src/stable/synchroqueue.h
new file mode 100644
index 0000000..79d5e49
--- /dev/null
+++ b/src/stable/synchroqueue.h
@@ -0,0 +1,240 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_SYNCHRO_QUEUE_H
+#define BU_SYNCHRO_QUEUE_H
+
+#include <pthread.h>
+
+#include "bu/mutex.h"
+#include "bu/condition.h"
+
+namespace Bu
+{
+        /**
+         * A thread-safe queue class.  This class is a very simple queue with some
+         * cool extra functionality for use with the Synchro 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.
+         *@ingroup Threading Containers
+         */
+        template <class T>
+        class SynchroQueue
+        {
+        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.
+                 */
+                SynchroQueue() :
+                        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!
+                 */
+                ~SynchroQueue()
+                {
+                        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. */
+
+                Mutex mOperate; /**< The master mutex, used on all operations. */
+                Condition cBlock;       /**< The condition for blocking dequeues. */
+        };
+}
+
+#endif
diff --git a/src/stable/taf.h b/src/stable/taf.h
new file mode 100644
index 0000000..951f80f
--- /dev/null
+++ b/src/stable/taf.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+//
+// There's no protection on this file, it just includes other files.
+//
+
+#include "bu/tafnode.h"
+#include "bu/tafgroup.h"
+#include "bu/tafproperty.h"
+#include "bu/tafcomment.h"
+#include "bu/tafreader.h"
+#include "bu/tafwriter.h"
+
diff --git a/src/stable/tafcomment.cpp b/src/stable/tafcomment.cpp
new file mode 100644
index 0000000..c7096ca
--- /dev/null
+++ b/src/stable/tafcomment.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/tafcomment.h"
+
+Bu::TafComment::TafComment( const Bu::TafComment &rSrc ) :
+        TafNode( typeComment ),
+        sText( rSrc.sText ),
+        bEOL( rSrc.bEOL )
+{
+}
+
+Bu::TafComment::TafComment( const Bu::String &sText, bool bEOL ) :
+        TafNode( typeComment ),
+        sText( sText ),
+        bEOL( bEOL )
+{
+}
+
+Bu::TafComment::~TafComment()
+{
+}
+
+const Bu::String &Bu::TafComment::getText() const
+{
+        return sText;
+}
+
+bool Bu::TafComment::isEOLStyle() const
+{
+        return bEOL;
+}
+
diff --git a/src/stable/tafcomment.h b/src/stable/tafcomment.h
new file mode 100644
index 0000000..4efd548
--- /dev/null
+++ b/src/stable/tafcomment.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_TAF_COMMENT_H
+#define BU_TAF_COMMENT_H
+
+#include <stdint.h>
+#include "bu/tafnode.h"
+
+namespace Bu
+{
+        /**
+         *
+         *@ingroup Taf
+         */
+        class TafComment : public TafNode
+        {
+        public:
+                TafComment( const Bu::TafComment &rSrc );
+                TafComment( const Bu::String &sText, bool bEOL=false );
+                virtual ~TafComment();
+
+                const Bu::String &getText() const;
+                bool isEOLStyle() const;
+
+        private:
+                Bu::String sText;
+                bool bEOL;
+        };
+}
+
+#endif
diff --git a/src/stable/tafgroup.cpp b/src/stable/tafgroup.cpp
new file mode 100644
index 0000000..ee180c3
--- /dev/null
+++ b/src/stable/tafgroup.cpp
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/tafgroup.h"
+#include "bu/tafproperty.h"
+#include "bu/tafcomment.h"
+
+Bu::TafGroup::TafGroup( const TafGroup &rSrc ) :
+        TafNode( typeGroup ),
+        sName( rSrc.sName )
+{
+        for( NodeList::const_iterator i = rSrc.lChildren.begin(); i; i++ )
+        {
+                switch( (*i)->getType() )
+                {
+                        case typeGroup:
+                                addChild( new TafGroup( *dynamic_cast<const TafGroup *>(*i) ) );
+                                break;
+
+                        case typeProperty:
+                                addChild( new TafProperty( *dynamic_cast<const TafProperty *>(*i) ) );
+                                break;
+
+                        case typeComment:
+                                addChild( new TafComment( *dynamic_cast<const TafComment *>(*i) ) );
+                                break;
+                }
+        }
+}
+
+Bu::TafGroup::TafGroup( const Bu::String &sName ) :
+        TafNode( typeGroup ),
+        sName( sName )
+{
+}
+
+Bu::TafGroup::~TafGroup()
+{
+        for( NodeList::iterator i = lChildren.begin(); i != lChildren.end(); i++ )
+        {
+                delete (*i);
+        }
+}
+
+const Bu::String &Bu::TafGroup::getName() const
+{
+        return sName;
+}
+
+void Bu::TafGroup::setName( const Bu::String &sName )
+{
+        this->sName = 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;
+}
+
+Bu::TafGroup *Bu::TafGroup::addGroup( const Bu::String &sName )
+{
+        return addChild( new TafGroup( sName ) );
+}
+
+Bu::TafProperty *Bu::TafGroup::addProperty(
+        const Bu::String &sName, const Bu::String &sValue )
+{
+        return addChild( new TafProperty( sName, sValue ) );
+}
+
+bool Bu::TafGroup::hasChild( const Bu::String &sName ) const
+{
+        return hChildren.has( sName );
+}
+
+const Bu::TafGroup::GroupList &Bu::TafGroup::getChildren( const Bu::String &sName ) const
+{
+        try {
+                return hChildren.get( sName );
+        } catch( Bu::HashException &e )
+        {
+                throw Bu::TafException("No children of group \"%s\" match \"%s\".",
+                        this->sName.getStr(), sName.getStr() );
+        }
+}
+
+const Bu::TafGroup::NodeList &Bu::TafGroup::getChildren() const
+{
+        return lChildren;
+}
+
+const Bu::TafGroup *Bu::TafGroup::getChild( const Bu::String &sName ) const
+{
+        try {
+                return hChildren.get( sName ).first();
+        } catch( Bu::HashException &e )
+        {
+                throw Bu::TafException("No children of group \"%s\" match \"%s\".",
+                        this->sName.getStr(), sName.getStr() );
+        }
+}
+
+bool Bu::TafGroup::hasProperty( const Bu::String &sName ) const
+{
+        return hProp.has( sName );
+}
+
+const Bu::TafGroup::PropList &Bu::TafGroup::getProperties( const Bu::String &sName ) const
+{
+        try {
+                return hProp.get( sName );
+        } catch( Bu::HashException &e )
+        {
+                throw Bu::TafException("No properties of group \"%s\" match \"%s\".",
+                        this->sName.getStr(), sName.getStr() );
+        }
+}
+
+const Bu::String &Bu::TafGroup::getProperty( const Bu::String &sName ) const
+{
+        try {
+                return hProp.get( sName ).first();
+        } catch( Bu::HashException &e )
+        {
+                throw Bu::TafException("No properties of group \"%s\" match \"%s\".",
+                        this->sName.getStr(), sName.getStr() );
+        }       
+}
+
+const Bu::String &Bu::TafGroup::getProperty( const Bu::String &sName,
+        const Bu::String &sDef ) const
+{
+        try
+        {
+                return hProp.get( sName ).first();
+        }
+        catch( Bu::HashException &e )
+        {
+                return sDef;
+        }
+}
+
+const Bu::TafGroup *Bu::TafGroup::getChildByPath(
+                const Bu::String &sPath ) const
+{
+        return getChildByPath( sPath.split('/') );
+}
+
+const Bu::TafGroup *Bu::TafGroup::getChildByPath( Bu::StrList lPath ) const
+{
+        const Bu::TafGroup *cur = this;
+
+        for( Bu::StrList::const_iterator i = lPath.begin(); i; i++ )
+        {
+                cur = cur->getChild( *i );
+        }
+
+        return cur;
+}
+
+const Bu::String &Bu::TafGroup::getByPath( const Bu::String &sPath ) const
+{
+        return getByPath( sPath.split('/') );
+}
+
+const Bu::String &Bu::TafGroup::getByPath( Bu::StrList lPath ) const
+{
+        const Bu::TafGroup *cur = this;
+
+        for( Bu::StrList::const_iterator i = lPath.begin(); i; i++ )
+        {
+                if( !(i+1) )
+                        break;
+                cur = cur->getChild( *i );
+        }
+
+        return cur->getProperty( lPath.last() );
+}
+
diff --git a/src/stable/tafgroup.h b/src/stable/tafgroup.h
new file mode 100644
index 0000000..119e827
--- /dev/null
+++ b/src/stable/tafgroup.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_TAF_GROUP_H
+#define BU_TAF_GROUP_H
+
+#include <stdint.h>
+#include "bu/tafnode.h"
+#include "bu/string.h"
+#include "bu/hash.h"
+#include "bu/list.h"
+
+namespace Bu
+{
+        typedef Bu::List<Bu::String> StrList;
+        class TafProperty;
+        class TafComment;
+        /**
+         *
+         *@ingroup Taf
+         */
+        class TafGroup : public TafNode
+        {
+        public:
+                typedef Bu::List<Bu::String> PropList;
+                typedef Bu::Hash<Bu::String, PropList> PropHash;
+                typedef Bu::List<class Bu::TafGroup *> GroupList;
+                typedef Bu::Hash<Bu::String, GroupList> GroupHash;
+                typedef Bu::List<class Bu::TafNode *> NodeList;
+
+                TafGroup( const TafGroup &rSrc );
+                TafGroup( const Bu::String &sName );
+                virtual ~TafGroup();
+
+                const Bu::String &getName() const;
+                void setName( const Bu::String &sName );
+
+                bool hasProperty( const Bu::String &sName ) const;
+                const Bu::String &getProperty( const Bu::String &sName ) const;
+                const Bu::String &getProperty( const Bu::String &sName,
+                        const Bu::String &sDef ) const;
+                const PropList &getProperties( const Bu::String &sName ) const;
+                bool hasChild( const Bu::String &sName ) const;
+                const TafGroup *getChild( const Bu::String &sName ) const;
+                const GroupList &getChildren( const Bu::String &sName ) const;
+                TafNode *addChild( TafNode *pNode );
+                TafGroup *addChild( TafGroup *pNode );
+                TafProperty *addChild( TafProperty *pNode );
+                TafComment *addChild( TafComment *pNode );
+                TafGroup *addGroup( const Bu::String &sName );
+                TafProperty *addProperty(
+                        const Bu::String &sName, const Bu::String &sValue );
+                const NodeList &getChildren() const;
+                const TafGroup *getChildByPath( const Bu::String &sPath ) const;
+                const TafGroup *getChildByPath( StrList lPath ) const;
+                const Bu::String &getByPath( const Bu::String &sPath ) const;
+                const Bu::String &getByPath( StrList lPath ) const;
+
+        private:
+                Bu::String sName;
+                PropHash hProp;
+                GroupHash hChildren;
+                NodeList lChildren;
+        };
+}
+
+#endif
diff --git a/src/stable/tafnode.cpp b/src/stable/tafnode.cpp
new file mode 100644
index 0000000..0757a46
--- /dev/null
+++ b/src/stable/tafnode.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/tafnode.h"
+
+namespace Bu { subExceptionDef( TafException ) }
+
+Bu::TafNode::TafNode( NodeType eType ) :
+        eType( eType )
+{
+}
+
+Bu::TafNode::~TafNode()
+{
+}
+
+Bu::TafNode::NodeType Bu::TafNode::getType() const
+{
+        return eType;
+}
+
diff --git a/src/stable/tafnode.h b/src/stable/tafnode.h
new file mode 100644
index 0000000..d7a9159
--- /dev/null
+++ b/src/stable/tafnode.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_TAF_NODE_H
+#define BU_TAF_NODE_H
+
+#include <stdint.h>
+#include "bu/string.h"
+#include "bu/hash.h"
+#include "bu/exceptionbase.h"
+
+namespace Bu
+{
+        subExceptionDecl( TafException );
+        /**
+         *
+         *@ingroup Taf
+         */
+        class TafNode
+        {
+        public:
+                enum NodeType
+                {
+                        typeGroup,
+                        typeProperty,
+                        typeComment
+                };
+
+        public:
+                TafNode( NodeType eType );
+                virtual ~TafNode();
+
+                NodeType getType() const;
+
+        private:
+                NodeType eType;
+        };
+}
+
+#endif
diff --git a/src/stable/tafproperty.cpp b/src/stable/tafproperty.cpp
new file mode 100644
index 0000000..4ef5c24
--- /dev/null
+++ b/src/stable/tafproperty.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/tafproperty.h"
+
+Bu::TafProperty::TafProperty( const Bu::TafProperty &rSrc ) :
+        TafNode( typeProperty ),
+        sName( rSrc.sName ),
+        sValue( rSrc.sValue )
+{
+}
+
+Bu::TafProperty::TafProperty( const Bu::String &sName, const Bu::String &sValue ) :
+        TafNode( typeProperty ),
+        sName( sName ),
+        sValue( sValue )
+{
+}
+
+Bu::TafProperty::~TafProperty()
+{
+}
+
+const Bu::String &Bu::TafProperty::getName() const
+{
+        return sName;
+}
+
+const Bu::String &Bu::TafProperty::getValue() const
+{
+        return sValue;
+}
+
diff --git a/src/stable/tafproperty.h b/src/stable/tafproperty.h
new file mode 100644
index 0000000..7091de5
--- /dev/null
+++ b/src/stable/tafproperty.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_TAF_PROPERTY_H
+#define BU_TAF_PROPERTY_H
+
+#include <stdint.h>
+#include "bu/tafnode.h"
+
+namespace Bu
+{
+        /**
+         *
+         *@ingroup Taf
+         */
+        class TafProperty : public TafNode
+        {
+        public:
+                TafProperty( const Bu::TafProperty &rSrc );
+                TafProperty( const Bu::String &sName, const Bu::String &sValue );
+                virtual ~TafProperty();
+
+                const Bu::String &getName() const;
+                const Bu::String &getValue() const;
+
+        private:
+                Bu::String sName;
+                Bu::String sValue;
+        };
+}
+
+#endif
diff --git a/src/stable/tafreader.cpp b/src/stable/tafreader.cpp
new file mode 100644
index 0000000..6708c8c
--- /dev/null
+++ b/src/stable/tafreader.cpp
@@ -0,0 +1,252 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/taf.h"
+#include "bu/string.h"
+#include "bu/stream.h"
+
+#include <stdlib.h>
+
+using namespace Bu;
+
+Bu::TafReader::TafReader( Bu::Stream &sIn ) :
+        c( 0 ),
+        la( 0 ),
+        sIn( sIn ),
+        iLine( 1 ), iCol( -1 )
+{
+        next(); next();
+}
+
+Bu::TafReader::~TafReader()
+{
+
+}
+
+Bu::TafGroup *Bu::TafReader::readGroup()
+{
+        ws();
+        if( c != '{' )
+                throw TafException("%d:%d: Expected '{' got '%c'.", iLine, iCol, c );
+        next();
+        ws();
+        String sName = readStr();
+        TafGroup *pGroup = new TafGroup( sName );
+        try
+        {
+                ws();
+                if( c != ':' )
+                        throw TafException("%d:%d: Expected ':' got '%c'.",
+                                iLine, iCol, c );
+                next();
+                //printf("Node[%s]:\n", sName.getStr() );
+
+                groupContent( pGroup );
+
+                if( c != '}' )
+                        throw TafException("%d:%d: Expected '}' got '%c'.",
+                                iLine, iCol, c );
+
+                //next();
+
+                return pGroup;
+        }
+        catch(...)
+        {
+                delete pGroup;
+                throw;
+        }
+}
+
+void Bu::TafReader::groupContent( Bu::TafGroup *pGroup )
+{
+        for(;;)
+        {
+                ws();
+                if( c == '{' )
+                {
+                        pGroup->addChild( readGroup() );
+                        next();
+                }
+                else if( c == '}' )
+                        return;
+                else if( c == '/' && la == '*' )
+                        pGroup->addChild( readComment() );
+                else if( c == '/' && la == '/' )
+                        pGroup->addChild( readComment( true ) );
+                else if( c == ':' )
+                        throw TafException("%d:%d: Encountered stray ':' in taf stream.",
+                                iLine, iCol );
+                else
+                        pGroup->addChild( readProperty() );
+        }
+}
+
+Bu::TafProperty *Bu::TafReader::readProperty()
+{
+        String sName = readStr();
+        ws();
+        if( c != '=' )
+        {
+                //printf("  %s (true)\n", sName.getStr() );
+                return new Bu::TafProperty( "", sName );
+        }
+        next();
+        String sValue = readStr();
+        return new Bu::TafProperty( sName, sValue );
+        //printf("  %s = %s\n", sName.getStr(), sValue.getStr() );
+}
+
+Bu::TafComment *Bu::TafReader::readComment( bool bEOL )
+{
+        String sCmnt;
+        next();
+        if( bEOL )
+        {
+                for(;;)
+                {
+                        next();
+                        if( c == '\n' && la == '\r' )
+                        {
+                                next(); next();
+                                break;
+                        }
+                        else if( c == '\n' || c == '\r' )
+                        {
+                                next();
+                                break;
+                        }
+                        sCmnt += c;
+                }
+        }
+        else
+        {
+                for(;;)
+                {
+                        next();
+                        if( c == '*' && la == '/' )
+                        {
+                                next(); next();
+                                break;
+                        }
+                        sCmnt += c;
+                }
+        }
+
+        return new TafComment( sCmnt, bEOL );
+}
+
+Bu::String Bu::TafReader::readStr()
+{
+        ws();
+        String 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 if( c == '\\' )
+                                        c = '\\';
+                                else if( c == 'n' )
+                                        c = '\n';
+                                else if( c == 't' )
+                                        c = '\t';
+                                else
+                                        throw TafException("%d:%d: Invalid escape sequence '\\%c'.",
+                                                iLine, iCol, c );
+                        }
+                        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()
+{
+        if( c == '\n' )
+        {
+                iLine++;
+                iCol = 1;
+        }
+        else
+                iCol++;
+        if( c == '}' )
+        {
+                rawread( &c );
+                if( c != '}' )
+                        rawread( &la );
+        }
+        else
+        {
+                c = la;
+                if( c != '}' )
+                        rawread( &la );
+        }
+}
+
+void Bu::TafReader::rawread( char *c )
+{
+        if( sIn.read( c, 1 ) < 1 )
+        {
+                if( sIn.isEos() )
+                {
+                        throw TafException("%d:%d: Premature end of stream.",
+                                iLine, iCol, c );
+                }
+                else
+                {
+                        throw TafException("%d:%d: No data read, but not end of stream?",
+                                iLine, iCol, c );
+                }
+        }
+}
+
diff --git a/src/stable/tafreader.h b/src/stable/tafreader.h
new file mode 100644
index 0000000..10ebfc0
--- /dev/null
+++ b/src/stable/tafreader.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_TAF_READER_H
+#define BU_TAF_READER_H
+
+#include <stdint.h>
+#include "bu/string.h"
+
+namespace Bu
+{
+        class TafNode;
+        class TafGroup;
+        class TafProperty;
+        class TafComment;
+        class Stream;
+
+        /**
+         *
+         *@ingroup Taf
+         */
+        class TafReader
+        {
+        public:
+                TafReader( Bu::Stream &sIn );
+                virtual ~TafReader();
+
+                Bu::TafGroup *readGroup();
+
+        private:
+                void groupContent( Bu::TafGroup *pNode );
+                Bu::TafProperty *readProperty();
+                Bu::TafComment *readComment( bool bEOL=false );
+                void ws();
+                bool isws();
+                void next();
+                Bu::String readStr();
+                void rawread( char *c );
+                char c, la;
+                Bu::Stream &sIn;
+                int iLine, iCol;
+        };
+}
+
+#endif
diff --git a/src/stable/tafwriter.cpp b/src/stable/tafwriter.cpp
new file mode 100644
index 0000000..b24bd1e
--- /dev/null
+++ b/src/stable/tafwriter.cpp
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/taf.h"
+#include "bu/stream.h"
+
+Bu::TafWriter::TafWriter( Bu::Stream &sOut ) :
+        sOut( sOut ),
+        iDepth( 0 )
+{
+}
+
+Bu::TafWriter::~TafWriter()
+{
+}
+
+void Bu::TafWriter::ident()
+{
+        for( int j = 0; j < iDepth; j++ )
+                sOut.write("    ", 4 );
+}
+
+void Bu::TafWriter::writeGroup( const Bu::TafGroup *pRoot )
+{
+        ident();
+        sOut.write("{", 1 );
+        if( pRoot->getName().isSet() )
+                writeString( pRoot->getName() );
+        sOut.write(":\n", 2 );
+        iDepth++;
+        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;
+                }
+        }
+        iDepth--;
+        ident();
+        sOut.write("}\n", 2 );
+}
+
+void Bu::TafWriter::writeProperty( const Bu::TafProperty *pProp )
+{
+        ident();
+        if( !pProp->getName().isEmpty() )
+        {
+                writeString( pProp->getName() );
+                sOut.write("=", 1 );
+                writeString( pProp->getValue() );
+        }
+        else
+        {
+                writeString( pProp->getValue() );
+        }
+        sOut.write("\n", 1 );
+}
+
+void Bu::TafWriter::writeComment( const Bu::TafComment *pComment )
+{
+        ident();
+        if( pComment->isEOLStyle() )
+        {
+                sOut.write("//", 2 );
+                sOut.write( pComment->getText().getStr(), pComment->getText().getSize() );
+                sOut.write("\n", 1 );
+        }
+        else
+        {
+                sOut.write("/*", 2 );
+                sOut.write( pComment->getText().getStr(), pComment->getText().getSize() );
+                sOut.write("*/ ", 3 );
+        }
+}
+
+void Bu::TafWriter::writeString( const Bu::String &str )
+{
+        sOut.write("\"", 1 );
+        for( Bu::String::const_iterator s = str.begin(); s != str.end(); s++ )
+        {
+                if( *s == '\"' )
+                        sOut.write("\\\"", 2 );
+                else if( *s == '\\' )
+                        sOut.write("\\\\", 2 );
+                else if( *s < 32 || *s > 126 )
+                {
+                        char buf[5];
+                        sprintf( buf, "\\x%02X", (unsigned char)*s );
+                        sOut.write(buf, 4 );
+                }
+                else
+                {
+                        const char buf = *s;
+                        sOut.write( &buf, 1 );
+                }
+        }
+        sOut.write("\"", 1 );
+}
+
diff --git a/src/stable/tafwriter.h b/src/stable/tafwriter.h
new file mode 100644
index 0000000..3fd71de
--- /dev/null
+++ b/src/stable/tafwriter.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_TAF_WRITER_H
+#define BU_TAF_WRITER_H
+
+#include <stdint.h>
+
+#include "bu/string.h"
+
+namespace Bu
+{
+        class Stream;
+        class TafNode;
+        class TafGroup;
+        class TafProperty;
+        class TafComment;
+
+        /**
+         *
+         *@ingroup Taf
+         */
+        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::String &str );
+                void ident();
+                Bu::Stream &sOut;
+                int iDepth;
+        };
+}
+
+#endif
diff --git a/src/stable/tcpserversocket.cpp b/src/stable/tcpserversocket.cpp
new file mode 100644
index 0000000..a2fe6b4
--- /dev/null
+++ b/src/stable/tcpserversocket.cpp
@@ -0,0 +1,249 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef WIN32
+ #include <sys/socket.h>
+ #include <netinet/in.h>
+ #include <netdb.h>
+ #include <arpa/inet.h>
+#endif
+
+#include <time.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+//#include <termios.h>
+#include <fcntl.h>
+#include "bu/tcpserversocket.h"
+
+#include "bu/config.h"
+
+namespace Bu { subExceptionDef( TcpServerSocketException ) }
+
+Bu::TcpServerSocket::TcpServerSocket( int nPort, int nPoolSize ) :
+        nPort( nPort )
+{
+#ifdef WIN32
+        Bu::Winsock2::getInstance();
+#endif
+        
+        /* 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 = bu_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 = bu_htonl( INADDR_ANY );
+
+        startServer( name, nPoolSize );
+}
+
+Bu::TcpServerSocket::TcpServerSocket(const String &sAddr,int nPort, int nPoolSize) :
+        nPort( nPort )
+{
+#ifdef WIN32
+        Bu::Winsock2::getInstance();
+#endif
+
+        /* 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 = bu_htons( nPort );
+
+#ifdef WIN32
+        name.sin_addr.s_addr = bu_inet_addr( sAddr.getStr() );
+#else
+        inet_aton( sAddr.getStr(), &name.sin_addr );
+#endif
+
+        startServer( name, nPoolSize );
+}
+
+Bu::TcpServerSocket::TcpServerSocket( int nServer, bool bInit, int nPoolSize ) :
+        nServer( nServer ),
+        nPort( 0 )
+{
+#ifdef WIN32
+        Bu::Winsock2::getInstance();
+#endif
+        
+        if( bInit )
+        {
+                struct sockaddr name;
+                socklen_t namelen = sizeof(name);
+                getpeername( nServer, &name, &namelen );
+
+                initServer( *((sockaddr_in *)&name), nPoolSize );
+        }
+        else
+        {
+                FD_ZERO( &fdActive );
+                FD_SET( nServer, &fdActive );
+        }
+}
+
+Bu::TcpServerSocket::TcpServerSocket( const TcpServerSocket &rSrc )
+{
+#ifdef WIN32
+        Bu::Winsock2::getInstance();
+#endif
+
+        nServer = dup( rSrc.nServer );
+        nPort = rSrc.nPort;
+        FD_ZERO( &fdActive );
+        FD_SET( nServer, &fdActive );
+}
+
+Bu::TcpServerSocket::~TcpServerSocket()
+{
+        if( nServer > -1 )
+                ::close( nServer );
+}
+
+void Bu::TcpServerSocket::startServer( struct sockaddr_in &name, int nPoolSize )
+{
+        /* Create the socket. */
+        nServer = bu_socket( PF_INET, SOCK_STREAM, 0 );
+
+        if( nServer < 0 )
+        {
+                throw Bu::TcpServerSocketException("Couldn't create a listen socket.");
+        }
+        
+        int opt = 1;
+        bu_setsockopt(
+                        nServer,
+                        SOL_SOCKET,
+                        SO_REUSEADDR,
+                        (char *)&opt,
+                        sizeof( opt )
+                        );
+
+        initServer( name, nPoolSize );
+}
+
+void Bu::TcpServerSocket::initServer( struct sockaddr_in &name, int nPoolSize )
+{
+        if( bu_bind( nServer, (struct sockaddr *) &name, sizeof(name) ) < 0 )
+        {
+                throw Bu::TcpServerSocketException("Couldn't bind to the listen socket.");
+        }
+
+        if( bu_listen( nServer, nPoolSize ) < 0 )
+        {
+                throw Bu::TcpServerSocketException(
+                        "Couldn't begin listening to the server socket."
+                        );
+        }
+
+        FD_ZERO( &fdActive );
+        /* Initialize the set of active sockets. */
+        FD_SET( nServer, &fdActive );
+}
+
+int Bu::TcpServerSocket::getSocket()
+{
+        return nServer;
+}
+
+int Bu::TcpServerSocket::accept( int nTimeoutSec, int nTimeoutUSec )
+{
+        fd_set fdRead = fdActive;
+
+        struct timeval xT;
+
+        xT.tv_sec = nTimeoutSec;
+        xT.tv_usec = nTimeoutUSec;      
+
+        if( TEMP_FAILURE_RETRY(
+                bu_select( nServer+1, &fdRead, NULL, NULL, &xT )) < 0 )
+        {
+                throw Bu::TcpServerSocketException(
+                        "Error scanning for new connections: %s", strerror( errno )
+                        );
+        }
+
+        if( FD_ISSET( nServer, &fdRead ) )
+        {
+                struct sockaddr_in clientname;
+                socklen_t size;
+                int nClient;
+
+                size = sizeof( clientname );
+#ifdef WIN32
+                nClient = bu_accept( nServer, (struct sockaddr *)&clientname, &size);
+#else /* not-WIN32 */
+#ifdef __CYGWIN__
+                nClient = ::accept( nServer, (struct sockaddr *)&clientname,
+                                (int *)&size
+                                );
+#else /* not-cygwin */
+#ifdef __APPLE__
+                nClient = ::accept( nServer, (struct sockaddr *)&clientname, (socklen_t*)&size );
+#else /* linux */
+                nClient = ::accept( nServer, (struct sockaddr *)&clientname, &size );
+#endif /* __APPLE__ */
+#endif /* __CYGWIN__ */
+#endif /* WIN32 */
+                if( nClient < 0 )
+                {
+                        throw Bu::TcpServerSocketException(
+                                "Error accepting a new connection: %s", strerror( errno )
+                                );
+                }
+
+#ifndef WIN32
+                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) );
+#endif
+                
+                {
+#ifndef WIN32
+                        int flags;
+                        flags = fcntl( nClient, F_GETFL, 0 );
+                        flags |= O_NONBLOCK;
+                        if( fcntl( nClient, F_SETFL, flags ) < 0)
+                        {
+                                throw Bu::TcpServerSocketException(
+                                        "Error setting option on client socket: %s",
+                                        strerror( errno )
+                                        );
+                        }
+#else
+                        //-------------------------
+                        // Set the socket I/O mode: In this case FIONBIO
+                        // enables or disables the blocking mode for the 
+                        // socket based on the numerical value of iMode.
+                        // If iMode = 0, blocking is enabled; 
+                        // If iMode != 0, non-blocking mode is enabled.
+                        u_long iMode = 1;
+                        bu_ioctlsocket(nClient, FIONBIO, &iMode);                       
+#endif
+                }
+
+                return nClient;
+        }
+
+        return -1;
+}
+
+int Bu::TcpServerSocket::getPort()
+{
+        return nPort;
+}
+
diff --git a/src/stable/tcpserversocket.h b/src/stable/tcpserversocket.h
new file mode 100644
index 0000000..efb7287
--- /dev/null
+++ b/src/stable/tcpserversocket.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_TCP_SERVER_SOCKET_H
+#define BU_TCP_SERVER_SOCKET_H
+
+#include <stdint.h>
+#include "bu/string.h"
+#include "bu/exceptionbase.h"
+
+#ifdef WIN32
+ #include <Winsock2.h>
+#else
+ #include <sys/select.h>
+#endif
+
+namespace Bu
+{
+        subExceptionDecl( TcpServerSocketException );
+
+        /**
+         * 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.
+         *
+         *@ingroup Serving
+         */
+        class TcpServerSocket
+        {
+        public:
+                TcpServerSocket( int nPort, int nPoolSize=40 );
+                TcpServerSocket( const String &sAddr, int nPort, int nPoolSize=40 );
+                TcpServerSocket( int nSocket, bool bInit, int nPoolSize=40 );
+                TcpServerSocket( const TcpServerSocket &rSrc );
+                virtual ~TcpServerSocket();
+
+                int accept( int nTimeoutSec=0, int nTimeoutUSec=0 );
+                int getSocket();
+                int getPort();
+
+        private:
+                void startServer( struct sockaddr_in &name, int nPoolSize );
+                void initServer( struct sockaddr_in &name, int nPoolSize );
+
+                fd_set fdActive;
+#ifdef WIN32
+                unsigned int nServer;
+#else
+                int nServer;
+#endif
+                int nPort;
+        };
+}
+
+#endif
diff --git a/src/stable/tcpsocket.cpp b/src/stable/tcpsocket.cpp
new file mode 100644
index 0000000..b9b215c
--- /dev/null
+++ b/src/stable/tcpsocket.cpp
@@ -0,0 +1,478 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <errno.h>
+#include <fcntl.h>
+#include "bu/tcpsocket.h"
+
+#include "bu/config.h"
+
+#ifndef WIN32
+ #include <sys/socket.h>
+ #include <netinet/in.h>
+ #include <netdb.h>
+ #include <arpa/inet.h>
+#else
+ #include <Winsock2.h>
+#endif
+
+#define RBS (1024*2)
+
+namespace Bu { subExceptionDef( TcpSocketException ) }
+
+Bu::TcpSocket::TcpSocket( handle nTcpSocket ) :
+        nTcpSocket( nTcpSocket ),
+        bActive( true ),
+        bBlocking( true )
+{
+#ifdef WIN32
+        Bu::Winsock2::getInstance();
+#endif
+        setAddress();
+}
+
+Bu::TcpSocket::TcpSocket( const Bu::String &sAddr, int nPort, int nTimeout,
+                bool bBlocking ) :
+        nTcpSocket( 0 ),
+        bActive( false ),
+        bBlocking( true )
+{
+#ifdef WIN32
+        Bu::Winsock2::getInstance();
+#endif
+
+        /* Create the socket. */
+        nTcpSocket = bu_socket( PF_INET, SOCK_STREAM, 0 );
+        
+        if( nTcpSocket < 0 )
+        {
+                throw ExceptionBase("Couldn't create socket.\n");
+        }
+
+        setBlocking( false );
+     
+        /* Connect to the server. */
+        //printf("Resolving hostname (%s)...\n", sAddr );
+        {
+                struct addrinfo *pAddr = NULL;
+                struct addrinfo aiHints;
+                memset( &aiHints, 0, sizeof(addrinfo) );
+                aiHints.ai_flags = AI_CANONNAME;
+                aiHints.ai_family = AF_INET;
+                aiHints.ai_socktype = SOCK_STREAM;
+                char ibuf[10]; 
+                sprintf( ibuf, "%d", nPort );
+     
+                int ret;
+                if( (ret = bu_getaddrinfo(
+                        sAddr.getStr(), ibuf, &aiHints, &pAddr )) != 0 )
+                {
+                        close();
+                        throw Bu::TcpSocketException("Couldn't resolve hostname %s (%s).\n",
+                                sAddr.getStr(), bu_gai_strerror(ret));
+                }
+
+                bu_connect(
+                        nTcpSocket,
+                        pAddr->ai_addr,
+                        pAddr->ai_addrlen
+                        );
+
+                sAddress = pAddr->ai_canonname;
+
+                bu_freeaddrinfo( pAddr );
+        }
+
+        bActive = true;
+
+        if( nTimeout > 0 )
+        {
+                fd_set rfds, wfds, efds;
+                int retval;
+                
+                FD_ZERO(&rfds);
+                FD_SET(nTcpSocket, &rfds);
+                FD_ZERO(&wfds);
+                FD_SET(nTcpSocket, &wfds);
+                FD_ZERO(&efds);
+                FD_SET(nTcpSocket, &efds);
+
+                struct timeval tv;
+                tv.tv_sec = nTimeout;
+                tv.tv_usec = 0;
+                
+                retval = bu_select( nTcpSocket+1, &rfds, &wfds, &efds, &tv );
+
+                if( retval == 0 )
+                {
+                        close();
+                        throw ExceptionBase("Connection timeout.\n");
+                }
+                read( NULL, 0 ); // See if we can get any errors out of the way early.
+        }
+
+        if( bBlocking )
+                setBlocking( bBlocking );
+}
+
+Bu::TcpSocket::~TcpSocket()
+{
+        close();
+}
+
+void Bu::TcpSocket::close()
+{
+        if( bActive )
+        {
+#ifndef WIN32
+                fsync( nTcpSocket );
+#endif
+#ifdef WIN32
+ #ifndef SHUT_RDWR
+  #define SHUT_RDWR (SD_BOTH)
+ #endif
+#endif
+                bu_shutdown( nTcpSocket, SHUT_RDWR );
+                ::close( nTcpSocket );
+        }
+        bActive = false;
+}
+
+Bu::size Bu::TcpSocket::read( void *pBuf, Bu::size nBytes )
+{
+        fd_set rfds;
+        FD_ZERO(&rfds);
+        FD_SET(nTcpSocket, &rfds);
+        struct timeval tv = {0, 0};
+        if( bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv ) < 0 )
+        {
+                int iErr = errno;
+                close();
+                throw TcpSocketException( TcpSocketException::cRead, strerror(iErr) );
+        }
+        if( FD_ISSET( nTcpSocket, &rfds ) || bBlocking )
+        {
+                int nRead = TEMP_FAILURE_RETRY( 
+                        bu_recv( nTcpSocket, (char *) pBuf, nBytes, 0 ) );
+                if( nRead == 0 && nBytes > 0 )
+                {
+                        close();
+                        throw TcpSocketException( TcpSocketException::cClosed, "TcpSocket closed.");
+                }
+                if( nRead < 0 )
+                {
+#ifdef WIN32
+                        int iWSAError = bu_WSAGetLastError();
+                        if( iWSAError == WSAEWOULDBLOCK )
+                                return 0;
+#else
+                        if( errno == ENETRESET || errno == ECONNRESET )
+                        {
+                                close();
+                                throw TcpSocketException( TcpSocketException::cClosed,
+                                        strerror(errno) );
+                        }
+                        if( errno == EAGAIN )
+                                return 0;
+                        int iErr = errno;
+                        close();
+                        throw TcpSocketException( TcpSocketException::cRead, strerror(iErr) );
+#endif
+                }
+                return nRead;
+        }
+        return 0;
+}
+
+Bu::size Bu::TcpSocket::read( void *pBuf, Bu::size nBytes,
+                uint32_t nSec, uint32_t nUSec )
+{
+        struct timeval tv;
+        Bu::size nRead = 0;
+        
+        fd_set rfds;
+        FD_ZERO(&rfds);
+        FD_SET(nTcpSocket, &rfds);
+
+#ifdef WIN32
+        DWORD dwStart = GetTickCount();
+        uint64_t uOver = dwStart + ((nUSec / 1000) * (nSec * 1000));
+        DWORD dwEnd = uOver>4294967295U?uOver-4294967295U:uOver;
+#else
+        struct timeval nt, ct;
+        gettimeofday( &nt, NULL );
+        nt.tv_sec += nSec;
+        nt.tv_usec += nUSec;
+#endif
+
+        for(;;)
+        {
+                tv.tv_sec = nSec;
+                tv.tv_usec = nUSec;
+                bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv );
+                nRead += read( ((char *)pBuf)+nRead, nBytes-nRead );
+                if( nRead >= nBytes )
+                        break;
+#ifdef WIN32
+                DWORD dwNow = GetTickCount();
+                if( dwNow > dwEnd )
+                        break;
+#else
+                gettimeofday( &ct, NULL );
+                if( (ct.tv_sec > nt.tv_sec) ||
+                        (ct.tv_sec == nt.tv_sec &&
+                        ct.tv_usec >= nt.tv_usec) )
+                        break;
+#endif
+        }
+        return nRead;
+}
+
+Bu::size Bu::TcpSocket::write( const void *pBuf, Bu::size nBytes )
+{
+//#ifdef WIN32
+        int nWrote = TEMP_FAILURE_RETRY( 
+                bu_send( nTcpSocket, (const char *) pBuf, nBytes, 0 ) );
+//#else
+//      int nWrote = TEMP_FAILURE_RETRY( ::write( nTcpSocket, pBuf, nBytes ) );
+//#endif
+        if( nWrote < 0 )
+        {
+#ifdef WIN32
+                int iWSAError = bu_WSAGetLastError();
+                if( iWSAError == WSAEWOULDBLOCK )
+                        return 0;
+#else
+                if( errno == EAGAIN ) return 0;
+#endif
+                throw TcpSocketException( TcpSocketException::cWrite, strerror(errno) );
+        }
+        return nWrote;
+}
+
+Bu::size Bu::TcpSocket::write( const void *pBuf, Bu::size nBytes, uint32_t nSec, uint32_t nUSec )
+{
+        struct timeval tv;
+        Bu::size nWrote = 0;
+        
+        fd_set wfds;
+        FD_ZERO(&wfds);
+        FD_SET(nTcpSocket, &wfds);
+
+#ifdef WIN32
+        DWORD dwStart = GetTickCount();
+        uint64_t uOver = dwStart + ((nUSec / 1000) * (nSec * 1000));
+        DWORD dwEnd = uOver>4294967295U?uOver-4294967295U:uOver;
+#else
+        struct timeval nt, ct;
+        gettimeofday( &nt, NULL );
+        nt.tv_sec += nSec;
+        nt.tv_usec += nUSec;
+#endif
+
+        for(;;)
+        {
+                tv.tv_sec = nSec;
+                tv.tv_usec = nUSec;
+                bu_select( nTcpSocket+1, NULL, &wfds, NULL, &tv );
+                nWrote += write( ((char *)pBuf)+nWrote, nBytes-nWrote );
+                if( nWrote >= nBytes )
+                        break;
+#ifdef WIN32
+                DWORD dwNow = GetTickCount();
+                if( dwNow > dwEnd )
+                        break;
+#else
+                gettimeofday( &ct, NULL );
+                if( (ct.tv_sec > nt.tv_sec) ||
+                        (ct.tv_sec == nt.tv_sec &&
+                        ct.tv_usec >= nt.tv_usec) )
+                        break;
+#endif
+        }
+        return nWrote;
+}
+
+Bu::size Bu::TcpSocket::tell()
+{
+        throw UnsupportedException();
+}
+
+void Bu::TcpSocket::seek( Bu::size )
+{
+        throw UnsupportedException();
+}
+
+void Bu::TcpSocket::setPos( Bu::size )
+{
+        throw UnsupportedException();
+}
+
+void Bu::TcpSocket::setPosEnd( Bu::size )
+{
+        throw UnsupportedException();
+}
+
+bool Bu::TcpSocket::isEos()
+{
+        return !bActive;
+}
+
+bool Bu::TcpSocket::canRead()
+{
+        fd_set rfds;
+        FD_ZERO(&rfds);
+        FD_SET(nTcpSocket, &rfds);
+        struct timeval tv = { 0, 0 };
+        int retval = bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv );
+        if( retval == -1 )
+                throw TcpSocketException(
+                        TcpSocketException::cBadRead,
+                        "Bad Read error"
+                        );
+
+        if( !FD_ISSET( nTcpSocket, &rfds ) )
+                return false;
+        return true;
+}
+
+bool Bu::TcpSocket::canWrite()
+{
+        fd_set wfds;
+        FD_ZERO(&wfds);
+        FD_SET(nTcpSocket, &wfds);
+        struct timeval tv = { 0, 0 };
+        int retval = bu_select( nTcpSocket+1, NULL, &wfds, NULL, &tv );
+        if( retval == -1 )
+                throw TcpSocketException(
+                        TcpSocketException::cBadRead,
+                        "Bad Read error"
+                        );
+        if( !FD_ISSET( nTcpSocket, &wfds ) )
+                return false;
+        return true;
+}
+
+bool Bu::TcpSocket::isReadable()
+{
+        return true;
+}
+
+bool Bu::TcpSocket::isWritable()
+{
+        return true;
+}
+
+bool Bu::TcpSocket::isSeekable()
+{
+        return false;
+}
+
+bool Bu::TcpSocket::isBlocking()
+{
+#ifndef WIN32
+        return ((fcntl( nTcpSocket, F_GETFL, 0 ) & O_NONBLOCK) != O_NONBLOCK);
+#else
+        return false;
+#endif
+}
+
+void Bu::TcpSocket::setBlocking( bool bBlocking )
+{
+        this->bBlocking = bBlocking;
+#ifndef WIN32
+        if( bBlocking )
+        {
+                fcntl( nTcpSocket, F_SETFL, fcntl( nTcpSocket, F_GETFL, 0 ) & (~O_NONBLOCK) );
+        }
+        else
+        {
+                fcntl( nTcpSocket, F_SETFL, fcntl( nTcpSocket, F_GETFL, 0 ) | O_NONBLOCK );
+        }
+#else
+        u_long iMode;
+        if( bBlocking )
+                iMode = 0;
+        else
+                iMode = 1;
+        //-------------------------
+        // Set the socket I/O mode: In this case FIONBIO
+        // enables or disables the blocking mode for the 
+        // socket based on the numerical value of iMode.
+        // If iMode = 0, blocking is enabled; 
+        // If iMode != 0, non-blocking mode is enabled.
+        bu_ioctlsocket(nTcpSocket, FIONBIO, &iMode);
+#endif  
+}
+
+void Bu::TcpSocket::setSize( Bu::size )
+{
+}
+
+void Bu::TcpSocket::flush()
+{
+}
+
+bool Bu::TcpSocket::isOpen()
+{
+        return bActive;
+}
+
+void Bu::TcpSocket::setAddress()
+{
+        struct sockaddr_in addr;
+        socklen_t len = sizeof(addr);
+        addr.sin_family = AF_INET;
+        bu_getpeername( nTcpSocket, (sockaddr *)(&addr), &len );
+        sAddress = bu_inet_ntoa( addr.sin_addr );
+}
+
+Bu::String Bu::TcpSocket::getAddress() const
+{
+        return sAddress;
+}
+
+Bu::TcpSocket::operator Bu::TcpSocket::handle() const
+{
+        return nTcpSocket;
+}
+
+Bu::TcpSocket::handle Bu::TcpSocket::getHandle() const
+{
+        return nTcpSocket;
+}
+
+Bu::TcpSocket::handle Bu::TcpSocket::takeHandle()
+{
+        handle nRet = nTcpSocket;
+        bActive = false;
+        nTcpSocket = 0;
+        return nRet;
+}
+
+Bu::size Bu::TcpSocket::getSize() const
+{
+        throw UnsupportedException();
+}
+
+Bu::size Bu::TcpSocket::getBlockSize() const
+{
+        return 1500; //TODO: Fix this, it's stupid.
+}
+
+Bu::String Bu::TcpSocket::getLocation() const
+{
+        return getAddress();
+}
+
diff --git a/src/stable/tcpsocket.h b/src/stable/tcpsocket.h
new file mode 100644
index 0000000..52218bd
--- /dev/null
+++ b/src/stable/tcpsocket.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_TCP_SOCKET_H
+#define BU_TCP_SOCKET_H
+
+#include <stdint.h>
+
+#include "bu/config.h"
+#include "bu/stream.h"
+#include "bu/string.h"
+#include "bu/exceptionbase.h"
+
+namespace Bu
+{
+        subExceptionDeclBegin( TcpSocketException );
+                enum {
+                        cRead,
+                        cWrite,
+                        cBadRead,
+                        cClosed,
+                        cTimeout
+                };
+        subExceptionDeclEnd();
+
+        /**
+         * Network socket stream class.  This class provides a mechanism for
+         * communicating over a network using TCP/IP.  It will provide other low
+         * level protocol and addressing support later on, but for now it's just
+         * standard STREAM TCP/IP sockets.
+         *
+         * Unlike system sockets, these sockets are opened by default in
+         * non-blocking mode, you can specify your own timeout for opening a socket,
+         * and a number of non-fatal error messages have been automatically handled
+         * and treated as standard no-data-available-yet situations on read.
+         *
+         * Please note that there is a condition that will occur eventually (at
+         * least on *nix systems) that will trigger a SIGPIPE condition.  This
+         * will terminate your program immediately unless handled properly.  Most
+         * people doing any connections with TcpSocket will want to put this in
+         * their program somewhere before they use it:
+         *@code
+         #include <signal.h>
+         ...
+         ...
+         ...
+         sigset( SIGPIPE, SIG_IGN ); // do this before you use a Bu::TcpSocket
+         @endcode
+         * When this is done, Bu::TcpSocket will simply throw a broken pipe
+         * exception just like every other error condition, allowing your program
+         * to handle it sanely.
+         *
+         *@ingroup Serving
+         *@ingroup Streams
+         */
+        class TcpSocket : public Stream
+        {
+        public:
+#ifdef WIN32
+                typedef unsigned int handle;
+#else
+                typedef int handle;
+#endif
+
+                TcpSocket( handle nTcpSocket );
+                TcpSocket( const String &sAddr, int nPort, int nTimeout=30,
+                                bool bBlocking=true );
+                virtual ~TcpSocket();
+                
+                virtual void close();
+                virtual size read( void *pBuf, size nBytes );
+                virtual size read( void *pBuf, size nBytes,
+                                uint32_t nSec, uint32_t nUSec=0 );
+                virtual size write( const void *pBuf, size nBytes );
+                virtual size write( const void *pBuf, size nBytes,
+                                uint32_t nSec, uint32_t nUSec=0 );
+                using Stream::write;
+
+                virtual size tell();
+                virtual void seek( size offset );
+                virtual void setPos( size pos );
+                virtual void setPosEnd( size 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 );
+
+                virtual void setSize( size iSize );
+
+                Bu::String getAddress() const;
+                operator handle() const;
+
+                handle getHandle() const;
+                handle takeHandle();
+
+                virtual size getSize() const;
+                virtual size getBlockSize() const;
+                virtual Bu::String getLocation() const;
+
+        private:
+                void setAddress();
+
+                handle nTcpSocket;
+                
+                bool bActive;
+                bool bBlocking;
+                String sReadBuf;
+                String sAddress;
+        };
+}
+
+#endif
diff --git a/src/stable/thread.cpp b/src/stable/thread.cpp
new file mode 100644
index 0000000..e4563a2
--- /dev/null
+++ b/src/stable/thread.cpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/thread.h"
+
+#include "bu/config.h"
+
+Bu::Thread::Thread()
+{
+}
+
+Bu::Thread::~Thread()
+{
+}
+
+bool Bu::Thread::start()
+{
+        nHandle = pthread_create( &ptHandle, NULL, threadRunner, this );
+
+        return true;
+}
+
+bool Bu::Thread::stop()
+{
+        pthread_cancel( ptHandle );
+
+        return true;
+}
+
+void *Bu::Thread::threadRunner( void *pThread )
+{
+        ((Thread *)pThread)->run();
+        pthread_exit( NULL );
+        return NULL;
+}
+
+bool Bu::Thread::join()
+{
+        pthread_join( ptHandle, NULL );
+        return true;
+}
+
+void Bu::Thread::yield()
+{
+#ifndef WIN32
+        pthread_yield();
+#else
+        #warning Bu::Thread::yield IS A STUB for WIN32!!!!      
+#endif
+}
+
diff --git a/src/stable/thread.h b/src/stable/thread.h
new file mode 100644
index 0000000..70e6f5f
--- /dev/null
+++ b/src/stable/thread.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_THREAD_H
+#define BU_THREAD_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.
+         *@ingroup Threading
+         */
+        class Thread
+        {
+        public:
+                /**
+                 * Construct an Thread thread.
+                 */
+                Thread();
+
+                /**
+                 * Destroy an Thread thread.
+                 */
+                virtual ~Thread();
+
+                /**
+                 * 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
+                 * ThreadMutex 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();
+
+                /**
+                 * 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 Thread 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:
+                /**
+                 * The workhorse of the Thread 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 ThreadMutex,
+                 * ThreadCondition, 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;
+
+                /**
+                 * 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 pThread 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/stable/trace.cpp b/src/stable/trace.cpp
new file mode 100644
index 0000000..03181e9
--- /dev/null
+++ b/src/stable/trace.cpp
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/trace.h"
+
+void Bu::__tracer( const char *pf )
+{
+        printf("trace: %s\n", pf );
+}
+
+template<> void Bu::__tracer_format<float>( const float &v )
+{
+        printf("%f", v );
+}
+
+template<> void Bu::__tracer_format<double>( const double &v )
+{
+        printf("%f", v );
+}
+
+template<> void Bu::__tracer_format<void *>( void * const &v )
+{
+        printf("0x%08X", (ptrdiff_t)v );
+}
+
+template<> void Bu::__tracer_format<char *>( char * const &v )
+{
+        printf("\"%s\"", v );
+}
+
+template<> void Bu::__tracer_format<char **>( char ** const &v )
+{
+        printf("[");
+        for( int j = 0; v[j]; j++ )
+        {
+                if( j > 0 )
+                        printf(", ");
+                printf("\"%s\"", v[j] );
+        }
+        printf("]");
+}
+
+template<> void Bu::__tracer_format<void const *>( void const * const &v )
+{
+        printf("0x%08X", (ptrdiff_t)v );
+}
+
+template<> void Bu::__tracer_format<char const *>( char const * const &v )
+{
+        printf("\"%s\"", v );
+}
+
+template<> void Bu::__tracer_format<char const **>( char const ** const &v )
+{
+        printf("[");
+        for( int j = 0; v[j]; j++ )
+        {
+                if( j > 0 )
+                        printf(", ");
+                printf("\"%s\"", v[j] );
+        }
+        printf("]");
+}
diff --git a/src/stable/trace.h b/src/stable/trace.h
new file mode 100644
index 0000000..51dfb8e
--- /dev/null
+++ b/src/stable/trace.h
@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_TRACE_H
+#define BU_TRACE_H
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+
+#include <bu/sio.h>
+
+namespace Bu
+{
+/*      template<typename t> void __tracer_format( t &v )
+        {
+                __tracer_format( *const_cast<const t *>(&v) );
+        }
+*/
+        template<typename t> void __tracer_format( const t &v )
+        {
+                Bu::sio << v;
+        }
+
+        void __tracer( const char *pf );
+
+        #define looper( vv )                                                            \
+                for( ; *n; n++ )                                                                \
+                {                                                                                               \
+                        if( bInBracket == true )                                        \
+                        {                                                                                       \
+                                if( *n == '>' )                                                 \
+                                        bInBracket = false;                                     \
+                        }                                                                                       \
+                        else if( *n == ',' || *n == ')' )                       \
+                        {                                                                                       \
+                                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, 1, stdout );      \
+                                fwrite("=", 1, 1, stdout);                              \
+                                __tracer_format( vv );                                  \
+                                s = n;                                                                  \
+                                n++;                                                                    \
+                                break;                                                                  \
+                        }                                                                                       \
+                        else if( *n == '<' )                                            \
+                        {                                                                                       \
+                                bInBracket = true;                                              \
+                        }                                                                                       \
+                } (void)0
+        
+        template<typename t1> void __tracer( const char *pf, t1 &v1 )
+        {
+                printf("trace: ");
+                const char *s = pf;
+                const char *n = pf;
+                bool bInBracket = false;
+                looper( v1 );
+                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+                fwrite( "\n", 1, 1, stdout );
+                fflush( stdout );
+        }
+        
+        template<typename t1, typename t2> void __tracer( const char *pf,
+                t1 &v1, t2 &v2 )
+        {
+                printf("trace: ");
+                const char *s = pf;
+                const char *n = pf;
+                bool bInBracket = false;
+                looper( v1 );
+                looper( v2 );
+                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+                fwrite( "\n", 1, 1, stdout );
+                fflush( stdout );
+        }
+        
+        template<typename t1, typename t2, typename t3>
+        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3 )
+        {
+                printf("trace: ");
+                const char *s = pf;
+                const char *n = pf;
+                bool bInBracket = false;
+                looper( v1 );
+                looper( v2 );
+                looper( v3 );
+                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+                fwrite( "\n", 1, 1, stdout );
+                fflush( stdout );
+        }
+        
+        template<typename t1, typename t2, typename t3, typename t4>
+        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4 )
+        {
+                printf("trace: ");
+                const char *s = pf;
+                const char *n = pf;
+                bool bInBracket = false;
+                looper( v1 );
+                looper( v2 );
+                looper( v3 );
+                looper( v4 );
+                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+                fwrite( "\n", 1, 1, stdout );
+                fflush( stdout );
+        }
+        
+        template<typename t1, typename t2, typename t3, typename t4, typename t5>
+        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5 )
+        {
+                printf("trace: ");
+                const char *s = pf;
+                const char *n = pf;
+                bool bInBracket = false;
+                looper( v1 );
+                looper( v2 );
+                looper( v3 );
+                looper( v4 );
+                looper( v5 );
+                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+                fwrite( "\n", 1, 1, stdout );
+                fflush( stdout );
+        }
+        
+        template<typename t1, typename t2, typename t3, typename t4, typename t5,
+        typename t6>
+        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5,
+                t6 &v6)
+        {
+                printf("trace: ");
+                const char *s = pf;
+                const char *n = pf;
+                bool bInBracket = false;
+                looper( v1 );
+                looper( v2 );
+                looper( v3 );
+                looper( v4 );
+                looper( v5 );
+                looper( v6 );
+                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+                fwrite( "\n", 1, 1, stdout );
+                fflush( stdout );
+        }
+        
+        template<typename t1, typename t2, typename t3, typename t4, typename t5,
+        typename t6, typename t7>
+        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5,
+                t6 &v6, t7 &v7 )
+        {
+                printf("trace: ");
+                const char *s = pf;
+                const char *n = pf;
+                bool bInBracket = false;
+                looper( v1 );
+                looper( v2 );
+                looper( v3 );
+                looper( v4 );
+                looper( v5 );
+                looper( v6 );
+                looper( v7 );
+                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+                fwrite( "\n", 1, 1, stdout );
+                fflush( stdout );
+        }
+#undef looper
+        
+        template<> void __tracer_format<float>( const float &v );
+        template<> void __tracer_format<double>( const double &v );
+        template<> void __tracer_format<void *>( void * const &v );
+        template<> void __tracer_format<char *>( char * const &v );
+        template<> void __tracer_format<char **>( char ** const &v );
+        template<> void __tracer_format<void const *>( void const * const &v );
+        template<> void __tracer_format<char const *>( char const * const &v );
+        template<> void __tracer_format<char const **>( char const ** const &v );
+}
+
+#ifdef BU_TRACE
+# define TRACE(args...) Bu::__tracer( __PRETTY_FUNCTION__, ##args )
+#else
+# define TRACE(args...) (void)0
+#endif
+
+#endif
diff --git a/src/stable/unitsuite.cpp b/src/stable/unitsuite.cpp
new file mode 100644
index 0000000..db930a4
--- /dev/null
+++ b/src/stable/unitsuite.cpp
@@ -0,0 +1,255 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/unitsuite.h"
+#include "bu/file.h"
+#include "bu/sio.h"
+#include "bu/optparser.h"
+#include <stdlib.h>
+#include <time.h>
+
+using namespace Bu;
+
+#include <unistd.h>
+
+Bu::UnitSuite::UnitSuite() :
+        iOptions( 0 ),
+        iNameWidth( 0 )
+{
+}
+
+Bu::UnitSuite::UnitSuite( int iOptions ) :
+        iOptions( iOptions ),
+        iNameWidth( 0 )
+{
+}
+
+Bu::UnitSuite::~UnitSuite()
+{
+}
+
+// Argument handling is coming soon, I promise.
+int Bu::UnitSuite::run( int argc, char *argv[] )
+{
+        bool bCleanup = true;
+        OptParser p;
+        p.addOption( Bu::slot( this, &Bu::UnitSuite::onListCases ), 'l', "list",
+                        "List available test cases." );
+        p.addOption( bCleanup, "no-cleanup", "Don't erase temp files.");
+        p.setOverride( "no-cleanup", false );
+        p.addHelpOption();
+        p.parse( argc, argv );
+
+        int iEPass = 0;
+        int iEFail = 0;
+        int iUPass = 0;
+        int iUFail = 0;
+        for( TestList::iterator i = lTests.begin(); i != lTests.end(); i++ )
+        {
+                sio << Fmt( iNameWidth+3, Fmt::Left ).fill('.') << i->sName
+                        << sio.flush;
+                try
+                {
+                        iStepCount = -1;
+                        iProgress = 0;
+                        (this->*(i->fTest))();
+                        switch( i->eExpect )
+                        {
+                                case expectPass:
+                                        sio << "pass." << sio.nl;
+                                        iEPass++;
+                                        break;
+
+                                case expectFail:
+                                        sio << "unexpected pass." << sio.nl;
+                                        iUPass++;
+                                        break;
+                        }
+                }
+                catch( Failed &e )
+                {
+                        switch( i->eExpect )
+                        {
+                                case expectPass:
+                                        sio << "unexpected ";
+                                        iUFail++;
+                                        break;
+
+                                case expectFail:
+                                        sio << "expected ";
+                                        iEFail++;
+                                        break;
+                        }
+                        if( e.bFile )
+                        {
+                                sio << "fail in unitTest(" << e.str << "). (" << e.sFile
+                                        << ":" << e.nLine << ")." << sio.nl;
+                        }
+                        else
+                        {
+                                sio << "fail in unitTest(" << e.str << ")." << sio.nl;
+                        }
+
+                        if( (iOptions & optStopOnError) )
+                                return 0;
+                }
+                catch( std::exception &e )
+                {
+                        switch( i->eExpect )
+                        {
+                                case expectPass:
+                                        sio << "unexpected ";
+                                        iUFail++;
+                                        break;
+
+                                case expectFail:
+                                        sio << "expected ";
+                                        iEFail++;
+                                        break;
+                        }
+                        sio << "fail with unknown exception.  what: " << e.what() << sio.nl;
+
+                        if( (iOptions & optStopOnError) )
+                                return 0;
+                }
+                catch( ... )
+                {
+                        switch( i->eExpect )
+                        {
+                                case expectPass:
+                                        sio << "unexpected ";
+                                        iUFail++;
+                                        break;
+
+                                case expectFail:
+                                        sio << "expected ";
+                                        iEFail++;
+                                        break;
+                        }
+                        sio << "fail with external exception." << sio.nl;
+
+                        if( (iOptions & optStopOnError) )
+                                return 0;
+                }
+        }
+
+        sio << sio.nl
+                << "Report:" << sio.nl
+                << "\tTotal tests run:     " << lTests.getSize() << sio.nl
+                << "\tExpected passes:     " << iEPass << sio.nl
+                << "\tExpected failures:   " << iEFail << sio.nl
+                << "\tUnexpected passes:   " << iUPass << sio.nl
+                << "\tUnexpected failures: " << iUFail << sio.nl << sio.nl;
+        if( iUPass == 0 && iUFail == 0 )
+                sio << "\tNothing unexpected." << sio.nl << sio.nl;
+
+        if( bCleanup )
+        {
+                for( StrList::iterator i = lFileCleanup.begin(); i; i++ )
+                {
+                        unlink( (*i).getStr() );
+                }
+        }
+
+        return 0;
+}
+
+Bu::File Bu::UnitSuite::tempFile( Bu::String &sFileName )
+{
+        Bu::File f = Bu::File::tempFile( sFileName );
+        lFileCleanup.append( sFileName );
+        return f;
+}
+
+void Bu::UnitSuite::add( Test fTest, const Bu::String &sName, Expect e )
+{
+        TestInfo ti;
+        ti.sName = sName;
+        ti.eExpect = e;
+        long index = ti.sName.rfindIdx("::");
+        if( index != -1 )
+        {
+                String tmp = sSuiteName;
+                tmp += ti.sName.getStr()+index;
+                ti.sName = tmp;
+        }
+        ti.fTest = fTest;
+        lTests.append( ti );
+        if( iNameWidth < ti.sName.getSize() )
+                iNameWidth = ti.sName.getSize();
+}
+
+void Bu::UnitSuite::setName( const String &sName )
+{
+        sSuiteName = sName;
+}
+
+void Bu::UnitSuite::dispProgress()
+{
+        if( tLastUpdate == time( NULL ) )
+                return;
+        sio << Fmt(3) << (iProgress*100/iStepCount) << "%" << "\b\b\b\b"
+                << sio.flush;
+        tLastUpdate = time( NULL );
+}
+
+void Bu::UnitSuite::setStepCount( int iSteps )
+{
+        iStepCount = iSteps;
+        if( iStepCount < 0 )
+                return;
+        tLastUpdate = 0;
+        dispProgress();
+}
+
+void Bu::UnitSuite::incProgress( int iAmnt )
+{
+        iProgress += iAmnt;
+        if( iProgress < 0 )
+                iProgress = 0;
+        if( iProgress > iStepCount )
+                iProgress = iStepCount;
+        dispProgress();
+}
+
+void Bu::UnitSuite::setProgress( int iAmnt )
+{
+        iProgress = iAmnt;
+        if( iProgress < 0 )
+                iProgress = 0;
+        if( iProgress > iStepCount )
+                iProgress = iStepCount;
+        dispProgress();
+}
+
+int Bu::UnitSuite::onListCases( StrArray )
+{
+        sio << "Test cases:" << sio.nl;
+        for( TestList::iterator i = lTests.begin(); i; i++ )
+        {
+                sio << "\t- " << Fmt( iNameWidth, 10, Fmt::Left ) << (*i).sName << "  "
+                        << (*i).eExpect << sio.nl;
+        }
+        sio << sio.nl;
+        exit( 0 );
+        return 0;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::UnitSuite::Expect &e )
+{
+        switch( e )
+        {
+                case Bu::UnitSuite::expectPass:
+                        return f << "expect pass";
+
+                case Bu::UnitSuite::expectFail:
+                        return f << "expect fail";
+        }
+
+        return f << "**error**";
+}
+
diff --git a/src/stable/unitsuite.h b/src/stable/unitsuite.h
new file mode 100644
index 0000000..2250a4d
--- /dev/null
+++ b/src/stable/unitsuite.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_UNIT_SUITE_H
+#define BU_UNIT_SUITE_H
+
+#include <stdint.h>
+#include "bu/list.h"
+#include "bu/string.h"
+#include "bu/file.h"
+#include "bu/array.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();
+                UnitSuite( int iOptions );
+                virtual ~UnitSuite();
+
+                int run( int argc=0, char *argv[]=NULL );
+
+                Bu::File tempFile( Bu::String &sFileName );
+
+                typedef void (UnitSuite::*Test)();
+
+                class Failed
+                {
+                public:
+                        Failed() : str(""), bFile( false ) { }
+                        Failed( const String &s ) : str( s ), bFile( false ) { }
+                        Failed( const String &s, const String &sFile, int nLine ) :
+                                str( s ), sFile( sFile ), nLine( nLine ), bFile( true ) { }
+
+                        String str;
+                        String sFile;
+                        int nLine;
+                        bool bFile;
+                };
+
+                enum
+                {
+                        optStopOnError          = 0x000001
+                };
+
+                enum Expect
+                {
+                        expectPass,
+                        expectFail
+                };
+                
+        protected:
+                void add( Test fTest, const Bu::String &sName, Expect e=expectPass );
+                void setName( const String &sName );
+
+                void dispProgress();
+                void setStepCount( int iSteps );
+                void incProgress( int iAmnt = 1 );
+                void setProgress( int iAmnt );
+
+        private:
+                int onListCases( Bu::Array<Bu::String> aParam );
+
+        private:
+                typedef struct TestInfo
+                {
+                        String sName;
+                        Test fTest;
+                        Expect eExpect;
+                } TestInfo;
+
+                typedef Bu::List<TestInfo> TestList;
+                TestList lTests;
+                String sSuiteName;
+
+                int iOptions;
+
+                typedef Bu::List<Bu::String> StrList;
+                StrList lFileCleanup;
+                int iNameWidth;
+                int iStepCount;
+                int iProgress;
+                time_t tLastUpdate;
+        };
+
+Bu::Formatter &operator<<( Bu::Formatter &f, const Bu::UnitSuite::Expect &e );
+}
+
+#define addTest( fn ) add( static_cast<Bu::UnitSuite::Test>(&fn), #fn )
+#define unitTest( tst ) if( !(tst) )                                                    \
+{                                                                                                                               \
+        throw Bu::UnitSuite::Failed( #tst, __FILE__, __LINE__ );        \
+} else (void)0
+#define unitFailed( msg ) throw Bu::UnitSuite::Failed(msg, __FILE__, __LINE__)
+
+#endif
diff --git a/src/stable/util.cpp b/src/stable/util.cpp
new file mode 100644
index 0000000..6983dfd
--- /dev/null
+++ b/src/stable/util.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/util.h"
+
+int Bu::getDaysInMonth( int iMonth, int iYear )
+{
+        if( iMonth > 11 )
+        {
+                iYear += iMonth/12;
+                iMonth = iMonth%12;
+        }
+        switch( iMonth )
+        {
+        case 0:
+        case 2:
+        case 4:
+        case 6:
+        case 7:
+        case 9:
+        case 11:
+                return 31;
+                break;
+
+        case 3:
+        case 5:
+        case 8:
+        case 10:
+                return 30;
+                break;
+
+        case 1:
+                if( iYear%400 == 0 )
+                        return 29;
+                if( iYear%100 == 0 )
+                        return 28;
+                if( iYear%4 == 0 )
+                        return 29;
+                return 28;
+                break;
+
+        default:
+                return -1;
+        }
+}
+void Bu::memcpy( void *pDest, const void *pSrc, size_t iBytes )
+{
+#ifdef VALTEST
+        const char *src = (const char *)pSrc;
+        char *dest = (char *)pDest;
+        for( int j = 0; j < count; j++ )
+        {
+                *dest = *src;
+                dest++;
+                src++;
+        }
+#else
+        ::memcpy( pDest, pSrc, iBytes );
+#endif
+}
+
diff --git a/src/stable/util.h b/src/stable/util.h
new file mode 100644
index 0000000..691184d
--- /dev/null
+++ b/src/stable/util.h
@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_UTIL_H
+#define BU_UTIL_H
+
+#ifndef NULL
+# define NULL 0
+#endif
+
+/* I borrowed this from someone who borrowed it from glib who borrowed it
+ * from...
+ */
+#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+# define DEPRECATED  __attribute__((__deprecated__))
+#else
+# define DEPRECATED
+#endif /* __GNUC__ */
+
+#include <string.h>
+
+namespace Bu
+{
+        /**
+         * Swap the value of two variables, uses references, so it's pretty safe.
+         * Objects passed in must support a basic assignemnt operator (=);
+         *@param a Variable to recieve the value of parameter b
+         *@param b Variable to recieve the value of parameter a
+         */
+        template<typename item>
+        void swap( item &a, item &b )
+        {
+                item tmp = a;
+                a = b;
+                b = tmp;
+        }
+
+#ifdef WIN32
+        #warning: removing min and max win32 macros because of compile conflict
+        #undef min
+        #undef max
+#endif
+        /**
+         * Finds the lesser of the two objects, objects passed in must be
+         * less-than-comparable.
+         *@param a A value to test.
+         *@param b Another value to test.
+         *@returns A reference to the lesser of a or b.
+         */
+        template<typename item>
+        const item &min( const item &a, const item &b )
+        {
+                return a<b?a:b;
+        }
+        
+        /**
+         * Finds the lesser of the two objects, objects passed in must be
+         * less-than-comparable.
+         *@param a A value to test.
+         *@param b Another value to test.
+         *@returns A reference to the lesser of a or b.
+         */
+        template<typename item>
+        item &min( item &a, item &b )
+        {
+                return a<b?a:b;
+        }
+        
+        /**
+         * Finds the greater of the two objects, objects passed in must be
+         * less-than-comparable.
+         *@param a A value to test.
+         *@param b Another value to test.
+         *@returns A reference to the greater of a or b.
+         */
+        template<typename item>
+        const item &max( const item &a, const item &b )
+        {
+                return b<a?a:b;
+        }
+        
+        /**
+         * Finds the greater of the two objects, objects passed in must be
+         * less-than-comparable.
+         *@param a A value to test.
+         *@param b Another value to test.
+         *@returns A reference to the greater of a or b.
+         */
+        template<typename item>
+        item &max( item &a, item &b )
+        {
+                return b<a?a:b;
+        }
+
+        /**
+         * Given three objects this finds the one between the other two.
+         *@param a A value to test.
+         *@param b Another value to test.
+         *@param c Yet another value to test.
+         *@returns A reference to the mid-value of a, b, and c.
+         */
+        template<typename item>
+        const item &mid( const item &a, const item &b, const item &c )
+        {
+                return min( max( a, b ), c );
+        }
+                
+        /**
+         * Given three objects this finds the one between the other two.
+         *@param a A value to test.
+         *@param b Another value to test.
+         *@param c Yet another value to test.
+         *@returns A reference to the mid-value of a, b, and c.
+         */
+        template<typename item>
+        item &mid( item &a, item &b, item &c )
+        {
+                return min( max( a, b ), c );
+        }
+        
+        //
+        //  Basic comparison functors
+        //
+        /**
+         * Simple less-than comparison functor.  Objects being used should be
+         * less-than-comparable.
+         */
+        template<typename item>
+        struct __basicLTCmp
+        {
+                bool operator()( const item &a, const item &b )
+                {
+                        return a < b;
+                }
+        };
+        
+        /**
+         * Simple greater-than comparison functor.  Objects being used should be
+         * greater-than-comparable.
+         */
+        template<typename item>
+        struct __basicGTCmp
+        {
+                bool operator()( const item &a, const item &b )
+                {
+                        return a > b;
+                }
+        };
+
+        /**
+         * As __basicLTCmp but dereferences the passed in pointers before comparing.
+         */
+        template<typename item>
+        struct __basicPtrLTCmp
+        {
+                bool operator()( const item &a, const item &b )
+                {
+                        return *a < *b;
+                }
+        };
+        
+        /**
+         * As __basicGTCmp but dereferences the passed in pointers before comparing.
+         */
+        template<typename item>
+        struct __basicPtrGTCmp
+        {
+                bool operator()( const item &a, const item &b )
+                {
+                        return *a > *b;
+                }
+        };
+
+        /**
+         * Get the number of days in the month in the gregorian calendar, taking
+         * leap years into account.
+         */
+        int getDaysInMonth( int iMonth, int iYear );
+
+        void memcpy( void *pDest, const void *pSrc, size_t iBytes );
+};
+
+#endif
diff --git a/src/stable/variant.cpp b/src/stable/variant.cpp
new file mode 100644
index 0000000..5cdaa5b
--- /dev/null
+++ b/src/stable/variant.cpp
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/variant.h"
+#include "bu/formatter.h"
+#include "bu/membuf.h"
+
+namespace Bu
+{
+        Formatter &operator<<( Formatter &f, const String &s );
+};
+
+Bu::VariantTypeRoot::VariantTypeRoot()
+{
+}
+
+Bu::VariantTypeRoot::~VariantTypeRoot()
+{
+}
+
+Bu::Variant::Variant() :
+        pCore( NULL )
+{
+}
+
+Bu::Variant::Variant( const Variant &v ) :
+        pCore( NULL )
+{
+        if( v.pCore )
+        {
+                pCore = v.pCore->clone();
+        }
+}
+
+Bu::Variant::Variant( const char *t ) :
+        pCore( NULL )
+{
+        set( Bu::String( t ) );
+}
+
+Bu::Variant::~Variant()
+{
+        if( pCore )
+        {
+                delete pCore;
+                pCore = NULL;
+        }
+}
+
+Bu::String Bu::Variant::toString() const
+{
+        Bu::MemBuf mb;
+        Bu::Formatter f( mb );
+        f << *this;
+        return mb.getString();
+}
+
+bool Bu::Variant::isSet() const
+{
+        return pCore != NULL;
+}
+
+const std::type_info &Bu::Variant::getType() const
+{
+        if( !pCore )
+        {
+                throw Bu::ExceptionBase("No data!");
+        }
+        return pCore->getType();
+}
+
+Bu::Variant &Bu::Variant::operator=( const Bu::Variant &rhs )
+{
+        if( pCore )
+        {
+                delete pCore;
+                pCore = NULL;
+        }
+        if( rhs.pCore )
+        {
+                pCore = rhs.pCore->clone();
+        }
+
+        return *this;
+}
+
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::Variant &v )
+{
+        if( !v.pCore )
+                return f << "(null)";
+
+        v.pCore->format( f );
+        return f;
+}
+
diff --git a/src/stable/variant.h b/src/stable/variant.h
new file mode 100644
index 0000000..45e3339
--- /dev/null
+++ b/src/stable/variant.h
@@ -0,0 +1,236 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_VARIANT_H
+#define BU_VARIANT_H
+
+//#include <bu/string.h>
+#include <typeinfo>
+// #include <bu/formatter.h>
+
+#ifndef NULL
+#define NULL (0L)
+#endif
+
+#include "bu/exceptionbase.h"
+
+namespace Bu
+{
+        class String;
+        class Formatter;
+        class Variant;
+        /** @cond DEVEL */
+        template<class t> class VariantType;
+
+        class VariantTypeRoot
+        {
+        public:
+                VariantTypeRoot();
+                virtual ~VariantTypeRoot();
+
+                virtual const std::type_info &getType() const=0;
+                virtual VariantTypeRoot *clone() const=0;
+                virtual void format( Bu::Formatter &f ) const=0;
+        };
+
+        template<class t>
+        class VariantType : public VariantTypeRoot
+        {
+                friend class Variant;
+        private:
+                VariantType()
+                {
+                }
+
+                VariantType( const t &d ) : 
+                        data( d )
+                {
+                }
+
+                VariantType( const VariantType<t> &vt ) :
+                        data( vt.data )
+                {
+                }
+
+                virtual ~VariantType()
+                {
+                }
+
+        public:
+                t &getData()
+                {
+                        return data;
+                }
+                
+                const t &getData() const
+                {
+                        return data;
+                }
+
+                virtual void format( Formatter &f ) const
+                {
+                        f << data;
+                }
+
+                virtual const std::type_info &getType() const
+                {
+                        return typeid( data );
+                }
+
+                VariantType<t> operator=( const t &rhs )
+                {
+                        data = rhs;
+
+                        return *this;
+                }
+
+                virtual VariantTypeRoot *clone() const
+                {
+                        return new VariantType<t>( *this );
+                }
+
+        private:
+                t data;
+        };
+        /** @endcond */
+
+        /**
+         * Store any data type and access it safely.  Variant gives you a way to
+         * pass arbitrary data types around without having to worry about what
+         * type a variable is.  It allows code to be easily extended and to manage
+         * data without having to know what type it is ahead of time.
+         *
+         * Because of the generic method that this class was implemented it may seem
+         * to have some drawbacks compared to other Variant classes you may have
+         * seen, however it is fairly easy to get it to do just about anything you
+         * may need.  It is also very low overhead.  On most compilers the class
+         * itself has only 3 words of overhead + the size of the variable you store
+         * in it.  And, since many parts of it are templatized they can often be
+         * optimized quite a bit.
+         */
+        class Variant
+        {
+        friend Bu::Formatter &operator<<( Bu::Formatter &f, const Variant &v );
+        public:
+                Variant();
+                Variant( const Variant &v );
+                Variant( const char *t );
+                template<class t>
+                Variant( const t &v ) :
+                        pCore( new VariantType<t>() )
+                {
+                        (*dynamic_cast<VariantType<t> *>(pCore)) = v;
+                }
+                virtual ~Variant();
+
+                Bu::String toString() const;
+                bool isSet() const;
+                const std::type_info &getType() const;
+
+                Variant &operator=( const Variant &rhs );
+
+                template<class t>
+                Variant &operator=( const t &rhs )
+                {
+                        if( pCore ) // && pCore->getType() != typeid(t) )
+                        {
+                                delete pCore;
+                                pCore = NULL;
+                        }
+                        pCore = new VariantType<t>();
+                        (*dynamic_cast<VariantType<t> *>(pCore)) = rhs;
+                        return *this;
+                }
+
+                template<class t>
+                t &get()
+                {
+                        if( !pCore )
+                        {
+                                throw Bu::ExceptionBase("No data!");
+                        }
+                        if( pCore->getType() != typeid(t) )
+                        {
+                                throw Bu::ExceptionBase("Invalid type conversion.");
+                        }
+                        return dynamic_cast<VariantType<t> *>(pCore)->getData();
+                }
+                
+                template<class t>
+                t &get() const
+                {
+                        if( !pCore )
+                        {
+                                throw Bu::ExceptionBase("No data!");
+                        }
+                        if( pCore->getType() != typeid(t) )
+                        {
+                                throw Bu::ExceptionBase("Invalid type conversion.");
+                        }
+                        return dynamic_cast<VariantType<t> *>(pCore)->getData();
+                }
+                
+                template<class t>
+                void set( const t &val )
+                {
+                        if( pCore && pCore->getType() != typeid(t) )
+                        {
+                                delete pCore;
+                                pCore = NULL;
+                        }
+                        pCore = new VariantType<t>();
+                        (*dynamic_cast<VariantType<t> *>(pCore)) = val;
+                }
+
+                template<class t>
+                bool isType() const
+                {
+                        return pCore->getType() == typeid(t);
+                }
+
+                template<class t>
+                operator t()
+                {
+                        if( !pCore )
+                        {
+                                throw Bu::ExceptionBase("No data!");
+                        }
+                        if( pCore->getType() != typeid(t) )
+                        {
+                                throw Bu::ExceptionBase("Invalid type conversion.");
+                        }
+                        return dynamic_cast<VariantType<t> *>(pCore)->getData();
+                }
+                
+                template<class t>
+                operator t() const
+                {
+                        if( !pCore )
+                        {
+                                throw Bu::ExceptionBase("No data!");
+                        }
+                        if( pCore->getType() != typeid(t) )
+                        {
+                                throw Bu::ExceptionBase("Invalid type conversion.");
+                        }
+                        return dynamic_cast<VariantType<t> *>(pCore)->getData();
+                }
+
+        private:
+                VariantTypeRoot *pCore;
+        };
+/*
+        template<class t>
+        Bu::Formatter &operator<<( Bu::Formatter &f, const VariantType<t> &vt )
+        {
+                return f << vt.getData;
+        }*/
+
+        Bu::Formatter &operator<<( Bu::Formatter &f, const Variant &v );
+};
+
+#endif