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() );
+        }
 }