← Back to branch summary

~ubuntu-branches/ubuntu/vivid/mygui/vivid

« back to all changes in this revision

Viewing changes to Wrappers/WrapperGenerator/StringUtility.h

  • Committer: Package Import Robot
  • Author(s): Scott Howard, Bret Curtis, Scott Howard
  • Date: 2014-09-18 17:57:48 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20140918175748-dd8va78mvpw1jbes
Tags: 3.2.1-1
[ Bret Curtis ]
* Updated license for majority of files from LGPL to Expat (MIT)

[ Scott Howard ]
* New upstream release
* Updated patch to add build option for system GLEW libraries
* All patches accepted upstream except shared_libraries.patch
* Bumped SONAME due to dropped symbols, updated *.symbols and package
  names
* Updated license of debian/* to Expat with permission of all authors
* Don't install Doxygen autogenerated md5 and map files (thanks
  lintian)

Show diffs side-by-side

added added

removed removed

Lines of Context:
Wrappers/WrapperGenerator/StringUtility.h
1
 
/*!
2
 
        @file
3
 
        @author         Albert Semenov
4
 
        @date           11/2007
5
 
*/
6
 
#ifndef __STRING_UTILITY_H__
7
 
#define __STRING_UTILITY_H__
8
 
 
9
 
#include <sstream>
10
 
#include <vector>
11
 
 
12
 
#ifndef _MANAGED
13
 
        #define nullptr 0
14
 
#endif
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
 
        inline std::string trim_result(const std::string& _str, bool _left = true, bool _right = true)
26
 
        {
27
 
                std::string result = _str;
28
 
                if (_right) result.erase(_str.find_last_not_of(" \t\r") + 1);
29
 
                if (_left) result.erase(0, _str.find_first_not_of(" \t\r"));
30
 
                return result;
31
 
        }
32
 
 
33
 
        // ��������������� � ������
34
 
        template<typename T >
35
 
        inline std::string toString (T p)
36
 
        {
37
 
                std::ostringstream stream;
38
 
                stream << p;
39
 
                return stream.str();
40
 
        }
41
 
 
42
 
        inline const std::string& toString (const std::string& _value)
43
 
        {
44
 
                return _value;
45
 
        }
46
 
 
47
 
        template<typename T1,  typename T2 >
48
 
        inline std::string toString (T1 p1, T2 p2)
49
 
        {
50
 
                std::ostringstream stream;
51
 
                stream << p1 << p2;
52
 
                return stream.str();
53
 
        }
54
 
 
55
 
        template<typename T1,  typename T2,  typename T3 >
56
 
        inline std::string toString (T1 p1, T2 p2, T3 p3)
57
 
        {
58
 
                std::ostringstream stream;
59
 
                stream << p1 << p2 << p3;
60
 
                return stream.str();
61
 
        }
62
 
 
63
 
        template<typename T1,  typename T2,  typename T3, typename T4 >
64
 
        inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4)
65
 
        {
66
 
                std::ostringstream stream;
67
 
                stream << p1 << p2 << p3 << p4;
68
 
                return stream.str();
69
 
        }
70
 
 
71
 
        template<typename T1,  typename T2,  typename T3, typename T4, typename T5 >
72
 
        inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
73
 
        {
74
 
                std::ostringstream stream;
75
 
                stream << p1 << p2 << p3 << p4 << p5;
76
 
                return stream.str();
77
 
        }
78
 
 
79
 
        template<typename T1,  typename T2,  typename T3, typename T4, typename T5, typename T6 >
80
 
        inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
81
 
        {
82
 
                std::ostringstream stream;
83
 
                stream << p1 << p2 << p3 << p4 << p5 << p6;
84
 
                return stream.str();
85
 
        }
86
 
 
87
 
        template<typename T1,  typename T2,  typename T3, typename T4, typename T5, typename T6, typename T7 >
88
 
        inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7)
89
 
        {
90
 
                std::ostringstream stream;
91
 
                stream << p1 << p2 << p3 << p4 << p5 << p6 << p7;
92
 
                return stream.str();
93
 
        }
94
 
 
95
 
        template<typename T1,  typename T2,  typename T3, typename T4, typename T5, typename T6, typename T7, typename T8 >
