• Main Page
  • Related Pages
  • Namespaces
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

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 <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         // отдельная имплементация под bool
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         // отдельная имплементация под char
00154         template<>
00155         inline char parseValue( const std::string& _value ) { return (char)parseValue<short>(_value); }
00156 
00157         // отдельная имплементация под unsigned char
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         } // namespace templates
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     } // namespace utility
00351 
00352 } // namespace MyGUI
00353 
00354 #endif // __MYGUI_UTILITY_H__

Generated on Sun Jan 30 2011 for MyGUI by  doxygen 1.7.1