server/include/dynbuf.h

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992 Frank Tore Johansen
 * 
 * Deliantra is free software: you can redistribute it and/or modify it under
 * the terms of the Affero GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the Affero GNU General Public License
 * and the GNU General Public License along with this program. If not, see
 * <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

#ifndef DYNBUF_H__
#define DYNBUF_H__

#include <cstring>
#include <cassert>

#include "compiler.h"
#include "util.h"
#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, *end;
  int _size;

  int extend, cextend;
  chunk *first, *last;

  void reserve (int size);
  void init (int initial);  // allocate sinitial chunk
  void free (chunk *&chain); // free chain of chunks
  char *_linearise (int extra = 0);
  void finalise ();

public:
  
  // initial - the size of the initial chunk to be allocated
  // extend  - first incremental step when buffer size exceeded
  dynbuf (int initial = 4096, int extend = 16384)
  : extend (extend)
  {
    init (initial);
  }

  ~dynbuf ()
  {
    free (first);
  }

  // resets the dynbuf, but does not free the first chunk
  // which is either of size "initial" or the size of the last
  // linearise
  void clear ();

  int  size  () const { return _size + (ptr - last->data); }
  bool empty () const { return !size (); }

  void linearise (void *data);
  char *linearise () // does not 0-terminate(!)
  { 
    return first->next ? _linearise () : first->data;
  }

  int room () const { return end - ptr; }

  // make sure we have "size" extra room
  char *force (int size)
  {
    if (expect_false (ptr + size > end))
      reserve (size);

    assume (ptr + size <= end);

    return ptr;
  }

  // used for force + alloc combo
  void alloc (char *p)
  {
    ptr = p;
  }

  // allocate size bytes and return pointer to them (caller must force())
  char *falloc (int size)
  {
    char *res = ptr;
    ptr += size;
    return res;
  }

  // allocate size bytes and return pointer to them
  char *alloc (int size)
  {
    force (size);
    return falloc (size);
  }

  void fadd (char c) { *ptr++ = c; }
  void fadd (unsigned char c) { fadd (char (c)); }
  void fadd (const void *p, int len)
  {
    memcpy (falloc (len), p, len);
  }

  void add (const void *p, int len)
  {
    force (len);
    fadd (p, len);
  }

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

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

  void add (shstr_tmp s)
  {
    add (s.s, s.length ());
  }

  // rather inefficient
  void splice (int offset, int olen, const char *s, int slen);
  void splice (int offset, int olen) { splice (offset, olen, "", 0); }

  //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 << (shstr_tmp 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;
  void add (sint32 i);
  void add (sint64 i);

  //TODO: should optimise the case printf "(name %+d)" as it comes up extremely often

  //using dynbuf::operator <<; // doesn't work, sometimes C++ just suxx
  // instead we use an ugly template function
  template<typename T>
  dynbuf_text &operator << (T c) { *(dynbuf *)this << c; return *this; }

  dynbuf_text &operator << (sint16 i) { add (sint32 (i)); return *this; }
  dynbuf_text &operator << (uint16 i) { add (sint32 (i)); return *this; }
  dynbuf_text &operator << (sint32 i) { add (sint32 (i)); return *this; }
  dynbuf_text &operator << (sint64 i) { add (sint64 (i)); return *this; }
  dynbuf_text &operator << (uint32 i) { add (sint64 (i)); return *this; }
  dynbuf_text &operator << (uint64 i) { add (sint64 (i)); return *this; }

  void printf (const char *format, ...) attribute ((format (printf, 2, 3)));
  void vprintf (const char *format, va_list ap);

  void add_abilities (const char *name, uint32 abilities);
  void add_paths     (const char *name, uint32 paths);

  // we need to redefine, to keep the API :/
  using dynbuf::splice;
  void splice (int offset, int olen, const char *s)
  {
    dynbuf::splice (offset, olen, s, strlen (s));
  }

  // returns the string, linearised and with trailing \0
  operator char *();
};

#endif