96
 
        inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8)
97
 
        {
98
 
                std::ostringstream stream;
99
 
                stream << p1 << p2 << p3 << p4 << p5 << p6 << p7 << p8;
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()) return T();
118
 
                else
119
 
                {
120
 
                        int item = stream.get();
121
 
                        while (item != -1)
122
 
                        {
123
 
                                if (item != ' ' && item != '\t') return T();
124
 
                                item = stream.get();
125
 
                        };
126
 
                }
127
 
                return result;
128
 
        }
129
 
 
130
 
        inline char parseChar(const std::string& _value)
131
 
        {
132
 
                return static_cast<char>(parseValue<short>(_value));
133
 
        }
134
 
        inline unsigned char parseUChar(const std::string& _value)
135
 
        {
136
 
                return static_cast<unsigned char>(parseValue<unsigned short>(_value));
137
 
        }
138
 
        inline short parseShort(const std::string& _value)
139
 
        {
140
 
                return parseValue<short>(_value);
141
 
        }
142
 
        inline unsigned short parseUShort(const std::string& _value)
143
 
        {
144
 
                return parseValue<unsigned short>(_value);
145
 
        }
146
 
        inline int parseInt(const std::string& _value)
147
 
        {
148
 
                return parseValue<int>(_value);
149
 
        }
150
 
        inline unsigned int parseUInt(const std::string& _value)
151
 
        {
152
 
                return parseValue<unsigned int>(_value);
153
 
        }
154
 
        inline size_t parseSizeT(const std::string& _value)
155
 
        {
156
 
                return parseValue<size_t>(_value);
157
 
        }
158
 
        inline float parseFloat(const std::string& _value)
159
 
        {
160
 
                return parseValue<float>(_value);
161
 
        }
162
 
        inline double parseDouble(const std::string& _value)
163
 
        {
164
 
                return parseValue<double>(_value);
165
 
        }
166
 
        inline bool parseBool(const std::string& _value)
167
 
        {
168
 
                std::string value(_value);
169
 
                trim(value);
170
 
                return ( (value == "true") || (value == "1") );
171
 
        }
172
 
 
173
 
        // ��� �������� ������� �����, ��������� �� �������
174
 
        template<typename T1, typename T2 >
175
 
        inline T1 parseValueEx2(const std::string& _value)
176
 
        {
177
 
                T2 p1, p2;
178
 
                std::istringstream stream(_value);
179
 
                stream >> p1 >> p2;
180
 
                if (stream.fail()) return T1();
181
 
                else
182
 
                {
183
 
                        int item = stream.get();
184
 
                        while (item != -1)
185
 
                        {
186
 
                                if (item != ' ' && item != '\t') return T1();
187
 
                                item = stream.get();
188
 
                        };
189
 
                }
190
 
                return T1(p1, p2);
191
 
        }
192
 
 
193
 
        template<typename T1, typename T2 >
194
 
        inline T1 parseValueEx3(const std::string& _value)
195
 
        {
196
 
                T2 p1, p2, p3;
197
 
                std::istringstream stream(_value);
198
 
                stream >> p1 >> p2 >> p3;
199
 
                if (stream.fail()) return T1();
200
 
                else
201
 
                {
202
 
                        int item = stream.get();
203
 
                        while (item != -1)
204
 
                        {
205
 
                                if (item != ' ' && item != '\t') return T1();
206
 
                                item = stream.get();
207
 
                        };
208
 
                }
209
 
                return T1(p1, p2, p3);
210
 
        }
211
 
 
212
 
        template<typename T1, typename T2 >
213
 
        inline T1 parseValueEx4(const std::string& _value)
214
 
        {
215
 
                T2 p1, p2, p3, p4;
216
 
                std::istringstream stream(_value);
217
 
                stream >> p1 >> p2 >> p3 >> p4;
218
 
                if (stream.fail()) return T1();
219
 
                else
220
 
                {
221
 
                        int item = stream.get();
222
 
                        while (item != -1)
223
 
                        {
224
 
                                if (item != ' ' && item != '\t') return T1();
225
 
                                item = stream.get();
226
 
                        };
227
 
                }
228
 
                return T1(p1, p2, p3, p4);
229
 
        }
