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

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

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)
  : 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 shstr_ ## id;
#define def(id)      def2(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.28
Committed:	Thu Jan 1 11:41:17 2009 UTC (15 years, 4 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.27:	+20 -5 lines
Log Message:	* empty log message *
#	Content
1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	*
6	* Deliantra is free software: you can redistribute it and/or modify
7	* 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	*
11	* 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	*
16	* 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	*
19	* The authors can be reached via e-mail to <support@deliantra.net>
20	*/
21
22	#ifndef SHSTR_H__
23	#define SHSTR_H__
24
25	#include <cstring>
26	#include <sstream>
27
28	#include "traits.h"
29
30	extern size_t shstr_alloc;
31
32	extern int buf_overflow (const char buf1, const char buf2, int bufsize);
33
34	template<int size>
35	struct shstr_vec
36	{
37	uint32_t len;
38	uint32_t refcnt;
39	char string[size];
40	};
41
42	// 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	{
49	static shstr_vec<sizeof ("(null)")> nullvec;
50	static const char *null () { return nullvec.string; } // this is the null pointer value
51
52	const char *s;
53
54	static unsigned int &length (const char *s)
55	{
56	return ((unsigned int )s - 2);
57	}
58
59	int length () const
60	{
61	return length (s);
62	}
63
64	// 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	{
68	int plen = strlen (prefix);
69
70	return length () >= plen && !strncasecmp (s, prefix, plen);
71	}
72
73	bool contains (const char *substring) const
74	{
75	return strstr (s, substring);
76	}
77
78	//TODO: case sensitive should be eradicated
79	bool eq_nc (const char *otherstring) const
80	{
81	return !strcasecmp (s, otherstring);
82	}
83
84	shstr_tmp ()
85	: s (null ())
86	{
87	}
88
89	shstr_tmp (const shstr_tmp &sh)
90	: s (sh.s)
91	{
92	}
93
94	shstr_tmp operator =(const shstr_tmp &sh)
95	{
96	s = sh.s;
97
98	return *this;
99	}
100
101	// this is used for informational messages and the like
102	const char *operator &() const { return s; }
103
104	operator const char *() const { return s == null () ? 0 : s; }
105
106	protected:
107	// dummy is there so it isn't used as type converter accidentally
108	shstr_tmp (int dummy, const char *s)
109	: s(s)
110	{
111	}
112	};
113
114	inline bool operator ==(const shstr_tmp &a, const shstr_tmp &b)
115	{
116	return a.s == b.s;
117	}
118
119	inline bool operator !=(const shstr_tmp &a, const shstr_tmp &b)
120	{
121	return a.s != b.s;
122	}
123
124	inline int strlen (const shstr_tmp &sh)
125	{
126	return sh.length ();
127	}
128
129	static std::ostream &operator <<(std::ostream &o, shstr_tmp sh)
130	{
131	o.write (sh.s, sh.length ());
132
133	return o;
134	}
135
136	struct shstr : shstr_tmp
137	{
138	static unsigned int &refcnt (const char *s)
139	{
140	return ((unsigned int )s - 1);
141	}
142
143	unsigned int &refcnt () const
144	{
145	return refcnt (s);
146	}
147
148	shstr ()
149	{
150	}
151
152	static const char find (const char s);
153	static const char intern (const char s);
154
155	static void gc (); // garbage collect a few strings
156
157	shstr (const shstr &sh)
158	: shstr_tmp (sh)
159	{
160	++refcnt ();
161	}
162
163	shstr (const shstr_tmp &sh)
164	: shstr_tmp (sh)
165	{
166	++refcnt ();
167	}
168
169	explicit shstr (const char *str)
170	: shstr_tmp (0, is_constant (str) && !str ? null () : intern (str))
171	{
172	}
173
174	~shstr ()
175	{
176	--refcnt ();
177	}
178
179	using shstr_tmp::operator &;
180	using shstr_tmp::operator const char *;
181
182	// (note: not the copy constructor)
183	shstr &operator =(const shstr_tmp &sh)
184	{
185	--refcnt ();
186	s = sh.s;
187	++refcnt ();
188
189	return *this;
190	}
191
192	// here it comes
193	shstr &operator =(const shstr &sh)
194	{
195	return (*this) = (shstr_tmp)sh;
196	}
197
198	// shstr_tmp doesn't have this one
199	shstr &operator =(const char *str)
200	{
201	--refcnt ();
202	s = is_constant (str) && !str ? null () : intern (str);
203
204	return *this;
205	}
206	};
207
208	// only good for mass comparisons to shstr objects, or very
209	// temporary passing, basically a non-refcounted shstr
210	struct shstr_cmp
211	{
212	const char *s;
213
214	// initialies to the non-matching string (as opposed to the null string)
215	shstr_cmp ()
216	{
217	s = 0;
218	}
219
220	shstr_cmp (const char *str)
221	: s (shstr::find (str))
222	{
223	}
224
225	shstr_cmp (shstr_tmp sh)
226	: s (sh.s)
227	{
228	}
229
230	// this is used for informational messages and the like
231	const char *operator &() const { return s; }
232
233	operator const char *() const { return s; }
234	};
235
236	inline bool operator ==(const shstr_cmp &a, const shstr_tmp &b)
237	{
238	return a.s == b.s;
239	}
240
241	inline bool operator ==(const shstr_tmp &a, const shstr_cmp &b)
242	{
243	return a.s == b.s;
244	}
245
246	#define def2(id,str) extern const shstr shstr_ ## id;
247	#define def(id) def2(id, # id)
248	# include "shstrinc.h"
249	#undef def
250	#undef def2
251
252	// undefined external reference to catch people using str* functions when they shouldn't
253	//template<class any> void strcmp (const shstr_tmp &a, any b);
254	//template<class any> void strstr (const shstr_tmp &a, any b);
255
256	#endif
257