--- deliantra/server/include/util.h	2006/09/14 00:07:15	1.13
+++ deliantra/server/include/util.h	2006/12/23 06:21:02	1.22
@@ -11,6 +11,9 @@
 
 #include <glib.h>
 
+// use a gcc extension for auto declarations until ISO C++ sanctifies them
+#define AUTODECL(var,expr) typeof(expr) var = (expr)
+
 // makes dynamically allocated objects zero-initialised
 struct zero_initialised
 {
@@ -41,12 +44,27 @@
   }
 };
 
+void *salloc_ (int n)            throw (std::bad_alloc);
+void *salloc_ (int n, void *src) throw (std::bad_alloc);
+
 // strictly the same as g_slice_alloc, but never returns 0
-void *alloc (int s) throw (std::bad_alloc);
+template<typename T>
+inline T *salloc (int n = 1)     throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T));              }
+
+// also copies src into the new area, like "memdup"
+// if src is 0, clears the memory
+template<typename T>
+inline T *salloc (int n, T *src) throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T), (void *)src); }
+
+// clears the memory
+template<typename T>
+inline T *salloc0(int n = 1)     throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T), 0);           }
+
 // for symmetry
-inline void dealloc (void *p, int s) throw ()
+template<typename T>
+inline void sfree (T *ptr, int n = 1) throw ()
 {
-  g_slice_free1 (s, p);
+  g_slice_free1 (n * sizeof (T), (void *)ptr);
 }
 
 // a STL-compatible allocator that uses g_slice
@@ -80,12 +98,12 @@
 
   pointer allocate (size_type n, const_pointer = 0)
   {
-    return static_cast<pointer>(alloc (n * sizeof (Tp)));
+    return salloc<Tp> (n);
   }
 
   void deallocate (pointer p, size_type n)
   {
-    dealloc (static_cast<void *>(p), n * sizeof (Tp));
+    sfree<Tp> (p, n);
   }
 
   size_type max_size ()const throw ()
@@ -106,11 +124,17 @@
 
 struct refcounted
 {
-  mutable int refcnt;
   refcounted () : refcnt (0) { }
+//  virtual ~refcounted ();
   void refcnt_inc () { ++refcnt; }
-  void refcnt_dec () { --refcnt;
-  if (refcnt < 0)abort();}//D
+  void refcnt_dec () { --refcnt; }
+  bool dead () { return refcnt == 0; }
+  mutable int refcnt;
+#if 0
+private:
+  static refcounted *rc_first;
+  refcounted *rc_next;
+#endif
 };
 
 template<class T>
@@ -144,6 +168,10 @@
   operator T *() const { return p; }
 };
 
+typedef refptr<player>    player_ptr;
+typedef refptr<object>    object_ptr;
+typedef refptr<archetype> arch_ptr;
+
 struct str_hash
 {
   std::size_t operator ()(const char *s) const
@@ -215,5 +243,10 @@
   assign ((char *)&dst, src, N);
 }
 
+typedef double tstamp;
+
+// return current time as timestampe
+tstamp now ();
+
 #endif