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