Wow, craziness. Part way through working on the confpair system I got some

sudden insperation and completely redid Hash.  Now everything but delete is
implemented, including typesafe iterators and more.   It's really cool, and
everyone should check it out and start using it right away!

10 files changed, 662 insertions, 72 deletions

diff --git a/src/confpair.h b/src/confpair.h
index 5be33c8..56eb06e 100644
--- a/src/confpair.h
+++ b/src/confpair.h
@@ -3,11 +3,14 @@
 
 #include <stdint.h>
 #include <string>
+#include <sstream>
+#include "confpairbase.h"
+
 /**
  *
  */
 template<class T>
-class ConfPair
+class ConfPair : public ConfPairBase
 {
 public:
         ConfPair( const std::string &sName ) :
@@ -27,9 +30,52 @@ public:
                 return sName;
         }
 
+        virtual void setFromString( const std::string &sStr )
+        {
+                std::stringstream(sStr) >> tValue;
+        }
+
+        virtual std::string getAsString()
+        {
+                std::stringstream tmp;
+                tmp << tValue;
+                return tmp.str();
+        }
+
 private:
         std::string sName;
         T tValue;
 };
 
+template<>
+void ConfPair<std::string>::setFromString( const std::string &sStr )
+{
+        tValue = sStr;
+}
+
+template<>
+std::string ConfPair<std::string>::getAsString()
+{
+        return tValue;
+}
+
+template<>
+void ConfPair<bool>::setFromString( const std::string &sStr )
+{
+        if( !strcasecmp( sStr.c_str(), "true" ) ||
+                !strcasecmp( sStr.c_str(), "yes" ) ||
+                !strcasecmp( sStr.c_str(), "on" ) )
+                tValue = true;
+        else
+                tValue = false;
+}
+
+template<>
+std::string ConfPair<bool>::getAsString()
+{
+        if( tValue == true )
+                return "True";
+        return "False";
+}
+
 #endif
diff --git a/src/confpairbase.cpp b/src/confpairbase.cpp
new file mode 100644
index 0000000..1203dc0
--- /dev/null
+++ b/src/confpairbase.cpp
@@ -0,0 +1,17 @@
+#include "confpairbase.h"
+
+ConfPairBase::ConfPairBase()
+{
+}
+
+ConfPairBase::~ConfPairBase()
+{
+}
+
+ConfPairBase &ConfPairBase::operator=( const std::string &s )
+{
+        setFromString( s );
+
+        return *this;
+}
+
diff --git a/src/confpairbase.h b/src/confpairbase.h
new file mode 100644
index 0000000..2530756
--- /dev/null
+++ b/src/confpairbase.h
@@ -0,0 +1,24 @@
+#ifndef CONF_PAIR_BASE_H
+#define CONF_PAIR_BASE_H
+
+#include <stdint.h>
+#include <string>
+#include <ostream>
+#include <istream>
+
+class ConfPairBase
+{
+public:
+        ConfPairBase();
+        virtual ~ConfPairBase();
+
+        virtual void setFromString( const std::string &sStr )=0;
+        virtual std::string getAsString()=0;
+
+        ConfPairBase &operator=( const std::string &s );
+
+private:
+
+};
+
+#endif
diff --git a/src/hash.cpp b/src/hash.cpp
index b4aac77..14be208 100644
--- a/src/hash.cpp
+++ b/src/hash.cpp
@@ -1 +1,81 @@
 #include "hash.h"
