server/include/shstr.h

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008 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 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 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 len;
  uint32_t refcnt;
  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 &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);
  }

  bool contains (const char *substring) const
  {
    return strstr (s, substring);
  }

  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; }
};

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 (const shstr_tmp &sh)
{
  return sh.length ();
}

// undefined external reference to catch people using strcmp when they shouldn't
int strcmp (const shstr_tmp &a, const shstr_tmp &b);

static 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)
  {
    s = 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;

  explicit 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 def(str) extern const shstr shstr_ ## str;
# include "shstrinc.h"
#undef def

#endif

Revision:	1.25
Committed:	Wed Dec 31 18:07:41 2008 UTC (15 years, 4 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.24:	+16 -15 lines
Log Message:	further optimisations
#	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.22	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	root	1.16	*
6	root	1.20	* Deliantra is free software: you can redistribute it and/or modify
7	root	1.17	* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your 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.17	* You should have received a copy of the GNU General Public License
17			* along with this program. If not, see <http://www.gnu.org/licenses/>.
18	root	1.16	*
19	root	1.20	* The authors can be reached via e-mail to <support@deliantra.net>
20	root	1.16	*/
21
22	root	1.2	#ifndef SHSTR_H__
23			#define SHSTR_H__
24
25	root	1.24	#include <cstring>
26	root	1.13	#include <sstream>
27
28	root	1.25	#include "traits.h"
29	root	1.8
30	root	1.19	extern size_t shstr_alloc;
31
32	root	1.8	extern int buf_overflow (const char buf1, const char buf2, int bufsize);
33	root	1.5
34	root	1.25	template<int size>
35			struct shstr_vec
36			{
37			uint32_t len;
38			uint32_t refcnt;
39			char string[size];
40			};
41
42	root	1.24	// this class is a non-refcounted shared string
43			// it cannot be used to create or store shared strings, but
44			// it can be used to apss shared strings around, i.e. as function arguments
45			// or return values. their lifetime must not span a gc () call, i.e.
46			// they are only valid as temporary values within the same server tick.
47			struct shstr_tmp
48	root	1.5	{
49	root	1.25	static shstr_vec<sizeof ("(null)")> nullvec;
50			static const char *null () { return nullvec.string; } // this is the null pointer value
51	root	1.8
52	root	1.5	const char *s;
53	root	1.4
54	root	1.24	static unsigned int &length (const char *s)
55	root	1.5	{
56	root	1.24	return ((unsigned int )s - 2);
57	root	1.5	}
58
59	root	1.24	int length () const
60	root	1.7	{
61	root	1.24	return length (s);
62	root	1.7	}
63
64	root	1.24	// returns whether this shared string begins with the given prefix,
65			// used mainly for searches when users give only the start of a name.
66			bool starts_with (const char *prefix) const
67	root	1.7	{
68	root	1.24	int plen = strlen (prefix);
69
70			return length () >= plen && !strncasecmp (s, prefix, plen);
71	root	1.7	}
72
73	root	1.24	bool contains (const char *substring) const
74	root	1.7	{
75	root	1.24	return strstr (s, substring);
76	root	1.7	}
77
78	root	1.24	shstr_tmp ()
79	root	1.25	: s (null ())
80	root	1.24	{
81			}
82
83			shstr_tmp (const shstr_tmp &sh)
84			: s (sh.s)
85	root	1.15	{
86			}
87
88	root	1.24	shstr_tmp operator =(const shstr_tmp &sh)
89			{
90			s = sh.s;
91	root	1.5
92	root	1.24	return *this;
93			}
94	root	1.5
95	root	1.6	// this is used for informational messages and the like
96	root	1.8	const char *operator &() const { return s; }
97	root	1.5
98	root	1.25	operator const char *() const { return s == null () ? 0 : s; }
99	root	1.24	};
100
101			inline bool operator ==(const shstr_tmp &a, const shstr_tmp &b)
102			{
103			return a.s == b.s;
104			}
105
106			inline bool operator !=(const shstr_tmp &a, const shstr_tmp &b)
107			{
108			return a.s != b.s;
109			}
110
111			inline int strlen (const shstr_tmp &sh)
112			{
113			return sh.length ();
114			}
115
116			// undefined external reference to catch people using strcmp when they shouldn't
117			int strcmp (const shstr_tmp &a, const shstr_tmp &b);
118
119			static std::ostream &operator <<(std::ostream &o, shstr_tmp sh)
120			{
121			o.write (sh.s, sh.length ());
122
123			return o;
124			}
125
126			struct shstr : shstr_tmp
127			{
128			static unsigned int &refcnt (const char *s)
129			{
130			return ((unsigned int )s - 1);
131			}
132
133			unsigned int &refcnt () const
134			{
135			return refcnt (s);
136			}
137	root	1.5
138			shstr ()
139			{
140			}
141
142	root	1.24	static const char find (const char s);
143			static const char intern (const char s);
144
145			static void gc (); // garbage collect a few strings
146
147	root	1.6	shstr (const shstr &sh)
148	root	1.24	: shstr_tmp (sh)
149			{
150			++refcnt ();
151			}
152
153			shstr (const shstr_tmp &sh)
154			: shstr_tmp (sh)
155	root	1.5	{
156	root	1.8	++refcnt ();
157	root	1.5	}
158
159	root	1.24	explicit shstr (const char *str)
160	root	1.5	{
161	root	1.25	s = is_constant (str) && !str ? null () : intern (str);
162	root	1.5	}
163
164			~shstr ()
165			{
166	root	1.8	--refcnt ();
167	root	1.5	}
168
169	root	1.24	using shstr_tmp::operator &;
170			using shstr_tmp::operator const char *;
171
172			// (note: not the copy constructor)
173			shstr &operator =(const shstr_tmp &sh)
174	root	1.5	{
175	root	1.8	--refcnt ();
176	root	1.5	s = sh.s;
177	root	1.8	++refcnt ();
178	root	1.5
179			return *this;
180			}
181
182	root	1.24	// here it comes
183			shstr &operator =(const shstr &sh)
184			{
185			return (*this) = (shstr_tmp)sh;
186			}
187
188			// shstr_tmp doesn't have this one
189			shstr &operator =(const char *str)
190	root	1.5	{
191	root	1.8	--refcnt ();
192	root	1.25	s = is_constant (str) && !str ? null () : intern (str);
193	root	1.1
194	root	1.5	return *this;
195			}
196			};
197	root	1.1
198	root	1.24	// only good for mass comparisons to shstr objects, or very
199			// temporary passing, basically a non-refcounted shstr
200	root	1.10	struct shstr_cmp
201			{
202			const char *s;
203
204	root	1.24	explicit shstr_cmp (const char *str)
205			: s (shstr::find (str))
206	root	1.10	{
207			}
208
209	root	1.25	shstr_cmp (shstr_tmp sh)
210	root	1.23	: s (sh.s)
211			{
212			}
213
214			// this is used for informational messages and the like
215			const char *operator &() const { return s; }
216
217	root	1.10	operator const char *() const { return s; }
218			};
219
220	root	1.24	inline bool operator ==(const shstr_cmp &a, const shstr_tmp &b)
221	root	1.5	{
222			return a.s == b.s;
223			}
224	root	1.4
225	root	1.24	inline bool operator ==(const shstr_tmp &a, const shstr_cmp &b)
226	root	1.4	{
227	root	1.24	return a.s == b.s;
228	root	1.5	}
229	root	1.4
230	root	1.18	#define def(str) extern const shstr shstr_ ## str;
231			# include "shstrinc.h"
232			#undef def
233	root	1.9
234	root	1.2	#endif
235