Ejemplo n.º 1
0
int main(int argc, char ** argv)
{
   CompleteSetupSystem css;

   PrintExampleDescription();

   Hashtable<String, int> table;

   // If we know up-front a limit on the number of items we are likely to place
   // into the table, we can reserve that many slots in advance, and thereby 
   // avoid any chance of the Hashtable having to reallocate its internal array 
   // while we are adding items to it.  
   //
   // That avoids some inefficiency, and it also means we don't have
   // to worry about out-of-memory errors, or the memory-locations of key or 
   // value-items changing, while populating the table.

   if (table.EnsureSize(20) != B_NO_ERROR) WARN_OUT_OF_MEMORY;

   // Put some initial data into the table
   table.Put("One", 1);
   table.Put("Two", 2);

   // table.GetWithDefault() returns a reference to the value of the specified
   // key, or a reference to a default-constructed value otherwise.
   const int & oneRef   = table.GetWithDefault("One");
   const int & twoRef   = table.GetWithDefault("Two");
   const int & threeRef = table.GetWithDefault("Three");
   printf("A: OneRef=%i twoRef=%i threeRef=%i\n", oneRef, twoRef, threeRef);

   printf("\n");

   // The [] operator is a synonym for GetWithDefault()
   printf("B: table[\"One\"]=%i table[\"Two\"]=%i table[\"Three\"]=%i\n", table["One"], table["Two"], table["Three"]);

   printf("\n");

   // GetOrPut() returns a pointer to the value of the given key, if the key is present
   // If the key isn't present, it places a key/value pair into the Hashtable and returns
   // a pointer to the (default-constructed) placed value.  This is very useful when 
   // demand-allocating records.
   int * pEight = table.GetOrPut("Eight");
   printf("C:  table.GetOrPut(\"Eight\") returned %p\n", pEight);
   if (pEight) *pEight = 8;
          else WARN_OUT_OF_MEMORY;   // GetOrPut() returns NULL only on memory-exhaustion

   printf("\n");

   // The next time we call GetOrPut() we'll get a pointer to the existing value
   pEight = table.GetOrPut("Eight");
   printf("C:  Second call to table.GetOrPut(\"Eight\") returned %p (aka %i)\n", pEight, pEight?*pEight:666);

   printf("\n");

   // We can also call GetOrPut() with a suggested default-value which will be
   // placed into the key/value pair if the supplied key isn't already present.
   int * pNine = table.GetOrPut("Nine", 9);
   printf("C:  table.GetOrPut(\"Nine\", 9) returned %p (aka %i)\n", pNine, pNine?*pNine:666);

   printf("\n");

   // PutAndGet() is similar to GetOrPut() except it *always* places a value.
   // (if the key already existed in the table, its value will be overwritten)
   int * pTen = table.PutAndGet("Ten", 10);
   printf("D:  table.PutAndGet(\"Ten\", 10) returned %p (aka %i)\n", pTen, pTen?*pTen:666);

   // Demonstrate PutAndGet()'s overwrite of the previous value
   pTen = table.PutAndGet("Ten", 11);
   printf("E:  table.PutAndGet(\"Ten\", 11) returned %p (aka %i)\n", pTen, pTen?*pTen:666);

   // If you want a Hashtable with keys only and don't need values at all
   // (similar to e.g. a std::unordered_set<>), a good way to get that is
   // to use the Void class as your value-type.  A Void object is just a
   // placeholder that contains no data.
   Hashtable<String, Void> keysOnlyTable;
   (void) keysOnlyTable.PutWithDefault("Blue");
   (void) keysOnlyTable.PutWithDefault("Red");
   (void) keysOnlyTable.PutWithDefault("Green");

   printf("\n");

   return 0;
}
Ejemplo n.º 2
0
// This program exercises the Hashtable class.
int main(int argc, char ** argv)
{
   CompleteSetupSystem css;

   Message temp; if (ParseArgs(argc, argv, temp) == B_NO_ERROR) HandleStandardDaemonArgs(temp);

   if (temp.HasName("inter")) return DoInteractiveTest();

   // Make sure that setting equal to an empty Hashtable clears the buffer (FogBugz #10274)
   {
      Hashtable<String,String> table;
      for (int32 i=0; i<1000; i++) table.Put(String("xxx%1").Arg(i), "foo");
      printf("After population of " UINT32_FORMAT_SPEC " items, table size is " UINT32_FORMAT_SPEC "\n", table.GetNumItems(), table.GetNumAllocatedItemSlots());
  
      if (table.ShrinkToFit() == B_NO_ERROR) printf("After shrink-to-fit, table allocation is " UINT32_FORMAT_SPEC " for " UINT32_FORMAT_SPEC " items\n", table.GetNumAllocatedItemSlots(), table.GetNumItems());
                                        else printf("Shrink-to-fit failed!?\n");

      printf("Before copy-from-empty, table allocation is " UINT32_FORMAT_SPEC "\n", table.GetNumAllocatedItemSlots()); 
      table = GetDefaultObjectForType< Hashtable<String,String> > ();
      printf(" After copy-from-empty, table allocation is " UINT32_FORMAT_SPEC "\n", table.GetNumAllocatedItemSlots()); 
   }

   // Test C++11 move semantics to make sure they aren't stealing
   {
      String key = "key";
      String value = "value";
      Hashtable<String,String> table;
      table.Put(key, value);
      if (key != "key") {printf("ERROR, Hashtable stole my key!\n"); exit(10);}
      if (value != "value") {printf("ERROR, Hashtable stole my value!\n"); exit(10);}
   }

   // Test muscleSwap()
   TestMuscleSwap<Hashtable<String,String> >("Hashtable");
   TestMuscleSwap<OrderedKeysHashtable<String,String> >("OrderedKeysHashtable");
   TestMuscleSwap<OrderedValuesHashtable<String,String> >("OrderedValuesHashtable");

   // Test iterator behaviour when deleting keys
   TestIteratorSanityOnRemoval(false);
   TestIteratorSanityOnRemoval(true);

   {
      LogTime(MUSCLE_LOG_INFO, "Testing a keys-only Hashtable value...\n");

      Hashtable<int, Void> keysOnly;
      printf("sizeof(keysOnly)=%u\n", (unsigned int) sizeof(keysOnly));
      keysOnly.PutWithDefault(1);
      keysOnly.PutWithDefault(2);
      keysOnly.PutWithDefault(5);
      keysOnly.PutWithDefault(10);
      for (HashtableIterator<int, Void> iter(keysOnly); iter.HasData(); iter++)  printf("key=%i\n", iter.GetKey());
   }

   {
      LogTime(MUSCLE_LOG_INFO, "Testing Tuple as a Hashtable key...\n");

      // A quick test of the Tuple class as a Hashtable key
      typedef Tuple<2,int> MyType;
      Hashtable<MyType, int> tupleTable;

      MyType a; a[0] = 5; a[1] = 6;
      MyType b; b[0] = 7; b[1] = 8;
      tupleTable.Put(a, 1);
      tupleTable.Put(b, 2);
      for (HashtableIterator<MyType, int> iter(tupleTable); iter.HasData(); iter++)  
      {  
         const MyType & key = iter.GetKey();
         printf("key=%i,%i val=%i\n", key[0], key[1], iter.GetValue());
      }
      int * ra = tupleTable.Get(a);
      int * rb = tupleTable.Get(b);
      printf("tuple: ra=[%i] rb=[%i]\n", ra?*ra:666, rb?*rb:666);
   }

   {
      LogTime(MUSCLE_LOG_INFO, "Testing Rect as a Hashtable key...\n");

      // A quick test of the Tuple class as a Hashtable key
      Hashtable<Rect, int> tupleTable;

      Rect a(1,2,3,4);
      Rect b(5,6,7,8);
      tupleTable.Put(a, 1);
      tupleTable.Put(b, 2);
      for (HashtableIterator<Rect, int> iter(tupleTable); iter.HasData(); iter++)  
      {  
         const Rect & key = iter.GetKey();
         printf("key=%f,%f,%f,%f val=%i\n", key.left(), key.top(), key.right(), key.bottom(), iter.GetValue());
      }
      int * ra = tupleTable.Get(a);
      int * rb = tupleTable.Get(b);
      printf("Rect: ra=[%p] rb=[%p]\n", ra, rb);
   }

   {
      LogTime(MUSCLE_LOG_INFO, "Testing Point as a Hashtable key...\n");

      // A quick test of the Tuple class as a Hashtable key
      Hashtable<Point, int> tupleTable;

      Point a(9,10);
      Point b(-11,-12);
      tupleTable.Put(a, 1);
      tupleTable.Put(b, 2);
      for (HashtableIterator<Point, int> iter(tupleTable); iter.HasData(); iter++)  
      {  
         const Point & key = iter.GetKey();
         printf("key=%f,%f val=%i\n", key.x(), key.y(), iter.GetValue());
      }
      int * ra = tupleTable.Get(a);
      int * rb = tupleTable.Get(b);
      printf("Point: ra=[%p] rb=[%p]\n", ra, rb);
   }

   {
      LogTime(MUSCLE_LOG_INFO, "Preparing large table for sort...\n");

      const uint32 numItems = 100000;
      Hashtable<int, Void> table; (void) table.EnsureSize(100000);
      for (uint32 i=0; i<numItems; i++) table.PutWithDefault((int)rand());
      uint32 actualNumItems = table.GetNumItems();  // may be smaller than numItems, due to duplicate values!
      (void) table.CountAverageLookupComparisons(true);

      LogTime(MUSCLE_LOG_INFO, "Sorting...\n");
      uint64 start = GetRunTime64();
      table.SortByKey();
      uint64 end = GetRunTime64();

      LogTime(MUSCLE_LOG_INFO, "Time to sort " UINT32_FORMAT_SPEC" items: " UINT64_FORMAT_SPEC "ms\n", numItems, (end-start)/1000);

      // Check the resulting sorted table for correctness in both directions
      CheckTable(table, actualNumItems, false);
      CheckTable(table, actualNumItems, true);
   }

   // Test the sort algorithm for efficiency and correctness
   {
      LogTime(MUSCLE_LOG_INFO, "Preparing large table for sort...\n");

      const uint32 numItems = 100000;
      Hashtable<int, Void> table;
      for (uint32 i=0; i<numItems; i++) table.PutWithDefault((int)rand());
      uint32 actualNumItems = table.GetNumItems();  // may be smaller than numItems, due to duplicate values!

      LogTime(MUSCLE_LOG_INFO, "Sorting...\n");
      uint64 start = GetRunTime64();
      table.SortByKey();
      uint64 end = GetRunTime64();

      LogTime(MUSCLE_LOG_INFO, "Time to sort " UINT32_FORMAT_SPEC" items: " UINT64_FORMAT_SPEC "ms\n", numItems, (end-start)/1000);

      // Check the resulting sorted table for correctness in both directions
      CheckTable(table, actualNumItems, false);
      CheckTable(table, actualNumItems, true);
   }

   Hashtable<String, String> table;
   {
      table.Put("Hello", "World");
      table.Put("Peanut Butter", "Jelly");
      table.Put("Ham", "Eggs");
      table.Put("Pork", "Beans");
      table.Put("Slash", "Dot");
      table.Put("Data", "Mining");  
      table.Put("TestDouble", "Play");
      table.Put("Abbot", "Costello");
      table.Put("Laurel", "Hardy");
      table.Put("Thick", "Thin");
      table.Put("Butter", "Parkay");
      table.Put("Total", "Carnage");
      table.Put("Summer", "Time");
      table.Put("Terrible", "Twos");
      table.CountAverageLookupComparisons(true);

      printf("table[\"Summer\"] = [%s]\n", table["Summer"]());
      printf("table[\"Butter\"] = [%s]\n", table["Butter"]());
      printf("table[\"Total\"]  = [%s]\n", table["Total"]());
      printf("table[\"Winter\"] = [%s] (should be blank!)\n", table["Winter"]());

      if (table.GetNumItems() != 14)
      {
         LogTime(MUSCLE_LOG_CRITICALERROR, "String table has %i entries in it, expected 14!\n", table.GetNumItems());
         ExitWithoutCleanup(10);
      }

      {
         LogTime(MUSCLE_LOG_INFO, "Test partial backwards iteration\n");
         for (HashtableIterator<String, String> iter(table, "Slash", HTIT_FLAG_BACKWARDS); iter.HasData(); iter++) LogTime(MUSCLE_LOG_INFO,"[%s] <-> [%s]\n", iter.GetKey()(), iter.GetValue()());
      }

      String lookup;
      if (table.Get(String("Hello"), lookup) == B_NO_ERROR) LogTime(MUSCLE_LOG_DEBUG, "Hello -> %s\n", lookup());
                                                       else bomb("Lookup 1 failed.\n");
      if (table.Get(String("Peanut Butter"), lookup) == B_NO_ERROR) LogTime(MUSCLE_LOG_DEBUG, "Peanut Butter -> %s\n", lookup());
                                                               else bomb("Lookup 2 failed.\n");


      LogTime(MUSCLE_LOG_INFO, "Testing delete-as-you-go traveral\n");
      for (HashtableIterator<String, String> st(table); st.HasData(); st++)
      {
         LogTime(MUSCLE_LOG_INFO, "t3 = %s -> %s (tableSize=" UINT32_FORMAT_SPEC")\n", st.GetKey()(), st.GetValue()(), table.GetNumItems());
         if (table.Remove(st.GetKey()) != B_NO_ERROR) bomb("Could not remove string!\n");
#if 0
         for (HashtableIterator<String,String> st2(table); st2.HasData(); st2++) printf("  tx = %s -> %s\n", nextKeyString(), nextValueString());
#endif
      }

      Hashtable<uint32, const char *> sillyTable;
      sillyTable.Put(15, "Fifteen");
      sillyTable.Put(100, "One Hundred");
      sillyTable.Put(150, "One Hundred and Fifty");
      sillyTable.Put(200, "Two Hundred");
      sillyTable.Put((uint32)-1, "2^32 - 1!");
      if (sillyTable.ContainsKey((uint32)-1) == false) bomb("large value failed!");

      const char * temp = NULL;
      sillyTable.Get(100, temp);
      sillyTable.Get(101, temp); // will fail
      printf("100 -> %s\n",temp);

      printf("Entries in sillyTable:\n");
      for (HashtableIterator<uint32, const char *> it(sillyTable); it.HasData(); it++)
      {
         const char * nextValue = NULL;
         status_t ret = sillyTable.Get(it.GetKey(), nextValue);
         printf("%i %s: " UINT32_FORMAT_SPEC" -> %s\n", it.HasData(), (ret == B_NO_ERROR) ? "OK" : "ERROR", it.GetKey(), nextValue);
      }
   }
   table.Clear();   

   {
      const uint32 NUM_ITEMS = 1000000;
      const uint32 NUM_RUNS  = 3;
      Hashtable<int, int> testCopy;
      Hashtable<String, double> tallies;
      for (uint32 t=0; t<NUM_RUNS; t++)
      {
         Hashtable<int, int> table; (void) table.EnsureSize(NUM_ITEMS);
         printf("SORT SPEED TEST ROUND " UINT32_FORMAT_SPEC"/" UINT32_FORMAT_SPEC":\n", t+1, NUM_RUNS);

         uint64 startTime = GetRunTime64();
         srand(0); for (uint32 i=0; i<NUM_ITEMS; i++) table.Put(rand(), rand());  // we want this to be repeatable, hence srand(0)
         AddTally(tallies, "place", startTime, NUM_ITEMS);
         
         startTime = GetRunTime64();
         table.SortByValue();
         AddTally(tallies, "sort", startTime, NUM_ITEMS);

         startTime = GetRunTime64();
         testCopy = table;  // just to make sure copying a table works
         AddTally(tallies, "copy", startTime, NUM_ITEMS);

         startTime = GetRunTime64();
         if (testCopy != table) bomb("Copy was not the same!");
         AddTally(tallies, "compare", startTime, NUM_ITEMS);

         startTime = GetRunTime64();
         if (testCopy.IsEqualTo(table, true) == false) bomb("Copy was not the same, considering ordering!");
         AddTally(tallies, "o-compare", startTime, NUM_ITEMS);

         startTime = GetRunTime64();
         table.Clear();
         AddTally(tallies, "clear", startTime, NUM_ITEMS);
      }
      printf("GRAND AVERAGES OVER ALL " UINT32_FORMAT_SPEC" RUNS ARE:\n", NUM_RUNS); 
      for (HashtableIterator<String, double> iter(tallies); iter.HasData(); iter++) printf("   %f items/second for %s\n", iter.GetValue()/NUM_RUNS, iter.GetKey()());
   }

   // Now some timing test with String keys and values, for testing of the C++11 move semantics
   PrintAndClearStringCopyCounts("Before String Sort test");
   {
      const uint32 NUM_ITEMS = 1000000;
      const uint32 NUM_RUNS  = 3;
      Hashtable<String, String> testCopy;
      Hashtable<String, double> tallies;
      for (uint32 t=0; t<NUM_RUNS; t++)
      {
         Hashtable<String, String> table; (void) table.EnsureSize(NUM_ITEMS);
         printf("STRING SORT SPEED TEST ROUND " UINT32_FORMAT_SPEC"/" UINT32_FORMAT_SPEC":\n", t+1, NUM_RUNS);

         uint64 startTime = GetRunTime64();
         srand(0); for (uint32 i=0; i<NUM_ITEMS; i++) table.Put(String("%1").Arg(rand()), String("%1").Arg(rand()));  // we want this to be repeatable, hence srand(0)
         AddTally(tallies, "place", startTime, NUM_ITEMS);
         
         startTime = GetRunTime64();
         table.SortByValue();
         AddTally(tallies, "sort", startTime, NUM_ITEMS);

         startTime = GetRunTime64();
         testCopy = table;  // just to make sure copying a table works
         AddTally(tallies, "copy", startTime, NUM_ITEMS);

         startTime = GetRunTime64();
         if (testCopy != table) bomb("Copy was not the same!");
         AddTally(tallies, "compare", startTime, NUM_ITEMS);

         startTime = GetRunTime64();
         if (testCopy.IsEqualTo(table, true) == false) bomb("Copy was not the same, considering ordering!");
         AddTally(tallies, "o-compare", startTime, NUM_ITEMS);

         startTime = GetRunTime64();
         table.Clear();
         AddTally(tallies, "clear", startTime, NUM_ITEMS);
      }
      printf("STRING GRAND AVERAGES OVER ALL " UINT32_FORMAT_SPEC" RUNS ARE:\n", NUM_RUNS); 
      for (HashtableIterator<String, double> iter(tallies); iter.HasData(); iter++) printf("   STRING %f items/second for %s\n", iter.GetValue()/NUM_RUNS, iter.GetKey()());
   }
   PrintAndClearStringCopyCounts("After String Sort test");

   printf("Begin torture test!\n");
   _state = 4;
   {
      bool fastClear = false;
      Hashtable<String, uint32> t;
      for (uint32 numEntries=1; numEntries < 1000; numEntries++)
      {
         uint32 half = numEntries/2;
         bool ok = true;

         printf(UINT32_FORMAT_SPEC" ", numEntries); fflush(stdout);
         _state = 5;
         {
            for(uint32 i=0; i<numEntries; i++)
            {
               char temp[300];
               muscleSprintf(temp, UINT32_FORMAT_SPEC, i);
               if (t.Put(temp, i) != B_NO_ERROR)
               {
                  printf("Whoops, (hopefully simulated) memory failure!  (Put(" UINT32_FORMAT_SPEC"/" UINT32_FORMAT_SPEC") failed) ... recovering\n", i, numEntries);

                  ok = false;
                  numEntries--;  // let's do this one over
                  half = i;    // so the remove code won't freak out about not everything being there
                  break;
               }
            }
         }

         if (ok)
         {
            //printf("Checking that all entries are still there...\n");
            _state = 6;
            {
               if (t.GetNumItems() != numEntries) bomb("ERROR, WRONG SIZE %i vs %i!\n", t.GetNumItems(), numEntries);
               for (int32 i=((int32)numEntries)-1; i>=0; i--)
               {
                  char temp[300];
                  muscleSprintf(temp, UINT32_FORMAT_SPEC, i);
                  uint32 tv = 0;
                  if (t.Get(temp, tv) != B_NO_ERROR) bomb("ERROR, MISSING KEY [%s]\n", temp);
                  if (tv != ((uint32)i)) bomb("ERROR, WRONG KEY %s != " UINT32_FORMAT_SPEC"!\n", temp, tv);
               }
            }
      
            //printf("Iterating through table...\n");
            _state = 7;
            {
               uint32 count = 0;
               for (HashtableIterator<String, uint32> iter(t); iter.HasData(); iter++)
               {
                  char buf[300];
                  muscleSprintf(buf, UINT32_FORMAT_SPEC, count);
                  if (iter.GetKey() != buf) bomb("ERROR:  iteration was wrong, item " UINT32_FORMAT_SPEC" was [%s] not [%s]!\n", count, iter.GetKey()(), buf);
                  if (iter.GetValue() != count) bomb("ERROR:  iteration value was wrong, item " UINT32_FORMAT_SPEC" was " UINT32_FORMAT_SPEC" not " UINT32_FORMAT_SPEC"!i!\n", count, iter.GetValue(), count);
                  count++;
               }
            }

            //printf("Removing the second half of the entries...\n");
            _state = 8;
            {
               for (uint32 i=half; i<numEntries; i++)
               {
                  char temp[64];
                  muscleSprintf(temp, UINT32_FORMAT_SPEC, i);
                  uint32 tv = 0;  // just to shut the compiler up
                  if (t.Remove(temp, tv) != B_NO_ERROR) bomb("ERROR, MISSING REMOVE KEY [%s] A\n", temp);
                  if (tv != i) bomb("ERROR, REMOVE WAS WRONG VALUE " UINT32_FORMAT_SPEC"\n", tv);
               }
            }

            //printf("Iterating over only first half...\n");
            _state = 9;
            {
               uint32 sum = 0; 
               for (uint32 i=0; i<half; i++) sum += i;

               uint32 count = 0, checkSum = 0;
               for (HashtableIterator<String, uint32> iter(t); iter.HasData(); iter++)
               {
                  count++;
                  checkSum += iter.GetValue();
               }
               if (count != half) bomb("ERROR: Count mismatch " UINT32_FORMAT_SPEC" vs " UINT32_FORMAT_SPEC"!\n", count, numEntries);
               if (checkSum != sum)     bomb("ERROR: Sum mismatch " UINT32_FORMAT_SPEC" vs " UINT32_FORMAT_SPEC"!\n", sum, checkSum);
            }
         }

         //printf("Clearing Table (%s)\n", fastClear ? "Quickly" : "Slowly"); 
         _state = 10;
         if (fastClear) t.Clear();
         else
         {
            for (uint32 i=0; i<half; i++)
            {
               char temp[300];
               muscleSprintf(temp, UINT32_FORMAT_SPEC, i);
               uint32 tv = 0;  // just to shut the compiler up
               if (t.Remove(temp, tv) != B_NO_ERROR) bomb("ERROR, MISSING REMOVE KEY [%s] (" UINT32_FORMAT_SPEC"/" UINT32_FORMAT_SPEC") B\n", temp, i, half);
               if (tv != i) bomb("ERROR, REMOVE WAS WRONG VALUE " UINT32_FORMAT_SPEC"\n", tv);
            }
         }

         HashtableIterator<String, uint32> paranoia(t);
         if (paranoia.HasData()) bomb("ERROR, ITERATOR CONTAINED ITEMS AFTER CLEAR!\n");

         if (t.HasItems()) bomb("ERROR, SIZE WAS NON-ZERO (" UINT32_FORMAT_SPEC") AFTER CLEAR!\n", t.GetNumItems());
         fastClear = !fastClear;
      }
      printf("Finished torture test successfully!\n");
   }

#ifdef MUSCLE_AVOID_THREAD_SAFE_HASHTABLE_ITERATORS
   printf("Thread-safe hashtable iterators were disabled at compile time, so I won't test them!\n");
   return 0;
#else
   return DoThreadTest();
#endif
}
Ejemplo n.º 3
0
/* This little program demonstrates the semantics of the keys used in a Hashtable */
int main(int argc, char ** argv)
{
   CompleteSetupSystem css;

   PrintExampleDescription();

   // In order to use a type as a Key in a Hashtable, that type must have
   // two properties:  There must be a way to compute a hash-code for any
   // give Key object, and it must be possible to compare two Key objects
   // for equality (using the == operator).
   //
   // If you want to call SortByKey() or use the type as a key in an 
   // OrderedKeysHashtable, the < operator must also be defined for the type.

   // For primitive/POD key types, the Hashtable class uses SFINAE
   // magic so that Hashtables with those keys will automatically "just work".
   // For example:
   Hashtable<int,    String> tableWithIntKeys;     // works!
   Hashtable<uint16, String> tableWithUint16Keys;  // works!
   Hashtable<uint32, String> tableWithUint32Keys;  // works!
   Hashtable<int32,  String> tableWithInt32Keys;   // works!
   Hashtable<char,   String> tableWithCharKeys;    // works!
   Hashtable<float,  String> tableWithFloatKeys;   // works! (but probably a bad idea!)
  
   // When using a "Proper class" as a Key type, you'll want to make
   // sure it has a working == operator and that it has a method
   // like this one defined:  
   //
   //   uint32 HashCode() const;
   // 
   // This method should return a 32-bit value based on the object's
   // current state; that value will be used to place the key/value
   // pair within the Hashtable's array.

   Hashtable<MyKeyClass, int> myTable;
   (void) myTable.Put(MyKeyClass(12, 23), 0);
   (void) myTable.Put(MyKeyClass(21, 22), 5);
   (void) myTable.Put(MyKeyClass(37, 19), 6);

   printf("myTable's contents are:\n");
   for (HashtableIterator<MyKeyClass, int> iter(myTable); iter.HasData(); iter++)
   {
      printf("   [%s] -> %i\n", iter.GetKey().ToString()(), iter.GetValue());
   }

   printf("\n");

   // Test retrieving a value using a MyKeyClass object as the key
   int retVal;
   if (myTable.Get(MyKeyClass(21, 22), retVal) == B_NO_ERROR) 
   {
      printf("myTable.Get(MyKeyClass(21, 22) retrieved a key with value %i\n", retVal);
   }
   else printf("myTable.Get(MyKeyClass(21, 22) failed!\n");

   // You can even use pointers-to-objects as your keys as long as
   // the pointed-to-objects can be used as keys.  The pointer-keys
   // will generally work the same as the value-keys, but note that
   // you are responsible for making sure the pointers remain valid 
   // for the lifetime of the Hashtable!

   String s1 = "One";
   String s2 = "Two";
   String s3 = "Three";
   Hashtable<String *, int> ptrTable;
   ptrTable.Put(&s1, 1);
   ptrTable.Put(&s2, 2);
   ptrTable.Put(&s3, 3);

   printf("\n");
   printf("ptrTable's contents are:\n");
   for (HashtableIterator<String *, int> iter(ptrTable); iter.HasData(); iter++)
   {
      printf("   %s -> %i\n", iter.GetKey()->Cstr(), iter.GetValue());
   }

   printf("\n");

   // Refs can also be used as keys, if, you're in to that sort of thing.
   // Here's a Hashtable with ConstSocketRefs as keys!
   Hashtable<ConstSocketRef, Void> sockTable;
   for (int i=0; i<10; i++) sockTable.PutWithDefault(CreateUDPSocket());

   printf("sockTable's contents are:\n");
   for (HashtableIterator<ConstSocketRef, Void> iter(sockTable); iter.HasData(); iter++)
   {
      const Socket * s = iter.GetKey()();
      printf("   socket descriptor #%i\n", s ? s->GetFileDescriptor() : -1);
   }

   printf("\n");

   return 0;
}