MyGUI
3.2.0
|
00001 00006 /* 00007 This file is part of MyGUI. 00008 00009 MyGUI is free software: you can redistribute it and/or modify 00010 it under the terms of the GNU Lesser General Public License as published by 00011 the Free Software Foundation, either version 3 of the License, or 00012 (at your option) any later version. 00013 00014 MyGUI is distributed in the hope that it will be useful, 00015 but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00017 GNU Lesser General Public License for more details. 00018 00019 You should have received a copy of the GNU Lesser General Public License 00020 along with MyGUI. If not, see <http://www.gnu.org/licenses/>. 00021 */ 00022 #ifndef __MYGUI_STRING_UTILITY_H__ 00023 #define __MYGUI_STRING_UTILITY_H__ 00024 00025 #include "MyGUI_Prerequest.h" 00026 #include <vector> 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()) 00133 return T(); 00134 else 00135 { 00136 int item = stream.get(); 00137 while (item != -1) 00138 { 00139 if (item != ' ' && item != '\t') 00140 return T(); 00141 item = stream.get(); 00142 } 00143 } 00144 return result; 00145 } 00146 00147 // отдельная имплементация под bool 00148 template<> 00149 inline bool parseValue(const std::string& _value) 00150 { 00151 if (_value == "True" || _value == "true" || _value == "1") 00152 return true; 00153 return false; 00154 } 00155 00156 // отдельная имплементация под char 00157 template<> 00158 inline char parseValue(const std::string& _value) 00159 { 00160 return (char)parseValue<short>(_value); 00161 } 00162 00163 // отдельная имплементация под unsigned char 00164 template<> 00165 inline unsigned char parseValue(const std::string& _value) 00166 { 00167 return (unsigned char)parseValue<unsigned short>(_value); 00168 } 00169 00170 00171 inline short parseShort(const std::string& _value) 00172 { 00173 return parseValue<short>(_value); 00174 } 00175 00176 inline unsigned short parseUShort(const std::string& _value) 00177 { 00178 return parseValue<unsigned short>(_value); 00179 } 00180 00181 inline int parseInt(const std::string& _value) 00182 { 00183 return parseValue<int>(_value); 00184 } 00185 00186 inline unsigned int parseUInt(const std::string& _value) 00187 { 00188 return parseValue<unsigned int>(_value); 00189 } 00190 00191 inline size_t parseSizeT(const std::string& _value) 00192 { 00193 return parseValue<size_t>(_value); 00194 } 00195 00196 inline float parseFloat(const std::string& _value) 00197 { 00198 return parseValue<float>(_value); 00199 } 00200 00201 inline double parseDouble(const std::string& _value) 00202 { 00203 return parseValue<double>(_value); 00204 } 00205 00206 inline bool parseBool(const std::string& _value) 00207 { 00208 return parseValue<bool>(_value); 00209 } 00210 00211 inline char parseChar(const std::string& _value) 00212 { 00213 return parseValue<char>(_value); 00214 } 00215 00216 inline unsigned char parseUChar(const std::string& _value) 00217 { 00218 return parseValue<unsigned char>(_value); 00219 } 00220 00221 // для парсинга сложных типов, состоящих из простых 00222 template<typename T1, typename T2> 00223 inline T1 parseValueEx2(const std::string& _value) 00224 { 00225 T2 p1, p2; 00226 std::istringstream stream(_value); 00227 stream >> p1 >> p2; 00228 if (stream.fail()) 00229 return T1(); 00230 else 00231 { 00232 int item = stream.get(); 00233 while (item != -1) 00234 { 00235 if (item != ' ' && item != '\t') 00236 return T1(); 00237 item = stream.get(); 00238 } 00239 } 00240 return T1(p1, p2); 00241 } 00242 00243 template<typename T1, typename T2> 00244 inline T1 parseValueEx3(const std::string& _value) 00245 { 00246 T2 p1, p2, p3; 00247 std::istringstream stream(_value); 00248 stream >> p1 >> p2 >> p3; 00249 if (stream.fail()) 00250 return T1(); 00251 else 00252 { 00253 int item = stream.get(); 00254 while (item != -1) 00255 { 00256 if (item != ' ' && item != '\t') 00257 return T1(); 00258 item = stream.get(); 00259 } 00260 } 00261 return T1(p1, p2, p3); 00262 } 00263 00264 template<typename T1, typename T2> 00265 inline T1 parseValueEx4(const std::string& _value) 00266 { 00267 T2 p1, p2, p3, p4; 00268 std::istringstream stream(_value); 00269 stream >> p1 >> p2 >> p3 >> p4; 00270 if (stream.fail()) 00271 return T1(); 00272 else 00273 { 00274 int item = stream.get(); 00275 while (item != -1) 00276 { 00277 if (item != ' ' && item != '\t') 00278 return T1(); 00279 item = stream.get(); 00280 } 00281 } 00282 return T1(p1, p2, p3, p4); 00283 } 00284 00285 namespace templates 00286 { 00287 template<typename Type> 00288 inline void split(std::vector<Type>& _ret, const Type& _source, const Type& _delims) 00289 { 00290 size_t start = _source.find_first_not_of(_delims); 00291 while (start != _source.npos) 00292 { 00293 size_t end = _source.find_first_of(_delims, start); 00294 if (end != _source.npos) 00295 _ret.push_back(_source.substr(start, end - start)); 00296 else 00297 { 00298 _ret.push_back(_source.substr(start)); 00299 break; 00300 } 00301 start = _source.find_first_not_of(_delims, end + 1); 00302 } 00303 } 00304 } // namespace templates 00305 00306 inline std::vector<std::string> split(const std::string& _source, const std::string& _delims = "\t\n ") 00307 { 00308 std::vector<std::string> result; 00309 templates::split<std::string>(result, _source, _delims); 00310 return result; 00311 } 00312 00313 template<typename T1, typename T2, typename T3, typename T4> 00314 inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2, T3& _p3, T4& _p4) 00315 { 00316 std::istringstream stream(_value); 00317 00318 stream >> _p1 >> _p2 >> _p3 >> _p4; 00319 00320 if (stream.fail()) 00321 return false; 00322 int item = stream.get(); 00323 while (item != -1) 00324 { 00325 if (item != ' ' && item != '\t') 00326 return false; 00327 item = stream.get(); 00328 } 00329 00330 return true; 00331 } 00332 00333 template<typename T1, typename T2, typename T3> 00334 inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2, T3& _p3) 00335 { 00336 std::istringstream stream(_value); 00337 00338 stream >> _p1 >> _p2 >> _p3; 00339 00340 if (stream.fail()) 00341 return false; 00342 int item = stream.get(); 00343 while (item != -1) 00344 { 00345 if (item != ' ' && item != '\t') 00346 return false; 00347 item = stream.get(); 00348 } 00349 00350 return true; 00351 } 00352 00353 template<typename T1, typename T2> 00354 inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2) 00355 { 00356 std::istringstream stream(_value); 00357 00358 stream >> _p1 >> _p2; 00359 00360 if (stream.fail()) 00361 return false; 00362 int item = stream.get(); 00363 while (item != -1) 00364 { 00365 if (item != ' ' && item != '\t') 00366 return false; 00367 item = stream.get(); 00368 } 00369 00370 return true; 00371 } 00372 00373 template<typename T1> 00374 inline bool parseComplex(const std::string& _value, T1& _p1) 00375 { 00376 std::istringstream stream(_value); 00377 00378 stream >> _p1; 00379 00380 if (stream.fail()) 00381 return false; 00382 int item = stream.get(); 00383 while (item != -1) 00384 { 00385 if (item != ' ' && item != '\t') 00386 return false; 00387 item = stream.get(); 00388 } 00389 00390 return true; 00391 } 00392 00393 template<> 00394 inline bool parseComplex<bool>(const std::string& _value, bool& _p1) 00395 { 00396 std::string value(_value); 00397 trim(value); 00398 if ((value == "True") || (value == "true") || (value == "1")) 00399 { 00400 _p1 = true; 00401 return true; 00402 } 00403 else if ((value == "False") || (value == "false") || (value == "0")) 00404 { 00405 _p1 = false; 00406 return true; 00407 } 00408 00409 return false; 00410 } 00411 00412 inline bool startWith(const std::string& _source, const std::string& _value) 00413 { 00414 size_t count = _value.size(); 00415 if (_source.size() < count) 00416 return false; 00417 for (size_t index = 0; index < count; ++ index) 00418 { 00419 if (_source[index] != _value[index]) 00420 return false; 00421 } 00422 return true; 00423 } 00424 00425 inline bool endWith(const std::string& _source, const std::string& _value) 00426 { 00427 size_t count = _value.size(); 00428 if (_source.size() < count) 00429 return false; 00430 size_t offset = _source.size() - count; 00431 for (size_t index = 0; index < count; ++ index) 00432 { 00433 if (_source[index + offset] != _value[index]) 00434 return false; 00435 } 00436 return true; 00437 } 00438 00439 } // namespace utility 00440 00441 } // namespace MyGUI 00442 00443 #endif // __MYGUI_STRING_UTILITY_H__