+
+template<>
+uint32_t __calcHashCode<const char *>( const char * k )
+{
+        if (k == NULL)
+        {
+                return 0;
+        }
+        
+        unsigned long int nPos = 0;
+        for( const char *s = k; *s; s++ )
+        {
+                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
+        }
+
+        return nPos;
+}
+
+template<> bool __cmpHashKeys<const char *>( const char *a, const char *b )
+{
+        if( a == b )
+                return true;
+
+        for(; *a != *b; a++, b++ )
+                if( *a == '\0' && *b == '\0' )
+                        return true;
+
+        return false;
+}
+
+template<>
+uint32_t __calcHashCode<char *>( char *k )
+{
+        return __calcHashCode<const char *>((const char *)k );
+}
+
+template<> bool __cmpHashKeys<char *>( char *a, char *b )
+{
+        return __cmpHashKeys<const char *>((const char *)a, (const char *)b );
+}
+
+template<> uint32_t __calcHashCode<const std::string>( const std::string k )
+{
+        std::string::size_type j, sz = k.size();
+        const char *s = k.c_str();
+
+        unsigned long int nPos = 0;
+        for( j = 0; j < sz; j++, s++ )
+        {
+                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
+        }
+
+        return nPos;
+}
+
+template<> bool __cmpHashKeys<const std::string>( const std::string a, const std::string b )
+{
+        return a == b;
+}
+
+template<> uint32_t __calcHashCode<std::string>( std::string k )
+{
+        return __calcHashCode<const std::string>( k );
+}
+
+template<> bool __cmpHashKeys<std::string>( std::string a, std::string b )
+{
+        return __cmpHashKeys<const std::string>( a, b );
+}
+
+template<> uint32_t __calcHashCode<Hashable &>( Hashable &k )
+{
+        return k.getHashCode();
+}
+
+template<> bool __cmpHashKeys<Hashable &>( Hashable &a, Hashable &b )
+{
+        return a.compareForHash( b );
+}
+
diff --git a/src/hash.h b/src/hash.h
index 8385bb9..b8ced99 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -1,106 +1,431 @@
 #ifndef HASH_H
 #define HASH_H
