server/include/shstr.h

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * 
 * Deliantra is free software: you can redistribute it and/or modify it under
 * the terms of the Affero GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the Affero GNU General Public License
 * and the GNU General Public License along with this program. If not, see
 * <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

#ifndef SHSTR_H__
#define SHSTR_H__

#include <cstring>
#include <sstream>

#include "traits.h"

extern size_t shstr_alloc;

extern int buf_overflow (const char *buf1, const char *buf2, int bufsize);

template<int size>
struct shstr_vec
{
  uint32_t hash;
  uint32_t len;
  uint32_t refcnt;
  // pointer points here
  char string [size];
};

// this class is a non-refcounted shared string
// it cannot be used to create or store shared strings, but
// it can be used to apss shared strings around, i.e. as function arguments
// or return values. their lifetime must not span a gc () call, i.e.
// they are only valid as temporary values within the same server tick.
struct shstr_tmp
{
  static shstr_vec<sizeof ("(null)")> nullvec;
  static const char *null () { return nullvec.string; } // this is the null pointer value

  const char *s;

  static unsigned int &hash (const char *s)
  {
    return *((unsigned int *)s - 3);
  }

  int hash () const
  {
    return hash (s);
  }

  static unsigned int &length (const char *s)
  {
    return *((unsigned int *)s - 2);
  }

  int length () const
  {
    return length (s);
  }

  // returns whether this shared string begins with the given prefix,
  // used mainly for searches when users give only the start of a name.
  bool starts_with (const char *prefix) const
  {
    int plen = strlen (prefix);

    return length () >= plen && !strncasecmp (s, prefix, plen);
  }

  // returns true if the substring is contained in the shstr
  // if the shstr is 0, then this always returns false.
  // the shstr is (theoretically) treated as a comma/colon/space etc. separated list.
  bool contains (const char *substring) const
  {
    return s != null () && strstr (s, substring);
  }

  //TODO: case sensitive should be eradicated
  bool eq_nc (const char *otherstring) const
  {
    return !strcasecmp (s, otherstring);
  }

  shstr_tmp ()
  : s (null ())
  {
  }

  shstr_tmp (const shstr_tmp &sh)
  : s (sh.s)
  {
  }

  shstr_tmp operator =(const shstr_tmp &sh)
  {
    s = sh.s;

    return *this;
  }

  // this is used for informational messages and the like
  const char *operator &() const { return s; }

  operator const char *() const { return s == null () ? 0 : s; }

protected:
  // dummy is there so it isn't used as type converter accidentally
  shstr_tmp (int dummy, const char *s)
  : s(s)
  {
  }
};

inline bool operator ==(const shstr_tmp &a, const shstr_tmp &b)
{
  return a.s == b.s;
}

inline bool operator !=(const shstr_tmp &a, const shstr_tmp &b)
{
  return a.s != b.s;
}

inline int strlen (shstr_tmp sh)
{
  return sh.length ();
}

static inline std::ostream &operator <<(std::ostream &o, shstr_tmp sh)
{
  o.write (sh.s, sh.length ());

  return o;
}

struct shstr : shstr_tmp
{
  static unsigned int &refcnt (const char *s)
  {
    return *((unsigned int *)s - 1);
  }

  unsigned int &refcnt () const
  {
    return refcnt (s);
  }

  shstr ()
  {
  }

  static const char *find (const char *s);
  static const char *intern (const char *s);

  static void gc (); // garbage collect a few strings

  shstr (const shstr &sh)
  : shstr_tmp (sh)
  {
    ++refcnt ();
  }

  shstr (const shstr_tmp &sh)
  : shstr_tmp (sh)
  {
    ++refcnt ();
  }

  explicit shstr (const char *str)
  : shstr_tmp (0, is_constant (str) && !str ? null () : intern (str))
  {
  }

  ~shstr ()
  {
    --refcnt ();
  }

  using shstr_tmp::operator &;
  using shstr_tmp::operator const char *;

  // (note: not the copy constructor)
  shstr &operator =(const shstr_tmp &sh)
  {
    --refcnt ();
    s = sh.s;
    ++refcnt ();

    return *this;
  }

  // here it comes
  shstr &operator =(const shstr &sh)
  {
    return (*this) = (shstr_tmp)sh;
  }

  // shstr_tmp doesn't have this one
  shstr &operator =(const char *str)
  {
    --refcnt ();
    s = is_constant (str) && !str ? null () : intern (str);

    return *this;
  }
};

// only good for mass comparisons to shstr objects, or very
// temporary passing, basically a non-refcounted shstr
struct shstr_cmp
{
  const char *s;

  // initialies to the non-matching string (as opposed to the null string)
  shstr_cmp ()
  {
    s = 0;
  }

  shstr_cmp (const char *str)
  : s (shstr::find (str))
  {
  }

