server/include/dynbuf.h

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Deliantra is free software: you can redistribute it and/or modify
 * it under the terms of the 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 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 "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;
  chunk *first, *last;

  void reserve (int size);
  void init (int initial);  // allocate sinitial chunk
  void free (chunk *&chain); // free chain of chunks
  char *_linearise ();
  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; }

  char *force (int size)
  {
    if (expect_false (ptr + size >= end))
      reserve (size);

    return ptr;
  }

  char *falloc (int size)
  {
    char *res = ptr;
    ptr += size;
    return res;
  }

  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 (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 shstr &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, sometiems 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, ...);
  void vprintf (const char *format, va_list ap);

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

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

#endif

Revision:	1.18
Committed:	Sat Aug 30 05:19:03 2008 UTC (15 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_7
Changes since 1.17:	+5 -1 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.11	/*
2	root	1.15	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	root	1.11	*
4	root	1.17	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	root	1.11	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6			* Copyright (©) 1992,2007 Frank Tore Johansen
7			*
8	root	1.15	* Deliantra is free software: you can redistribute it and/or modify
9	root	1.12	* it under the terms of the GNU General Public License as published by
10			* the Free Software Foundation, either version 3 of the License, or
11			* (at your option) any later version.
12	root	1.11	*
13	root	1.12	* 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	root	1.11	*
18	root	1.12	* You should have received a copy of the GNU General Public License
19			* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	root	1.11	*
21	root	1.15	* The authors can be reached via e-mail to <support@deliantra.net>
22	root	1.11	*/
23
24	root	1.1	#ifndef DYNBUF_H__
25			#define DYNBUF_H__
26
27			#include <cstring>
28			#include <cassert>
29
30	root	1.8	#include "util.h"
31	root	1.4	#include "shstr.h"
32
33	root	1.1	// this is a "buffer" that can grow fast
34			// and is still somewhat space-efficient.
35			// unlike obstacks or other data structures,
36			// it never moves data around. basically,
37			// this is a fast strstream without the overhead.
38
39	root	1.4	struct dynbuf
40	root	1.1	{
41	root	1.4	protected:
42	root	1.1	struct chunk
43			{
44			chunk *next;
45	root	1.5	int alloc;
46	root	1.1	int size;
47			char data[0];
48			};
49
50	root	1.6	char ptr, end;
51	root	1.1	int _size;
52
53	root	1.13	int extend;
54	root	1.1	chunk first, last;
55
56	root	1.13	void reserve (int size);
57			void init (int initial); // allocate sinitial chunk
58			void free (chunk *&chain); // free chain of chunks
59			char *_linearise ();
60			void finalise ();
61	root	1.1
62			public:
63
64	root	1.13	// initial - the size of the initial chunk to be allocated
65			// extend - first incremental step when buffer size exceeded
66			dynbuf (int initial = 4096, int extend = 16384)
67			: extend (extend)
68			{
69			init (initial);
70			}
71
72			~dynbuf ()
73			{
74			free (first);
75			}
76
77			// resets the dynbuf, but does not free the first chunk
78			// which is either of size "initial" or the size of the last
79			// linearise
80			void clear ();
81	root	1.1
82	root	1.6	int size () const { return _size + (ptr - last->data); }
83			bool empty () const { return !size (); }
84	root	1.1
85			void linearise (void *data);
86	root	1.13	char *linearise () // does not 0-terminate(!)
87			{
88			return first->next ? _linearise () : first->data;
89			}
90	root	1.6
91			int room () const { return end - ptr; }
92	root	1.1
93			char *force (int size)
94			{
95	root	1.8	if (expect_false (ptr + size >= end))
96	root	1.13	reserve (size);
97	root	1.1
98			return ptr;
99			}
100
101	root	1.10	char *falloc (int size)
102	root	1.1	{
103	root	1.10	char *res = ptr;
104	root	1.9	ptr += size;
105	root	1.1	return res;
106			}
107
108	root	1.10	char *alloc (int size)
109			{
110			force (size);
111			return falloc (size);
112			}
113
114	root	1.6	void fadd (char c) { *ptr++ = c; }
115	root	1.2	void fadd (unsigned char c) { fadd (char (c)); }
116	root	1.10	void fadd (const void *p, int len)
117			{
118			memcpy (falloc (len), p, len);
119			}
120	root	1.1
121			void add (const void *p, int len)
122			{
123	root	1.10	force (len);
124			fadd (p, len);
125	root	1.1	}
126
127			void add (char c)
128			{
129	root	1.3	alloc (1)[0] = c;
130	root	1.1	}
131
132			void add (const char *s)
133			{
134			add (s, strlen (s));
135			}
136
137	root	1.4	void add (const shstr &s)
138			{
139			add (s.s, s.length ());
140			}
141	root	1.1
142			//TODO
143			//void add_destructive (dynbuf &buf);
144
145			dynbuf &operator << (char c) { add (c); return *this; }
146			dynbuf &operator << (unsigned char c) { return *this << char (c); }
147			dynbuf &operator << (const char s) { add (s); return this; }
148	root	1.6	dynbuf &operator << (const shstr &s) { add (s); return *this; }
149	root	1.4	dynbuf &operator << (const std::string &s) { add (s.data(), s.size ()); return *this; }
150
151			operator std::string ();
152			};
153
154			struct dynbuf_text : dynbuf
155			{
156			dynbuf_text (int initial = 4096, int extend = 16384)
157			: dynbuf (initial, extend)
158			{ }
159
160			using dynbuf::add;
161			void add (sint32 i);
162			void add (sint64 i);
163
164	root	1.16	//TODO: should optimise the case printf "(name %+d)" as it comes up extremely often
165	root	1.13
166	root	1.18	//using dynbuf::operator <<; // doesn't work, sometiems C++ just suxx
167			// instead we use an ugly template function
168			template<typename T>
169			dynbuf_text &operator << (T c) { (dynbuf )this << c; return *this; }
170
171	root	1.16	dynbuf_text &operator << (sint16 i) { add (sint32 (i)); return *this; }
172			dynbuf_text &operator << (uint16 i) { add (sint32 (i)); return *this; }
173			dynbuf_text &operator << (sint32 i) { add (sint32 (i)); return *this; }
174			dynbuf_text &operator << (sint64 i) { add (sint64 (i)); return *this; }
175			dynbuf_text &operator << (uint32 i) { add (sint64 (i)); return *this; }
176			dynbuf_text &operator << (uint64 i) { add (sint64 (i)); return *this; }
177	root	1.13
178	root	1.4	void printf (const char *format, ...);
179	root	1.14	void vprintf (const char *format, va_list ap);
180	root	1.13
181			void add_abilities (const char *name, uint32 abilities);
182			void add_paths (const char *name, uint32 paths);
183
184			// returns the string, linearised and with trailing \0
185			operator const char * ();
186	root	1.1	};
187
188			#endif
189	root	1.6