--- deliantra/server/common/arch.C	2006/11/07 16:30:54	1.25
+++ deliantra/server/common/arch.C	2006/12/31 17:17:22	1.33
@@ -23,19 +23,17 @@
 
 #include <cassert>
 
-#include <tr1/unordered_map>
-
 #include <global.h>
-#include <arch.h>
 #include <funcpoint.h>
 #include <loader.h>
 
-/* IF set, does a little timing on the archetype load. */
-#define TIME_ARCH_LOAD 0
+#define USE_UNORDERED_MAP 0
 
-static void add_arch (archetype *at);
+#if USE_UNORDERED_MAP
+# include <tr1/functional>
+# include <tr1/unordered_map>
+#endif
 
-static archetype *arch_table[ARCHTABLE];
 int arch_cmp = 0;               /* How many strcmp's */
 int arch_search = 0;            /* How many searches */
 int arch_init;                  /* True if doing arch initialization */
@@ -53,14 +51,16 @@
 typedef std::tr1::unordered_map
   <
     std::size_t,
-    archetype *,
-    std::hash<size_t>,
+    arch_ptr,
+    std::tr1::hash<size_t>,
     std::equal_to<size_t>,
     slice_allocator< std::pair<const std::size_t, archetype *> >
     true,
   > HT;
 
 static HT ht;
+#else
+static arch_ptr arch_table[ARCHTABLE];
 #endif
 
 /**
@@ -360,7 +360,7 @@
   LOG (llevDebug, " Setting up archetable...\n");
 
   for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
-    add_arch (at);
+    at->hash_add ();
 
   LOG (llevDebug, "done\n");
 }
@@ -383,13 +383,13 @@
 
       i++;
     }
+
   LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
 }
 
 archetype::archetype ()
 {
-  clear_object (&clone);        /* to initial state other also */
-  CLEAR_FLAG (&clone, FLAG_FREED);      /* This shouldn't matter, since copy_object() */
+  CLEAR_FLAG (&clone, FLAG_FREED);      /* This shouldn't matter, since copy_to */
   SET_FLAG (&clone, FLAG_REMOVED);      /* doesn't copy these flags... */
 }
 
@@ -404,9 +404,10 @@
 void
 first_arch_pass (object_thawer & fp)
 {
-  archetype *at, *head = NULL, *last_more = NULL;
+  archetype *head = 0, *last_more = 0;
 
-  at->clone.arch = first_archetype = at = new archetype;
+  archetype *at = new archetype;
+  at->clone.arch = first_archetype = at;
 
   while (int i = load_object (fp, &at->clone, 0))
     {
@@ -554,12 +555,6 @@
 {
   char filename[MAX_BUF];
 
-#if TIME_ARCH_LOAD
-  struct timeval
-    tv1,
-    tv2;
-#endif
-
   sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
   LOG (llevDebug, "Reading archetypes from %s:\n", filename);
 
@@ -596,7 +591,6 @@
  * Creates and returns a new object which is a copy of the given archetype.
  * This function returns NULL on failure.
  */
-
 object *
 arch_to_object (archetype *at)
 {
@@ -610,8 +604,7 @@
       return NULL;
     }
 
-  op = get_object ();
-  copy_object (&at->clone, op);
+  op = at->clone.clone ();
   op->arch = at;
   op->instantiate ();
   return op;
@@ -623,7 +616,6 @@
  * Thus get_archetype() will be guaranteed to always return
  * an object, and never NULL.
  */
-
 object *
 create_singularity (const char *name)
 {
@@ -631,7 +623,7 @@
   char buf[MAX_BUF];
 
   sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
-  op = get_object ();
+  op = object::create ();
   op->name = op->name_pl = buf;
   SET_FLAG (op, FLAG_NO_PICK);
   return op;
@@ -641,7 +633,6 @@
  * Finds which archetype matches the given name, and returns a new
  * object containing a copy of the archetype.
  */
-
 object *
 get_archetype (const char *name)
 {
@@ -733,22 +724,21 @@
 /*
  * Adds an archetype to the hashtable.
  */
-
-static void
-add_arch (archetype *at)
+void
+archetype::hash_add ()
 {
 #if USE_UNORDERED_MAP
-  ht.insert (std::make_pair ((size_t) (const char *) at->name, at));
-#endif
+  ht.insert (std::make_pair ((size_t) (const char *) name, this));
+#else
 
-  int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
+  int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
 
   for (;;)
     {
-      if (arch_table[index] == NULL)
+      if (!arch_table[index])
         {
-          arch_table[index] = at;
-          return;
+          arch_table[index] = this;
+          break;
         }
 
       if (++index == ARCHTABLE)
@@ -757,6 +747,33 @@
       if (index == org_index)
         fatal (ARCHTABLE_TOO_SMALL);
     }
+#endif
+}
+
+void
+archetype::hash_del ()
+{
+#if USE_UNORDERED_MAP
+# error remove this from HT
+#else
+
+  int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
+
+  for (;;)
+    {
+      if (arch_table[index] == this)
+        {
+          arch_table[index] = 0;
+          break;
+        }
+
+      if (++index == ARCHTABLE)
+        index = 0;
+
+      if (index == org_index)
+        break;
+    }
+#endif
 }
 
 /*
@@ -786,16 +803,14 @@
 clone_arch (int type)
 {
   archetype *at;
-  object *op = get_object ();
 
   if ((at = type_to_archetype (type)) == NULL)
     {
       LOG (llevError, "Can't clone archetype %d\n", type);
-      free_object (op);
-      return NULL;
+      return 0;
     }
 
-  copy_object (&at->clone, op);
+  object *op = at->clone.clone ();
   op->instantiate ();
   return op;
 }