server/include/shstr.h

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 *
 * Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 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 pass 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;

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