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, 10 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.
#	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	extern const shstr undead_name; /* Used in hit_player() in main.c */
183
184	#endif
185