--- deliantra/server/include/util.h	2006/09/04 11:07:59	1.3
+++ deliantra/server/include/util.h	2006/12/16 03:08:26	1.17
@@ -7,14 +7,229 @@
 # define is_constant(c) 0
 #endif
 
+#include <cstddef>
+
+#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
 {
-  void *operator new (size_t s);
-  void *operator new [] (size_t s);
-  void operator delete (void *p, size_t s);
-  void operator delete [] (void *p, size_t s);
+  void *operator new (size_t s, void *p)
+  {
+    memset (p, 0, s);
+    return p;
+  }
+
+  void *operator new (size_t s)
+  {
+    return g_slice_alloc0 (s);
+  }
+
+  void *operator new[] (size_t s)
+  {
+    return g_slice_alloc0 (s);
+  }
+
+  void operator delete (void *p, size_t s)
+  {
+    g_slice_free1 (s, p);
+  }
+
+  void operator delete[] (void *p, size_t s)
+  {
+    g_slice_free1 (s, p);
+  }
 };
 
+// strictly the same as g_slice_alloc, but never returns 0
+void *salloc (int size)            throw (std::bad_alloc);
+// also copies src into the new area, like "memdup"
+void *salloc (int size, void *src) throw (std::bad_alloc);
+// for symmetry
+inline void sfree (void *ptr, int size) throw ()
+{
+  g_slice_free1 (size, ptr);
+}
+
+// a STL-compatible allocator that uses g_slice
+// boy, this is verbose
+template<typename Tp>
+struct slice_allocator
+{
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef Tp *pointer;
+  typedef const Tp *const_pointer;
+  typedef Tp &reference;
+  typedef const Tp &const_reference;
+  typedef Tp value_type;
+
+  template <class U> 
+  struct rebind
+  {
+    typedef slice_allocator<U> other;
+  };
+
+  slice_allocator () throw () { }
+  slice_allocator (const slice_allocator &o) throw () { }
+  template<typename Tp2>
+  slice_allocator (const slice_allocator<Tp2> &) throw () { }
+
+  ~slice_allocator () { }
+
+  pointer address (reference x) const { return &x; }
+  const_pointer address (const_reference x) const { return &x; }
+
+  pointer allocate (size_type n, const_pointer = 0)
+  {
+    return static_cast<pointer>(salloc (n * sizeof (Tp)));
+  }
+
+  void deallocate (pointer p, size_type n)
+  {
+    sfree (static_cast<void *>(p), n * sizeof (Tp));
+  }
+
+  size_type max_size ()const throw ()
+  {
+    return size_t (-1) / sizeof (Tp);
+  }
+
+  void construct (pointer p, const Tp &val)
+  {
+    ::new (p) Tp (val);
+  }
+
+  void destroy (pointer p)
+  {
+    p->~Tp ();
+  }
+};
+
+struct refcounted
+{
+  refcounted () : refcnt (0) { }
+//  virtual ~refcounted ();
+  void refcnt_inc () { ++refcnt; }
+  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>
+struct refptr
+{
+  T *p;
+
+  refptr () : p(0) { }
+  refptr (const refptr<T> &p) : p(p.p) { if (p) p->refcnt_inc (); }
+  refptr (T *p) : p(p) { if (p) p->refcnt_inc (); }
+  ~refptr () { if (p) p->refcnt_dec (); }
+
+  const refptr<T> &operator =(T *o)
+  {
+    if (p) p->refcnt_dec ();
+    p = o;
+    if (p) p->refcnt_inc ();
+
+    return *this;
+  }
+
+  const refptr<T> &operator =(const refptr<T> o)
+  {
+    *this = o.p;
+    return *this;
+  }
+
+  T &operator * () const { return *p; }
+  T *operator ->() const { return p; }
+
+  operator T *() const { return p; }
+};
+
+struct str_hash
+{
+  std::size_t operator ()(const char *s) const
+  {
+    unsigned long hash = 0;
+
+    /* use the one-at-a-time hash function, which supposedly is
+     * better than the djb2-like one used by perl5.005, but
+     * certainly is better then the bug used here before.
+     * see http://burtleburtle.net/bob/hash/doobs.html
+     */
+    while (*s)
+      {
+        hash += *s++;
+        hash += hash << 10;
+        hash ^= hash >>  6;
+      }
+
+    hash += hash <<  3;
+    hash ^= hash >> 11;
+    hash += hash << 15;
+
+    return hash;
+  }
+};
+
+struct str_equal
+{
+  bool operator ()(const char *a, const char *b) const
+  {
+    return !strcmp (a, b);
+  }
+};
+
+#include <vector>
+
+template<class obj>
+struct unordered_vector : std::vector<obj, slice_allocator<obj> >
+{
+  typedef typename unordered_vector::iterator iterator;
+
+  void erase (unsigned int pos)
+  {
+    if (pos < this->size () - 1)
+      (*this)[pos] = (*this)[this->size () - 1];
+
+    this->pop_back ();
+  }
+
+  void erase (iterator i)
+  {
+    erase ((unsigned int )(i - this->begin ()));
+  }
+};
+
+template<typename T, typename U> static inline T min (T a, U b) { return a < (T)b ? a : (T)b; }
+template<typename T, typename U> static inline T max (T a, U b) { return a > (T)b ? a : (T)b; }
+template<typename T, typename U, typename V> static inline T clamp (T v, U a, V b) { return v < (T)a ? a : v >(T)b ? b : v; }
+
+template<typename T, typename U> static inline void swap (T& a, U& b) { T t=a; a=(T)b; b=(U)t; }
+
+// basically does what strncpy should do, but appends "..." to strings exceeding length
+void assign (char *dst, const char *src, int maxlen);
+
+// type-safe version of assign
+template<int N>
+inline void assign (char (&dst)[N], const char *src)
+{
+  assign ((char *)&dst, src, N);
+}
+
+typedef double tstamp;
+
+// return current time as timestampe
+tstamp now ();
+
 #endif