server/include/dynbuf.h

/*
 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Crossfire TRT 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 <crossfire@schmorp.de>
 */

#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 ext;
  int _size;

  chunk *first, *last;

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

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

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

  void linearise (void *data);
  char *linearise (); // does not 0-terminate(!)

  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);

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

#endif

Revision:	1.12
Committed:	Sun Jul 1 05:00:18 2007 UTC (16 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.11:	+11 -12 lines
Log Message:	- upgrade crossfire trt to the GPL version 3 (hopefully correctly). - add a single file covered by the GNU Affero General Public License (which is not yet released, so I used the current draft, which is legally a bit wavy, but its likely better than nothing as it expresses direct intent by the authors, and we can upgrade as soon as it has been released). * this should ensure availability of source code for the server at least and hopefully also archetypes and maps even when modified versions are not being distributed, in accordance of section 13 of the agplv3.
#	Content
1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*
8	* Crossfire TRT is free software: you can redistribute it and/or modify
9	* 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	*
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 GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	*
21	* The authors can be reached via e-mail to <crossfire@schmorp.de>
22	*/
23
24	#ifndef DYNBUF_H__
25	#define DYNBUF_H__
26
27	#include <cstring>
28	#include <cassert>
29
30	#include "util.h"
31	#include "shstr.h"
32
33	// 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	struct dynbuf
40	{
41	protected:
42	struct chunk
43	{
44	chunk *next;
45	int alloc;
46	int size;
47	char data[0];
48	};
49
50	char ptr, end;
51	int ext;
52	int _size;
53
54	chunk first, last;
55
56	void _reserve (int size);
57	void _clear ();
58	void clear ();
59	void finish ();
60
61	public:
62
63	dynbuf (int initial = 4096, int extend = 16384);
64	~dynbuf ();
65
66	int size () const { return _size + (ptr - last->data); }
67	bool empty () const { return !size (); }
68
69	void linearise (void *data);
70	char *linearise (); // does not 0-terminate(!)
71
72	int room () const { return end - ptr; }
73
74	char *force (int size)
75	{
76	if (expect_false (ptr + size >= end))
77	_reserve (size);
78
79	return ptr;
80	}
81
82	char *falloc (int size)
83	{
84	char *res = ptr;
85	ptr += size;
86	return res;
87	}
88
89	char *alloc (int size)
90	{
91	force (size);
92	return falloc (size);
93	}
94
95	void fadd (char c) { *ptr++ = c; }
96	void fadd (unsigned char c) { fadd (char (c)); }
97	void fadd (const void *p, int len)
98	{
99	memcpy (falloc (len), p, len);
100	}
101
102	void add (const void *p, int len)
103	{
104	force (len);
105	fadd (p, len);
106	}
107
108	void add (char c)
109	{
110	alloc (1)[0] = c;
111	}
112
113	void add (const char *s)
114	{
115	add (s, strlen (s));
116	}
117
118	void add (const shstr &s)
119	{
120	add (s.s, s.length ());
121	}
122
123	//TODO
124	//void add_destructive (dynbuf &buf);
125
126	dynbuf &operator << (char c) { add (c); return *this; }
127	dynbuf &operator << (unsigned char c) { return *this << char (c); }
128	dynbuf &operator << (const char s) { add (s); return this; }
129	dynbuf &operator << (const shstr &s) { add (s); return *this; }
130	dynbuf &operator << (const std::string &s) { add (s.data(), s.size ()); return *this; }
131
132	operator std::string ();
133	};
134
135	struct dynbuf_text : dynbuf
136	{
137	dynbuf_text (int initial = 4096, int extend = 16384)
138	: dynbuf (initial, extend)
139	{ }
140
141	using dynbuf::add;
142
143	void add (sint32 i);
144	void add (sint64 i);
145
146	void printf (const char *format, ...);
147	};
148
149	#endif
150