-/*
+
 #include <stddef.h>
 #include <string.h>
+#include <memory>
+#include <iostream>
 #include "hashable.h"
 
-#define bitsToBytes( n ) (n/8+(n%8>0 ? 1 : 0))
+#define bitsToBytes( n ) (n/32+(n%32>0 ? 1 : 0))
+
+template<typename T>
+uint32_t __calcHashCode( T k );
+
+template<typename T>
+bool __cmpHashKeys( T a, T b );
+
+struct __calcNextTSize_fast
+{
+  uint32_t operator()( uint32_t nCapacity, uint32_t nFill, uint32_t nDeleted ) const
+  {
+    return nCapacity*2+1;
+  }
+};
+
+template<typename key, typename value, typename sizecalc = __calcNextTSize_fast, typename keyalloc = std::allocator<key>, typename valuealloc = std::allocator<value>, typename challoc = std::allocator<uint32_t> >
+class Hash;
+
+template< typename key, typename value, typename sizecalc, typename keyalloc, typename valuealloc, typename challoc >
+struct HashProxy
+{
+        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+private:
+        HashProxy( Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &h, key k, value v ) :
+                hsh( h ),
+                tKey( k ),
+                tValue( v ),
+                bFilled( true )
+        {
+        }
+
+        HashProxy( Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &h, key k ) :
+                hsh( h ),
+                tKey( k ),
+                bFilled( false )
+        {
+        }
+
+        Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh;
+        key tKey;
+        value tValue;
+        bool bFilled;
+
+public:
+        operator value()
+        {
+                if( bFilled == false )
+                        throw "Nope, no data there";
+                return tValue;
+        }
 
-template<class key, class value>
+        value operator=( value nval )
+        {
+                hsh.insert( tKey, nval );
+                return nval;
+        }
+
+};
+
+template<typename key, typename value, typename sizecalc, typename keyalloc, typename valuealloc, typename challoc >
 class Hash
 {
-        class iterator
+public:
+        Hash() :
+                nCapacity( 11 ),
+                nFilled( 0 ),
+                nDeleted( 0 ),
+                bFilled( NULL ),
+                aKeys( NULL ),
+                aValues( NULL ),
+                aHashCodes( NULL )
         {
-                friend class Hash<key, value>;
-        private:
-                iterator( Hash<key, value> *hsh, int nIndex, key keyval, bool bInsert ) :
-                        hsh( hsh ),
-                        nIndex( nIndex ),
-                        keyval( keyval ),
-                        bInsert( bInsert )
+                nKeysSize = bitsToBytes( nCapacity );
+                bFilled = ca.allocate( nKeysSize );
+                bDeleted = ca.allocate( nKeysSize );
+                clearBits();
+
+                aHashCodes = ca.allocate( nCapacity );
+                aKeys = ka.allocate( nCapacity );
+                aValues = va.allocate( nCapacity );
+        }
+
+        virtual ~Hash()
+        {
+                for( uint32_t j = 0; j < nCapacity; j++ )
                 {
+                        if( isFilled( 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 );
+        }
 
-        public:
-                iterator() :
-                        hsh( NULL ),
-                        nIndex( -1 )
+        void clearBits()
+        {
+                for( uint32_t j = 0; j < nKeysSize; j++ )
                 {
+                        bFilled[j] = bDeleted[j] = 0;
                 }
+        }
+
+        int hasKey( key keyval )
+        {
+                printf("%s\n", keyval );
+        }
+
+        uint32_t getCapacity()
+        {
+                return nCapacity;
+        }
+
+        uint32_t getFill()
+        {
+                return nFilled;
+        }
+
+        uint32_t getDeleted()
+        {
+                return nDeleted;
+        }
+
+        HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc> operator[]( key k )
+        {
+                uint32_t hash = __calcHashCode( k );
+                bool bFill;
+                uint32_t nPos = probe( hash, k, bFill );
 
-                iterator &operator=( iterator &src )
+                if( bFill )
                 {
-                        this->hsh = src.hsh;
-                        this->nIndex = src.nIndex;
+                        return HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>( *this, aKeys[nPos], aValues[nPos] );
                 }
+                else
+                {
+                        return HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>( *this, k );
+                }
+        }
+
+        void insert( key k, value v )
+        {
+                uint32_t hash = __calcHashCode( k );
+                bool bFill;
+                uint32_t nPos = probe( hash, k, bFill );
 
-                iterator &operator=( value &src )
+                if( bFill )
                 {
-                        if( bInsert )
-                                printf("You wanted to insert %d\n", src );
-                        else
-                                printf("You wanted to insert %d\n", src );
+                        va.destroy( &aValues[nPos] );
+                        va.construct( &aValues[nPos], v );
+                }
+                else
+                {
+                        va.construct( &aValues[nPos], v );
+                        ka.construct( &aKeys[nPos], k );
+                        fill( nPos );
+                        aHashCodes[nPos] = hash;
+                        nFilled++;
                 }
+        }
 
-        private:
-                Hash<key, value> *hsh;
-                int nIndex;
-                bool bInsert;
-                key keyval;
-        };
+        value get( key k )
+        {
+                uint32_t hash = __calcHashCode( k );
+                bool bFill;
+                uint32_t nPos = probe( hash, k, bFill );
+
+                if( bFill )
+                {
+                        return aValues[nPos];
+                }
+                else
+                {
+                        throw "Hey, no such thing...";
+                }
+        }
+
+        uint32_t probe( uint32_t hash, 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
+                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] )
+                        {
+                                // Is it really the same key? (for safety)
+                                if( __cmpHashKeys( aKeys[nCur], k ) == true &&
+                                        isDeleted( nCur ) == false )
+                                {
+                                        bFill = true;
+                                        return nCur;
+                                }
+                        }
+                }
+
+                // This is our insurance, if the table is full, then go ahead and
+                // rehash, then try again.
+                if( isFilled( nCur ) && rehash == true )
+                {
+                        reHash( szCalc(getCapacity(), getFill(), getDeleted()) );
+
+                        // This is potentially dangerous, and could cause an infinite loop.
+                        // Be careful writing probe, eh?
+                        return probe( hash, k, bFill );
+                }
+
+                bFill = false;
+                return nCur;
+        }
+
+        void reHash( uint32_t nNewSize )
+        {
+                // 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 );
+
+                // 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 )
+                        {
+                                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 )
+                        {
+                                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 );
+        }
 
-        template<class refval>
-        class VRef
+        void fill( uint32_t loc )
         {
+                bFilled[loc/32] |= (1<<(loc%32));
+        }
+
+        bool isFilled( uint32_t loc )
+        {
+                return (bFilled[loc/32]&(1<<(loc%32)))!=0;
+        }
+
+        bool isDeleted( uint32_t loc )
+        {
+                return (bDeleted[loc/32]&(1<<(loc%32)))!=0;
+        }
+
+        typedef struct iterator
+        {
+                friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+        private:
+                iterator( Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh ) :
+                        hsh( hsh ),
+                        bFinished( false ),
+                        nPos( 0 )
+                {
+                        nPos = hsh.getFirstPos( bFinished );
+                }
+                
+                iterator( Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh, bool bDone ) :
+                        hsh( hsh ),
+                        nPos( 0 ),
+                        bFinished( bDone )
+                {
+                }
+
+                Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh;
+
+                uint32_t nPos;
+                bool bFinished;
+
         public:
-                VRef( refval &data ) :
-                        data( data )
+                iterator operator++( int )
                 {
+                        if( bFinished == false )
+                                nPos = hsh.getNextPos( nPos, bFinished );
+
+                        return *this;
+                }
+                
+                iterator operator++()
+                {
+                        if( bFinished == false )
+                                nPos = hsh.getNextPos( nPos, bFinished );
+
+                        return *this;
+                }
+
+                bool operator==( const iterator &oth )
+                {
+                        if( bFinished != oth.bFinished )
+                                return false;
+                        if( bFinished == true )
+                        {
+                                return true;
+                        }
+                        else
+                        {
+                                if( oth.nPos == nPos )
+                                        return true;
+                                return false;
+                        }
+                }
+                
+                bool operator!=( const iterator &oth )
+                {
+                        return !(*this == oth );
+                }
+
+                std::pair<key,value> operator *()
+                {
+                        return hsh.getAtPos( nPos );
                 }
-                refval &data;
         };
 
-public:
-        Hash() :
-                nCapacity( 11 ),
-                nFilled( 0 ),
-                bFilled( NULL ),
-                aKeys( NULL ),
-                aValues( NULL ),
-                aHashCodes( NULL )
+        iterator begin()
         {
-                int nKeysSize = bitsToBytes( nCapacity );
-                bFilled = new unsigned char[ nKeysSize ];
-                memset( bFilled, 0, nKeysSize );
-
-                aKeys = new VRef<key>*[nCapacity];
-                aValues = new value[nCapacity];
+                return iterator( *this );
+        }
+        
+        iterator end()
+        {
+                return iterator( *this, true );
         }
 
-        virtual ~Hash()
+private:
+        std::pair<key,value> getAtPos( uint32_t nPos )
         {
+                return std::pair<key,value>(aKeys[nPos],aValues[nPos]);
         }
 
-        iterator operator[]( key keyval )
+        uint32_t getFirstPos( bool &bFinished )
         {
-                //iterator i( this, 4, keyval, true );
-                //return i;
-                printf("%s\n", keyval.getString() );
+                for( uint32_t j = 0; j < nCapacity; j++ )
+                {
+                        if( isFilled( j ) )
+                                return j;
+                }
+
+                bFinished = true;
         }
 
-        int hasKey( key keyval )
+        uint32_t getNextPos( uint32_t nPos, bool &bFinished )
         {
-                printf("%s\n", keyval.getString() );
+                for( uint32_t j = nPos+1; j < nCapacity; j++ )
+                {
+                        if( isFilled( j ) )
+                                return j;
+                }
+
+                bFinished = true;
         }
 
 private:
-        int nCapacity;
-        int nFilled;
-        unsigned char *bFilled;
-        VRef<key> **aKeys;
-        unsigned long int *aHashCodes;
+        uint32_t nCapacity;
+        uint32_t nFilled;
+        uint32_t nDeleted;
+        uint32_t *bFilled;
+        uint32_t *bDeleted;
+        uint32_t *aHashCodes;
+        uint32_t nKeysSize;
         value *aValues;
+        key *aKeys;
+        valuealloc va;
+        keyalloc ka;
+        challoc ca;
+        sizecalc szCalc;
 };
-*/
+
+template<> uint32_t __calcHashCode<const char *>( const char *k );
+template<> bool __cmpHashKeys<const char *>( const char *a, const char *b );
+
+template<> uint32_t __calcHashCode<char *>( char *k );
+template<> bool __cmpHashKeys<char *>( char *a, char *b );
+
+template<> uint32_t __calcHashCode<const std::string>( const std::string k );
+template<> bool __cmpHashKeys<const std::string>( const std::string a, const std::string b );
+
+template<> uint32_t __calcHashCode<std::string>( std::string k );
+template<> bool __cmpHashKeys<std::string>( std::string a, std::string b );
+
+template<> uint32_t __calcHashCode<Hashable &>( Hashable &k );
+template<> bool __cmpHashKeys<Hashable &>( Hashable &a, Hashable &b );
+
 #endif
