server/include/dynbuf.h

#ifndef DYNBUF_H__
#define DYNBUF_H__

#include <cstring>
#include <cassert>

#include "shstr.h"

// this is a "buffer" that can grow fast
// and is still somewhat space-efficient.
// unlike obstacks or other data structures,
// it never moves data around. basically,
// this is a fast strstream without the overhead.

struct dynbuf
{
protected:
  struct chunk
  {
    chunk *next;
    int alloc;
    int size;
    char data[0];
  };

  char *ptr;
  int room;
  int ext;
  int _size;

  chunk *first, *last;

  void _reserve (int size);
  void clear ();
  void finish ();

public:
  
  dynbuf (int initial = 4096, int extend = 16384);
  ~dynbuf ();

  int size () { return _size + (ptr - last->data); }

  void linearise (void *data);
  char *linearise ();

  char *force (int size)
  {
    if (room < size)
      _reserve (size);

    return ptr;
  }

  char *alloc (int size)
  {
    char *res = force (size);

    room -= size;
    ptr += size;

    return res;
  }

  void fadd (char c) { --room; *ptr++ = c; }
  void fadd (unsigned char c) { fadd (char (c)); }

  void add (const void *p, int len)
  {
    memcpy (alloc (len), p, len);
  }

  void add (char c)
  {
    alloc (1)[0] = c;
  }

  void add (const char *s)
  {
     add (s, strlen (s));
  }

  void add (const shstr &s)
  {
    add (s.s, s.length ());
  }

  //TODO
  //void add_destructive (dynbuf &buf);

  dynbuf &operator << (char c) { add (c); return *this; }
  dynbuf &operator << (unsigned char c) { return *this << char (c); }
  dynbuf &operator << (const char *s) { add (s); return *this; }
  dynbuf &operator << (const std::string &s) { add (s.data(), s.size ()); return *this; }

  operator std::string ();
};

struct dynbuf_text : dynbuf
{
  dynbuf_text (int initial = 4096, int extend = 16384)
  : dynbuf (initial, extend)
  { }

  using dynbuf::add;

  static const int max_sint32_size = 11;
  static const int max_sint64_size = 20;

  void add (sint32 i);
  void add (sint64 i);

  void printf (const char *format, ...);
};

#endif
Revision:	1.5
Committed:	Mon Apr 23 18:21:54 2007 UTC (17 years, 1 month ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.4:	+1 -0 lines
Log Message:	use g_slice for dynbufs
#	User	Rev	Content
1	root	1.1	#ifndef DYNBUF_H__
2			#define DYNBUF_H__
3
4			#include <cstring>
5			#include <cassert>
6
7	root	1.4	#include "shstr.h"
8
9	root	1.1	// this is a "buffer" that can grow fast
10			// and is still somewhat space-efficient.
11			// unlike obstacks or other data structures,
12			// it never moves data around. basically,
13			// this is a fast strstream without the overhead.
14
15	root	1.4	struct dynbuf
16	root	1.1	{
17	root	1.4	protected:
18	root	1.1	struct chunk
19			{
20			chunk *next;
21	root	1.5	int alloc;
22	root	1.1	int size;
23			char data[0];
24			};
25
26			char *ptr;
27			int room;
28			int ext;
29			int _size;
30
31			chunk first, last;
32
33			void _reserve (int size);
34			void clear ();
35			void finish ();
36
37			public:
38
39	root	1.2	dynbuf (int initial = 4096, int extend = 16384);
40	root	1.1	~dynbuf ();
41
42			int size () { return _size + (ptr - last->data); }
43
44			void linearise (void *data);
45			char *linearise ();
46
47			char *force (int size)
48			{
49			if (room < size)
50			_reserve (size);
51
52			return ptr;
53			}
54
55			char *alloc (int size)
56			{
57			char *res = force (size);
58
59			room -= size;
60			ptr += size;
61
62			return res;
63			}
64
65			void fadd (char c) { --room; *ptr++ = c; }
66	root	1.2	void fadd (unsigned char c) { fadd (char (c)); }
67	root	1.1
68			void add (const void *p, int len)
69			{
70			memcpy (alloc (len), p, len);
71			}
72
73			void add (char c)
74			{
75	root	1.3	alloc (1)[0] = c;
76	root	1.1	}
77
78			void add (const char *s)
79			{
80			add (s, strlen (s));
81			}
82
83	root	1.4	void add (const shstr &s)
84			{
85			add (s.s, s.length ());
86			}
87	root	1.1
88			//TODO
89			//void add_destructive (dynbuf &buf);
90
91			dynbuf &operator << (char c) { add (c); return *this; }
92			dynbuf &operator << (unsigned char c) { return *this << char (c); }
93			dynbuf &operator << (const char s) { add (s); return this; }
94	root	1.4	dynbuf &operator << (const std::string &s) { add (s.data(), s.size ()); return *this; }
95
96			operator std::string ();
97			};
98
99			struct dynbuf_text : dynbuf
100			{
101			dynbuf_text (int initial = 4096, int extend = 16384)
102			: dynbuf (initial, extend)
103			{ }
104
105			using dynbuf::add;
106
107			static const int max_sint32_size = 11;
108			static const int max_sint64_size = 20;
109
110			void add (sint32 i);
111			void add (sint64 i);
112
113			void printf (const char *format, ...);
114	root	1.1	};
115
116			#endif