ermyth/include/shstr.h

#ifndef SHSTR_H
#define SHSTR_H

#include <string>
#include <vector>
#include <iostream>

#include <glib.h>

#ifdef WANT_STRLEN
# define WANT_STRLEN 1
#else
# define WANT_STRLEN 0
#endif

#if WANT_STRLEN
# define SHSTRLEN(str)  strlen (str)
#else
# define SHSTRLEN(str)  0
#endif

struct shentry
{
  shentry (char const *str, const size_t hash)
  : m_refcnt (0), m_str (str), m_len (SHSTRLEN (str)), m_hash (hash)
  {
  }

  void *operator new (size_t n)
  {
    return g_slice_alloc (n);
  }

  void operator delete (void *ptr, size_t n)
  {
    g_slice_free1 (n, ptr);
  }

  size_t m_refcnt;
  char const * const m_str;
  size_t m_len;
  size_t m_hash;
};

class shstr
{
public:
  static char const *insert (char const *str, size_t *size);

  static void erase (char const *str);

  static size_t refs (char const *str);
  static size_t strcnt ();

  static size_t memused ();

protected:
  static size_t m_cnt;

  static size_t m_bucketcnt;

  typedef std::vector<shentry *> pairs;

  static pairs *m_buckets;

  static shentry *prepare (char const *str);
  static bool unref (char const *str);
  static const shentry *get (char const *str);

  static pairs::iterator find (char const *str, size_t n);

  static size_t hash (char const *str);

public:
  void *operator new (size_t n)
  {
    return g_slice_alloc (n);
  }

  void operator delete (void *ptr, size_t n)
  {
    g_slice_free1 (n, ptr);
  }

  typedef size_t size_type;

  shstr (char const *str = "");
  shstr (const shstr &rhs);
  ~shstr ();

  char const *c_str () const;
  size_type length () const;
  shstr &operator = (char const *rhs);
  shstr &operator = (const shstr &rhs);
  bool operator == (const shstr &rhs) const;
  bool operator != (const shstr &rhs) const;

  friend std::ostream &operator << (std::ostream &os, const shstr &str)
  {
    os << str.m_str;
    return os;
  }

protected:
  char const *m_str;
  size_type m_len;

  void erase ()
  {
    erase (m_str);
    m_str = NULL;
  }

  void insert (char const *newstr)
  {
    m_str = insert (newstr, &m_len);
  }
};

#endif // SHSTR_H
Revision:	1.2
Committed:	Tue Aug 28 17:12:24 2007 UTC (16 years, 8 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	removed old files
#	Content
1	#ifndef SHSTR_H
2	#define SHSTR_H
3
4	#include <string>
5	#include <vector>
6	#include <iostream>
7
8	#include <glib.h>
9
10	#ifdef WANT_STRLEN
11	# define WANT_STRLEN 1
12	#else
13	# define WANT_STRLEN 0
14	#endif
15
16	#if WANT_STRLEN
17	# define SHSTRLEN(str) strlen (str)
18	#else
19	# define SHSTRLEN(str) 0
20	#endif
21
22	struct shentry
23	{
24	shentry (char const *str, const size_t hash)
25	: m_refcnt (0), m_str (str), m_len (SHSTRLEN (str)), m_hash (hash)
26	{
27	}
28
29	void *operator new (size_t n)
30	{
31	return g_slice_alloc (n);
32	}
33
34	void operator delete (void *ptr, size_t n)
35	{
36	g_slice_free1 (n, ptr);
37	}
38
39	size_t m_refcnt;
40	char const * const m_str;
41	size_t m_len;
42	size_t m_hash;
43	};
44
45	class shstr
46	{
47	public:
48	static char const insert (char const str, size_t *size);
49
50	static void erase (char const *str);
51
52	static size_t refs (char const *str);
53	static size_t strcnt ();
54
55	static size_t memused ();
56
57	protected:
58	static size_t m_cnt;
59
60	static size_t m_bucketcnt;
61
62	typedef std::vector<shentry *> pairs;
63
64	static pairs *m_buckets;
65
66	static shentry prepare (char const str);
67	static bool unref (char const *str);
68	static const shentry get (char const str);
69
70	static pairs::iterator find (char const *str, size_t n);
71
72	static size_t hash (char const *str);
73
74	public:
75	void *operator new (size_t n)
76	{
77	return g_slice_alloc (n);
78	}
79
80	void operator delete (void *ptr, size_t n)
81	{
82	g_slice_free1 (n, ptr);
83	}
84
85	typedef size_t size_type;
86
87	shstr (char const *str = "");
88	shstr (const shstr &rhs);
89	~shstr ();
90
91	char const *c_str () const;
92	size_type length () const;
93	shstr &operator = (char const *rhs);
94	shstr &operator = (const shstr &rhs);
95	bool operator == (const shstr &rhs) const;
96	bool operator != (const shstr &rhs) const;
97
98	friend std::ostream &operator << (std::ostream &os, const shstr &str)
99	{
100	os << str.m_str;
101	return os;
102	}
103
104	protected:
105	char const *m_str;
106	size_type m_len;
107
108	void erase ()
109	{
110	erase (m_str);
111	m_str = NULL;
112	}
113
114	void insert (char const *newstr)
115	{
116	m_str = insert (newstr, &m_len);
117	}
118	};
119
120	#endif // SHSTR_H