MyGUI 3.0.1
MyGUI_Utility.h
Go to the documentation of this file.
00001 
00007 /*
00008     This file is part of MyGUI.
00009 
00010     MyGUI is free software: you can redistribute it and/or modify
00011     it under the terms of the GNU Lesser General Public License as published by
00012     the Free Software Foundation, either version 3 of the License, or
00013     (at your option) any later version.
00014 
00015     MyGUI is distributed in the hope that it will be useful,
00016     but WITHOUT ANY WARRANTY; without even the implied warranty of
00017     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018     GNU Lesser General Public License for more details.
00019 
00020     You should have received a copy of the GNU Lesser General Public License
00021     along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
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         // отдельная имплементация под bool
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         // отдельная имплементация под char
00155         template<>
00156         inline char parseValue( const std::string& _value ) { return (char)parseValue<short>(_value); }
00157 
00158         // отдельная имплементация под unsigned char
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         } // namespace templates
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     } // namespace utility
00352 
00353 } // namespace MyGUI
00354 
00355 #endif // __MYGUI_UTILITY_H__