MyGUI  3.2.0
MyGUI_StringUtility.h
Go to the documentation of this file.
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__