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 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.4
Committed:	Mon Apr 23 18:09:57 2007 UTC (17 years, 1 month ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+28 -6 lines
Log Message:	- add format utility function. - split dynbuf into dynbuf and dynbuf_text. - use dynbuf_text for examine strings instead of outputting each line seperately. tried to use stringstreams but they add insane overheads (as does std::string, but less so).
#	Content
1	#ifndef DYNBUF_H__
2	#define DYNBUF_H__
3
4	#include <cstring>
5	#include <cassert>
6
7	#include "shstr.h"
8
9	// 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	struct dynbuf
16	{
17	protected:
18	struct chunk
19	{
20	chunk *next;
21	int size;
22	char data[0];
23	};
24
25	char *ptr;
26	int room;
27	int ext;
28	int _size;
29
30	chunk first, last;
31
32	void _reserve (int size);
33	void clear ();
34	void finish ();
35
36	public:
37
38	dynbuf (int initial = 4096, int extend = 16384);
39	~dynbuf ();
40
41	int size () { return _size + (ptr - last->data); }
42
43	void linearise (void *data);
44	char *linearise ();
45
46	char *force (int size)
47	{
48	if (room < size)
49	_reserve (size);
50
51	return ptr;
52	}
53
54	char *alloc (int size)
55	{
56	char *res = force (size);
57
58	room -= size;
59	ptr += size;
60
61	return res;
62	}
63
64	void fadd (char c) { --room; *ptr++ = c; }
65	void fadd (unsigned char c) { fadd (char (c)); }
66
67	void add (const void *p, int len)
68	{
69	memcpy (alloc (len), p, len);
70	}
71
72	void add (char c)
73	{
74	alloc (1)[0] = c;
75	}
76
77	void add (const char *s)
78	{
79	add (s, strlen (s));
80	}
81
82	void add (const shstr &s)
83	{
84	add (s.s, s.length ());
85	}
86
87	//TODO
88	//void add_destructive (dynbuf &buf);
89
90	dynbuf &operator << (char c) { add (c); return *this; }
91	dynbuf &operator << (unsigned char c) { return *this << char (c); }
92	dynbuf &operator << (const char s) { add (s); return this; }
93	dynbuf &operator << (const std::string &s) { add (s.data(), s.size ()); return *this; }
94
95	operator std::string ();
96	};
97
98	struct dynbuf_text : dynbuf
99	{
100	dynbuf_text (int initial = 4096, int extend = 16384)
101	: dynbuf (initial, extend)
102	{ }
103
104	using dynbuf::add;
105
106	static const int max_sint32_size = 11;
107	static const int max_sint64_size = 20;
108
109	void add (sint32 i);
110	void add (sint64 i);
111
112	void printf (const char *format, ...);
113	};
114
115	#endif