MyGUI: MyGUI_StringUtility.h Source File

MyGUI 3.4.2

- Main Page
- Related Pages
- Namespaces
- Data Structures
- Files
- Examples

- File List
- Globals

MyGUI_StringUtility.h
Go to the documentation of this file.
1/*
2 * This source file is part of MyGUI. For the latest info, see http://mygui.info/
3 * Distributed under the MIT License
4 * (See accompanying file COPYING.MIT or copy at http://opensource.org/licenses/MIT)
5 */
6
7#ifndef MYGUI_STRING_UTILITY_H_
8#define MYGUI_STRING_UTILITY_H_
9
10#include "MyGUI_Prerequest.h"
11#include <vector>
12#include <sstream>
13
14namespace MyGUI
15{
16 namespace utility
17 {
18
19 inline void trim(std::string& _str, bool _left = true, bool _right = true)
20 {
21 if (_right) _str.erase(_str.find_last_not_of(" \t\r") + 1);
22 if (_left) _str.erase(0, _str.find_first_not_of(" \t\r"));
23 }
24
25 // конвертирование в строку
26 template<typename T>
27 inline std::string toString (T p)
28 {
29 std::ostringstream stream;
30 stream << p;
31 return stream.str();
32 }
33
34 inline const std::string& toString (const std::string& _value)
35 {
36 return _value;
37 }
38
39 template<typename T1, typename T2>
40 inline std::string toString (T1 p1, T2 p2)
41 {
42 std::ostringstream stream;
43 stream << p1 << p2;
44 return stream.str();
45 }
46
47 template<typename T1, typename T2, typename T3>
48 inline std::string toString (T1 p1, T2 p2, T3 p3)
49 {
50 std::ostringstream stream;
51 stream << p1 << p2 << p3;
52 return stream.str();
53 }
54
55 template<typename T1, typename T2, typename T3, typename T4>
56 inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4)
57 {
58 std::ostringstream stream;
59 stream << p1 << p2 << p3 << p4;
60 return stream.str();
61 }
62
63 template<typename T1, typename T2, typename T3, typename T4, typename T5>
64 inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
65 {
66 std::ostringstream stream;
67 stream << p1 << p2 << p3 << p4 << p5;
68 return stream.str();
69 }
70
71 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
72 inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
73 {
74 std::ostringstream stream;
75 stream << p1 << p2 << p3 << p4 << p5 << p6;
76 return stream.str();
77 }
78
79 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
80 inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7)
81 {
82 std::ostringstream stream;
83 stream << p1 << p2 << p3 << p4 << p5 << p6 << p7;
84 return stream.str();
85 }
86
87 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
88 inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8)
89 {
90 std::ostringstream stream;
91 stream << p1 << p2 << p3 << p4 << p5 << p6 << p7 << p8;
92 return stream.str();
93 }
94
95 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
96 inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9)
97 {
98 std::ostringstream stream;
99 stream << p1 << p2 << p3 << p4 << p5 << p6 << p7 << p8 << p9;
100 return stream.str();
101 }
102
103 template<>
104 inline std::string toString<bool> (bool _value)
105 {
106 return _value ? "true" : "false";
107 }
108
109
110 // утилиты для парсинга
111 template<typename T>
112 inline T parseValue( const std::string& _value )
113 {
114 std::istringstream stream(_value);
115 T result;
116 stream >> result;
117 if (stream.fail())
118 return T();
119 else
120 {
121 int item = stream.get();
122 while (item != -1)
123 {
124 if (item != ' ' && item != '\t')
125 return T();
126 item = stream.get();
127 }
128 }
129 return result;
130 }
131
132 // отдельная имплементация под bool
133 template<>
134 inline bool parseValue(const std::string& _value)
135 {
136 return _value == "True" || _value == "true" || _value == "1";
137 }
138
139 // отдельная имплементация под char
140 template<>
141 inline char parseValue(const std::string& _value)
142 {
143 return (char)parseValue<short>(_value);
144 }
145
146 // отдельная имплементация под unsigned char
147 template<>
148 inline unsigned char parseValue(const std::string& _value)
149 {
150 return (unsigned char)parseValue<unsigned short>(_value);
151 }
152
153
154 inline short parseShort(const std::string& _value)
155 {
156 return parseValue<short>(_value);
157 }
158
159 inline unsigned short parseUShort(const std::string& _value)
160 {
161 return parseValue<unsigned short>(_value);
162 }
163
164 inline int parseInt(const std::string& _value)
165 {
166 return parseValue<int>(_value);
167 }
168
169 inline unsigned int parseUInt(const std::string& _value)
170 {
171 return parseValue<unsigned int>(_value);
172 }
173
174 inline size_t parseSizeT(const std::string& _value)
175 {
176 return parseValue<size_t>(_value);
177 }
178
179 inline float parseFloat(const std::string& _value)
180 {
181 return parseValue<float>(_value);
182 }
183
184 inline double parseDouble(const std::string& _value)
185 {
186 return parseValue<double>(_value);
187 }
188
189 inline bool parseBool(const std::string& _value)
190 {
191 return parseValue<bool>(_value);
192 }
193
194 inline char parseChar(const std::string& _value)
195 {
196 return parseValue<char>(_value);
197 }
198
199 inline unsigned char parseUChar(const std::string& _value)
200 {
201 return parseValue<unsigned char>(_value);
202 }
203
204 // для парсинга сложных типов, состоящих из простых
205 template<typename T1, typename T2>
206 inline T1 parseValueEx2(const std::string& _value)
207 {
208 T2 p1, p2;
209 std::istringstream stream(_value);
210 stream >> p1 >> p2;
211 if (stream.fail())
212 return T1();
213 else
214 {
215 int item = stream.get();
216 while (item != -1)
217 {
218 if (item != ' ' && item != '\t')
219 return T1();
220 item = stream.get();
221 }
222 }
223 return T1(p1, p2);
224 }
225
226 template<typename T1, typename T2>
227 inline T1 parseValueEx3(const std::string& _value)
228 {
229 T2 p1, p2, p3;
230 std::istringstream stream(_value);
231 stream >> p1 >> p2 >> p3;
232 if (stream.fail())
233 return T1();
234 else
235 {
236 int item = stream.get();
237 while (item != -1)
238 {
239 if (item != ' ' && item != '\t')
240 return T1();
241 item = stream.get();
242 }
243 }
244 return T1(p1, p2, p3);
245 }
246
247 template<typename T1, typename T2>
248 inline T1 parseValueEx4(const std::string& _value)
249 {
250 T2 p1, p2, p3, p4;
251 std::istringstream stream(_value);
252 stream >> p1 >> p2 >> p3 >> p4;
253 if (stream.fail())
254 return T1();
255 else
256 {
257 int item = stream.get();
258 while (item != -1)
259 {
260 if (item != ' ' && item != '\t')
261 return T1();
262 item = stream.get();
263 }
264 }
265 return T1(p1, p2, p3, p4);
266 }
267
268 namespace templates
269 {
270 template<typename Type>
271 inline void split(std::vector<Type>& _ret, const Type& _source, const Type& _delims)
272 {
273 size_t start = _source.find_first_not_of(_delims);
274 while (start != _source.npos)
275 {
276 size_t end = _source.find_first_of(_delims, start);
277 if (end != _source.npos)
278 _ret.push_back(_source.substr(start, end - start));
279 else
280 {
281 _ret.push_back(_source.substr(start));
282 break;
283 }
284 start = _source.find_first_not_of(_delims, end + 1);
285 }
286 }
287 } // namespace templates
288
289 inline std::vector<std::string> split(const std::string& _source, const std::string& _delims = "\t\n ")
290 {
291 std::vector<std::string> result;
292 templates::split<std::string>(result, _source, _delims);
293 return result;
294 }
295
296 template<typename T1, typename T2, typename T3, typename T4>
297 inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2, T3& _p3, T4& _p4)
298 {
299 std::istringstream stream(_value);
300
301 stream >> _p1 >> _p2 >> _p3 >> _p4;
302
303 if (stream.fail())
304 return false;
305 int item = stream.get();
306 while (item != -1)
307 {
308 if (item != ' ' && item != '\t')
309 return false;
310 item = stream.get();
311 }
312
313 return true;
314 }
315
316 template<typename T1, typename T2, typename T3>
317 inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2, T3& _p3)
318 {
319 std::istringstream stream(_value);
320
321 stream >> _p1 >> _p2 >> _p3;
322
323 if (stream.fail())
324 return false;
325 int item = stream.get();
326 while (item != -1)
327 {
328 if (item != ' ' && item != '\t')
329 return false;
330 item = stream.get();
331 }
332
333 return true;
334 }
335
336 template<typename T1, typename T2>
337 inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2)
338 {
339 std::istringstream stream(_value);
340
341 stream >> _p1 >> _p2;
342
343 if (stream.fail())
344 return false;
345 int item = stream.get();
346 while (item != -1)
347 {
348 if (item != ' ' && item != '\t')
349 return false;
350 item = stream.get();
351 }
352
353 return true;
354 }
355
356 template<typename T1>
357 inline bool parseComplex(const std::string& _value, T1& _p1)
358 {
359 std::istringstream stream(_value);
360
361 stream >> _p1;
362
363 if (stream.fail())
364 return false;
365 int item = stream.get();
366 while (item != -1)
367 {
368 if (item != ' ' && item != '\t')
369 return false;
370 item = stream.get();
371 }
372
373 return true;
374 }
375
376 template<>
377 inline bool parseComplex<bool>(const std::string& _value, bool& _p1)
378 {
379 std::string value(_value);
380 trim(value);
381 if ((value == "True") || (value == "true") || (value == "1"))
382 {
383 _p1 = true;
384 return true;
385 }
386 else if ((value == "False") || (value == "false") || (value == "0"))
387 {
388 _p1 = false;
389 return true;
390 }
391
392 return false;
393 }
394
395 inline bool startWith(const std::string& _source, const std::string& _value)
396 {
397 size_t count = _value.size();
398 if (_source.size() < count)
399 return false;
400 for (size_t index = 0; index < count; ++ index)
401 {
402 if (_source[index] != _value[index])
403 return false;
404 }
405 return true;
406 }
407
408 inline bool endWith(const std::string& _source, const std::string& _value)
409 {
410 size_t count = _value.size();
411 if (_source.size() < count)
412 return false;
413 size_t offset = _source.size() - count;
414 for (size_t index = 0; index < count; ++ index)
415 {
416 if (_source[index + offset] != _value[index])
417 return false;
418 }
419 return true;
420 }
421
422 } // namespace utility
423
424} // namespace MyGUI
425
426#endif // MYGUI_STRING_UTILITY_H_
MyGUI_Prerequest.h
MyGUI::utility::templates::split
void split(std::vector< Type > &_ret, const Type &_source, const Type &_delims)
Definition MyGUI_StringUtility.h:271
MyGUI::utility::parseSizeT
size_t parseSizeT(const std::string &_value)
Definition MyGUI_StringUtility.h:174
MyGUI::utility::split
std::vector< std::string > split(const std::string &_source, const std::string &_delims="\t\n ")
Definition MyGUI_StringUtility.h:289
MyGUI::utility::parseComplex< bool >
bool parseComplex< bool >(const std::string &_value, bool &_p1)
Definition MyGUI_StringUtility.h:377
MyGUI::utility::parseInt
int parseInt(const std::string &_value)
Definition MyGUI_StringUtility.h:164
MyGUI::utility::parseValueEx2
T1 parseValueEx2(const std::string &_value)
Definition MyGUI_StringUtility.h:206
MyGUI::utility::parseBool
bool parseBool(const std::string &_value)
Definition MyGUI_StringUtility.h:189
MyGUI::utility::parseValue
T parseValue(const std::string &_value)
Definition MyGUI_StringUtility.h:112
MyGUI::utility::parseDouble
double parseDouble(const std::string &_value)
Definition MyGUI_StringUtility.h:184
MyGUI::utility::parseShort
short parseShort(const std::string &_value)
Definition MyGUI_StringUtility.h:154
MyGUI::utility::parseUInt
unsigned int parseUInt(const std::string &_value)
Definition MyGUI_StringUtility.h:169
MyGUI::utility::parseChar
char parseChar(const std::string &_value)
Definition MyGUI_StringUtility.h:194
MyGUI::utility::parseComplex
bool parseComplex(const std::string &_value, T1 &_p1, T2 &_p2, T3 &_p3, T4 &_p4)
Definition MyGUI_StringUtility.h:297
MyGUI::utility::parseUChar
unsigned char parseUChar(const std::string &_value)
Definition MyGUI_StringUtility.h:199
MyGUI::utility::toString< bool >
std::string toString< bool >(bool _value)
Definition MyGUI_StringUtility.h:104
MyGUI::utility::parseValueEx4
T1 parseValueEx4(const std::string &_value)
Definition MyGUI_StringUtility.h:248
MyGUI::utility::toString
std::string toString(T p)
Definition MyGUI_StringUtility.h:27
MyGUI::utility::startWith
bool startWith(const std::string &_source, const std::string &_value)
Definition MyGUI_StringUtility.h:395
MyGUI::utility::endWith
bool endWith(const std::string &_source, const std::string &_value)
Definition MyGUI_StringUtility.h:408
MyGUI::utility::parseValueEx3
T1 parseValueEx3(const std::string &_value)
Definition MyGUI_StringUtility.h:227
MyGUI::utility::trim
void trim(std::string &_str, bool _left=true, bool _right=true)
Definition MyGUI_StringUtility.h:19
MyGUI::utility::parseFloat
float parseFloat(const std::string &_value)
Definition MyGUI_StringUtility.h:179
MyGUI::utility::parseUShort
unsigned short parseUShort(const std::string &_value)
Definition MyGUI_StringUtility.h:159
MyGUI
Definition MyGUI_ActionController.h:15