  shstr_cmp (shstr_tmp sh)
  : s (sh.s)
  {
  }

  // this is used for informational messages and the like
  const char *operator &() const { return s; }

  operator const char *() const { return s; }
};

inline bool operator ==(const shstr_cmp &a, const shstr_tmp &b)
{
  return a.s == b.s;
}

inline bool operator ==(const shstr_tmp &a, const shstr_cmp &b)
{
  return a.s == b.s;
}

#define def2(id,str) extern const shstr id;
#define def(id)      def2(shstr_ ## id, # id)
# include "shstrinc.h"
#undef def
#undef def2

// undefined external reference to catch people using str* functions when they shouldn't
//template<class any> void strcmp (const shstr_tmp &a, any b);
template<class any> void strstr (const shstr_tmp &a, any b);

#endif

Revision:	1.36
Committed:	Tue Nov 10 00:01:31 2009 UTC (14 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.35:	+13 -1 lines
Log Message:	store hash in shstr
#	User	Rev	Content
1	root	1.16	/*
2	root	1.20	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	root	1.16	*
4	root	1.34	* Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	root	1.16	*
6	root	1.33	* Deliantra is free software: you can redistribute it and/or modify it under
7			* the terms of the Affero GNU General Public License as published by the
8			* Free Software Foundation, either version 3 of the License, or (at your
9			* option) any later version.
10	root	1.16	*
11	root	1.17	* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15	root	1.16	*
16	root	1.33	* You should have received a copy of the Affero GNU General Public License
17			* and the GNU General Public License along with this program. If not, see
18			* <http://www.gnu.org/licenses/>.
19	root	1.16	*
20	root	1.20	* The authors can be reached via e-mail to <support@deliantra.net>
21	root	1.16	*/
22
23	root	1.2	#ifndef SHSTR_H__
24			#define SHSTR_H__
25
26	root	1.24	#include <cstring>
27	root	1.13	#include <sstream>
28
29	root	1.25	#include "traits.h"
30	root	1.8
31	root	1.19	extern size_t shstr_alloc;
32
33	root	1.8	extern int buf_overflow (const char buf1, const char buf2, int bufsize);
34	root	1.5
35	root	1.25	template<int size>
36			struct shstr_vec
37			{
38	root	1.36	uint32_t hash;
39	root	1.25	uint32_t len;
40			uint32_t refcnt;
41	root	1.36	// pointer points here
42			char string [size];
43	root	1.25	};
44
45	root	1.24	// this class is a non-refcounted shared string
46			// it cannot be used to create or store shared strings, but
47			// it can be used to apss shared strings around, i.e. as function arguments
48			// or return values. their lifetime must not span a gc () call, i.e.
49			// they are only valid as temporary values within the same server tick.
50			struct shstr_tmp
51	root	1.5	{
52	root	1.25	static shstr_vec<sizeof ("(null)")> nullvec;
53			static const char *null () { return nullvec.string; } // this is the null pointer value
54	root	1.8
55	root	1.5	const char *s;
56	root	1.4
57	root	1.36	static unsigned int &hash (const char *s)
58			{
59			return ((unsigned int )s - 3);
60			}
61
62			int hash () const
63			{
64			return hash (s);
65			}
66
67	root	1.24	static unsigned int &length (const char *s)
68	root	1.5	{
69	root	1.24	return ((unsigned int )s - 2);
70	root	1.5	}
71
72	root	1.24	int length () const
73	root	1.7	{
74	root	1.24	return length (s);
75	root	1.7	}
76
77	root	1.24	// returns whether this shared string begins with the given prefix,
78			// used mainly for searches when users give only the start of a name.
79			bool starts_with (const char *prefix) const
80	root	1.7	{
81	root	1.24	int plen = strlen (prefix);
82
83			return length () >= plen && !strncasecmp (s, prefix, plen);
84	root	1.7	}
85
86	root	1.32	// returns true if the substring is contained in the shstr
87			// if the shstr is 0, then this always returns false.
88			// the shstr is (theoretically) treated as a comma/colon/space etc. separated list.
89	root	1.24	bool contains (const char *substring) const
90	root	1.7	{
91	root	1.29	return s != null () && strstr (s, substring);
92	root	1.7	}
93
94	root	1.28	//TODO: case sensitive should be eradicated
95			bool eq_nc (const char *otherstring) const
96			{
97			return !strcasecmp (s, otherstring);
98			}
99
100	root	1.24	shstr_tmp ()
101	root	1.25	: s (null ())
102	root	1.24	{
103			}
104
105			shstr_tmp (const shstr_tmp &sh)
106			: s (sh.s)
107	root	1.15	{
108			}
109
110	root	1.24	shstr_tmp operator =(const shstr_tmp &sh)
111			{
112			s = sh.s;
113	root	1.5
114	root	1.24	return *this;
115			}
116	root	1.5
117	root	1.6	// this is used for informational messages and the like
118	root	1.8	const char *operator &() const { return s; }
119	root	1.5
120	root	1.25	operator const char *() const { return s == null () ? 0 : s; }
121	root	1.26
122			protected:
123			// dummy is there so it isn't used as type converter accidentally
124			shstr_tmp (int dummy, const char *s)
125			: s(s)
126			{
127			}
128	root	1.24	};
129
130			inline bool operator ==(const shstr_tmp &a, const shstr_tmp &b)
131			{
132			return a.s == b.s;
133			}
134
135			inline bool operator !=(const shstr_tmp &a, const shstr_tmp &b)
136			{
137			return a.s != b.s;
138			}
139
140	root	1.31	inline int strlen (shstr_tmp sh)
141	root	1.24	{
142			return sh.length ();
143			}
144
145	root	1.35	static inline std::ostream &operator <<(std::ostream &o, shstr_tmp sh)
146	root	1.24	{
147			o.write (sh.s, sh.length ());
148
149			return o;
150			}
151
152			struct shstr : shstr_tmp
153			{
154			static unsigned int &refcnt (const char *s)
155			{
156			return ((unsigned int )s - 1);
157			}
158
159			unsigned int &refcnt () const
160			{
161			return refcnt (s);
162			}
163	root	1.5
164			shstr ()
165			{
166			}
167
168	root	1.24	static const char find (const char s);
169			static const char intern (const char s);
170
171			static void gc (); // garbage collect a few strings
172
173	root	1.6	shstr (const shstr &sh)
174	root	1.24	: shstr_tmp (sh)
175			{
176			++refcnt ();
177			}
178
179			shstr (const shstr_tmp &sh)
180			: shstr_tmp (sh)
181	root	1.5	{
182	root	1.8	++refcnt ();
183	root	1.5	}
184
185	root	1.24	explicit shstr (const char *str)
186	root	1.26	: shstr_tmp (0, is_constant (str) && !str ? null () : intern (str))
187	root	1.5	{
188			}
189
190			~shstr ()
191			{
192	root	1.8	--refcnt ();
193	root	1.5	}
194
195	root	1.24	using shstr_tmp::operator &;
196			using shstr_tmp::operator const char *;
197
198			// (note: not the copy constructor)
199			shstr &operator =(const shstr_tmp &sh)
200	root	1.5	{
201	root	1.8	--refcnt ();
202	root	1.5	s = sh.s;
203	root	1.8	++refcnt ();
204	root	1.5
205			return *this;
206			}
207
208	root	1.24	// here it comes
209			shstr &operator =(const shstr &sh)
210			{
211			return (*this) = (shstr_tmp)sh;
212			}
213
214			// shstr_tmp doesn't have this one
215			shstr &operator =(const char *str)
216	root	1.5	{
217	root	1.8	--refcnt ();
218	root	1.25	s = is_constant (str) && !str ? null () : intern (str);
219	root	1.1
220	root	1.5	return *this;
221			}
222			};
223	root	1.1
224	root	1.24	// only good for mass comparisons to shstr objects, or very
225			// temporary passing, basically a non-refcounted shstr
226	root	1.10	struct shstr_cmp
227			{
228			const char *s;
229
230	root	1.28	// initialies to the non-matching string (as opposed to the null string)
231			shstr_cmp ()
232			{
233			s = 0;
234			}
235
236			shstr_cmp (const char *str)
237	root	1.24	: s (shstr::find (str))
238	root	1.10	{
239			}
240
241	root	1.25	shstr_cmp (shstr_tmp sh)
242	root	1.23	: s (sh.s)
243			{
244			}
245
246			// this is used for informational messages and the like
247			const char *operator &() const { return s; }
248
249	root	1.10	operator const char *() const { return s; }
250			};
251
252	root	1.24	inline bool operator ==(const shstr_cmp &a, const shstr_tmp &b)
253	root	1.5	{
254			return a.s == b.s;
255			}
256	root	1.4
257	root	1.24	inline bool operator ==(const shstr_tmp &a, const shstr_cmp &b)
258	root	1.4	{
259	root	1.24	return a.s == b.s;
260	root	1.5	}
261	root	1.4
262	root	1.30	#define def2(id,str) extern const shstr id;
263			#define def(id) def2(shstr_ ## id, # id)
264	root	1.18	# include "shstrinc.h"
265			#undef def
266	root	1.28	#undef def2
267
268			// undefined external reference to catch people using str* functions when they shouldn't
269			//template<class any> void strcmp (const shstr_tmp &a, any b);
270	root	1.29	template<class any> void strstr (const shstr_tmp &a, any b);
271	root	1.9
272	root	1.2	#endif
273