Subversion Repositories spk

Rev

Rev 1 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1 Rev 114
Line 4... Line 4...
4 
#include <math.h>
 4 
#include <math.h>
- 
 
 5 
#include <string.h>
5 
#include "ext_stream.h"
 6 
#include "stream_base.h"
6 
 
 7 
 
7 
template <class Ty>
 8 
template <class Ty>
8 
class string_builder_base : public ext::stream_base
 9 
class string_builder_base : public mystream::stream_base
9 
{
 10 
{
10 
	public:
 11 
	public:
11 
		typedef ext::stream_base base;
 12 
		typedef mystream::stream_base base;
12 
		typedef Ty value_type;
 13 
		typedef Ty value_type;
13 
		typedef Ty* value_type_ptr;
 14 
		typedef Ty* value_type_ptr;
14 
		typedef const Ty* const_value_type_ptr;
 15 
		typedef const Ty* const_value_type_ptr;
- 
 
 16 
		typedef size_t size_type;
15
17
16 
	private:
 18 
	private:
17 
		value_type_ptr m_buffer;
 19 
		value_type_ptr m_buffer;
18 
		size_t m_bufferSize;
 20 
		size_type m_bufferSize;
19 
		size_t m_stringSize;
 21 
		size_type m_stringSize;
20 
		size_t m_growby;
 22 
		size_type m_growby;
21
23
22 
		bool allocate(size_t newsize)
 24 
		bool allocate(size_type newsize)
23 
		{
 25 
		{
24 
			if(allocated() < newsize) {
 26 
			if(allocated() < newsize) {
25 
				value_type_ptr old=m_buffer;
 27 
				value_type_ptr old=m_buffer;
26 
				size_t oldsize=m_bufferSize;
 28 
				size_type oldsize=m_bufferSize;
27
29
28 
				int c=(int)ceil((float)newsize / growby());
 30 
				int c=(int)ceil((float)newsize / growby());
29 
				m_bufferSize=c * growby();
 31 
				m_bufferSize=c * growby();
30 
				m_buffer=new value_type[m_bufferSize];
 32 
				m_buffer=new value_type[m_bufferSize];
31 
				if(m_buffer==NULL){
 33 
				if(m_buffer==NULL){
Line 38... Line 40...
38 
					delete[] old;
 40 
					delete[] old;
39 
				}
 41 
				}
40 
			}
 42 
			}
41 
			return (state() & failbit)==0;
 43 
			return (state() & failbit)==0;
42 
		}
 44 
		}
43
- 
 
44 
		void size(size_t newsize) { m_stringSize=newsize; }
 - 
 
45
45
46 
		void init()
 46 
		void init()
47 
		{
 47 
		{
48 
			m_buffer=0; m_bufferSize=m_stringSize=0;
48 
			m_buffer=0; m_bufferSize=m_stringSize=0;
49 
			base::clear(badbit);
 49 
			base::clear(badbit);
50 
		}
 50 
		}
51
51
52 
		size_t strlen(const wchar_t *str) { return ::wcslen(str); }
 52 
		size_type strlen(const wchar_t *str) { return (size_type)::wcslen(str); }
53 
		size_t strlen(const char *str) { return ::strlen(str); }
 53 
		size_type strlen(const char *str) { return (size_type)::strlen(str); }
54
54
55 
	public:
 55 
	public:
56 
		string_builder_base() { init(); growby(0); }
 56 
		string_builder_base() { init(); growby(0); }
57 
		string_builder_base(const_value_type_ptr str)
57 
		string_builder_base(const_value_type_ptr str)
58 
		{
 58 
		{
59 
			init();	growby(0);
 59 
			init();	growby(0);
60 
			append(str);
 60 
			append(str);
61 
		}
 61 
		}
62
62
- 
 
 63 
		string_builder_base(const string_builder_base& str)
- 
 
 64 
		{
- 
 
 65 
			init();	growby(0);
- 
 
 66 
			append(str);
- 
 
 67 
		}
- 
 
 68
- 
 
 69 
		bool reserve(size_type newsize) { return allocate(newsize); }
63 
		size_t allocated() const { return m_bufferSize; }
 70 
		size_type allocated() const { return m_bufferSize; }
64 
		size_t size() const { return m_stringSize; }
 71 
		size_type size() const { return m_stringSize; }
- 
 
 72 
		void size(size_type newsize) { m_stringSize=(newsize > allocated() ? allocated() : newsize); }
65
73
66 
		size_t growby() const { return m_growby; }
 74 
		size_type growby() const { return m_growby; }
67 
		void growby(size_t newgrow) { if(newgrow==0) newgrow=50; m_growby=newgrow; }
 75 
		void growby(size_type newgrow) { if(newgrow==0) newgrow=100; m_growby=newgrow; }
68
76
69 
		~string_builder_base() { delete[] m_buffer; }
 77 
		~string_builder_base() { delete[] m_buffer; }
70
78
71 
		void append(const_value_type_ptr str)
 79 
		string_builder_base& append(const_value_type_ptr str)
- 
 
 80 
		{
- 
 
 81 
			size_type s=strlen(str);
- 
 
 82 
			size_type newsize=size() + s;
- 
 
 83 
			if(allocate(newsize + 1)==false)
- 
 
 84 
				return *this;
- 
 
 85 
			memcpy(m_buffer + size(), str, (s + 1) * sizeof(value_type));
- 
 
 86 
			size(newsize);
- 
 
 87 
			base::clear(m_buffer ? goodbit : badbit);
- 
 
 88
- 
 
 89 
			return *this;
- 
 
 90 
		}
- 
 
 91
- 
 
 92 
		string_builder_base& append(const string_builder_base& str)
72 
		{
 93 
		{
73 
			size_t s=strlen(str);
 - 
 
74 
			size_t newsize=size() + s;
 94 
			size_type newsize=size() + str.size();
75 
			if(allocate(newsize + 1)==false)
 95 
			if(allocate(newsize + 1)==false)
76 
				return;
 96 
				return *this;
77 
			memcpy(m_buffer + size(), str, (s + 1) * sizeof(value_type));
 97 
			memcpy(m_buffer + size(), str, (str.size() + 1) * sizeof(value_type));
78 
			size(newsize);
 98 
			size(newsize);
79 
			base::clear(m_buffer ? goodbit : badbit);
 99 
			base::clear(m_buffer ? goodbit : badbit);
- 
 
 100
- 
 
 101 
			return *this;
80 
		}
 102 
		}
81
103
82 
		void append(const value_type& ch)
 104 
		string_builder_base& append(const value_type& ch)
83 
		{
 105 
		{
84 
			if(!good()) return;
 106 
			//if(!good()) return;
85 
			size_t newsize=size() + 1;
 107 
			size_type newsize=size() + 1;
86 
			if(allocate(newsize + 1)==false)
108 
			if(allocate(newsize + 1)==false)
87 
				return;
 109 
				return *this;
88 
			m_buffer[size()]=ch;
 110 
			m_buffer[size()]=ch;
89 
			m_buffer[size() + 1]=0;
 111 
			m_buffer[size() + 1]=0;
90 
			size(newsize);
 112 
			size(newsize);
91 
			base::clear(m_buffer ? goodbit : badbit);
 113 
			base::clear(m_buffer ? goodbit : badbit);
- 
 
 114 
			return *this;
92 
		}
 115 
		}
93
116
94 
		value_type_ptr getbuffer()
117 
		value_type_ptr getbuffer()
95 
		{
 118 
		{
96 
			value_type_ptr b=m_buffer;
 119 
			value_type_ptr b=m_buffer;
97 
			init();
 120 
			init();
98 
			return b;
 121 
			return b;
99 
		}
 122 
		}
100
123
101 
		void clear()
 124 
		void clear()
102 
		{
 125 
		{
103 
			delete[] m_buffer;
 126 
			delete[] m_buffer;
104 
			init();
 127 
			init();
105 
		}
 128 
		}
- 
 
 129
- 
 
 130 
		const_value_type_ptr buffer() const { return m_buffer; }
106
131
107 
		operator const_value_type_ptr () const { return m_buffer; }
 132 
		operator const_value_type_ptr () const { return m_buffer; }
108
133
109 
		string_builder_base& operator = (const string_builder_base& other)
 134 
		string_builder_base& operator = (const string_builder_base& other)
110 
		{
 135 
		{
111 
			if(other.m_buffer==0) {
 136 
			if(other.m_buffer==0) {
112 
				delete[] m_buffer;
 137 
				delete[] m_buffer;
Line 129... Line 154...
129 
};
 154 
};
130 
 
 155 
 
131 
class string_builder : public string_builder_base<char>
 156 
class string_builder : public string_builder_base<char>
132 
{
 157 
{
133 
	public:
 158 
	public:
- 
 
 159 
		typedef string_builder_base<char> base;
134 
		string_builder() : string_builder_base<char>() { }
 160 
		string_builder() : string_builder_base<char>() { }
135 
		string_builder(const char *str) : string_builder_base<char>(str) { }
 161 
		string_builder(const char *str) : string_builder_base<char>(str) { }
- 
 
 162
- 
 
 163 
		string_builder& operator = (const_value_type_ptr str) { return (string_builder&)base::operator =(str); }
136 
};
 164 
};
137 
 
 165 
 
138 
inline string_builder& operator << (string_builder& is, const char *str)
 166 
inline string_builder& operator << (string_builder& is, const char *str)
139 
{
 167 
{
140 
	is.append(str);
 168 
	is.append(str);
Line 166... Line 194...
166 
	return is;
 194 
	return is;
167 
}
 195 
}
168 
 
 196 
 
169 
inline wstring_builder& operator << (wstring_builder& is, int i)
 197 
inline wstring_builder& operator << (wstring_builder& is, int i)
170 
{
 198 
{
171 
	is.append(i);
 199 
	is.append((wstring_builder::value_type)i);
172 
	return is;
 200 
	return is;
173 
}
 201 
}
174 
 
 202 
 
175 
#endif // !defined(STRING_BUILDER_INCLUDED)
 203 
#endif // !defined(STRING_BUILDER_INCLUDED)