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 (19 years, 3 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.
#	User	Rev	Content
1	root	1.16	/*
2	root	1.17	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	root	1.16	*
4			* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5			*
6	root	1.17	* 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	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			* The authors can be reached via e-mail to <crossfire@schmorp.de>
20			*/
21
22	root	1.2	#ifndef SHSTR_H__
23			#define SHSTR_H__
24
25	root	1.13	#include <sstream>
26
27	root	1.8	#include "util.h"
28
29			extern int buf_overflow (const char buf1, const char buf2, int bufsize);
30	root	1.5
31			struct shstr
32			{
33	root	1.8	static const char *null;
34
35	root	1.5	const char *s;
36	root	1.4
37	root	1.7	static int &refcnt (const char *s)
38	root	1.5	{
39			return ((int )s - 1);
40			}
41
42	root	1.7	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	root	1.8	return length (s);
55	root	1.7	}
56
57	root	1.15	// 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	root	1.5	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	root	1.6	// this is used for informational messages and the like
71	root	1.8	const char *operator &() const { return s; }
72	root	1.5
73	root	1.6	const char &operator [](int i) const { return s[i]; }
74	root	1.8	operator const char *() const { return s == null ? 0 : s; }
75	root	1.5
76			shstr ()
77	root	1.8	: s (null)
78	root	1.5	{
79			}
80
81	root	1.6	shstr (const shstr &sh)
82	root	1.5	: s (sh.s)
83			{
84	root	1.8	++refcnt ();
85	root	1.5	}
86
87			explicit shstr (const char *s)
88			: s (intern (s))
89			{
90			}
91
92			~shstr ()
93			{
94	root	1.8	--refcnt ();
95	root	1.5	}
96
97			const shstr &operator =(const shstr &sh)
98			{
99	root	1.8	--refcnt ();
100	root	1.5	s = sh.s;
101	root	1.8	++refcnt ();
102	root	1.5
103			return *this;
104			}
105
106			const shstr &operator =(const char *str)
107			{
108	root	1.8	--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	root	1.1
116	root	1.5	return *this;
117			}
118	root	1.10
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	root	1.5	};
129	root	1.1
130	root	1.5	inline int strlen (const shstr &sh)
131			{
132			return sh.length ();
133			}
134	root	1.2
135	root	1.12	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	root	1.14	static std::ostream &operator <<(std::ostream &o, const shstr &sh)
148	root	1.13	{
149			o.write (sh.s, sh.length ());
150			return o;
151			}
152
153	root	1.10	// 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	root	1.11	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	root	1.10	operator const char *() const { return s; }
170			};
171
172			inline bool operator ==(const shstr_cmp &a, const shstr &b)
173	root	1.5	{
174			return a.s == b.s;
175			}
176	root	1.4
177	root	1.10	inline bool operator ==(const shstr &a, const shstr_cmp &b)
178	root	1.4	{
179	root	1.10	return b == a;
180	root	1.5	}
181	root	1.4
182	root	1.18	#define def(str) extern const shstr shstr_ ## str;
183			# include "shstrinc.h"
184			#undef def
185	root	1.9
186	root	1.2	#endif
187