server/include/shstr.h

/*
 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
 * 
 * Crossfire TRT 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 <crossfire@schmorp.de>
 */

#ifndef SHSTR_H__
#define SHSTR_H__

#include <sstream>

#include "util.h"

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

struct shstr
{
  static const char *null;

  const char *s;

  static int &refcnt (const char *s)
  {
    return *((int *)s - 1);
  }

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

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

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

  // returns wether this shared string begins with the given prefix,
  // used mainly for searched when users give only the start of a name.
  bool begins_with (const char *prefix) const
  {
    int plen = strlen (prefix);
    return !strncasecmp (s, prefix, plen) && length () >= plen;
  }

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

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

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

  const char &operator [](int i) const { return s[i]; }
  operator const char *() const { return s == null ? 0 : s; }

  shstr ()
  : s (null)
  {
  }

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

  explicit shstr (const char *s)
  : s (intern (s))
  {
  }

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

  const shstr &operator =(const shstr &sh)
  {
    --refcnt ();
    s = sh.s;
    ++refcnt ();

    return *this;
  }

  const shstr &operator =(const char *str)
  {
    --refcnt ();

    // this optimises the important case of str == constant 0
    if (is_constant (str))
      s = str ? intern (str) : null;
    else
      s = intern (str);

    return *this;
  }

  bool operator ==(const shstr &b)
  {
    return s == b.s;
  }

  bool operator !=(const shstr &b)
  {
    return !(*this == b);
  }
};

inline int strlen (const shstr &sh)
{
  return sh.length ();
}

inline int strcmp (const shstr &a, const shstr &b)
{
  // TODO: use this to find all the occurences of people using strcmp
  // all uses should be bogus, as we should be never interested in
  // comparing shstr's alphabetically
#if 0
  extern void do_not_use_strcmp_to_compare_shstr_values ();
  do_not_use_strcmp_to_compare_shstr_values ();
#endif
  return a != b;
}

static std::ostream &operator <<(std::ostream &o, const shstr &sh)
{
  o.write (sh.s, sh.length ());
  return o;
}

// only good for mass comparisons to shstr objects
struct shstr_cmp
{
  const char *s;

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

  shstr_cmp (const shstr_cmp &sh)
  : s (sh.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 &b)
{
  return a.s == b.s;
}

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

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

#endif

Revision:	1.18
Committed:	Tue Jul 10 05:51:38 2007 UTC (16 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_2
Changes since 1.17:	+3 -1 lines
Log Message:	- improve dynbuf implementation further - save now saves shstrs longer than HUGE_BUF, lets fix any brokenness remaining in the server... - converted most describe_*-functions to dynbuf_text, making them likely faster (or maybe slower), while removing any hardcoded length limit. - memory allocated for static dynbuf's is not being returned ever (at least not the initial chunk, maybe fix this?) - implement framework for predeclared const shstrs for comparison purposes (shstrinc.h). - enabled and enforced new material code. - implement hack to clean up book titles. - increases HUGE_BUF to 10240, to be similar to mac network packet size.
#	Content
1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5	*
6	* Crossfire TRT 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 <crossfire@schmorp.de>
20	*/
21
22	#ifndef SHSTR_H__
23	#define SHSTR_H__
24
25	#include <sstream>
26
27	#include "util.h"
28
29	extern int buf_overflow (const char buf1, const char buf2, int bufsize);
30
31	struct shstr
32	{
33	static const char *null;
34
35	const char *s;
36
37	static int &refcnt (const char *s)
38	{
39	return ((int )s - 1);
40	}
41
42	static int &length (const char *s)
43	{
44	return ((int )s - 2);
45	}
46
47	int &refcnt () const
48	{
49	return refcnt (s);
50	}
51
52	int length () const
53	{
54	return length (s);
55	}
56
57	// returns wether this shared string begins with the given prefix,
58	// used mainly for searched when users give only the start of a name.
59	bool begins_with (const char *prefix) const
60	{
61	int plen = strlen (prefix);
62	return !strncasecmp (s, prefix, plen) && length () >= plen;
63	}
64
65	static const char find (const char s);
66	static const char intern (const char s);
67
68	static void gc (); // garbage collect a few strings
69
70	// this is used for informational messages and the like
71	const char *operator &() const { return s; }
72
73	const char &operator [](int i) const { return s[i]; }
74	operator const char *() const { return s == null ? 0 : s; }
75
76	shstr ()
77	: s (null)
78	{
79	}
80
81	shstr (const shstr &sh)
82	: s (sh.s)
83	{
84	++refcnt ();
85	}
86
87	explicit shstr (const char *s)
88	: s (intern (s))
89	{
90	}
91
92	~shstr ()
93	{
94	--refcnt ();
95	}
96
97	const shstr &operator =(const shstr &sh)
98	{
99	--refcnt ();
100	s = sh.s;
101	++refcnt ();
102
103	return *this;
104	}
105
106	const shstr &operator =(const char *str)
107	{
108	--refcnt ();
109
110	// this optimises the important case of str == constant 0
111	if (is_constant (str))
112	s = str ? intern (str) : null;
113	else
114	s = intern (str);
115
116	return *this;
117	}
118
119	bool operator ==(const shstr &b)
120	{
121	return s == b.s;
122	}
123
124	bool operator !=(const shstr &b)
125	{
126	return !(*this == b);
127	}
128	};
129
130	inline int strlen (const shstr &sh)
131	{
132	return sh.length ();
133	}
134
135	inline int strcmp (const shstr &a, const shstr &b)
136	{
137	// TODO: use this to find all the occurences of people using strcmp
138	// all uses should be bogus, as we should be never interested in
139	// comparing shstr's alphabetically
140	#if 0
141	extern void do_not_use_strcmp_to_compare_shstr_values ();
142	do_not_use_strcmp_to_compare_shstr_values ();
143	#endif
144	return a != b;
145	}
146
147	static std::ostream &operator <<(std::ostream &o, const shstr &sh)
148	{
149	o.write (sh.s, sh.length ());
150	return o;
151	}
152
153	// only good for mass comparisons to shstr objects
154	struct shstr_cmp
155	{
156	const char *s;
157
158	explicit shstr_cmp (const char *s)
159	: s (shstr::find (s))
160	{
161	}
162
163	shstr_cmp (const shstr_cmp &sh)
164	: s (sh.s)
165	{
166	}
167
168	shstr_cmp &operator =(const shstr_cmp sh) { s = sh.s; return *this; }
169	operator const char *() const { return s; }
170	};
171
172	inline bool operator ==(const shstr_cmp &a, const shstr &b)
173	{
174	return a.s == b.s;
175	}
176
177	inline bool operator ==(const shstr &a, const shstr_cmp &b)
178	{
179	return b == a;
180	}
181
182	#define def(str) extern const shstr shstr_ ## str;
183	# include "shstrinc.h"
184	#undef def
185
186	#endif
187