Merged in the core branch. This is a major update that fixes many things, and

changes many others, including source files that were deleted and renamed.

Before doing this update, I reccomend a full clean, or even a fresh checkout.

Things to note, most outstanding about this update:
 - Bu::Socket was changed to Bu::TcpSocket and the default mode is blocking.
 - All templatized container classes are SharedCore now, which is good, but
   SharedCore is inherently non-reentrant safe.  However, all SharedCore classes
   have a "clone" function that return a non-shared copy of the object, safe for
   passing into a reentrant safe function accessing shared memory.

1 files changed, 560 insertions, 497 deletions

diff --git a/src/hash.h b/src/hash.h
index 1cb539b..354569e 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -12,7 +12,8 @@
 #include "bu/exceptionbase.h"
 #include "bu/list.h"
 #include "bu/util.h"
-#include "archivebase.h"
+#include "bu/archivebase.h"
+#include "bu/sharedcore.h"
 
 #define bitsToBytes( n ) (n/32+(n%32>0 ? 1 : 0))
 
@@ -49,138 +50,357 @@ namespace Bu
                 }
         };
 
-        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> >
+        template<typename key, typename value, typename sizecalc, typename keyalloc,
+                typename valuealloc, typename challoc>
         class Hash;
 
-        template< typename key, typename _value, typename sizecalc = __calcNextTSize_fast, typename keyalloc = std::allocator<key>, typename valuealloc = std::allocator<_value>, typename challoc = std::allocator<uint32_t> >
-        struct HashProxy
+        /** @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 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:
-                HashProxy( Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &h, const key *k, uint32_t nPos, uint32_t hash ) :
-                        hsh( h ),
-                        pKey( k ),
-                        nPos( nPos ),
-                        hash( hash ),
-                        bFilled( false )
+                HashCore() :
+                        nCapacity( 0 ),
+                        nFilled( 0 ),
+                        nDeleted( 0 ),
+                        bFilled( NULL ),
+                        bDeleted( NULL ),
+                        aKeys( NULL ),
+                        aValues( NULL ),
+                        aHashCodes( NULL )
                 {
                 }
 
-                HashProxy( Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &h, uint32_t nPos, _value *pValue ) :
-                        hsh( h ),
-                        nPos( nPos ),
-                        pValue( pValue ),
-                        bFilled( true )
+                virtual ~HashCore()
                 {
+                        clear();
                 }
 
-                Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &hsh;
-                const key *pKey;
-                uint32_t nPos;
-                _value *pValue;
-                uint32_t hash;
-                bool bFilled;
+                void init()
+                {
+                        if( nCapacity > 0 )
+                                return;
 
-        public:
-                /**
-                 * Cast operator for HashProxy.
-                 *@returns (value_type &) The value the HashProxy is pointing to.
-                 */
-                operator _value &()
+                        nCapacity = 11;
+                        nKeysSize = bitsToBytes( 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( bFilled == false )
-                                throw HashException(
-                                                excodeNotFilled,
-                                                "No data assosiated with that key."
-                                                );
-                        return *pValue;
+                        if( nCapacity == 0 )
+                                return;
+
+                        for( uint32_t j = 0; j < nKeysSize; j++ )
+                        {
+                                bFilled[j] = bDeleted[j] = 0;
+                        }
                 }
 
-                /**
-                 * Direct function for retrieving a value out of the HashProxy.
-                 *@returns (value_type &) The value pointed to by this HashProxy.
-                 */
-                DEPRECATED
-                _value &value()
+                void fill( uint32_t loc, const key &k, const value &v, uint32_t hash )
                 {
-                        if( bFilled == false )
-                                throw HashException(
-                                                excodeNotFilled,
-                                                "No data assosiated with that key."
-                                                );
-                        return *pValue;
+                        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];
                 }
                 
-                /**
-                 * Direct function for retrieving a value out of the HashProxy.
-                 *@returns (value_type &) The value pointed to by this HashProxy.
-                 */
-                _value &getValue()
+                const key &getKeyAtPos( uint32_t nPos ) const
                 {
-                        if( bFilled == false )
-                                throw HashException(
-                                                excodeNotFilled,
-                                                "No data assosiated with that key."
-                                                );
-                        return *pValue;
+                        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];
                 }
 
