#ifndef UTIL_H__
#define UTIL_H__

#if __GNUC__ >= 3
# define is_constant(c) __builtin_constant_p (c)
#else
# define is_constant(c) 0
#endif

// makes dynamically allocated objects zero-initialised
struct zero_initialised
{
  void *operator new (size_t s, void *);
  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);
};

struct refcounted
{
  mutable int refcnt;
  refcounted () : refcnt (0) { }
  void refcnt_inc () { ++refcnt; }
  void refcnt_dec () { --refcnt;
  if (refcnt < 0)abort();}//D
};

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>
{
  typedef typename std::vector<obj>::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 ()));
  }
};

#endif