SharedCore has more features now, which is cool, including a test to see if

another object of the parent type has the same core, and another to clone the
parent object.  That one is pretty cool, it means you can now get a real copy
when you want to, great for multi-threaded stuff.

Also, two more classes are now SharedCore: Hash and Heap!

1 files changed, 528 insertions, 508 deletions

diff --git a/src/hash.h b/src/hash.h
index 1cb539b..714a7f7 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,137 +50,354 @@ 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
+        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
                 {
-                        return bFilled;
+                        for( uint32_t j = 0; 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 getNextPos( uint32_t nPos, bool &bFinished ) const
                 {
-                        if( bFilled )
+                        for( uint32_t j = nPos+1; j < nCapacity; j++ )
                         {
-                                hsh._erase( nPos );
-                                hsh.onDelete();
+                                if( isFilled( j ) )
+                                        if( !isDeleted( j ) )
+                                                return j;
                         }
+
+                        bFinished = true;
+                        return 0;
                 }
 
-                /**
-                 * Assign data to this point in the hash table.
-                 *@param nval (value_type) the data to assign.
-                 */
-                _value operator=( _value nval )
+                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++
+                                )
                         {
-                                hsh.va.destroy( &hsh.aValues[nPos] );
-                                hsh.va.construct( &hsh.aValues[nPos], nval );
-                                hsh.onUpdate();
+                                // 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
                         {
-                                hsh.fill( nPos, *pKey, nval, hash ); 
-                                hsh.onInsert();
+                                fill( nPos, k, v, hash );
                         }
+                }
 
-                        return nval;
+                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 );
                 }
 
-                /**
-                 * Pointer extraction operator. Access to members of data pointed to
-                 *              by HashProxy.
-                 *@returns (value_type *)
-                 */
-                _value *operator->()
+                bool isFilled( 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 (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;
         };
 
         /**
@@ -224,119 +442,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 )
+                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 );
                 }
 
-                Hash( const Hash &src ) :
-                        nCapacity( src.nCapacity ),
-                        nFilled( 0 ),
-                        nDeleted( 0 ),
-                        bFilled( NULL ),
-                        bDeleted( NULL ),
-                        aKeys( NULL ),
-                        aValues( NULL ),
-                        aHashCodes( NULL )
+                Hash( const MyType &src ) :
+                        SharedCore<MyType, Core >( src )
                 {
-                        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 )
-                {
-                        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 +482,7 @@ namespace Bu
                  */
                 uint32_t getCapacity() const
                 {
-                        return nCapacity;
+                        return core->nCapacity;
                 }
 
                 /**
@@ -355,7 +492,7 @@ namespace Bu
                  */
                 uint32_t getFill() const
                 {
-                        return nFilled;
+                        return core->nFilled;
                 }
 
                 /**
@@ -364,12 +501,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 +516,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 +658,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 +689,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 +707,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 +715,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 +742,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 +766,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 +786,7 @@ namespace Bu
                                 nPos( 0 ),
                                 bFinished( false )
                         {
-                                nPos = hsh->getFirstPos( bFinished );
+                                nPos = hsh->core->getFirstPos( bFinished );
                         }
                         
                         iterator( MyType *hsh, bool bDone ) :
@@ -590,11 +815,6 @@ namespace Bu
                         {
                         }
 
-                        DEPRECATED bool isActive() const
-                        {
-                                return !bFinished;
-                        }
-
                         bool isValid() const
                         {
                                 return !bFinished;
@@ -611,7 +831,7 @@ namespace Bu
                         iterator operator++( int )
                         {
                                 if( bFinished == false )
-                                        nPos = hsh->getNextPos( nPos, bFinished );
+                                        nPos = hsh->core->getNextPos( nPos, bFinished );
 
                                 return *this;
                         }
@@ -622,7 +842,7 @@ namespace Bu
                         iterator operator++()
                         {
                                 if( bFinished == false )
-                                        nPos = hsh->getNextPos( nPos, bFinished );
+                                        nPos = hsh->core->getNextPos( nPos, bFinished );
 
                                 return *this;
                         }
@@ -671,21 +891,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 +915,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 +941,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 +993,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 +1004,7 @@ namespace Bu
                         const_iterator operator++()
                         {
                                 if( bFinished == false )
-                                        nPos = hsh->getNextPos( nPos, bFinished );
+                                        nPos = hsh->core->getNextPos( nPos, bFinished );
 
                                 return *this;
                         }
@@ -822,7 +1053,7 @@ namespace Bu
                          */
                         const value &operator *() const
                         {
-                                return hsh->getValueAtPos( nPos );
+                                return hsh->core->getValueAtPos( nPos );
                         }
                         
                         /**
@@ -831,7 +1062,7 @@ namespace Bu
                          */
                         const key &getKey() const
                         {
-                                return hsh->getKeyAtPos( nPos );
+                                return hsh->core->getKeyAtPos( nPos );
                         }
 
                         /**
@@ -840,7 +1071,7 @@ namespace Bu
                          */
                         const value &getValue() const
                         {
-                                return hsh->getValueAtPos( nPos );
+                                return hsh->core->getValueAtPos( nPos );
                         }
                 } const_iterator;
 
@@ -883,13 +1114,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 +1132,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] );
                                         }
                                 }
                         }
@@ -916,243 +1147,32 @@ namespace Bu
                 }
 
         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
-                {
-                        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++
-                                )
-                        {
-                                // 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(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;
-                }
-                
-                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;
-                }
-
-                void reHash( uint32_t nNewSize )
+                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 );
+                        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();
 
-                        nDeleted = nFilled = 0;
+                        pRet->aHashCodes = pRet->ca.allocate( pRet->nCapacity );
+                        pRet->aKeys = pRet->ka.allocate( pRet->nCapacity );
+                        pRet->aValues = pRet->va.allocate( pRet->nCapacity );
 
-                        // Re-insert all of the old data (except deleted items)
-                        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 ) )
                                 {
-                                        insert( aOldKeys[j], aOldValues[j] );
+                                        pRet->insert( src->aKeys[j], src->aValues[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 );
-                }
-
-                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 )