trunk/Src/StringBuffer.h

#ifndef __STRING_BUFFER_H
#define __STRING_BUFFER_H

/* Copyright (C) 2006, 2007 Timo Schulz
   Released under the GNU General Public License, Version 2. */

#define DEFSIZE 128

/* A simple string buffer implementation which allows to manipulate
   the underlying buffer in a unified and easy way. The code is written
   for clarity and simplicty, _not_ speed. */
class StringBuffer
{
private:
    char *private_contents;
    int alloced_size;
    int size;

private:
    /* Add the converted data at the end of the internal buffer.
       Allocate more memory if needed, plus some extra bytes. */
    void addCharacters (const char *buffer, int bufsize);

public:
    StringBuffer ();

    /* Create an empty buffer object with an inital size. */
    StringBuffer (int bufsize);


    /* Create a buffer object with the given contents. */
    StringBuffer (const char *contents);

    /* Destructor which fres the used memory. */
    ~StringBuffer ();

    /* Overwrite buffer contents in a safe manner. */
    void wipeContents (void);

    /* Return a constant pointer to the 'char*' data of the buffer. */
    const char *getBuffer (void);

    /* Return a copy of the buffer which must be freed after use. */
    char* getBufferCopy (void);

    /* Return the size of the underlying string. */
    int getSize (void);

    /* Reset the buffer contents. */
    void reset (void);

    /* Add an integer to the buffer. */
    void add (int val);

    /* Add a single character to the buffer. */
    void add (char val);

    /* Add a long-integer to the buffer. */
    void add (long val);

    /* Add a string to the buffer. */
    void add (const char *val);

    /* Add an unsigned integer to the buffer. */
    void add (unsigned long val);

    /* Add an unsigned integer in hex format to the buffer. */
    void addHex (unsigned long val);

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

    StringBuffer& operator +(unsigned long val);

    StringBuffer& operator +(const char *val);

    StringBuffer& operator +=(int val);

    StringBuffer& operator +=(unsigned long val);

    StringBuffer& operator +=(const char *val);

    StringBuffer& operator +=(char val);

    StringBuffer& operator=(const char *val);
};


#endif /*__STRING_BUFFER_H*/
1	twoaday	326	#ifndef __STRING_BUFFER_H
2			#define __STRING_BUFFER_H
3
4			/* Copyright (C) 2006, 2007 Timo Schulz
5			Released under the GNU General Public License, Version 2. */
6
7			#define DEFSIZE 128
8
9			/* A simple string buffer implementation which allows to manipulate
10			the underlying buffer in a unified and easy way. The code is written
11			for clarity and simplicty, _not_ speed. */
12			class StringBuffer
13			{
14			private:
15			char *private_contents;
16			int alloced_size;
17			int size;
18
19			private:
20			/* Add the converted data at the end of the internal buffer.
21			Allocate more memory if needed, plus some extra bytes. */
22			void addCharacters (const char *buffer, int bufsize);
23
24			public:
25			StringBuffer ();
26
27			/* Create an empty buffer object with an inital size. */
28			StringBuffer (int bufsize);
29
30
31			/* Create a buffer object with the given contents. */
32			StringBuffer (const char *contents);
33
34			/* Destructor which fres the used memory. */
35			~StringBuffer ();
36
37			/* Overwrite buffer contents in a safe manner. */
38			void wipeContents (void);
39
40			/* Return a constant pointer to the 'char' data of the buffer. /
41			const char *getBuffer (void);
42
43			/* Return a copy of the buffer which must be freed after use. */
44			char* getBufferCopy (void);
45
46			/* Return the size of the underlying string. */
47			int getSize (void);
48
49			/* Reset the buffer contents. */
50			void reset (void);
51
52			/* Add an integer to the buffer. */
53			void add (int val);
54
55			/* Add a single character to the buffer. */
56			void add (char val);
57
58			/* Add a long-integer to the buffer. */
59			void add (long val);
60
61			/* Add a string to the buffer. */
62			void add (const char *val);
63
64			/* Add an unsigned integer to the buffer. */
65			void add (unsigned long val);
66
67			/* Add an unsigned integer in hex format to the buffer. */
68			void addHex (unsigned long val);
69
70			/* Overloaded operators to provide an easier interface
71			for manipulating the underlying buffer. */
72			StringBuffer& operator +(int val);
73
74			StringBuffer& operator +(unsigned long val);
75
76			StringBuffer& operator +(const char *val);
77
78			StringBuffer& operator +=(int val);
79
80			StringBuffer& operator +=(unsigned long val);
81
82			StringBuffer& operator +=(const char *val);
83
84			StringBuffer& operator +=(char val);
85
86			StringBuffer& operator=(const char *val);
87			};
88
89
90			#endif /__STRING_BUFFER_H/