nevrax.org : docs

00001 
+00008 /* Copyright, 2000 Nevrax Ltd.
+00009  *
+00010  * This file is part of NEVRAX NEL.
+00011  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00012  * it under the terms of the GNU General Public License as published by
+00013  * the Free Software Foundation; either version 2, or (at your option)
+00014  * any later version.
+00015 
+00016  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00017  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00018  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00019  * General Public License for more details.
+00020 
+00021  * You should have received a copy of the GNU General Public License
+00022  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00023  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00024  * MA 02111-1307, USA.
+00025  */
+00026 
+00027 #ifndef NL_UCSTRING_H
+00028 #define NL_UCSTRING_H
+00029 
+00030 #include "nel/misc/types_nl.h"
+00031 
+00032 #include <string>
+00033 
+00039 typedef std::basic_string<ucchar> ucstringbase;
+00040 
+00041 class ucstring : public ucstringbase
+00042 {
+00043 public:
+00044 
+00045         ucstring () {}
+00046 
+00047         ucstring (const ucstringbase &str) : ucstringbase (str) {}
+00048 
+00049         ucstring (const std::string &str) : ucstringbase ()
+00050         {
+00051                 *this=str;
+00052         }
+00053 
+00054         ucstring &operator= (ucchar c)
+00055         {
+00056                 resize (1);
+00057                 operator[](0) = c;
+00058                 return *this;
+00059         }
+00060 
+00061         ucstring &operator= (const char *str)
+00062         {
+00063                 resize (strlen (str));
+00064                 for (sint i = 0; i < (sint) strlen (str); i++)
+00065                 {
+00066                         operator[](i) = str[i];
+00067                 }
+00068                 return *this;
+00069         }
+00070 
+00071         ucstring &operator= (const std::string &str)
+00072         {
+00073                 resize (str.size ());
+00074                 for (sint i = 0; i < (sint) str.size (); i++)
+00075                 {
+00076                         operator[](i) = str[i];
+00077                 }
+00078                 return *this;
+00079         }
+00080 
+00081         ucstring &operator= (const ucstringbase &str)
+00082         {
+00083                 ucstringbase::operator =(str);
+00084                 return *this;
+00085         }
+00086 
+00087         ucstring &operator+= (ucchar c)
+00088         {
+00089                 resize (size() + 1);
+00090                 operator[](size()-1) = c;
+00091                 return *this;
+00092         }
+00093 
+00094         ucstring &operator+= (const char *str)
+00095         {
+00096                 sint s = size();
+00097                 resize (s + strlen(str));
+00098                 for (sint i = 0; i < (sint) strlen(str); i++)
+00099                 {
+00100                         operator[](s+i) = str[i];
+00101                 }
+00102                 return *this;
+00103         }
+00104 
+00105         ucstring &operator+= (const std::string &str)
+00106         {
+00107                 sint s = size();
+00108                 resize (s + str.size());
+00109                 for (sint i = 0; i < (sint) str.size(); i++)
+00110                 {
+00111                         operator[](s+i) = str[i];
+00112                 }
+00113                 return *this;
+00114         }
+00115 
+00116         ucstring &operator+= (const ucstringbase &str)
+00117         {
+00118                 ucstringbase::operator +=(str);
+00119                 return *this;
+00120         }
+00121 
+00122 
+00124         void toString (std::string &str) const
+00125         {
+00126                 str.resize (size ());
+00127                 for (sint i = 0; i < (sint) str.size (); i++)
+00128                 {
+00129                         str[i] = (char) operator[](i);
+00130                 }
+00131         }
+00132 
+00134         std::string toString () const
+00135         {
+00136                 std::string str;
+00137                 toString(str);
+00138                 return str;
+00139         }
+00140 
+00141 };
+00142 
+00143 inline ucstring operator+(const ucstringbase &ucstr, ucchar c)
+00144 {
+00145         ucstring        ret;
+00146         ret= ucstr;
+00147         ret+= c;
+00148         return ret;
+00149 }
+00150 
+00151 inline ucstring operator+(const ucstringbase &ucstr, const char *c)
+00152 {
+00153         ucstring        ret;
+00154         ret= ucstr;
+00155         ret+= c;
+00156         return ret;
+00157 }
+00158 
+00159 inline ucstring operator+(const ucstringbase &ucstr, const std::string &c)
+00160 {
+00161         ucstring        ret;
+00162         ret= ucstr;
+00163         ret+= c;
+00164         return ret;
+00165 }
+00166 
+00167 inline ucstring operator+(ucchar c, const ucstringbase &ucstr)
+00168 {
+00169         ucstring        ret;
+00170         ret= c;
+00171         ret += ucstr;
+00172         return ret;
+00173 }
+00174 
+00175 inline ucstring operator+(const char *c, const ucstringbase &ucstr)
+00176 {
+00177         ucstring        ret;
+00178         ret= c;
+00179         ret += ucstr;
+00180         return ret;
+00181 }
+00182 
+00183 inline ucstring operator+(const std::string &c, const ucstringbase &ucstr)
+00184 {
+00185         ucstring        ret;
+00186         ret= c;
+00187         ret += ucstr;
+00188         return ret;
+00189 }
+00190 
+00191 #endif // NL_UCSTRING_H
+
ucstring.h