-                /**
-                 * Whether this HashProxy points to something real or not.
-                 */
-                bool isFilled()
+                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
                 {
-                        return bFilled;
+                        for( uint32_t j = nPos+1; j < nCapacity; j++ )
+                        {
+                                if( isFilled( j ) )
+                                        if( !isDeleted( j ) )
+                                                return j;
+                        }
+
+                        bFinished = true;
+                        return 0;
                 }
 
-                /**
-                 * Erase the data pointed to by this HashProxy.
-                 */
-                void erase()
+                uint32_t probe( uint32_t hash, const key &k, bool &bFill, bool rehash=true )
                 {
-                        if( bFilled )
+                        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 )
                         {
-                                hsh._erase( nPos );
-                                hsh.onDelete();
+                                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.");
 
-                /**
-                 * Assign data to this point in the hash table.
-                 *@param nval (value_type) the data to assign.
-                 */
-                _value operator=( _value nval )
+                        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 )
                 {
-                        if( bFilled )
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = probe( hash, k, bFill );
+
+                        if( bFill )
                         {
-                                hsh.va.destroy( &hsh.aValues[nPos] );
-                                hsh.va.construct( &hsh.aValues[nPos], nval );
-                                hsh.onUpdate();
+                                va.destroy( &aValues[nPos] );
+                                va.construct( &aValues[nPos], v );
                         }
                         else
                         {
-                                hsh.fill( nPos, *pKey, nval, hash ); 
-                                hsh.onInsert();
+                                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 = bitsToBytes( 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 );
+                }
 
-                        return nval;
+                bool isFilled( uint32_t loc ) const
+                {
+                        if( loc >= nCapacity )
+                                throw HashException("Referenced position invalid.");
+                        return (bFilled[loc/32]&(1<<(loc%32)))!=0;
                 }
 
-                /**
-                 * Pointer extraction operator. Access to members of data pointed to
-                 *              by HashProxy.
-                 *@returns (value_type *)
-                 */
-                _value *operator->()
+                bool isDeleted( uint32_t loc ) const
                 {
-                        if( bFilled == false )
-                                throw HashException(
-                                                excodeNotFilled,
-                                                "No data assosiated with that key."
-                                                );
-                        return pValue;
+                        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
@@ -224,119 +444,38 @@ namespace Bu
          *@param challoc (typename) Byte allocator for bitflags
          *@ingroup Containers
          */
-        template<typename key, typename value, typename sizecalc, typename keyalloc, typename valuealloc, typename challoc >
-        class Hash
+        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>
+                                 >
         {
-                friend struct HashProxy<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() :
-                        nCapacity( 11 ),
-                        nFilled( 0 ),
-                        nDeleted( 0 ),
-                        bFilled( NULL ),
-                        bDeleted( NULL ),
-                        aKeys( NULL ),
-                        aValues( NULL ),
-                        aHashCodes( NULL )
-                {
-                        nKeysSize = bitsToBytes( nCapacity );
-                        bFilled = ca.allocate( nKeysSize );
-                        bDeleted = ca.allocate( nKeysSize );
-                        clearBits();
-
-                        aHashCodes = ca.allocate( nCapacity );
-                        aKeys = ka.allocate( nCapacity );
-                        aValues = va.allocate( nCapacity );
-                }
-
-                Hash( const Hash &src ) :
-                        nCapacity( src.nCapacity ),
-                        nFilled( 0 ),
-                        nDeleted( 0 ),
-                        bFilled( NULL ),
-                        bDeleted( NULL ),
-                        aKeys( NULL ),
-                        aValues( NULL ),
-                        aHashCodes( NULL )
+                Hash()
                 {
-                        nKeysSize = bitsToBytes( nCapacity );
-                        bFilled = ca.allocate( nKeysSize );
-                        bDeleted = ca.allocate( nKeysSize );
-                        clearBits();
-
-                        aHashCodes = ca.allocate( nCapacity );
-                        aKeys = ka.allocate( nCapacity );
-                        aValues = va.allocate( nCapacity );
-
-                        for( uint32_t j = 0; j < src.nCapacity; j++ )
-                        {
-                                if( src.isFilled( j ) && !src.isDeleted( j ) )
-                                {
-                                        insert( src.aKeys[j], src.aValues[j] );
-                                }
-                        }
                 }
 
-                /**
-                 * Hashtable assignment operator. Clears this hashtable and
-                 * copies RH into it.
-                 */
-                Hash &operator=( const Hash &src )
+                Hash( const MyType &src ) :
+                        SharedCore<MyType, Core >( src )
                 {
-                        for( uint32_t j = 0; j < nCapacity; j++ )
-                        {
-                                if( isFilled( j ) && !isDeleted( j ) )
-                                {
-                                        va.destroy( &aValues[j] );
-                                        ka.destroy( &aKeys[j] );
-                                }
-                        }
-                        va.deallocate( aValues, nCapacity );
-                        ka.deallocate( aKeys, nCapacity );
-                        ca.deallocate( bFilled, nKeysSize );
-                        ca.deallocate( bDeleted, nKeysSize );
-                        ca.deallocate( aHashCodes, nCapacity );
-
-                        nFilled = 0;
-                        nDeleted = 0;
-                        nCapacity = src.nCapacity;
-                        nKeysSize = bitsToBytes( nCapacity );
-                        bFilled = ca.allocate( nKeysSize );
-                        bDeleted = ca.allocate( nKeysSize );
-                        clearBits();
-
-                        aHashCodes = ca.allocate( nCapacity );
-                        aKeys = ka.allocate( nCapacity );
-                        aValues = va.allocate( nCapacity );
-
-                        for( uint32_t j = 0; j < src.nCapacity; j++ )
-                        {
-                                if( src.isFilled( j ) && !src.isDeleted( j ) )
-                                {
-                                        insert( src.aKeys[j], src.aValues[j] );
-                                }
-                        }
-
-                        return *this;
                 }
 
                 virtual ~Hash()
                 {
-                        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 );
                 }
 
                 /**
@@ -345,7 +484,7 @@ namespace Bu
                  */
                 uint32_t getCapacity() const
                 {
-                        return nCapacity;
+                        return core->nCapacity;
                 }
 
                 /**
@@ -355,7 +494,7 @@ namespace Bu
                  */
                 uint32_t getFill() const
                 {
-                        return nFilled;
+                        return core->nFilled;
                 }
 
                 /**
@@ -364,12 +503,12 @@ namespace Bu
                  */
                 uint32_t getSize() const
                 {
-                        return nFilled-nDeleted;
+                        return core->nFilled-core->nDeleted;
                 }
 
                 bool isEmpty() const
                 {
-                        return (nFilled-nDeleted) == 0;
+                        return (core->nFilled-core->nDeleted) == 0;
                 }
 
                 /**
@@ -379,27 +518,140 @@ namespace Bu
                  */
                 uint32_t getDeleted() const
                 {
-                        return nDeleted;
+                        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.
                  */
-                virtual HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc> operator[]( const key &k )
+                HashProxy operator[]( const key &k )
                 {
+                        _hardCopy();
+
                         uint32_t hash = __calcHashCode( k );
                         bool bFill;
-                        uint32_t nPos = probe( hash, k, bFill );
+                        uint32_t nPos = core->probe( hash, k, bFill );
 
                         if( bFill )
                         {
-                                return HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>( *this, nPos, &aValues[nPos] );
+                                return HashProxy( *this, nPos, &core->aValues[nPos] );
                         }
                         else
                         {
-                                return HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>( *this, &k, nPos, hash );
+                                return HashProxy( *this, &k, nPos, hash );
                         }
                 }
 
@@ -408,39 +660,28 @@ namespace Bu
                  *@param k (key_type) Key to list the value under.
                  *@param v (value_type) Value to store in the hash table.
                  */
-                virtual void insert( const key &k, const value &v )
+                void insert( const key &k, const value &v )
                 {
-                        uint32_t hash = __calcHashCode( k );
-                        bool bFill;
-                        uint32_t nPos = probe( hash, k, bFill );
+                        _hardCopy();
 
-                        if( bFill )
-                        {
-                                va.destroy( &aValues[nPos] );
-                                va.construct( &aValues[nPos], v );
-                                onUpdate();
-                        }
-                        else
-                        {
-                                fill( nPos, k, v, hash );
-                                onInsert();
-                        }
+                        core->insert( k, v );
                 }
 
                 /**
                  * Remove a value from the hash table.
                  *@param k (key_type) The data under this key will be erased.
                  */
-                virtual void erase( const key &k )
+                void erase( const key &k )
                 {
+                        _hardCopy();
+
                         uint32_t hash = __calcHashCode( k );
                         bool bFill;
-                        uint32_t nPos = probe( hash, k, bFill );
+                        uint32_t nPos = core->probe( hash, k, bFill );
 
                         if( bFill )
                         {
-                                _erase( nPos );
-                                onDelete();
+                                core->_erase( nPos );
                         }
                 }
 
@@ -450,14 +691,16 @@ namespace Bu
                  * Remove a value from the hash pointed to from an iterator.
                  *@param i (iterator &) The data to be erased.
                  */
-                virtual void erase( struct iterator &i )
+                void erase( struct iterator &i )
                 {
                         if( this != i.hsh )
                                 throw HashException("This iterator didn't come from this Hash.");
-                        if( isFilled( i.nPos ) && !isDeleted( i.nPos ) )
+                        
+                        _hardCopy();
+
+                        if( core->isFilled( i.nPos ) && !core->isDeleted( i.nPos ) )
                         {
-                                _erase( i.nPos );
-                                onDelete();
+                                core->_erase( i.nPos );
                         }
                 }
 
@@ -466,17 +709,7 @@ namespace Bu
                  */
                 virtual void clear()
                 {
-                        for( uint32_t j = 0; j < nCapacity; j++ )
-                        {
-                                if( isFilled( j ) )
-                                        if( !isDeleted( j ) )
-                                        {
-                                                _erase( j );
-                                                onDelete();
-                                        }
-                        }
-                        
-                        clearBits();
+                        _resetCore();
                 }
 
                 /**
@@ -484,15 +717,17 @@ namespace Bu
                  *@param k (key_type) Key pointing to the data to be retrieved.
                  *@returns (value_type &) The data pointed to by (k).
                  */
-                virtual value &get( const key &k )
+                value &get( const key &k )
                 {
+                        _hardCopy();
+
                         uint32_t hash = __calcHashCode( k );
                         bool bFill;
-                        uint32_t nPos = probe( hash, k, bFill, false );
+                        uint32_t nPos = core->probe( hash, k, bFill, false );
 
                         if( bFill )
                         {
-                                return aValues[nPos];
+                                return core->aValues[nPos];
                         }
                         else
                         {
@@ -509,15 +744,15 @@ namespace Bu
                  *@returns (const value_type &) A const version of the data pointed
                  *              to by (k).
                  */
-                virtual const value &get( const key &k ) const
+                const value &get( const key &k ) const
                 {
                         uint32_t hash = __calcHashCode( k );
                         bool bFill;
-                        uint32_t nPos = probe( hash, k, bFill );
+                        uint32_t nPos = core->probe( hash, k, bFill );
 
                         if( bFill )
                         {
-                                return aValues[nPos];
+                                return core->aValues[nPos];
                         }
                         else
                         {
@@ -533,18 +768,10 @@ namespace Bu
                  *@param k (key_type) The key to check.
                  *@returns (bool) Whether there was an item in the hash under key (k).
                  */
-                virtual bool has( const key &k )
+                bool has( const key &k ) const
                 {
                         bool bFill;
-                        probe( __calcHashCode( k ), k, bFill, false );
-
-                        return bFill;
-                }
-                
-                virtual bool has( const key &k ) const
-                {
-                        bool bFill;
-                        probe( __calcHashCode( k ), k, bFill );
+                        core->probe( __calcHashCode( k ), k, bFill );
 
                         return bFill;
                 }
@@ -561,7 +788,7 @@ namespace Bu
                                 nPos( 0 ),
                                 bFinished( false )
                         {
-                                nPos = hsh->getFirstPos( bFinished );
+                                nPos = hsh->core->getFirstPos( bFinished );
                         }
                         
                         iterator( MyType *hsh, bool bDone ) :
@@ -590,11 +817,6 @@ namespace Bu
                         {
                         }
 
-                        DEPRECATED bool isActive() const
-                        {
-                                return !bFinished;
-                        }
-
                         bool isValid() const
                         {
                                 return !bFinished;
@@ -611,7 +833,7 @@ namespace Bu
                         iterator operator++( int )
                         {
                                 if( bFinished == false )
-                                        nPos = hsh->getNextPos( nPos, bFinished );
+                                        nPos = hsh->core->getNextPos( nPos, bFinished );
 
                                 return *this;
                         }
@@ -622,7 +844,7 @@ namespace Bu
                         iterator operator++()
                         {
                                 if( bFinished == false )
-                                        nPos = hsh->getNextPos( nPos, bFinished );
+                                        nPos = hsh->core->getNextPos( nPos, bFinished );
 
                                 return *this;
                         }
@@ -671,21 +893,22 @@ namespace Bu
                          */
                         value &operator *()
                         {
-                                return hsh->getValueAtPos( nPos );
+                                hsh->_hardCopy();
+                                return hsh->core->getValueAtPos( nPos );
                         }
 
                         const value &operator *() const
                         {
-                                return hsh->getValueAtPos( nPos );
+                                return hsh->core->getValueAtPos( nPos );
                         }
                         
                         /**
                          * Get the key behind this iterator.
                          *@returns (key_type &) The key behind this iterator.
                          */
-                        key &getKey()
+                        const key &getKey() const
                         {
-                                return hsh->getKeyAtPos( nPos );
+                                return hsh->core->getKeyAtPos( nPos );
                         }
 
                         /**
@@ -694,7 +917,17 @@ namespace Bu
                          */
                         value &getValue()
                         {
-                                return hsh->getValueAtPos( nPos );
+                                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;
                 
@@ -710,7 +943,7 @@ namespace Bu
                                 nPos( 0 ),
                                 bFinished( false )
                         {
-                                nPos = hsh->getFirstPos( bFinished );
+                                nPos = hsh->core->getFirstPos( bFinished );
                         }
                         
                         const_iterator( const MyType *hsh, bool bDone ) :
@@ -762,7 +995,7 @@ namespace Bu
                         const_iterator operator++( int )
                         {
                                 if( bFinished == false )
-                                        nPos = hsh->getNextPos( nPos, bFinished );
+                                        nPos = hsh->core->getNextPos( nPos, bFinished );
 
                                 return *this;
                         }
@@ -773,7 +1006,7 @@ namespace Bu
                         const_iterator operator++()
                         {
                                 if( bFinished == false )
-                                        nPos = hsh->getNextPos( nPos, bFinished );
+                                        nPos = hsh->core->getNextPos( nPos, bFinished );
 
                                 return *this;
                         }
@@ -822,7 +1055,7 @@ namespace Bu
                          */
                         const value &operator *() const
                         {
-                                return hsh->getValueAtPos( nPos );
+                                return hsh->core->getValueAtPos( nPos );
                         }
                         
                         /**
@@ -831,7 +1064,7 @@ namespace Bu
                          */
                         const key &getKey() const
                         {
-                                return hsh->getKeyAtPos( nPos );
+                                return hsh->core->getKeyAtPos( nPos );
                         }
 
                         /**
@@ -840,7 +1073,7 @@ namespace Bu
                          */
                         const value &getValue() const
                         {
-                                return hsh->getValueAtPos( nPos );
+                                return hsh->core->getValueAtPos( nPos );
                         }
                 } const_iterator;
 
@@ -883,13 +1116,13 @@ namespace Bu
                 {
                         Bu::List<key> lKeys;
 
-                        for( uint32_t j = 0; j < nCapacity; j++ )
+                        for( uint32_t j = 0; j < core->nCapacity; j++ )
                         {
-                                if( isFilled( j ) )
+                                if( core->isFilled( j ) )
                                 {
-                                        if( !isDeleted( j ) )
+                                        if( !core->isDeleted( j ) )
                                         {
-                                                lKeys.append( aKeys[j] );
+                                                lKeys.append( core->aKeys[j] );
                                         }
                                 }
                         }
@@ -901,13 +1134,13 @@ namespace Bu
                 {
                         Bu::List<value> lValues;
 
-                        for( uint32_t j = 0; j < nCapacity; j++ )
+                        for( uint32_t j = 0; j < core->nCapacity; j++ )
                         {
-                                if( isFilled( j ) )
+                                if( core->isFilled( j ) )
                                 {
-                                        if( !isDeleted( j ) )
+                                        if( !core->isDeleted( j ) )
                                         {
-                                                lValues.append( aValues[j] );
+                                                lValues.append( core->aValues[j] );
                                         }
                                 }
                         }
@@ -915,244 +1148,74 @@ namespace Bu
                         return lValues;
                 }
 
-        protected:
-                virtual void onInsert() {}
-                virtual void onUpdate() {}
-                virtual void onDelete() {}
-                virtual void onReHash() {}
-
-                virtual void clearBits()
-                {
-                        for( uint32_t j = 0; j < nKeysSize; j++ )
-                        {
-                                bFilled[j] = bDeleted[j] = 0;
-                        }
-                }
-
-                virtual void fill( uint32_t loc, const key &k, const value &v, uint32_t hash )
-                {
-                        bFilled[loc/32] |= (1<<(loc%32));
-                        va.construct( &aValues[loc], v );
-                        ka.construct( &aKeys[loc], k );
-                        aHashCodes[loc] = hash;
-                        nFilled++;
-                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                        //      nFilled, nDeleted, nCapacity );
-                }
-
-                virtual void _erase( uint32_t loc )
-                {
-                        bDeleted[loc/32] |= (1<<(loc%32));
-                        va.destroy( &aValues[loc] );
-                        ka.destroy( &aKeys[loc] );
-                        nDeleted++;
-                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                        //      nFilled, nDeleted, nCapacity );
-                }
-
-                virtual key &getKeyAtPos( uint32_t nPos )
-                {
-                        return aKeys[nPos];
-                }
-                
-                virtual const key &getKeyAtPos( uint32_t nPos ) const
-                {
-                        return aKeys[nPos];
-                }
-                
-                virtual value &getValueAtPos( uint32_t nPos )
-                {
-                        return aValues[nPos];
-                }
-                
-                virtual const value &getValueAtPos( uint32_t nPos ) const
-                {
-                        return aValues[nPos];
-                }
-
-                virtual 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;
-                }
-
-                virtual uint32_t getNextPos( uint32_t nPos, bool &bFinished ) const
+                bool operator==( const MyType &rhs ) 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 )
-                {
-                        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++
-                                )
+                        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++ )
                         {
-                                // Is this the same hash code we were looking for?
-                                if( hash == aHashCodes[nCur] )
+                                if( core->isFilled( j ) )
                                 {
-                                        // Skip over deleted entries.  Deleted entries are also filled,
-                                        // so we only have to do this check here.
-                                        if( isDeleted( nCur ) )
-                                                continue;
-
-                                        // Is it really the same key? (for safety)
-                                        if( __cmpHashKeys( aKeys[nCur], k ) == true )
+                                        if( !core->isDeleted( j ) )
                                         {
-                                                bFill = true;
-                                                return nCur;
+                                                // 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;
+                                                }
                                         }
                                 }
                         }
 
-                        // 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(getCapacity(), getFill(), getDeleted()) );
-
-                                // This is potentially dangerous, and could cause an infinite loop.
-                                // Be careful writing probe, eh?
-                                return probe( hash, k, bFill );
-                        }
-
-                        bFill = false;
-                        return nCur;
+                        return true;
                 }
-                
-                uint32_t probe( uint32_t hash, key k, bool &bFill ) const
-                {
-                        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;
+                bool operator!=( const MyType &rhs ) const
+                {
+                        return !(*this == rhs);
                 }
 
-                void reHash( uint32_t nNewSize )
+        protected:
+                virtual Core *_copyCore( Core *src )
                 {
-                        //printf("---REHASH---");
-                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                        //      nFilled, nDeleted, nCapacity );
-                        
-                        // Save all the old data
-                        uint32_t nOldCapacity = nCapacity;
-                        uint32_t *bOldFilled = bFilled;
-                        uint32_t *aOldHashCodes = aHashCodes;
-                        uint32_t nOldKeysSize = nKeysSize;
-                        uint32_t *bOldDeleted = bDeleted;
-                        value *aOldValues = aValues;
-                        key *aOldKeys = aKeys;
-                        
-                        // Calculate new sizes
-                        nCapacity = nNewSize;
-                        nKeysSize = bitsToBytes( nCapacity );
-                
-                        // Allocate new memory + prep
-                        bFilled = ca.allocate( nKeysSize );
-                        bDeleted = ca.allocate( nKeysSize );
-                        clearBits();
+                        Core *pRet = _allocateCore();
 
-                        aHashCodes = ca.allocate( nCapacity );
-                        aKeys = ka.allocate( nCapacity );
-                        aValues = va.allocate( nCapacity );
-
-                        nDeleted = nFilled = 0;
+                        pRet->nFilled = 0;
+                        pRet->nDeleted = 0;
+                        pRet->nCapacity = src->nCapacity;
+                        pRet->nKeysSize = bitsToBytes( pRet->nCapacity );
+                        pRet->bFilled = pRet->ca.allocate( pRet->nKeysSize );
+                        pRet->bDeleted = pRet->ca.allocate( pRet->nKeysSize );
+                        pRet->clearBits();
 
-                        // 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] );
-                                }
-                        }
+                        pRet->aHashCodes = pRet->ca.allocate( pRet->nCapacity );
+                        pRet->aKeys = pRet->ka.allocate( pRet->nCapacity );
+                        pRet->aValues = pRet->va.allocate( pRet->nCapacity );
 
-                        // Delete all of the old data
-                        for( uint32_t j = 0; j < nOldCapacity; j++ )
+                        for( uint32_t j = 0; j < src->nCapacity; j++ )
                         {
-                                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
-                                        (bOldDeleted[j/32]&(1<<(j%32)))==0 )
+                                if( src->isFilled( j ) && !src->isDeleted( j ) )
                                 {
-                                        va.destroy( &aOldValues[j] );
-                                        ka.destroy( &aOldKeys[j] );
+                                        pRet->insert( src->aKeys[j], src->aValues[j] );
                                 }
                         }
-                        va.deallocate( aOldValues, nOldCapacity );
-                        ka.deallocate( aOldKeys, nOldCapacity );
-                        ca.deallocate( bOldFilled, nOldKeysSize );
-                        ca.deallocate( bOldDeleted, nOldKeysSize );
-                        ca.deallocate( aOldHashCodes, nOldCapacity );
-                }
 
-                virtual bool isFilled( uint32_t loc ) const
-                {
-                        return (bFilled[loc/32]&(1<<(loc%32)))!=0;
-                }
-
-                virtual bool isDeleted( uint32_t loc ) const
-                {
-                        return (bDeleted[loc/32]&(1<<(loc%32)))!=0;
+                        return pRet;
                 }
-
-        protected:
-                uint32_t nCapacity;
-                uint32_t nFilled;
-                uint32_t nDeleted;
-                uint32_t *bFilled;
-                uint32_t *bDeleted;
-                uint32_t nKeysSize;
-                key *aKeys;
-                value *aValues;
-                uint32_t *aHashCodes;
-                valuealloc va;
-                keyalloc ka;
-                challoc ca;
-                sizecalc szCalc;
         };
         
         template<typename T> uint32_t __calcHashCode( const T &k )