trunk/Src/StringBuffer.cpp

/* StringBuffer.cpp - A simple string buffer implementation.
   Copyright (C) 2006, 2007 Timo Schulz
   Released under the GNU General Public License, Version 2. */

#include <string.h>
#include <stdio.h>

#include "StringBuffer.h"

/* Add the converted data at the end of the internal buffer.
   Allocate more memory if needed, plus some extra bytes. */
void StringBuffer::addCharacters (const char *buffer, int bufsize)
{
    if (size+bufsize > alloced_size) {
        char *save = private_contents;
        
        alloced_size += bufsize+DEFSIZE+1;
        private_contents = new char[alloced_size+1];
        memset (private_contents, 0, alloced_size+1);
        if (save != NULL) {
            strcpy (private_contents, save);
            delete []save;
        }
    }
    strcat (private_contents, buffer);      
    size += bufsize;
}


/* Create an empty buffer object. */
StringBuffer::StringBuffer ()
{
    alloced_size = 0;
    size = 0;
    private_contents = NULL;
}


/* Create an empty buffer object with an inital size. */
StringBuffer::StringBuffer (int bufsize)
{
    alloced_size = bufsize+DEFSIZE+1;
    private_contents = new char[alloced_size+1];
    memset (private_contents, 0, alloced_size+1);
    size = 0;
}


/* Create a buffer object with the given contents. */
StringBuffer::StringBuffer (const char *contents)
{
    alloced_size = strlen (contents)+1+DEFSIZE;
    private_contents = new char[alloced_size+1];
    memset (private_contents, 0, alloced_size+1);
    strcpy (private_contents, contents);
    size = strlen (contents);
}


/* Destructor which fres the used memory. */
StringBuffer::~StringBuffer ()
{
    if (private_contents != NULL)
        delete []private_contents;
    private_contents = NULL;
    size = 0;
    alloced_size = 0;
}


/* Return a copy of the buffer which must be freed after use. */
char* StringBuffer::getBufferCopy (void)
{
    char *p = new char[strlen (private_contents)+1];
    strcpy (p, private_contents);
    return p;
}


/* Return a constant pointer to the 'char*' data of the buffer. */
const char *StringBuffer::getBuffer (void)
{       
    return private_contents;
}


/* Overwrite buffer contents in a safe manner. */
void StringBuffer::wipeContents (void)
{
    volatile char *ptr = (volatile char*)private_contents;
    int len = getSize ();
    
    while (len-- > 0) {
        *ptr = '\0';
        *ptr++;
    }
}

    
/* Return the size of the underlying string. */    
int StringBuffer::getSize (void)
{
    return size;
}

/* Reset the buffer contents. */
void StringBuffer::reset (void)
{
    memset (private_contents, 0, alloced_size);
    size = 0;
}    


/* Add an integer to the buffer. */
void StringBuffer::add (int val)
{
    char tmp[32];

    _snprintf (tmp, 31, "%d", val);     
    addCharacters (tmp, strlen (tmp));    
}


/* Add a single character to the buffer. */
void StringBuffer::add (char val)
{
    char tmp[4];
    
    _snprintf (tmp, 3, "%c", val);
    addCharacters (tmp, strlen (tmp));
}


/* Add a long-integer to the buffer. */
void StringBuffer::add (long val)
{
    char tmp[32];
    
    _snprintf (tmp, 31, "%d", val);
    addCharacters (tmp, strlen (tmp));
}


/* Add a string to the buffer. */
void StringBuffer::add (const char *val)
{
    addCharacters (val, strlen (val));
}


/* Add an unsigned integer to the buffer. */
void StringBuffer::add (unsigned long val)
{
    char tmp[32];
    
    _snprintf (tmp, 31, "%lu", val);
    addCharacters (tmp, strlen (tmp));
}


/* Add an unsigned integer in hex format to the buffer. */
void StringBuffer::addHex (unsigned long val)
{
    char tmp[32];
    
    _snprintf (tmp, 31, "%08lx", val);
    addCharacters (tmp, strlen (tmp));
}


/* Overloaded operators to provide an easier interface
 for manipulating the underlying buffer. */
StringBuffer& StringBuffer::operator +(int val)
{
    add (val);
    return *this;
}


StringBuffer& StringBuffer::operator +(unsigned long val)
{
    add (val);
    return *this;
}


StringBuffer& StringBuffer::operator +(const char *val)
{
    addCharacters (val, strlen (val));
    return *this;
}


StringBuffer& StringBuffer::operator +=(int val)
{
    add (val);
    return *this;
}


StringBuffer& StringBuffer::operator +=(unsigned long val)
{
    add (val);
    return *this;
}


StringBuffer& StringBuffer::operator +=(const char *val)
{
    addCharacters (val, strlen (val));
    return *this;
}


StringBuffer& StringBuffer::operator +=(char val)
{
    add (val);
    return *this;
}


