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)
{
  if (!s)
    return s;

  HT::iterator i = ht.find (s);

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

const char *
shstr::intern (const char *s)
{
  if (!s)
    return s;

  if (const char *found = find (s))
    return found;

  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.4
Committed:	Sun Sep 3 08:05:39 2006 UTC (17 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+7 -3 lines
Log Message:	for some unexplicable reasons, it seems to run after fixing the obvious errors
#	User	Rev	Content
1	elmex	1.1	/*
2	root	1.3	* shstr.C
3	elmex	1.1	*/
4
5	root	1.3	#include <cstring>
6			#include <cstdlib>
7
8			#include <tr1/unordered_set>
9	elmex	1.1
10			#include "shstr.h"
11
12	root	1.3	struct hash
13			{
14			std::size_t operator ()(const char *s) const
15			{
16	elmex	1.1	unsigned long hash = 0;
17	root	1.3	unsigned int i = 0;
18	elmex	1.1
19	root	1.3	/* 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	elmex	1.1	*/
24	root	1.3	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	elmex	1.1
39	root	1.3	struct equal
40			{
41			bool operator ()(const char a, const char b) const
42			{
43			return !strcmp (a, b);
44			}
45			};
46	elmex	1.1
47	root	1.3	typedef std::tr1::unordered_set<const char *, hash, equal> HT;
48	elmex	1.1
49	root	1.3	static HT ht;
50	elmex	1.1
51			const char *
52	root	1.3	shstr::find (const char *s)
53			{
54	root	1.4	if (!s)
55			return s;
56
57	root	1.3	HT::iterator i = ht.find (s);
58	elmex	1.1
59	root	1.3	return i != ht.end ()
60			? (char )i
61			: 0;
62	elmex	1.1	}
63
64			const char *
65	root	1.3	shstr::intern (const char *s)
66			{
67	root	1.4	if (!s)
68			return s;
69	elmex	1.1
70	root	1.4	if (const char *found = find (s))
71			return found;
72	elmex	1.1
73	root	1.3	int len = strlen (s);
74	elmex	1.1
75	root	1.3	int v = (int )malloc (sizeof (int) * 2 + len + 1);
76	elmex	1.1
77	root	1.3	v [0] = len;
78			v [1] = 0;
79	elmex	1.1
80	root	1.3	v += 2;
81	elmex	1.1
82	root	1.3	memcpy (v, s, len + 1);
83	elmex	1.1
84	root	1.3	ht.insert ((char *)v);
85	elmex	1.1
86	root	1.3	return (char *)v;
87	elmex	1.1	}
88
89	root	1.3	// TODO: periodically test refcounts == 0 for a few strings (e.g. one hash bucket,
90			// exploiting the fatc that iterators stay valid for unordered_set).
91	elmex	1.1	void
92	root	1.3	shstr::gc ()
93			{
94	elmex	1.1	}
95
96			/* buf_overflow() - we don't want to exceed the buffer size of
97			* buf1 by adding on buf2! Returns true if overflow will occur.
98			*/
99
100			int
101			buf_overflow (const char buf1, const char buf2, int bufsize)
102			{
103	root	1.3	int len1 = 0, len2 = 0;
104	elmex	1.1
105			if (buf1)
106	root	1.2	len1 = strlen (buf1);
107	elmex	1.1	if (buf2)
108	root	1.2	len2 = strlen (buf2);
109	elmex	1.1	if ((len1 + len2) >= bufsize)
110	root	1.2	return 1;
111	elmex	1.1	return 0;
112			}
113