server/include/util.h

#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 ()));
  }
};

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
template<int N>
inline void assign (char (&dst)[N], const char *src)
{
  // should be optimised at some point, maybe should also add "..."
  // when buffer is too small.
  snprintf (dst, N, "%s", src);
}

#endif

Revision:	1.9
Committed:	Tue Sep 12 18:15:34 2006 UTC (20 years ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.8:	+9 -0 lines
Log Message:	- introduce shstr_cmp for mass comparisons to shstr and make use of it - introduce assign utility function to replace strncpy
#	User	Rev	Content
1	root	1.1	#ifndef UTIL_H__
2			#define UTIL_H__
3
4	root	1.2	#if __GNUC__ >= 3
5			# define is_constant(c) __builtin_constant_p (c)
6			#else
7			# define is_constant(c) 0
8			#endif
9
10	root	1.1	// makes dynamically allocated objects zero-initialised
11			struct zero_initialised
12			{
13	root	1.6	void operator new (size_t s, void );
14	root	1.1	void *operator new (size_t s);
15	root	1.3	void *operator new [] (size_t s);
16	root	1.1	void operator delete (void *p, size_t s);
17	root	1.3	void operator delete [] (void *p, size_t s);
18	root	1.1	};
19
20	root	1.7	struct refcounted
21			{
22			mutable int refcnt;
23			refcounted () : refcnt (0) { }
24			void refcnt_inc () { ++refcnt; }
25			void refcnt_dec () { --refcnt;
26			if (refcnt < 0)abort();}//D
27			};
28
29			template<class T>
30			struct refptr
31			{
32			T *p;
33
34			refptr () : p(0) { }
35			refptr (const refptr<T> &p) : p(p.p) { if (p) p->refcnt_inc (); }
36			refptr (T *p) : p(p) { if (p) p->refcnt_inc (); }
37			~refptr () { if (p) p->refcnt_dec (); }
38
39			const refptr<T> &operator =(T *o)
40			{
41			if (p) p->refcnt_dec ();
42			p = o;
43			if (p) p->refcnt_inc ();
44
45			return *this;
46			}
47
48			const refptr<T> &operator =(const refptr<T> o)
49			{
50			*this = o.p;
51			return *this;
52			}
53
54			T &operator * () const { return *p; }
55			T *operator ->() const { return p; }
56
57			operator T *() const { return p; }
58			};
59
60	root	1.4	struct str_hash
61			{
62			std::size_t operator ()(const char *s) const
63			{
64			unsigned long hash = 0;
65
66			/* use the one-at-a-time hash function, which supposedly is
67			* better than the djb2-like one used by perl5.005, but
68			* certainly is better then the bug used here before.
69			* see http://burtleburtle.net/bob/hash/doobs.html
70			*/
71			while (*s)
72			{
73			hash += *s++;
74			hash += hash << 10;
75			hash ^= hash >> 6;
76			}
77
78			hash += hash << 3;
79			hash ^= hash >> 11;
80			hash += hash << 15;
81
82			return hash;
83			}
84			};
85
86			struct str_equal
87			{
88			bool operator ()(const char a, const char b) const
89			{
90			return !strcmp (a, b);
91			}
92			};
93
94	root	1.6	#include <vector>
95
96			template<class obj>
97			struct unordered_vector : std::vector<obj>
98			{
99			typedef typename std::vector<obj>::iterator iterator;
100
101			void erase (unsigned int pos)
102			{
103			if (pos < this->size () - 1)
104			(this)[pos] = (this)[this->size () - 1];
105
106			this->pop_back ();
107			}
108
109			void erase (iterator i)
110			{
111			erase ((unsigned int )(i - this->begin ()));
112			}
113			};
114
115	root	1.8	template<typename T, typename U> static inline T min (T a, U b) { return a < (T)b ? a : (T)b; }
116			template<typename T, typename U> static inline T max (T a, U b) { return a > (T)b ? a : (T)b; }
117			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; }
118
119			template<typename T, typename U> static inline void swap (T& a, U& b) { T t=a; a=(T)b; b=(U)t; }
120
121	root	1.9	// basically does what strncpy should do
122			template<int N>
123			inline void assign (char (&dst)[N], const char *src)
124			{
125			// should be optimised at some point, maybe should also add "..."
126			// when buffer is too small.
127			snprintf (dst, N, "%s", src);
128			}
129
130	root	1.1	#endif
131