StringBuffer& StringBuffer::operator=(const char *val)
{
    reset ();
    addCharacters (val, strlen (val));
    return *this;
}
1	twoaday	326	/* StringBuffer.cpp - A simple string buffer implementation.
2			Copyright (C) 2006, 2007 Timo Schulz
3			Released under the GNU General Public License, Version 2. */
4
5			#include <string.h>
6			#include <stdio.h>
7
8			#include "StringBuffer.h"
9
10			/* Add the converted data at the end of the internal buffer.
11			Allocate more memory if needed, plus some extra bytes. */
12			void StringBuffer::addCharacters (const char *buffer, int bufsize)
13			{
14			if (size+bufsize > alloced_size) {
15			char *save = private_contents;
16
17			alloced_size += bufsize+DEFSIZE+1;
18			private_contents = new char[alloced_size+1];
19			memset (private_contents, 0, alloced_size+1);
20			if (save != NULL) {
21			strcpy (private_contents, save);
22			delete []save;
23			}
24			}
25			strcat (private_contents, buffer);
26			size += bufsize;
27			}
28
29
30			/* Create an empty buffer object. */
31			StringBuffer::StringBuffer ()
32			{
33			alloced_size = 0;
34			size = 0;
35			private_contents = NULL;
36			}
37
38
39			/* Create an empty buffer object with an inital size. */
40			StringBuffer::StringBuffer (int bufsize)
41			{
42			alloced_size = bufsize+DEFSIZE+1;
43			private_contents = new char[alloced_size+1];
44			memset (private_contents, 0, alloced_size+1);
45			size = 0;
46			}
47
48
49			/* Create a buffer object with the given contents. */
50			StringBuffer::StringBuffer (const char *contents)
51			{
52			alloced_size = strlen (contents)+1+DEFSIZE;
53			private_contents = new char[alloced_size+1];
54			memset (private_contents, 0, alloced_size+1);
55			strcpy (private_contents, contents);
56			size = strlen (contents);
57			}
58
59
60			/* Destructor which fres the used memory. */
61			StringBuffer::~StringBuffer ()
62			{
63			if (private_contents != NULL)
64			delete []private_contents;
65			private_contents = NULL;
66			size = 0;
67			alloced_size = 0;
68			}
69
70
71			/* Return a copy of the buffer which must be freed after use. */
72			char* StringBuffer::getBufferCopy (void)
73			{
74			char *p = new char[strlen (private_contents)+1];
75			strcpy (p, private_contents);
76			return p;
77			}
78
79
80			/* Return a constant pointer to the 'char' data of the buffer. /
81			const char *StringBuffer::getBuffer (void)
82			{
83			return private_contents;
84			}
85
86
87			/* Overwrite buffer contents in a safe manner. */
88			void StringBuffer::wipeContents (void)
89			{
90			volatile char ptr = (volatile char)private_contents;
91			int len = getSize ();
92
93			while (len-- > 0) {
94			*ptr = '\0';
95			*ptr++;
96			}
97			}
98
99
100			/* Return the size of the underlying string. */
101			int StringBuffer::getSize (void)
102			{
103			return size;
104			}
105
106			/* Reset the buffer contents. */
107			void StringBuffer::reset (void)
108			{
109			memset (private_contents, 0, alloced_size);
110			size = 0;
111			}
112
113
114			/* Add an integer to the buffer. */
115			void StringBuffer::add (int val)
116			{
117			char tmp[32];
118
119			_snprintf (tmp, 31, "%d", val);
120			addCharacters (tmp, strlen (tmp));
121			}
122
123
124			/* Add a single character to the buffer. */
125			void StringBuffer::add (char val)
126			{
127			char tmp[4];
128
129			_snprintf (tmp, 3, "%c", val);
130			addCharacters (tmp, strlen (tmp));
131			}
132
133
134			/* Add a long-integer to the buffer. */
135			void StringBuffer::add (long val)
136			{
137			char tmp[32];
138
139			_snprintf (tmp, 31, "%d", val);
140			addCharacters (tmp, strlen (tmp));
141			}
142
143
144			/* Add a string to the buffer. */
145			void StringBuffer::add (const char *val)
146			{
147			addCharacters (val, strlen (val));
148			}
149
150
151			/* Add an unsigned integer to the buffer. */
152			void StringBuffer::add (unsigned long val)
153			{
154			char tmp[32];
155
156			_snprintf (tmp, 31, "%lu", val);
157			addCharacters (tmp, strlen (tmp));
158			}
159
160
161			/* Add an unsigned integer in hex format to the buffer. */
162			void StringBuffer::addHex (unsigned long val)
163			{
164			char tmp[32];
165
166			_snprintf (tmp, 31, "%08lx", val);
167			addCharacters (tmp, strlen (tmp));
168			}
169
170
171			/* Overloaded operators to provide an easier interface
172			for manipulating the underlying buffer. */
173			StringBuffer& StringBuffer::operator +(int val)
174			{
175			add (val);
176			return *this;
177			}
178
179
180			StringBuffer& StringBuffer::operator +(unsigned long val)
181			{
182			add (val);
183			return *this;
184			}
185
186
187			StringBuffer& StringBuffer::operator +(const char *val)
188			{
189			addCharacters (val, strlen (val));
190			return *this;
191			}
192
193
194			StringBuffer& StringBuffer::operator +=(int val)
195			{
196			add (val);
197			return *this;
198			}
199
200
201			StringBuffer& StringBuffer::operator +=(unsigned long val)
202			{
203			add (val);
204			return *this;
205			}
206
207
208			StringBuffer& StringBuffer::operator +=(const char *val)
209			{
210			addCharacters (val, strlen (val));
211			return *this;
212			}
213
214
215			StringBuffer& StringBuffer::operator +=(char val)
216			{
217			add (val);
218			return *this;
219			}
220
221
222			StringBuffer& StringBuffer::operator=(const char *val)
223			{
224			reset ();
225			addCharacters (val, strlen (val));
226			return *this;
227			}