00001
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #ifndef __MYGUI_UTILITY_H__
00024 #define __MYGUI_UTILITY_H__
00025
00026 #include "MyGUI_Prerequest.h"
00027 #include <vector>
00028 #include <sstream>
00029
00030 namespace MyGUI
00031 {
00032 namespace utility
00033 {
00034
00035 inline void trim(std::string& _str, bool _left = true, bool _right = true)
00036 {
00037 if (_right) _str.erase(_str.find_last_not_of(" \t\r")+1);
00038 if (_left) _str.erase(0, _str.find_first_not_of(" \t\r"));
00039 }
00040
00041
00042 template<typename T >
00043 inline std::string toString (T p)
00044 {
00045 std::ostringstream stream;
00046 stream << p;
00047 return stream.str();
00048 }
00049
00050 inline const std::string& toString (const std::string& _value)
00051 {
00052 return _value;
00053 }
00054
00055 template<typename T1, typename T2 >
00056 inline std::string toString (T1 p1, T2 p2)
00057 {
00058 std::ostringstream stream;
00059 stream << p1 << p2;
00060 return stream.str();
00061 }
00062
00063 template<typename T1, typename T2, typename T3 >
00064 inline std::string toString (T1 p1, T2 p2, T3 p3)
00065 {
00066 std::ostringstream stream;
00067 stream << p1 << p2 << p3;
00068 return stream.str();
00069 }
00070
00071 template<typename T1, typename T2, typename T3, typename T4 >
00072 inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4)
00073 {
00074 std::ostringstream stream;
00075 stream << p1 << p2 << p3 << p4;
00076 return stream.str();
00077 }
00078
00079 template<typename T1, typename T2, typename T3, typename T4, typename T5 >
00080 inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
00081 {
00082 std::ostringstream stream;
00083 stream << p1 << p2 << p3 << p4 << p5;
00084 return stream.str();
00085 }
00086
00087 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6 >
00088 inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
00089 {
00090 std::ostringstream stream;
00091 stream << p1 << p2 << p3 << p4 << p5 << p6;
00092 return stream.str();
00093 }
00094
00095 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7 >
00096 inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7)
00097 {
00098 std::ostringstream stream;
00099 stream << p1 << p2 << p3 << p4 << p5 << p6 << p7;
00100 return stream.str();
00101 }
00102
00103 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8 >
00104 inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8)
00105 {
00106 std::ostringstream stream;
00107 stream << p1 << p2 << p3 << p4 << p5 << p6 << p7 << p8;
00108 return stream.str();
00109 }
00110
00111 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9 >
00112 inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9)
00113 {
00114 std::ostringstream stream;
00115 stream << p1 << p2 << p3 << p4 << p5 << p6 << p7 << p8 << p9;
00116 return stream.str();
00117 }
00118
00119 template< >
00120 inline std::string toString<bool> (bool _value)
00121 {
00122 return _value ? "true" : "false";
00123 }
00124
00125
00126
00127 template<typename T >
00128 inline T parseValue( const std::string& _value )
00129 {
00130 std::istringstream stream(_value);
00131 T result;
00132 stream >> result;
00133 if (stream.fail()) return T();
00134 else
00135 {
00136 int item = stream.get();
00137 while (item != -1)
00138 {
00139 if (item != ' ' && item != '\t') return T();
00140 item = stream.get();
00141 }
00142 }
00143 return result;
00144 }
00145
00146
00147 template<>
00148 inline bool parseValue( const std::string& _value )
00149 {
00150 if (_value == "true" || _value == "1") return true;
00151 return false;
00152 }
00153
00154
00155 template<>
00156 inline char parseValue( const std::string& _value ) { return (char)parseValue<short>(_value); }
00157
00158
00159 template<>
00160 inline unsigned char parseValue( const std::string& _value ) { return (unsigned char)parseValue<unsigned short>(_value); }
00161
00162
00163 inline short parseShort(const std::string& _value) { return parseValue<short>(_value); }
00164 inline unsigned short parseUShort(const std::string& _value) { return parseValue<unsigned short>(_value); }
00165 inline int parseInt(const std::string& _value) { return parseValue<int>(_value); }
00166 inline unsigned int parseUInt(const std::string& _value) { return parseValue<unsigned int>(_value); }
00167 inline size_t parseSizeT(const std::string& _value) { return parseValue<size_t>(_value); }
00168 inline float parseFloat(const std::string& _value) { return parseValue<float>(_value); }
00169 inline double parseDouble(const std::string& _value) { return parseValue<double>(_value); }
00170
00171 inline bool parseBool(const std::string& _value) { return parseValue<bool>(_value); }
00172 inline char parseChar(const std::string& _value) { return parseValue<char>(_value); }
00173 inline unsigned char parseUChar(const std::string& _value) { return parseValue<unsigned char>(_value); }
00174
00175
00176 template<typename T1, typename T2 >
00177 inline T1 parseValueEx2(const std::string& _value)
00178 {
00179 T2 p1, p2;
00180 std::istringstream stream(_value);
00181 stream >> p1 >> p2;
00182 if (stream.fail()) return T1();
00183 else
00184 {
00185 int item = stream.get();
00186 while (item != -1)
00187 {
00188 if (item != ' ' && item != '\t') return T1();
00189 item = stream.get();
00190 }
00191 }
00192 return T1(p1, p2);
00193 }
00194
00195 template<typename T1, typename T2 >
00196 inline T1 parseValueEx3(const std::string& _value)
00197 {
00198 T2 p1, p2, p3;
00199 std::istringstream stream(_value);
00200 stream >> p1 >> p2 >> p3;
00201 if (stream.fail()) return T1();
00202 else
00203 {
00204 int item = stream.get();
00205 while (item != -1)
00206 {
00207 if (item != ' ' && item != '\t') return T1();
00208 item = stream.get();
00209 }
00210 }
00211 return T1(p1, p2, p3);
00212 }
00213
00214 template<typename T1, typename T2 >
00215 inline T1 parseValueEx4(const std::string& _value)
00216 {
00217 T2 p1, p2, p3, p4;
00218 std::istringstream stream(_value);
00219 stream >> p1 >> p2 >> p3 >> p4;
00220 if (stream.fail()) return T1();
00221 else
00222 {
00223 int item = stream.get();
00224 while (item != -1)
00225 {
00226 if (item != ' ' && item != '\t') return T1();
00227 item = stream.get();
00228 }
00229 }
00230 return T1(p1, p2, p3, p4);
00231 }
00232
00233 namespace templates
00234 {
00235 template<typename T>
00236 inline void split(std::vector<std::string>& _ret, const std::string& _source, const std::string& _delims)
00237 {
00238 size_t start = _source.find_first_not_of(_delims);
00239 while (start != _source.npos)
00240 {
00241 size_t end = _source.find_first_of(_delims, start);
00242 if (end != _source.npos) _ret.push_back(_source.substr(start, end-start));
00243 else
00244 {
00245 _ret.push_back(_source.substr(start));
00246 break;
00247 }
00248 start = _source.find_first_not_of(_delims, end + 1);
00249 }
00250 }
00251 }
00252
00253 inline std::vector<std::string> split(const std::string& _source, const std::string& _delims = "\t\n ")
00254 {
00255 std::vector<std::string> result;
00256 templates::split<void>(result, _source, _delims);
00257 return result;
00258 }
00259
00260 template<typename T1, typename T2, typename T3, typename T4>
00261 inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2, T3& _p3, T4& _p4)
00262 {
00263 std::istringstream stream(_value);
00264
00265 stream >> _p1 >> _p2 >> _p3 >> _p4;
00266
00267 if (stream.fail()) return false;
00268 int item = stream.get();
00269 while (item != -1)
00270 {
00271 if (item != ' ' && item != '\t') return false;
00272 item = stream.get();
00273 }
00274
00275 return true;
00276 }
00277
00278 template<typename T1, typename T2, typename T3>
00279 inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2, T3& _p3)
00280 {
00281 std::istringstream stream(_value);
00282
00283 stream >> _p1 >> _p2 >> _p3;
00284
00285 if (stream.fail()) return false;
00286 int item = stream.get();
00287 while (item != -1)
00288 {
00289 if (item != ' ' && item != '\t') return false;
00290 item = stream.get();
00291 }
00292
00293 return true;
00294 }
00295
00296 template<typename T1, typename T2>
00297 inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2)
00298 {
00299 std::istringstream stream(_value);
00300
00301 stream >> _p1 >> _p2;
00302
00303 if (stream.fail()) return false;
00304 int item = stream.get();
00305 while (item != -1)
00306 {
00307 if (item != ' ' && item != '\t') return false;
00308 item = stream.get();
00309 }
00310
00311 return true;
00312 }
00313
00314 template<typename T1>
00315 inline bool parseComplex(const std::string& _value, T1& _p1)
00316 {
00317 std::istringstream stream(_value);
00318
00319 stream >> _p1;
00320
00321 if (stream.fail()) return false;
00322 int item = stream.get();
00323 while (item != -1)
00324 {
00325 if (item != ' ' && item != '\t') return false;
00326 item = stream.get();
00327 }
00328
00329 return true;
00330 }
00331
00332 template<>
00333 inline bool parseComplex<bool>(const std::string& _value, bool& _p1)
00334 {
00335 std::string value(_value);
00336 trim(value);
00337 if ((value == "true") || (value == "1"))
00338 {
00339 _p1 = true;
00340 return true;
00341 }
00342 else if ((value == "false") || (value == "0"))
00343 {
00344 _p1 = false;
00345 return true;
00346 }
00347
00348 return false;
00349 }
00350
00351 }
00352
00353 }
00354
00355 #endif // __MYGUI_UTILITY_H__