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

extern const shstr undead_name; /* Used in hit_player() in main.c */

#endif

Revision:	1.17
Committed:	Sun Jul 1 05:00:18 2007 UTC (16 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.16:	+11 -12 lines
Log Message:	- upgrade crossfire trt to the GPL version 3 (hopefully correctly). - add a single file covered by the GNU Affero General Public License (which is not yet released, so I used the current draft, which is legally a bit wavy, but its likely better than nothing as it expresses direct intent by the authors, and we can upgrade as soon as it has been released). * this should ensure availability of source code for the server at least and hopefully also archetypes and maps even when modified versions are not being distributed, in accordance of section 13 of the agplv3.
#	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.9	extern const shstr undead_name; /* Used in hit_player() in main.c */
183
184	root	1.2	#endif
185