diff --git a/src/hashable.h b/src/hashable.h
index 33ff8b8..ce49130 100644
--- a/src/hashable.h
+++ b/src/hashable.h
@@ -1,10 +1,11 @@
 #ifndef HASHABLE_H
 #define HASHABLE_H
-/*
+
 class Hashable
 {
 public:
         virtual unsigned long int getHashCode() = 0;
+        virtual bool compareForHash( Hashable &other ) = 0;
 };
-*/
+
 #endif
diff --git a/src/staticstring.cpp b/src/staticstring.cpp
index 9eac92e..0012b0f 100644
--- a/src/staticstring.cpp
+++ b/src/staticstring.cpp
@@ -243,10 +243,28 @@ bool StaticString::operator!=( StaticString &str )
 unsigned long int StaticString::getHashCode()
 {
         unsigned long int nPos = nLen;
-        for( const char *s = (const char *)lpStr; *s; s++ )
+        unsigned long int j = 0;
+        for( const char *s = (const char *)lpStr; j< nLen; s++, j++ )
         {
                 nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
         }
         return nPos;
 }
 
+bool StaticString::compareForHash( Hashable &other )
+{
+        if( ((StaticString &)other).nLen != nLen )
+                return false;
+
+        const char *a = ((StaticString &)other).lpStr;
+        const char *b = lpStr;
+        if( a == b )
+                return true;
+
+        for( unsigned long j = 0; j < nLen; j++, a++, b++ )
+                if( *a != *b )
+                        return false;
+
+        return true;
+}
+
diff --git a/src/staticstring.h b/src/staticstring.h
index 61501bf..1ff3f63 100644
--- a/src/staticstring.h
+++ b/src/staticstring.h
@@ -3,7 +3,7 @@
 
 #include <string>
 #include "serializable.h"