Revision:	1.30
Committed:	Fri Mar 26 00:59:21 2010 UTC (14 years, 2 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.29:	+2 -2 lines
Log Message:	remove bogus 2007 copyright that was added wrongly by the script, update to affero license
#	Content
1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*
4	* Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992 Frank Tore Johansen
7	*
8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* the terms of the Affero GNU General Public License as published by the
10	* Free Software Foundation, either version 3 of the License, or (at your
11	* option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the Affero GNU General Public License
19	* and the GNU General Public License along with this program. If not, see
20	* <http://www.gnu.org/licenses/>.
21	*
22	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/
24
25	#ifndef DYNBUF_H__
26	#define DYNBUF_H__
27
28	#include <cstring>
29	#include <cassert>
30
31	#include "compiler.h"
32	#include "util.h"
33	#include "shstr.h"
34
35	// this is a "buffer" that can grow fast
36	// and is still somewhat space-efficient.
37	// unlike obstacks or other data structures,
38	// it never moves data around. basically,
39	// this is a fast strstream without the overhead.
40
41	struct dynbuf
42	{
43	protected:
44	struct chunk
45	{
46	chunk *next;
47	int alloc;
48	int size;
49	char data[0];
50	};
51
52	char ptr, end;
53	int _size;
54
55	int extend, cextend;
56	chunk first, last;
57
58	void reserve (int size);
59	void init (int initial); // allocate sinitial chunk
60	void free (chunk *&chain); // free chain of chunks
61	char *_linearise (int extra = 0);
62	void finalise ();
63
64	public:
65
66	// initial - the size of the initial chunk to be allocated
67	// extend - first incremental step when buffer size exceeded
68	dynbuf (int initial = 4096, int extend = 16384)
69	: extend (extend)
70	{
71	init (initial);
72	}
73
74	~dynbuf ()
75	{
76	free (first);
77	}
78
79	// resets the dynbuf, but does not free the first chunk
80	// which is either of size "initial" or the size of the last
81	// linearise
82	void clear ();
83
84	int size () const { return _size + (ptr - last->data); }
85	bool empty () const { return !size (); }
86
87	void linearise (void *data);
88	char *linearise () // does not 0-terminate(!)
89	{
90	return first->next ? _linearise () : first->data;
91	}
92
93	int room () const { return end - ptr; }
94
95	// make sure we have "size" extra room
96	char *force (int size)
97	{
98	if (expect_false (ptr + size > end))
99	reserve (size);
100
101	assume (ptr + size <= end);
102
103	return ptr;
104	}
105
106	// used for force + alloc combo
107	void alloc (char *p)
108	{
109	ptr = p;
110	}
111
112	// allocate size bytes and return pointer to them (caller must force())
113	char *falloc (int size)
114	{
115	char *res = ptr;
116	ptr += size;
117	return res;
118	}
119
120	// allocate size bytes and return pointer to them
121	char *alloc (int size)
122	{
123	force (size);
124	return falloc (size);
125	}
126
127	void fadd (char c) { *ptr++ = c; }
128	void fadd (unsigned char c) { fadd (char (c)); }
129	void fadd (const void *p, int len)
130	{
131	memcpy (falloc (len), p, len);
132	}
133
134	void add (const void *p, int len)
135	{
136	force (len);
137	fadd (p, len);
138	}
139
140	void add (char c)
141	{
142	alloc (1)[0] = c;
143	}
144
145	void add (const char *s)
146	{
147	add (s, strlen (s));
148	}
149
150	void add (shstr_tmp s)
151	{
152	add (s.s, s.length ());
153	}
154
155	// rather inefficient
156	void splice (int offset, int olen, const char *s, int slen);
157	void splice (int offset, int olen) { splice (offset, olen, "", 0); }
158
159	//TODO
160	//void add_destructive (dynbuf &buf);
161
162	dynbuf &operator << (char c) { add (c); return *this; }
163	dynbuf &operator << (unsigned char c) { return *this << char (c); }
164	dynbuf &operator << (const char s) { add (s); return this; }
165	dynbuf &operator << (shstr_tmp s) { add (s); return *this; }
166	dynbuf &operator << (const std::string &s) { add (s.data(), s.size ()); return *this; }
167
168	operator std::string ();
169	};
170
171	struct dynbuf_text : dynbuf
172	{
173	dynbuf_text (int initial = 4096, int extend = 16384)
174	: dynbuf (initial, extend)
175	{ }
176
177	using dynbuf::add;
178	void add (sint32 i);
179	void add (sint64 i);
180
181	//TODO: should optimise the case printf "(name %+d)" as it comes up extremely often
182
183	//using dynbuf::operator <<; // doesn't work, sometimes C++ just suxx
184	// instead we use an ugly template function
185	template<typename T>
186	dynbuf_text &operator << (T c) { (dynbuf )this << c; return *this; }
187
188	dynbuf_text &operator << (sint16 i) { add (sint32 (i)); return *this; }
189	dynbuf_text &operator << (uint16 i) { add (sint32 (i)); return *this; }
190	dynbuf_text &operator << (sint32 i) { add (sint32 (i)); return *this; }
191	dynbuf_text &operator << (sint64 i) { add (sint64 (i)); return *this; }
192	dynbuf_text &operator << (uint32 i) { add (sint64 (i)); return *this; }
193	dynbuf_text &operator << (uint64 i) { add (sint64 (i)); return *this; }
194
195	void printf (const char *format, ...) attribute ((format (printf, 2, 3)));
196	void vprintf (const char *format, va_list ap);
197
198	void add_abilities (const char *name, uint32 abilities);
199	void add_paths (const char *name, uint32 paths);
200
201	// we need to redefine, to keep the API :/
202	using dynbuf::splice;
203	void splice (int offset, int olen, const char *s)
204	{
205	dynbuf::splice (offset, olen, s, strlen (s));
206	}
207
208	// returns the string, linearised and with trailing \0
209	operator char *();
210	};
211
212	#endif
213