MyGUI  3.2.1
MyGUI_StringUtility.h
Go to the documentation of this file.
00001 /*
00002  * This source file is part of MyGUI. For the latest info, see http://mygui.info/
00003  * Distributed under the MIT License
00004  * (See accompanying file COPYING.MIT or copy at http://opensource.org/licenses/MIT)
00005  */
00006 
00007 #ifndef __MYGUI_STRING_UTILITY_H__
00008 #define __MYGUI_STRING_UTILITY_H__
00009 
00010 #include "MyGUI_Prerequest.h"
00011 #include <vector>
00012 #include <sstream>
00013 
00014 namespace MyGUI
00015 {
00016     namespace utility
00017     {
00018 
00019         inline void trim(std::string& _str, bool _left = true, bool _right = true)
00020         {
00021             if (_right) _str.erase(_str.find_last_not_of(" \t\r") + 1);
00022             if (_left) _str.erase(0, _str.find_first_not_of(" \t\r"));
00023         }
00024 
00025         // конвертирование в строку
00026         template<typename T>
00027         inline std::string toString (T p)
00028         {
00029             std::ostringstream stream;
00030             stream << p;
00031             return stream.str();
00032         }
00033 
00034         inline const std::string& toString (const std::string& _value)
00035         {
00036             return _value;
00037         }
00038 
00039         template<typename T1,  typename T2>
00040         inline std::string toString (T1 p1, T2 p2)
00041         {
00042             std::ostringstream stream;
00043             stream << p1 << p2;
00044             return stream.str();
00045         }
00046 
00047         template<typename T1,  typename T2,  typename T3>
00048         inline std::string toString (T1 p1, T2 p2, T3 p3)
00049         {
00050             std::ostringstream stream;
00051             stream << p1 << p2 << p3;
00052             return stream.str();
00053         }
00054 
00055         template<typename T1,  typename T2,  typename T3, typename T4>
00056         inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4)
00057         {
00058             std::ostringstream stream;
00059             stream << p1 << p2 << p3 << p4;
00060             return stream.str();
00061         }
00062 
00063         template<typename T1,  typename T2,  typename T3, typename T4, typename T5>
00064         inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
00065         {
00066             std::ostringstream stream;
00067             stream << p1 << p2 << p3 << p4 << p5;
00068             return stream.str();
00069         }
00070 
00071         template<typename T1,  typename T2,  typename T3, typename T4, typename T5, typename T6>
00072         inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
00073         {
00074             std::ostringstream stream;
00075             stream << p1 << p2 << p3 << p4 << p5 << p6;
00076             return stream.str();
00077         }
00078 
00079         template<typename T1,  typename T2,  typename T3, typename T4, typename T5, typename T6, typename T7>
00080         inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7)
00081         {
00082             std::ostringstream stream;
00083             stream << p1 << p2 << p3 << p4 << p5 << p6 << p7;
00084             return stream.str();
00085         }
00086 
00087         template<typename T1,  typename T2,  typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
00088         inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8)
00089         {
00090             std::ostringstream stream;
00091             stream << p1 << p2 << p3 << p4 << p5 << p6 << p7 << p8;
00092             return stream.str();
00093         }
00094 
00095         template<typename T1,  typename T2,  typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
00096         inline std::string toString (T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9)
00097         {
00098             std::ostringstream stream;
00099             stream << p1 << p2 << p3 << p4 << p5 << p6 << p7 << p8 << p9;
00100             return stream.str();
00101         }
00102 
00103         template<>
00104         inline std::string toString<bool> (bool _value)
00105         {
00106             return _value ? "true" : "false";
00107         }
00108 
00109 
00110         // утилиты для парсинга
00111         template<typename T>
00112         inline T parseValue( const std::string& _value )
00113         {
00114             std::istringstream stream(_value);
00115             T result;
00116             stream >> result;
00117             if (stream.fail())
00118                 return T();
00119             else
00120             {
00121                 int item = stream.get();
00122                 while (item != -1)
00123                 {
00124                     if (item != ' ' && item != '\t')
00125                         return T();
00126                     item = stream.get();
00127                 }
00128             }
00129             return result;
00130         }
00131 
00132         // отдельная имплементация под bool
00133         template<>
00134         inline bool parseValue(const std::string& _value)
00135         {
00136             if (_value == "True" || _value == "true" || _value == "1")
00137                 return true;
00138             return false;
00139         }
00140 
00141         // отдельная имплементация под char
00142         template<>
00143         inline char parseValue(const std::string& _value)
00144         {
00145             return (char)parseValue<short>(_value);
00146         }
00147 
00148         // отдельная имплементация под unsigned char
00149         template<>
00150         inline unsigned char parseValue(const std::string& _value)
00151         {
00152             return (unsigned char)parseValue<unsigned short>(_value);
00153         }
00154 
00155 
00156         inline short parseShort(const std::string& _value)
00157         {
00158             return parseValue<short>(_value);
00159         }
00160 
00161         inline unsigned short parseUShort(const std::string& _value)
00162         {
00163             return parseValue<unsigned short>(_value);
00164         }
00165 
00166         inline int parseInt(const std::string& _value)
00167         {
00168             return parseValue<int>(_value);
00169         }
00170 
00171         inline unsigned int parseUInt(const std::string& _value)
00172         {
00173             return parseValue<unsigned int>(_value);
00174         }
00175 
00176         inline size_t parseSizeT(const std::string& _value)
00177         {
00178             return parseValue<size_t>(_value);
00179         }
00180 
00181         inline float parseFloat(const std::string& _value)
00182         {
00183             return parseValue<float>(_value);
00184         }
00185 
00186         inline double parseDouble(const std::string& _value)
00187         {
00188             return parseValue<double>(_value);
00189         }
00190 
00191         inline bool parseBool(const std::string& _value)
00192         {
00193             return parseValue<bool>(_value);
00194         }
00195 
00196         inline char parseChar(const std::string& _value)
00197         {
00198             return parseValue<char>(_value);
00199         }
00200 
00201         inline unsigned char parseUChar(const std::string& _value)
00202         {
00203             return parseValue<unsigned char>(_value);
00204         }
00205 
00206         // для парсинга сложных типов, состоящих из простых
00207         template<typename T1, typename T2>
00208         inline T1 parseValueEx2(const std::string& _value)
00209         {
00210             T2 p1, p2;
00211             std::istringstream stream(_value);
00212             stream >> p1 >> p2;
00213             if (stream.fail())
00214                 return T1();
00215             else
00216             {
00217                 int item = stream.get();
00218                 while (item != -1)
00219                 {
00220                     if (item != ' ' && item != '\t')
00221                         return T1();
00222                     item = stream.get();
00223                 }
00224             }
00225             return T1(p1, p2);
00226         }
00227 
00228         template<typename T1, typename T2>
00229         inline T1 parseValueEx3(const std::string& _value)
00230         {
00231             T2 p1, p2, p3;
00232             std::istringstream stream(_value);
00233             stream >> p1 >> p2 >> p3;
00234             if (stream.fail())
00235                 return T1();
00236             else
00237             {
00238                 int item = stream.get();
00239                 while (item != -1)
00240                 {
00241                     if (item != ' ' && item != '\t')
00242                         return T1();
00243                     item = stream.get();
00244                 }
00245             }
00246             return T1(p1, p2, p3);
00247         }
00248 
00249         template<typename T1, typename T2>
00250         inline T1 parseValueEx4(const std::string& _value)
00251         {
00252             T2 p1, p2, p3, p4;
00253             std::istringstream stream(_value);
00254             stream >> p1 >> p2 >> p3 >> p4;
00255             if (stream.fail())
00256                 return T1();
00257             else
00258             {
00259                 int item = stream.get();
00260                 while (item != -1)
00261                 {
00262                     if (item != ' ' && item != '\t')
00263                         return T1();
00264                     item = stream.get();
00265                 }
00266             }
00267             return T1(p1, p2, p3, p4);
00268         }
00269 
00270         namespace templates
00271         {
00272             template<typename Type>
00273             inline void split(std::vector<Type>& _ret, const Type& _source, const Type& _delims)
00274             {
00275                 size_t start = _source.find_first_not_of(_delims);
00276                 while (start != _source.npos)
00277                 {
00278                     size_t end = _source.find_first_of(_delims, start);
00279                     if (end != _source.npos)
00280                         _ret.push_back(_source.substr(start, end - start));
00281                     else
00282                     {
00283                         _ret.push_back(_source.substr(start));
00284                         break;
00285                     }
00286                     start = _source.find_first_not_of(_delims, end + 1);
00287                 }
00288             }
00289         } // namespace templates
00290 
00291         inline std::vector<std::string> split(const std::string& _source, const std::string& _delims = "\t\n ")
00292         {
00293             std::vector<std::string> result;
00294             templates::split<std::string>(result, _source, _delims);
00295             return result;
00296         }
00297 
00298         template<typename T1, typename T2, typename T3, typename T4>
00299         inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2, T3& _p3, T4& _p4)
00300         {
00301             std::istringstream stream(_value);
00302 
00303             stream >> _p1 >> _p2 >> _p3 >> _p4;
00304 
00305             if (stream.fail())
00306                 return false;
00307             int item = stream.get();
00308             while (item != -1)
00309             {
00310                 if (item != ' ' && item != '\t')
00311                     return false;
00312                 item = stream.get();
00313             }
00314 
00315             return true;
00316         }
00317 
00318         template<typename T1, typename T2, typename T3>
00319         inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2, T3& _p3)
00320         {
00321             std::istringstream stream(_value);
00322 
00323             stream >> _p1 >> _p2 >> _p3;
00324 
00325             if (stream.fail())
00326                 return false;
00327             int item = stream.get();
00328             while (item != -1)
00329             {
00330                 if (item != ' ' && item != '\t')
00331                     return false;
00332                 item = stream.get();
00333             }
00334 
00335             return true;
00336         }
00337 
00338         template<typename T1, typename T2>
00339         inline bool parseComplex(const std::string& _value, T1& _p1, T2& _p2)
00340         {
00341             std::istringstream stream(_value);
00342 
00343             stream >> _p1 >> _p2;
00344 
00345             if (stream.fail())
00346                 return false;
00347             int item = stream.get();
00348             while (item != -1)
00349             {
00350                 if (item != ' ' && item != '\t')
00351                     return false;
00352                 item = stream.get();
00353             }
00354 
00355             return true;
00356         }
00357 
00358         template<typename T1>
00359         inline bool parseComplex(const std::string& _value, T1& _p1)
00360         {
00361             std::istringstream stream(_value);
00362 
00363             stream >> _p1;
00364 
00365             if (stream.fail())
00366                 return false;
00367             int item = stream.get();
00368             while (item != -1)
00369             {
00370                 if (item != ' ' && item != '\t')
00371                     return false;
00372                 item = stream.get();
00373             }
00374 
00375             return true;
00376         }
00377 
00378         template<>
00379         inline bool parseComplex<bool>(const std::string& _value, bool& _p1)
00380         {
00381             std::string value(_value);
00382             trim(value);
00383             if ((value == "True") || (value == "true") || (value == "1"))
00384             {
00385                 _p1 = true;
00386                 return true;
00387             }
00388             else if ((value == "False") || (value == "false") || (value == "0"))
00389             {
00390                 _p1 = false;
00391                 return true;
00392             }
00393 
00394             return false;
00395         }
00396 
00397         inline bool startWith(const std::string& _source, const std::string& _value)
00398         {
00399             size_t count = _value.size();
00400             if (_source.size() < count)
00401                 return false;
00402             for (size_t index = 0; index < count; ++ index)
00403             {
00404                 if (_source[index] != _value[index])
00405                     return false;
00406             }
00407             return true;
00408         }
00409 
00410         inline bool endWith(const std::string& _source, const std::string& _value)
00411         {
00412             size_t count = _value.size();
00413             if (_source.size() < count)
00414                 return false;
00415             size_t offset = _source.size() - count;
00416             for (size_t index = 0; index < count; ++ index)
00417             {
00418                 if (_source[index + offset] != _value[index])
00419                     return false;
00420             }
00421             return true;
00422         }
00423 
00424     } // namespace utility
00425 
00426 } // namespace MyGUI
00427 
00428 #endif // __MYGUI_STRING_UTILITY_H__