-//#include "hashable.h"
+#include "hashable.h"
 
 /**
  * Simple string managing class.  Allows for dynamically allocated string data
@@ -12,7 +12,7 @@
  * and making accessing meta-info like length fast and reliable as well.
  *@author Mike Buland
  */
-class StaticString : public Serializable//, public Hashable
+class StaticString : public Serializable, public Hashable
 {
 public:
         StaticString();
@@ -51,6 +51,7 @@ public:
         virtual void serialize( class Serializer &ar );
 
         virtual unsigned long int getHashCode();
+        virtual bool compareForHash( Hashable &other );
 
 private:
         char *lpStr;
diff --git a/src/tests/confpair.cpp b/src/tests/confpair.cpp
index 8e03730..fb1b0d3 100644
--- a/src/tests/confpair.cpp
+++ b/src/tests/confpair.cpp
@@ -5,10 +5,15 @@ using namespace std;
 
 int main()
 {
-        ConfPair<bool> p1("DebugMode");
-        p1.value() = true;
+        ConfPair<float> p1("DebugMode");
+        p1.value() = 12;
         cout << p1.value() << "\n";
-        p1.value() = false;
+        p1.value() = 55;
         cout << p1.value() << "\n";
+
+        ConfPairBase &p = p1;
+
+        p = "33.12";
+        cout << p.getAsString();
 }
 
diff --git a/src/tests/hash.cpp b/src/tests/hash.cpp
index d0f5fa6..8406439 100644
--- a/src/tests/hash.cpp
+++ b/src/tests/hash.cpp
@@ -3,8 +3,81 @@
 
 int main()
 {
-        //Hash<class StaticString, int> sTest;
+        const char *names[]={
+                "Homer the Great",
+                "And Maggie Makes Three",
+                "Bart's Comet",
+                "Homie The Clown",
+                "Bart Vs Australia",
+                "Homer vs Patty and Selma",
+                "A star is burns",
+                "Lisa's Wedding",
+                "Two Dozen and One Greyhounds",
+                "The PTA Disbands",
+                "Round Springfield",
+                "The Springfield connection",
+                "Lemon of Troy",
+                "Who Shot Mr. Burns (Pt. 1)",
+                "Who Shot Mr. Burns (pt. 2)",
+                "Radioactive Man",
+                "Home Sweet Homediddly-dum-doodly",
+                "Bart Sells His Soul",
+                "Lisa the Vegetarian",
+                "Treehouse of horror VI",
+                "King Size Homer",
+                "Mother Simpson",
+                "Sideshow Bob's Last Gleaming",
+                "The Simpson's 138th Show Spectacular",
+                "Marge Be Not Proud",
+                "Team Homer",
+                "Two Bad Neighbors",
+                "Scenes From the Class Struggle in Springfield",
+                "Bart the Fink",
+                "Lisa the Iconoclast",
+                "Homer the Smithers",
+                "The Day the Violence Died",
+                "A Fish Called Selma",
+                "Bart on the road",
+                "22 Short Films about Springfield",
+                "The Curse of the Flying Hellfish",
+                "Much Apu about Nothing",
+                "Homerpalooza",
+                "The Summer of 4 Ft 2",
+                "Treehouse of Horror VII",
+                "You Only Move Twice",
+                "The Homer They Fall",
+                "Burns Baby Burns",
+                "Bart After Dark",
+                "A Millhouse Divided",
+                "Lisas Date With Destiny",
+                "Hurricane Neddy",
+                "The Mysterious Voyage of Our Homer",
+                "The Springfield Files",
+                "The Twisted World of Marge Simpson",
+                "Mountain of Madness",
+                NULL
+        };
 
-        //sTest.hasKey("hello");
+        Hash<std::string, int> sTest;
+
+        printf("Inserting\n-------------------\n\n");
+        for( int j = 0; j < 33; j++ )
+        {
+                sTest[names[j]] = j;
+        }
+
+        printf("Getting\n-------------------\n\n");
+        printf("%d\n", sTest.get( names[10] ) );
+        printf("%d\n", (int)sTest[names[10]] );
+        sTest[names[10]] = 22;
+        sTest["That one guy"] = 135;
+        printf("%d\n", (int)sTest[names[10]] );
+
+        for( Hash<std::string, int>::iterator i = sTest.begin();
+                 i != sTest.end(); i++ )
+        {
+                Hash<std::string, int>::iterator j = i;
+                printf("%d: %s\n", (*j).second, (*j).first.c_str() );
+        }
 }