]> git.saurik.com Git - wxWidgets.git/blame - src/stc/scintilla/include/SString.h
Added wxBufferedDC, changes for wxMenu and wxMenuItem, and other
[wxWidgets.git] / src / stc / scintilla / include / SString.h
CommitLineData
65ec6247
RD
1// SciTE - Scintilla based Text Editor
2/** @file SString.h
3 ** A simple string class.
4 **/
5// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
6// The License.txt file describes the conditions under which this software may be distributed.
7
8#ifndef SSTRING_H
9#define SSTRING_H
10
11// These functions are implemented because each platform calls them something different
12int CompareCaseInsensitive(const char *a, const char *b);
13int CompareNCaseInsensitive(const char *a, const char *b, int len);
14bool EqualCaseInsensitive(const char *a, const char *b);
15
16// Define another string class.
17// While it would be 'better' to use std::string, that doubles the executable size.
18// An SString may contain embedded nul characters.
19
20/**
21 * Duplicate a C string.
22 * Allocate memory of the given size, or big enough to fit the string if length isn't given;
23 * then copy the given string in the allocated memory.
24 * @return the pointer to the new string
25 */
26inline char *StringDup(
27 const char *s, ///< The string to duplicate
28 int len=-1) ///< The length of memory to allocate. Optional.
29{
30 if (!s)
31 return 0;
32 if (len == -1)
33 len = strlen(s);
34 char *sNew = new char[len + 1];
35 if (sNew) {
36 strncpy(sNew, s, len);
37 sNew[len] = '\0';
38 }
39 return sNew;
40}
41
42/**
43 * @brief A simple string class.
44 * Hold the length of the string for quick operations,
45 * can have a buffer bigger than the string to avoid too many memory allocations and copies.
46 * May have embedded zeroes as a result of @a substitute, but rely too heavily on C string
47 * functions to allow reliable manipulations of these strings.
48 **/
49class SString {
50 char *s; ///< The C string
51 int sSize; ///< The size of the buffer, less 1: ie. the maximum size of the string
52 int sLen; ///< The size of the string in s
53 int sizeGrowth; ///< Minimum growth size when appending strings
54 enum { sizeGrowthDefault = 64 };
55
56public:
57 typedef int size_type;
58
59 SString() : s(0), sSize(0), sLen(0), sizeGrowth(sizeGrowthDefault) {
60 }
61 SString(const SString &source) : sizeGrowth(sizeGrowthDefault) {
62 s = StringDup(source.s);
63 sSize = sLen = (s) ? strlen(s) : 0;
64 }
65 SString(const char *s_) : sizeGrowth(sizeGrowthDefault) {
66 s = StringDup(s_);
67 sSize = sLen = (s) ? strlen(s) : 0;
68 }
69 SString(const char *s_, int first, int last) : sizeGrowth(sizeGrowthDefault) {
70 s = StringDup(s_ + first, last - first);
71 sSize = sLen = (s) ? strlen(s) : 0;
72 }
73 SString(int i) : sizeGrowth(sizeGrowthDefault) {
74 char number[32];
75 sprintf(number, "%0d", i);
76 s = StringDup(number);
77 sSize = sLen = (s) ? strlen(s) : 0;
78 }
79 ~SString() {
80 delete []s;
81 s = 0;
82 sSize = 0;
83 sLen = 0;
84 }
85 void clear(void) {
86 if (s) {
87 *s = '\0';
88 }
89 sLen = 0;
90 }
91 /** Size of buffer. */
92 size_type size(void) const { ///<
93 if (s)
94 return sSize;
95 else
96 return 0;
97 }
98 /** Size of string in buffer. */
99 int length() const {
100 return sLen;
101 }
102 SString &assign(const char* sOther, int sSize_ = -1) {
103 if (!sOther) {
104 sSize_ = 0;
105 }
106 if (sSize_ < 0) {
107 sSize_ = strlen(sOther);
108 }
109 if (sSize > 0 && sSize_ <= sSize) { // Does not allocate new buffer if the current is big enough
110 if (s && sSize_) {
111 strncpy(s, sOther, sSize_);
112 }
113 s[sSize_] = '\0';
114 sLen = sSize_;
115 } else {
116 delete []s;
117 s = StringDup(sOther, sSize_);
118 if (s) {
119 sSize = sSize_; // Allow buffer bigger than real string, thus providing space to grow
120 sLen = strlen(s);
121 } else {
122 sSize = sLen = 0;
123 }
124 }
125 return *this;
126 }
127 SString &assign(const SString& sOther, int sSize_ = -1) {
128 return assign(sOther.s, sSize_);
129 }
130 SString &operator=(const char *source) {
131 return assign(source);
132 }
133 SString &operator=(const SString &source) {
134 if (this != &source) {
135 assign(source.c_str());
136 }
137 return *this;
138 }
139 bool operator==(const SString &sOther) const {
140 if ((s == 0) && (sOther.s == 0))
141 return true;
142 if ((s == 0) || (sOther.s == 0))
143 return false;
144 return strcmp(s, sOther.s) == 0;
145 }
146 bool operator!=(const SString &sOther) const {
147 return !operator==(sOther);
148 }
149 bool operator==(const char *sOther) const {
150 if ((s == 0) && (sOther == 0))
151 return true;
152 if ((s == 0) || (sOther == 0))
153 return false;
154 return strcmp(s, sOther) == 0;
155 }
156 bool operator!=(const char *sOther) const {
157 return !operator==(sOther);
158 }
159 bool contains(char ch) {
160 if (s && *s)
161 return strchr(s, ch) != 0;
162 else
163 return false;
164 }
165 void setsizegrowth(int sizeGrowth_) {
166 sizeGrowth = sizeGrowth_;
167 }
168 const char *c_str() const {
169 if (s)
170 return s;
171 else
172 return "";
173 }
174 /** Give ownership of buffer to caller which must use delete[] to free buffer. */
175 char *detach() {
176 char *sRet = s;
177 s = 0;
178 sSize = 0;
179 sLen = 0;
180 return sRet;
181 }
182 char operator[](int i) const {
183 if (s && i < sSize) // Or < sLen? Depends on the use, both are OK
184 return s[i];
185 else
186 return '\0';
187 }
188 SString &append(const char* sOther, int sLenOther=-1, char sep=0) {
189 if (sLenOther < 0)
190 sLenOther = strlen(sOther);
191 int lenSep = 0;
192 if (sLen && sep) // Only add a separator if not empty
193 lenSep = 1;
194 int lenNew = sLen + sLenOther + lenSep;
195 if (lenNew + 1 < sSize) {
196 // Conservative about growing the buffer: don't do it, unless really needed
197 if (lenSep) {
198 s[sLen] = sep;
199 sLen++;
200 }
201 strncpy(&s[sLen], sOther, sLenOther);
202 s[sLen + sLenOther] = '\0';
203 sLen += sLenOther;
204 } else {
205 // Grow the buffer bigger than really needed, to have room for other appends
206 char *sNew = new char[lenNew + sizeGrowth + 1];
207 if (sNew) {
208 if (s) {
209 memcpy(sNew, s, sLen);
210 delete []s;
211 }
212 s = sNew;
213 sSize = lenNew + sizeGrowth;
214 if (lenSep) {
215 s[sLen] = sep;
216 sLen++;
217 }
218 strncpy(&s[sLen], sOther, sLenOther);
219 sNew[sLen + sLenOther] = '\0';
220 sLen += sLenOther;
221 }
222 }
223 return *this;
224 }
225 SString &operator +=(const char *sOther) {
226 return append(sOther, -1);
227 }
228 SString &operator +=(const SString &sOther) {
229 return append(sOther.s, sOther.sSize);
230 }
231 SString &operator +=(char ch) {
232 return append(&ch, 1);
233 }
234 SString &appendwithseparator(const char* sOther, char sep) {
235 return append(sOther, strlen(sOther), sep);
236 }
237 int value() const {
238 if (s)
239 return atoi(s);
240 else
241 return 0;
242 }
243 void substitute(char find, char replace) {
244 char *t = s;
245 while (t) {
246 t = strchr(t, find);
247 if (t) {
248 *t = replace;
249 t++;
250 }
251 }
252 }
253};
254
255#endif