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 "util.h"

extern size_t shstr_alloc;

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

// 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 const char *null;

  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 (const shstr_cmp &sh)
  : s (sh.s)
  {
  }

  shstr_cmp (const shstr &sh)
  : s (sh.s)
  {
  }

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

  shstr_cmp operator =(const shstr_cmp sh) { s = sh.s; return *this; }
  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;
}

extern const shstr shstr_null;

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

#endif

Revision:	1.24
Committed:	Wed Dec 31 17:35:37 2008 UTC (15 years, 5 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.23:	+105 -70 lines
Log Message:	refactoring of shstr classe,s new shstr_tmp, lots of minor rewriting
#	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 "util.h"
29
30	extern size_t shstr_alloc;
31
32	extern int buf_overflow (const char buf1, const char buf2, int bufsize);
33
34	// this class is a non-refcounted shared string
35	// it cannot be used to create or store shared strings, but
36	// it can be used to apss shared strings around, i.e. as function arguments
37	// or return values. their lifetime must not span a gc () call, i.e.
38	// they are only valid as temporary values within the same server tick.
39	struct shstr_tmp
40	{
41	static const char *null;
42
43	const char *s;
44
45	static unsigned int &length (const char *s)
46	{
47	return ((unsigned int )s - 2);
48	}
49
50	int length () const
51	{
52	return length (s);
53	}
54
55	// returns whether this shared string begins with the given prefix,
56	// used mainly for searches when users give only the start of a name.
57	bool starts_with (const char *prefix) const
58	{
59	int plen = strlen (prefix);
60
61	return length () >= plen && !strncasecmp (s, prefix, plen);
62	}
63
64	bool contains (const char *substring) const
65	{
66	return strstr (s, substring);
67	}
68
69	shstr_tmp ()
70	: s (null)
71	{
72	}
73
74	shstr_tmp (const shstr_tmp &sh)
75	: s (sh.s)
76	{
77	}
78
79	shstr_tmp operator =(const shstr_tmp &sh)
80	{
81	s = sh.s;
82
83	return *this;
84	}
85
86	// this is used for informational messages and the like
87	const char *operator &() const { return s; }
88
89	operator const char *() const { return s == null ? 0 : s; }
90	};
91
92	inline bool operator ==(const shstr_tmp &a, const shstr_tmp &b)
93	{
94	return a.s == b.s;
95	}
96
97	inline bool operator !=(const shstr_tmp &a, const shstr_tmp &b)
98	{
99	return a.s != b.s;
100	}
101
102	inline int strlen (const shstr_tmp &sh)
103	{
104	return sh.length ();
105	}
106
107	// undefined external reference to catch people using strcmp when they shouldn't
108	int strcmp (const shstr_tmp &a, const shstr_tmp &b);
109
110	static std::ostream &operator <<(std::ostream &o, shstr_tmp sh)
111	{
112	o.write (sh.s, sh.length ());
113
114	return o;
115	}
116
117	struct shstr : shstr_tmp
118	{
119	static unsigned int &refcnt (const char *s)
120	{
121	return ((unsigned int )s - 1);
122	}
123
124	unsigned int &refcnt () const
125	{
126	return refcnt (s);
127	}
128
129	shstr ()
130	{
131	}
132
133	static const char find (const char s);
134	static const char intern (const char s);
135
136	static void gc (); // garbage collect a few strings
137
138	shstr (const shstr &sh)
139	: shstr_tmp (sh)
140	{
141	++refcnt ();
142	}
143
144	shstr (const shstr_tmp &sh)
145	: shstr_tmp (sh)
146	{
147	++refcnt ();
148	}
149
150	explicit shstr (const char *str)
151	{
152	s = is_constant (str) && !str ? null : intern (str);
153	}
154
155	~shstr ()
156	{
157	--refcnt ();
158	}
159
160	using shstr_tmp::operator &;
161	using shstr_tmp::operator const char *;
162
163	// (note: not the copy constructor)
164	shstr &operator =(const shstr_tmp &sh)
165	{
166	--refcnt ();
167	s = sh.s;
168	++refcnt ();
169
170	return *this;
171	}
172
173	// here it comes
174	shstr &operator =(const shstr &sh)
175	{
176	return (*this) = (shstr_tmp)sh;
177	}
178
179	// shstr_tmp doesn't have this one
180	shstr &operator =(const char *str)
181	{
182	--refcnt ();
183	s = is_constant (str) && !str ? null : intern (str);
184
185	return *this;
186	}
187	};
188
189	// only good for mass comparisons to shstr objects, or very
190	// temporary passing, basically a non-refcounted shstr
191	struct shstr_cmp
192	{
193	const char *s;
194
195	explicit shstr_cmp (const char *str)
196	: s (shstr::find (str))
197	{
198	}
199
200	shstr_cmp (const shstr_cmp &sh)
201	: s (sh.s)
202	{
203	}
204
205	shstr_cmp (const shstr &sh)
206	: s (sh.s)
207	{
208	}
209
210	// this is used for informational messages and the like
211	const char *operator &() const { return s; }
212
213	shstr_cmp operator =(const shstr_cmp sh) { s = sh.s; return *this; }
214	operator const char *() const { return s; }
215	};
216
217	inline bool operator ==(const shstr_cmp &a, const shstr_tmp &b)
218	{
219	return a.s == b.s;
220	}
221
222	inline bool operator ==(const shstr_tmp &a, const shstr_cmp &b)
223	{
224	return a.s == b.s;
225	}
226
227	extern const shstr shstr_null;
228
229	#define def(str) extern const shstr shstr_ ## str;
230	# include "shstrinc.h"
231	#undef def
232
233	#endif
234