CrystalSpace

Public API Reference

Main Page   Modules   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

csstring.h

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 <ctype.h>
00024 #include "csutil/snprintf.h"
00025 
00030 class csString
00031 {
00032 protected:
00033   // Default number of bytes by which allocation should grow.
00034   // *** IMPORTANT *** This must be a power of two (i.e. 8, 16, 32, 64, etc.).
00035   enum { DEFAULT_GROW_BY = 64 };
00036 
00037   // String buffer.
00038   char *Data;
00039   // Length of string; not including null terminator.
00040   size_t Size;
00041   // Size in bytes of allocated string buffer.
00042   size_t MaxSize;
00043   // Size in bytes by which allocated buffer is increased when needed.
00044   size_t GrowBy;
00045   // Controls if allocated buffer grows exponentially (overrides GrowBy).
00046   bool GrowExponentially;
00047 
00048   // If necessary, increase the buffer capacity enough to hold NewSize bytes.
00049   // Buffer capacity is increased in GrowBy increments or exponentially
00050   // depending upon configuration.
00051   void ExpandIfNeeded(size_t NewSize);
00052 
00053 public:
00061   void SetCapacity (size_t NewSize);
00062 
00064   size_t GetCapacity() const
00065   { return MaxSize; }
00066 
00074   void SetGrowsBy(size_t);
00075 
00077   size_t GetGrowsBy() const
00078   { return GrowBy; }
00079 
00084   void SetGrowsExponentially(bool b)
00085   { GrowExponentially = b; }
00086 
00088   bool GetGrowsExponentially() const
00089   { return GrowExponentially; }
00090 
00092   void Free ();
00093 
00095   csString &Truncate (size_t iLen);
00096 
00098   csString &Reclaim ();
00099 
00101   csString& Clear ()
00102   { return Truncate (0); }
00103 
00108   char* GetData () const
00109   { return Data; }
00110 
00112   size_t Length () const
00113   { return Size; }
00114 
00116   bool IsEmpty () const
00117   { return (Size == 0); }
00118 
00120   char& operator [] (size_t n)
00121   {
00122     CS_ASSERT (n < Size);
00123     return Data [n];
00124   }
00125 
00127   char operator [] (size_t n) const
00128   {
00129     CS_ASSERT (n < Size);
00130     return Data[n];
00131   }
00132 
00137   void SetAt (size_t n, const char c)
00138   {
00139     CS_ASSERT (n < Size);
00140     Data [n] = c;
00141   }
00142 
00144   char GetAt (size_t n) const
00145   {
00146     CS_ASSERT (n < Size);
00147     return Data [n];
00148   }
00149 
00151   csString& DeleteAt (size_t iPos, size_t iCount = 1);
00152 
00154   csString& Insert (size_t iPos, const csString&);
00155 
00157   csString& Insert (size_t iPos, const char);
00158 
00160   csString& Overwrite (size_t iPos, const csString&);
00161 
00167   csString& Append (const char*, size_t iCount = (size_t)-1);
00168 
00173   csString& Append (const csString &iStr, size_t iCount = (size_t)-1);
00174 
00176   csString& Append (char c)
00177   { char s[2]; s[0] = c; s[1] = '\0'; return Append(s); }
00179   csString &Append (unsigned char c)
00180   { return Append(char(c)); }
00181 
00182 #define STR_APPEND(TYPE,FMT,SZ) csString& Append(TYPE n) \
00183   { char s[SZ]; cs_snprintf(s, SZ, #FMT, n); return Append(s); }
00184   STR_APPEND(short, %hd, 32)
00185   STR_APPEND(unsigned short, %hu, 32)
00186   STR_APPEND(int, %d, 32)
00187   STR_APPEND(unsigned int, %u, 32)
00188   STR_APPEND(long, %ld, 32)
00189   STR_APPEND(unsigned long, %lu, 32)
00190   STR_APPEND(float, %g, 64)
00191   STR_APPEND(double, %g, 64)
00192 #undef STR_APPEND
00193 
00194 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00195 
00196   csString& Append (bool b) { return Append (b ? "1" : "0"); }
00197 #endif
00198 
00204   csString& Replace (const csString& iStr, size_t iCount = (size_t)-1)
00205   {
00206     Size = 0;
00207     return Append (iStr, iCount);
00208   }
00209 
00215   csString& Replace (const char* iStr, size_t iCount = (size_t)-1)
00216   {
00217     Size = 0;
00218     return Append (iStr, iCount);
00219   }
00220 
00221 #define STR_REPLACE(TYPE) \
00222 csString& Replace (TYPE s) { Size = 0; return Append(s); }
00223   STR_REPLACE(char)
00224   STR_REPLACE(unsigned char)
00225   STR_REPLACE(short)
00226   STR_REPLACE(unsigned short)
00227   STR_REPLACE(int)
00228   STR_REPLACE(unsigned int)
00229   STR_REPLACE(long)
00230   STR_REPLACE(unsigned long)
00231   STR_REPLACE(float)
00232   STR_REPLACE(double)
00233 #ifndef CS_USE_FAKE_BOOL_TYPE
00234   STR_REPLACE(bool)
00235 #endif
00236 #undef STR_REPLACE
00237 
00239   bool Compare (const csString& iStr) const
00240   {
00241     if (&iStr == this)
00242       return true;
00243     size_t const n = iStr.Length();
00244     if (Size != n)
00245       return false;
00246     if (Size == 0 && n == 0)
00247       return true;
00248     return (memcmp (Data, iStr.GetData (), Size) == 0);
00249   }
00250 
00252   bool Compare (const char* iStr) const
00253   { return (strcmp (Data ? Data : "", iStr) == 0); }
00254 
00256   bool CompareNoCase (const csString& iStr) const
00257   {
00258     if (&iStr == this)
00259       return true;
00260     size_t const n = iStr.Length();
00261     if (Size != n)
00262       return false;
00263     if (Size == 0 && n == 0)
00264       return true;
00265     return (strncasecmp (Data, iStr.GetData (), Size) == 0);
00266   }
00267 
00269   bool CompareNoCase (const char* iStr) const
00270   { return (strncasecmp (Data ? Data : "", iStr, Size) == 0); }
00271 
00273   csString () : Data (NULL), Size (0), MaxSize (0), GrowBy (DEFAULT_GROW_BY),
00274     GrowExponentially (false) {}
00275 
00277   csString (size_t iLength) : Data (NULL), Size (0), MaxSize (0),
00278     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00279   { SetCapacity (iLength); }
00280 
00282   csString (const csString& copy) : Data (NULL), Size (0), MaxSize (0),
00283     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00284   { Append (copy); }
00285 
00287   csString (const char* copy) : Data (NULL), Size (0), MaxSize (0),
00288     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00289   { Append (copy); }
00290 
00292   csString (char c) : Data (NULL), Size (0), MaxSize (0),
00293     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00294   { Append (c); }
00295 
00297   csString (unsigned char c) : Data(NULL), Size (0), MaxSize (0),
00298     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00299   { Append ((char) c); }
00300 
00302   virtual ~csString ();
00303 
00305   csString Clone () const
00306   { return csString (*this); }
00307 
00309   csString& LTrim();
00310 
00312   csString& RTrim();
00313 
00315   csString& Trim();
00316 
00321   csString& Collapse();
00322 
00328   csString& Format(const char *format, ...) CS_GNUC_PRINTF (2, 3);
00329 
00335   csString& FormatV(const char *format, va_list args);
00336 
00337 
00338 #define STR_FORMAT(TYPE,FMT,SZ) \
00339   static csString Format (TYPE v);
00340   STR_FORMAT(short, %hd, 32)
00341   STR_FORMAT(unsigned short, %hu, 32)
00342   STR_FORMAT(int, %d, 32)
00343   STR_FORMAT(unsigned int, %u, 32)
00344   STR_FORMAT(long, %ld, 32)
00345   STR_FORMAT(unsigned long, %lu, 32)
00346   STR_FORMAT(float, %g, 64)
00347   STR_FORMAT(double, %g, 64)
00348 #undef STR_FORMAT
00349 
00350 #define STR_FORMAT_INT(TYPE,FMT) \
00351   static csString Format (TYPE v, int width, int prec=0);
00352   STR_FORMAT_INT(short, hd)
00353   STR_FORMAT_INT(unsigned short, hu)
00354   STR_FORMAT_INT(int, d)
00355   STR_FORMAT_INT(unsigned int, u)
00356   STR_FORMAT_INT(long, ld)
00357   STR_FORMAT_INT(unsigned long, lu)
00358 #undef STR_FORMAT_INT
00359 
00360 #define STR_FORMAT_FLOAT(TYPE) \
00361   static csString Format (TYPE v, int width, int prec=6);
00362   STR_FORMAT_FLOAT(float)
00363   STR_FORMAT_FLOAT(double)
00364 #undef STR_FORMAT_FLOAT
00365 
00367   csString& PadLeft (size_t iNewSize, char iChar=' ');
00368 
00370   csString AsPadLeft (size_t iNewSize, char iChar=' ');
00371 
00372   // Return a new left-padded string representation of a basic type
00373 #define STR_PADLEFT(TYPE) \
00374   static csString PadLeft (TYPE v, size_t iNewSize, char iChar=' ');
00375   STR_PADLEFT(const csString&)
00376   STR_PADLEFT(const char*)
00377   STR_PADLEFT(char)
00378   STR_PADLEFT(unsigned char)
00379   STR_PADLEFT(short)
00380   STR_PADLEFT(unsigned short)
00381   STR_PADLEFT(int)
00382   STR_PADLEFT(unsigned int)
00383   STR_PADLEFT(long)
00384   STR_PADLEFT(unsigned long)
00385   STR_PADLEFT(float)
00386   STR_PADLEFT(double)
00387 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00388   STR_PADLEFT(bool)
00389 #endif
00390 #undef STR_PADLEFT
00391 
00393   csString& PadRight (size_t iNewSize, char iChar=' ');
00394 
00396   csString AsPadRight (size_t iNewSize, char iChar=' ');
00397 
00398   // Return a new right-padded string representation of a basic type
00399 #define STR_PADRIGHT(TYPE) \
00400   static csString PadRight (TYPE v, size_t iNewSize, char iChar=' ');
00401   STR_PADRIGHT(const csString&)
00402   STR_PADRIGHT(const char*)
00403   STR_PADRIGHT(char)
00404   STR_PADRIGHT(unsigned char)
00405   STR_PADRIGHT(short)
00406   STR_PADRIGHT(unsigned short)
00407   STR_PADRIGHT(int)
00408   STR_PADRIGHT(unsigned int)
00409   STR_PADRIGHT(long)
00410   STR_PADRIGHT(unsigned long)
00411   STR_PADRIGHT(float)
00412   STR_PADRIGHT(double)
00413 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00414   STR_PADRIGHT(bool)
00415 #endif
00416 #undef STR_PADRIGHT
00417 
00419   csString& PadCenter (size_t iNewSize, char iChar=' ');
00420 
00422   csString AsPadCenter (size_t iNewSize, char iChar=' ');
00423 
00424   // Return a new left+right padded string representation of a basic type
00425 #define STR_PADCENTER(TYPE) \
00426   static csString PadCenter (TYPE v, size_t iNewSize, char iChar=' ');
00427   STR_PADCENTER(const csString&)
00428   STR_PADCENTER(const char*)
00429   STR_PADCENTER(char)
00430   STR_PADCENTER(unsigned char)
00431   STR_PADCENTER(short)
00432   STR_PADCENTER(unsigned short)
00433   STR_PADCENTER(int)
00434   STR_PADCENTER(unsigned int)
00435   STR_PADCENTER(long)
00436   STR_PADCENTER(unsigned long)
00437   STR_PADCENTER(float)
00438   STR_PADCENTER(double)
00439 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00440   STR_PADCENTER(bool)
00441 #endif
00442 #undef STR_PADCENTER
00443 
00444   // Assign a string to another
00445 #define STR_ASSIGN(TYPE) \
00446 const csString& operator = (TYPE s) { return Replace (s); }
00447   STR_ASSIGN(const csString&)
00448   STR_ASSIGN(const char*)
00449   STR_ASSIGN(char)
00450   STR_ASSIGN(unsigned char)
00451   STR_ASSIGN(short)
00452   STR_ASSIGN(unsigned short)
00453   STR_ASSIGN(int)
00454   STR_ASSIGN(unsigned int)
00455   STR_ASSIGN(long)
00456   STR_ASSIGN(unsigned long)
00457   STR_ASSIGN(float)
00458   STR_ASSIGN(double)
00459 #ifndef CS_USE_FAKE_BOOL_TYPE
00460   STR_ASSIGN(bool)
00461 #endif
00462 #undef STR_ASSIGN
00463 
00464 #define STR_APPEND(TYPE) csString &operator += (TYPE s) { return Append (s); }
00465   STR_APPEND(const csString&)
00466   STR_APPEND(const char*)
00467   STR_APPEND(char)
00468   STR_APPEND(unsigned char)
00469   STR_APPEND(short)
00470   STR_APPEND(unsigned short)
00471   STR_APPEND(int)
00472   STR_APPEND(unsigned int)
00473   STR_APPEND(long);
00474   STR_APPEND(unsigned long)
00475   STR_APPEND(float)
00476   STR_APPEND(double)
00477 #ifndef CS_USE_FAKE_BOOL_TYPE
00478   STR_APPEND(bool)
00479 #endif
00480 #undef STR_APPEND
00481 
00483   const csString& operator + (const csString &iStr) const
00484   { return Clone ().Append (iStr); }
00485 
00487   operator const char* () const
00488   { return Data; }
00489 
00491   bool operator == (const csString& iStr) const
00492   { return Compare (iStr); }
00493   bool operator == (const char* iStr) const
00494   { return Compare (iStr); }
00495   bool operator != (const csString& iStr) const
00496   { return !Compare (iStr); }
00497   bool operator != (const char* iStr) const
00498   { return !Compare (iStr); }
00499 
00507   char* Detach ()
00508   { char *d = Data; Data = 0; Size = 0; MaxSize = 0; return d; }
00509 
00510   void strlwr()
00511   {
00512     for (char *p = Data; *p; p++)
00513       *p = (char) tolower (*p);
00514   }
00515 };
00516 
00518 inline csString operator + (const char* iStr1, const csString &iStr2)
00519 {
00520   return csString (iStr1).Append (iStr2);
00521 }
00522 
00524 inline csString operator + (const csString &iStr1, const char* iStr2)
00525 {
00526   return iStr1.Clone ().Append (iStr2);
00527 }
00528 
00529 // Handy shift operators.
00530 #define STR_SHIFT(TYPE) \
00531   inline csString &operator << (csString &s, TYPE v) { return s.Append (v); }
00532 STR_SHIFT(const csString&)
00533 STR_SHIFT(const char*)
00534 STR_SHIFT(char)
00535 STR_SHIFT(unsigned char)
00536 STR_SHIFT(short)
00537 STR_SHIFT(unsigned short)
00538 STR_SHIFT(int)
00539 STR_SHIFT(unsigned int)
00540 STR_SHIFT(long);
00541 STR_SHIFT(unsigned long)
00542 STR_SHIFT(float)
00543 STR_SHIFT(double)
00544 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00545 STR_SHIFT(bool)
00546 #endif
00547 #undef STR_SHIFT
00548 
00549 #endif // __CS_CSSTRING_H__

Generated for Crystal Space by doxygen 1.2.14