server/common/shstr.C

/*
 * shstr.C
 */

#include <cstring>
#include <cstdlib>

#include <tr1/unordered_set>

#include "shstr.h"

struct hash
{
  std::size_t operator ()(const char *s) const
  {
    unsigned long hash = 0;
    unsigned int i = 0;

    /* use the one-at-a-time hash function, which supposedly is
     * better than the djb2-like one used by perl5.005, but
     * certainly is better then the bug used here before.
     * see http://burtleburtle.net/bob/hash/doobs.html
     */
    while (*s)
      {
        hash += *s++;
        hash += hash << 10;
        hash ^= hash >>  6;
      }

    hash += hash <<  3;
    hash ^= hash >> 11;
    hash += hash << 15;

    return hash;
  }
};

struct equal
{
  bool operator ()(const char *a, const char *b) const
  {
    return !strcmp (a, b);
  }
};

typedef std::tr1::unordered_set<const char *, hash, equal> HT;

static HT ht;

const char *
shstr::find (const char *s)
{
  HT::iterator i = ht.find (s);

  return i != ht.end ()
    ? (char *)*i
    : 0;
}

const char *
shstr::intern (const char *s)
{
  HT::iterator i = ht.find (s);

  if (i != ht.end ())
    return (char *)*i;

  int len = strlen (s);

  int *v = (int *)malloc (sizeof (int) * 2 + len + 1);

  v [0] = len;
  v [1] = 0;

  v += 2;

  memcpy (v, s, len + 1);

  ht.insert ((char *)v);

  return (char *)v;
}

// TODO: periodically test refcounts == 0 for a few strings (e.g. one hash bucket,
// exploiting the fatc that iterators stay valid for unordered_set).
void
shstr::gc ()
{
}

/* buf_overflow() - we don't want to exceed the buffer size of 
 * buf1 by adding on buf2! Returns true if overflow will occur.
 */

int 
buf_overflow (const char *buf1, const char *buf2, int bufsize)
{
    int len1 = 0, len2 = 0;

    if (buf1)
        len1 = strlen (buf1);
    if (buf2)
        len2 = strlen (buf2);
    if ((len1 + len2) >= bufsize)
        return 1;
    return 0;
}

Revision:	1.3
Committed:	Sun Sep 3 00:18:40 2006 UTC (17 years, 9 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.2:	+61 -373 lines
Log Message:	THIS CODE WILL NOT COMPILE use the STABLE tag instead. - major changes in object lifetime and memory management - replaced manual refcounting by shstr class - removed quest system - many optimisations - major changes
#	Content
1	/*
2	* shstr.C
3	*/
4
5	#include <cstring>
6	#include <cstdlib>
7
8	#include <tr1/unordered_set>
9
10	#include "shstr.h"
11
12	struct hash
13	{
14	std::size_t operator ()(const char *s) const
15	{
16	unsigned long hash = 0;
17	unsigned int i = 0;
18
19	/* use the one-at-a-time hash function, which supposedly is
20	* better than the djb2-like one used by perl5.005, but
21	* certainly is better then the bug used here before.
22	* see http://burtleburtle.net/bob/hash/doobs.html
23	*/
24	while (*s)
25	{
26	hash += *s++;
27	hash += hash << 10;
28	hash ^= hash >> 6;
29	}
30
31	hash += hash << 3;
32	hash ^= hash >> 11;
33	hash += hash << 15;
34
35	return hash;
36	}
37	};
38
39	struct equal
40	{
41	bool operator ()(const char a, const char b) const
42	{
43	return !strcmp (a, b);
44	}
45	};
46
47	typedef std::tr1::unordered_set<const char *, hash, equal> HT;
48
49	static HT ht;
50
51	const char *
52	shstr::find (const char *s)
53	{
54	HT::iterator i = ht.find (s);
55
56	return i != ht.end ()
57	? (char )i
58	: 0;
59	}
60
61	const char *
62	shstr::intern (const char *s)
63	{
64	HT::iterator i = ht.find (s);
65
66	if (i != ht.end ())
67	return (char )i;
68
69	int len = strlen (s);
70
71	int v = (int )malloc (sizeof (int) * 2 + len + 1);
72
73	v [0] = len;
74	v [1] = 0;
75
76	v += 2;
77
78	memcpy (v, s, len + 1);
79
80	ht.insert ((char *)v);
81
82	return (char *)v;
83	}
84
85	// TODO: periodically test refcounts == 0 for a few strings (e.g. one hash bucket,
86	// exploiting the fatc that iterators stay valid for unordered_set).
87	void
88	shstr::gc ()
89	{
90	}
91
92	/* buf_overflow() - we don't want to exceed the buffer size of
93	* buf1 by adding on buf2! Returns true if overflow will occur.
94	*/
95
96	int
97	buf_overflow (const char buf1, const char buf2, int bufsize)
98	{
99	int len1 = 0, len2 = 0;
100
101	if (buf1)
102	len1 = strlen (buf1);
103	if (buf2)
104	len2 = strlen (buf2);
105	if ((len1 + len2) >= bufsize)
106	return 1;
107	return 0;
108	}
109