server/include/dynbuf.h

#ifndef DYNBUF_H__
#define DYNBUF_H__

#include <cstring>
#include <cassert>

// 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.

class dynbuf
{
  struct chunk
  {
    chunk *next;
    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)
  {
    if (room < 1)
      _reserve (1);

    room--;
    *ptr++ = c;
  }

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

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

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

  //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; }
};

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