230
 
 
231
 
        namespace templates
232
 
        {
233
 
                template<typename T>
234
 
                inline void split(std::vector<std::string> & _ret, const std::string& _source, const std::string& _delims)
235
 
                {
236
 
                        size_t start = _source.find_first_not_of(_delims);
237
 
                        while (start != _source.npos)
238
 
                        {
239
 
                                size_t end = _source.find_first_of(_delims, start);
240
 
                                if (end != _source.npos) _ret.push_back(_source.substr(start, end - start));
241
 
                                else
242
 
                                {
243
 
                                        _ret.push_back(_source.substr(start));
244
 
                                        break;
245
 
                                }
246
 
                                start = _source.find_first_not_of(_delims, end + 1);
247
 
                        };
248
 
                }
249
 
        } // namespace templates
250
 
 
251
 
        inline std::vector<std::string> split(const std::string& _source, const std::string& _delims = "\t\n ")
252
 
        {
253
 
                std::vector<std::string> result;
254
 
                templates::split<void>(result, _source, _delims);
255
 
                return result;
256
 
        }
257
 
 
258
 
        template<typename T1, typename T2, typename T3, typename T4>
259
 
        inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2, T3& _p3, T4& _p4)
260
 
        {
261
 
                std::istringstream stream(_value);
262
 
 
263
 
                stream >> _p1 >> _p2 >> _p3 >> _p4;
264
 
 
265
 
                if (stream.fail()) return false;
266
 
                int item = stream.get();
267
 
                while (item != -1)
268
 
                {
269
 
                        if (item != ' ' && item != '\t') return false;
270
 
                        item = stream.get();
271
 
                };
272
 
 
273
 
                return true;
274
 
        }
275
 
 
276
 
        template<typename T1, typename T2, typename T3>
277
 
        inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2, T3& _p3)
278
 
        {
279
 
                std::istringstream stream(_value);
280
 
 
281
 
                stream >> _p1 >> _p2 >> _p3;
282
 
 
283
 
                if (stream.fail()) return false;
284
 
                int item = stream.get();
285
 
                while (item != -1)
286
 
                {
287
 
                        if (item != ' ' && item != '\t') return false;
288
 
                        item = stream.get();
289
 
                };
290
 
 
291
 
                return true;
292
 
        }
293
 
 
294
 
        template<typename T1, typename T2>
295
 
        inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2)
296
 
        {
297
 
                std::istringstream stream(_value);
298
 
 
299
 
                stream >> _p1 >> _p2;
300
 
 
301
 
                if (stream.fail()) return false;
302
 
                int item = stream.get();
303
 
                while (item != -1)
304
 
                {
305
 
                        if (item != ' ' && item != '\t') return false;
306
 
                        item = stream.get();
307
 
                };
308
 
 
309
 
                return true;
310
 
        }
311
 
 
312
 
        template<typename T1>
313
 
        inline bool parseComplex(const std::string& _value, T1& _p1)
314
 
        {
315
 
                std::istringstream stream(_value);
316
 
 
317
 
                stream >> _p1;
318
 
 
319
 
                if (stream.fail()) return false;
320
 
                int item = stream.get();
321
 
                while (item != -1)
322
 
                {
323
 
                        if (item != ' ' && item != '\t') return false;
324
 
                        item = stream.get();
325
 
                };
326
 
 
327
 
                return true;
328
 
        }
329
 
 
330
 
        template<>
331
 
        inline bool parseComplex<bool>(const std::string& _value, bool& _p1)
332
 
        {
333
 
                std::string value(_value);
334
 
                trim(value);
335
 
                if ((value == "true") || (value == "1"))
336
 
                {
337
 
                        _p1 = true;
338
 
                        return true;
339
 
                }
340
 
                else if ((value == "false") || (value == "0"))
341
 
                {
342
 
                        _p1 = false;
343
 
                        return true;
344
 
                }
345
 
 
346
 
                return false;
347
 
        }
348
 
 
349
 
} // namespace utility
350
 
 
351
 
#endif // __STRING_UTILITY_H__