csstring.h Source File

00001 /*
00002     Crystal Space utility library: string class
00003     Copyright (C) 1999,2000 by Andrew Zabolotny <bit@eltech.ru>
00004 
00005     This library is free software; you can redistribute it and/or
00006     modify it under the terms of the GNU Library General Public
00007     License as published by the Free Software Foundation; either
00008     version 2 of the License, or (at your option) any later version.
00009 
00010     This library is distributed in the hope that it will be useful,
00011     but WITHOUT ANY WARRANTY; without even the implied warranty of
00012     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013     Library General Public License for more details.
00014 
00015     You should have received a copy of the GNU Library General Public
00016     License along with this library; if not, write to the Free
00017     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00018 */
00019 #ifndef __CS_CSSTRING_H__
00020 #define __CS_CSSTRING_H__
00021 
00022 #include <stdarg.h>
00023 #include "csutil/snprintf.h"
00024 
00029 class csString
00030 {
00031 protected:
00033   char *Data;
00035   size_t Size;
00037   size_t MaxSize;
00038 
00039 public:
00045   void SetCapacity (size_t NewSize);
00046 
00048   void Free ();
00049 
00051   csString &Truncate (size_t iLen);
00052 
00054   csString &Reclaim ();
00055 
00057   csString& Clear ()
00058   { return Truncate (0); }
00059 
00064   char* GetData () const
00065   { return Data; }
00066 
00068   size_t Length () const
00069   { return Size; }
00070 
00072   bool IsEmpty () const
00073   { return (Size == 0); }
00074 
00076   char& operator [] (size_t n)
00077   {
00078     CS_ASSERT (n < Size);
00079     return Data [n];
00080   }
00081 
00083   char operator [] (size_t n) const
00084   {
00085     CS_ASSERT (n < Size);
00086     return Data[n];
00087   }
00088 
00093   void SetAt (size_t n, const char c)
00094   {
00095     CS_ASSERT (n < Size);
00096     Data [n] = c;
00097   }
00098 
00100   char GetAt (size_t n) const
00101   {
00102     CS_ASSERT (n < Size);
00103     return Data [n];
00104   }
00105 
00107   csString& DeleteAt (size_t iPos, size_t iCount = 1);
00108 
00110   csString& Insert (size_t iPos, const csString&);
00111 
00113   csString& Insert (size_t iPos, const char);
00114 
00116   csString& Overwrite (size_t iPos, const csString&);
00117 
00123   csString& Append (const char*, size_t iCount = (size_t)-1);
00124 
00129   csString& Append (const csString &iStr, size_t iCount = (size_t)-1);
00130 
00132   csString& Append (char c)
00133   { char s[2]; s[0] = c; s[1] = '\0'; return Append(s); }
00135   csString &Append (unsigned char c)
00136   { return Append(char(c)); }
00137 
00138 #define STR_APPEND(TYPE,FMT,SZ) csString& Append(TYPE n) \
00139   { char s[SZ]; cs_snprintf(s, SZ, #FMT, n); return Append(s); }
00140   STR_APPEND(short, %hd, 32)
00141   STR_APPEND(unsigned short, %hu, 32)
00142   STR_APPEND(int, %d, 32)
00143   STR_APPEND(unsigned int, %u, 32)
00144   STR_APPEND(long, %ld, 32)
00145   STR_APPEND(unsigned long, %lu, 32)
00146   STR_APPEND(float, %g, 64)
00147   STR_APPEND(double, %g, 64)
00148 #undef STR_APPEND
00149 
00150 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00151 
00152   csString& Append (bool b) { return Append (b ? "1" : "0"); }
00153 #endif
00154 
00160   csString& Replace (const csString& iStr, size_t iCount = (size_t)-1)
00161   {
00162     Size = 0;
00163     return Append (iStr, iCount);
00164   }
00165 
00171   csString& Replace (const char* iStr, size_t iCount = (size_t)-1)
00172   {
00173     Size = 0;
00174     return Append (iStr, iCount);
00175   }
00176 
00177 #define STR_REPLACE(TYPE) csString& Replace (TYPE s) { Size = 0; return Append(s); }
00178   STR_REPLACE(char)
00179   STR_REPLACE(unsigned char)
00180   STR_REPLACE(short)
00181   STR_REPLACE(unsigned short)
00182   STR_REPLACE(int)
00183   STR_REPLACE(unsigned int)
00184   STR_REPLACE(long)
00185   STR_REPLACE(unsigned long)
00186   STR_REPLACE(float)
00187   STR_REPLACE(double)
00188 #ifndef CS_USE_FAKE_BOOL_TYPE
00189   STR_REPLACE(bool)
00190 #endif
00191 #undef STR_REPLACE
00192 
00194   bool Compare (const csString& iStr) const
00195   {
00196     if (&iStr == this)
00197       return true;
00198     size_t const n = iStr.Length();
00199     if (Size != n)
00200       return false;
00201     if (Size == 0 && n == 0)
00202       return true;
00203     return (memcmp (Data, iStr.GetData (), Size) == 0);
00204   }
00205 
00207   bool Compare (const char* iStr) const
00208   { return (strcmp (Data ? Data : "", iStr) == 0); }
00209 
00211   bool CompareNoCase (const csString& iStr) const
00212   {
00213     if (&iStr == this)
00214       return true;
00215     size_t const n = iStr.Length();
00216     if (Size != n)
00217       return false;
00218     if (Size == 0 && n == 0)
00219       return true;
00220     return (strncasecmp (Data, iStr.GetData (), Size) == 0);
00221   }
00222 
00224   bool CompareNoCase (const char* iStr) const
00225   { return (strncasecmp (Data ? Data : "", iStr, Size) == 0); }
00226 
00228   csString () : Data (NULL), Size (0), MaxSize (0) {}
00229 
00231   csString (size_t iLength) : Data (NULL), Size (0), MaxSize (0)
00232   { SetCapacity (iLength); }
00233 
00235   csString (const csString& copy) : Data (NULL), Size (0), MaxSize (0)
00236   { Append (copy); }
00237 
00239   csString (const char* copy) : Data (NULL), Size (0), MaxSize (0)
00240   { Append (copy); }
00241 
00243   csString (char c) : Data (NULL), Size (0), MaxSize (0)
00244   { Append (c); }
00245 
00247   csString (unsigned char c) : Data(NULL), Size (0), MaxSize (0)
00248   { Append ((char) c); }
00249 
00251   virtual ~csString ();
00252 
00254   csString Clone () const
00255   { return csString (*this); }
00256 
00258   csString& LTrim();
00259 
00261   csString& RTrim();
00262 
00264   csString& Trim();
00265 
00270   csString& Collapse();
00271 
00277   csString& Format(const char *format, ...) CS_GNUC_PRINTF (2, 3);
00278 
00279 #define STR_FORMAT(TYPE,FMT,SZ) \
00280   static csString Format (TYPE v);
00281   STR_FORMAT(short, %hd, 32)
00282   STR_FORMAT(unsigned short, %hu, 32)
00283   STR_FORMAT(int, %d, 32)
00284   STR_FORMAT(unsigned int, %u, 32)
00285   STR_FORMAT(long, %ld, 32)
00286   STR_FORMAT(unsigned long, %lu, 32)
00287   STR_FORMAT(float, %g, 64)
00288   STR_FORMAT(double, %g, 64)
00289 #undef STR_FORMAT
00290 
00291 #define STR_FORMAT_INT(TYPE,FMT) \
00292   static csString Format (TYPE v, int width, int prec=0);
00293   STR_FORMAT_INT(short, hd)
00294   STR_FORMAT_INT(unsigned short, hu)
00295   STR_FORMAT_INT(int, d)
00296   STR_FORMAT_INT(unsigned int, u)
00297   STR_FORMAT_INT(long, ld)
00298   STR_FORMAT_INT(unsigned long, lu)
00299 #undef STR_FORMAT_INT
00300 
00301 #define STR_FORMAT_FLOAT(TYPE) \
00302   static csString Format (TYPE v, int width, int prec=6);
00303   STR_FORMAT_FLOAT(float)
00304   STR_FORMAT_FLOAT(double)
00305 #undef STR_FORMAT_FLOAT
00306 
00308   csString& PadLeft (size_t iNewSize, char iChar=' ');
00309 
00311   csString AsPadLeft (size_t iNewSize, char iChar=' ');
00312 
00313   // Return a new left-padded string representation of a basic type
00314 #define STR_PADLEFT(TYPE) \
00315   static csString PadLeft (TYPE v, size_t iNewSize, char iChar=' ');
00316   STR_PADLEFT(const csString&)
00317   STR_PADLEFT(const char*)
00318   STR_PADLEFT(char)
00319   STR_PADLEFT(unsigned char)
00320   STR_PADLEFT(short)
00321   STR_PADLEFT(unsigned short)
00322   STR_PADLEFT(int)
00323   STR_PADLEFT(unsigned int)
00324   STR_PADLEFT(long)
00325   STR_PADLEFT(unsigned long)
00326   STR_PADLEFT(float)
00327   STR_PADLEFT(double)
00328 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00329   STR_PADLEFT(bool)
00330 #endif
00331 #undef STR_PADLEFT
00332 
00334   csString& PadRight (size_t iNewSize, char iChar=' ');
00335 
00337   csString AsPadRight (size_t iNewSize, char iChar=' ');
00338 
00339   // Return a new right-padded string representation of a basic type
00340 #define STR_PADRIGHT(TYPE) \
00341   static csString PadRight (TYPE v, size_t iNewSize, char iChar=' ');
00342   STR_PADRIGHT(const csString&)
00343   STR_PADRIGHT(const char*)
00344   STR_PADRIGHT(char)
00345   STR_PADRIGHT(unsigned char)
00346   STR_PADRIGHT(short)
00347   STR_PADRIGHT(unsigned short)
00348   STR_PADRIGHT(int)
00349   STR_PADRIGHT(unsigned int)
00350   STR_PADRIGHT(long)
00351   STR_PADRIGHT(unsigned long)
00352   STR_PADRIGHT(float)
00353   STR_PADRIGHT(double)
00354 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00355   STR_PADRIGHT(bool)
00356 #endif
00357 #undef STR_PADRIGHT
00358 
00360   csString& PadCenter (size_t iNewSize, char iChar=' ');
00361 
00363   csString AsPadCenter (size_t iNewSize, char iChar=' ');
00364 
00365   // Return a new left+right padded string representation of a basic type
00366 #define STR_PADCENTER(TYPE) \
00367   static csString PadCenter (TYPE v, size_t iNewSize, char iChar=' ');
00368   STR_PADCENTER(const csString&)
00369   STR_PADCENTER(const char*)
00370   STR_PADCENTER(char)
00371   STR_PADCENTER(unsigned char)
00372   STR_PADCENTER(short)
00373   STR_PADCENTER(unsigned short)
00374   STR_PADCENTER(int)
00375   STR_PADCENTER(unsigned int)
00376   STR_PADCENTER(long)
00377   STR_PADCENTER(unsigned long)
00378   STR_PADCENTER(float)
00379   STR_PADCENTER(double)
00380 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00381   STR_PADCENTER(bool)
00382 #endif
00383 #undef STR_PADCENTER
00384 
00386 #define STR_ASSIGN(TYPE) const csString& operator = (TYPE s) { return Replace (s); }
00387   STR_ASSIGN(const csString&)
00388   STR_ASSIGN(const char*)
00389   STR_ASSIGN(char)
00390   STR_ASSIGN(unsigned char)
00391   STR_ASSIGN(short)
00392   STR_ASSIGN(unsigned short)
00393   STR_ASSIGN(int)
00394   STR_ASSIGN(unsigned int)
00395   STR_ASSIGN(long)
00396   STR_ASSIGN(unsigned long)
00397   STR_ASSIGN(float)
00398   STR_ASSIGN(double)
00399 #ifndef CS_USE_FAKE_BOOL_TYPE
00400   STR_ASSIGN(bool)
00401 #endif
00402 #undef STR_ASSIGN
00403 
00404 #define STR_APPEND(TYPE) csString &operator += (TYPE s) { return Append (s); }
00405   STR_APPEND(const csString&)
00406   STR_APPEND(const char*)
00407   STR_APPEND(char)
00408   STR_APPEND(unsigned char)
00409   STR_APPEND(short)
00410   STR_APPEND(unsigned short)
00411   STR_APPEND(int)
00412   STR_APPEND(unsigned int)
00413   STR_APPEND(long);
00414   STR_APPEND(unsigned long)
00415   STR_APPEND(float)
00416   STR_APPEND(double)
00417 #ifndef CS_USE_FAKE_BOOL_TYPE
00418   STR_APPEND(bool)
00419 #endif
00420 #undef STR_APPEND
00421 
00423   const csString& operator + (const csString &iStr) const
00424   { return Clone ().Append (iStr); }
00425 
00427   operator const char* () const
00428   { return Data; }
00429 
00431   bool operator == (const csString& iStr) const
00432   { return Compare (iStr); }
00433   bool operator == (const char* iStr) const
00434   { return Compare (iStr); }
00435 
00443   char* Detach ()
00444   { char *d = Data; Data = 0; Size = 0; MaxSize = 0; return d; }
00445 };
00446 
00448 inline csString operator + (const char* iStr1, const csString &iStr2)
00449 {
00450   return csString (iStr1).Append (iStr2);
00451 }
00452 
00454 inline csString operator + (const csString &iStr1, const char* iStr2)
00455 {
00456   return iStr1.Clone ().Append (iStr2);
00457 }
00458 
00459 // Handy shift operators.
00460 #define STR_SHIFT(TYPE) \
00461   inline csString &operator << (csString &s, TYPE v) { return s.Append (v); }
00462 STR_SHIFT(const csString&)
00463 STR_SHIFT(const char*)
00464 STR_SHIFT(char)
00465 STR_SHIFT(unsigned char)
00466 STR_SHIFT(short)
00467 STR_SHIFT(unsigned short)
00468 STR_SHIFT(int)
00469 STR_SHIFT(unsigned int)
00470 STR_SHIFT(long);
00471 STR_SHIFT(unsigned long)
00472 STR_SHIFT(float)
00473 STR_SHIFT(double)
00474 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00475 STR_SHIFT(bool)
00476 #endif
00477 #undef STR_SHIFT
00478 
00479 #endif // __CS_CSSTRING_H__