CrystalSpace

Public API Reference

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

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 
00186   void SubString (csString& sub, size_t start, size_t len);
00187 
00192   size_t FindFirst (const char c, size_t p = (size_t)-1);
00193 
00199   size_t FindLast (const char c, size_t p = (size_t)-1);
00200 
00201 #define STR_APPEND(TYPE,FMT,SZ) csString& Append(TYPE n) \
00202   { char s[SZ]; cs_snprintf(s, SZ, #FMT, n); return Append(s); }
00203   STR_APPEND(short, %hd, 32)
00204   STR_APPEND(unsigned short, %hu, 32)
00205   STR_APPEND(int, %d, 32)
00206   STR_APPEND(unsigned int, %u, 32)
00207   STR_APPEND(long, %ld, 32)
00208   STR_APPEND(unsigned long, %lu, 32)
00209   STR_APPEND(float, %g, 64)
00210   STR_APPEND(double, %g, 64)
00211 #undef STR_APPEND
00212 
00213 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00214 
00215   csString& Append (bool b) { return Append (b ? "1" : "0"); }
00216 #endif
00217 
00223   csString& Replace (const csString& iStr, size_t iCount = (size_t)-1)
00224   {
00225     Size = 0;
00226     return Append (iStr, iCount);
00227   }
00228 
00234   csString& Replace (const char* iStr, size_t iCount = (size_t)-1)
00235   {
00236     Size = 0;
00237     return Append (iStr, iCount);
00238   }
00239 
00240 #define STR_REPLACE(TYPE) \
00241 csString& Replace (TYPE s) { Size = 0; return Append(s); }
00242   STR_REPLACE(char)
00243   STR_REPLACE(unsigned char)
00244   STR_REPLACE(short)
00245   STR_REPLACE(unsigned short)
00246   STR_REPLACE(int)
00247   STR_REPLACE(unsigned int)
00248   STR_REPLACE(long)
00249   STR_REPLACE(unsigned long)
00250   STR_REPLACE(float)
00251   STR_REPLACE(double)
00252 #ifndef CS_USE_FAKE_BOOL_TYPE
00253   STR_REPLACE(bool)
00254 #endif
00255 #undef STR_REPLACE
00256 
00258   bool Compare (const csString& iStr) const
00259   {
00260     if (&iStr == this)
00261       return true;
00262     size_t const n = iStr.Length();
00263     if (Size != n)
00264       return false;
00265     if (Size == 0 && n == 0)
00266       return true;
00267     return (memcmp (Data, iStr.GetData (), Size) == 0);
00268   }
00269 
00271   bool Compare (const char* iStr) const
00272   { return (strcmp (Data ? Data : "", iStr) == 0); }
00273 
00275   bool CompareNoCase (const csString& iStr) const
00276   {
00277     if (&iStr == this)
00278       return true;
00279     size_t const n = iStr.Length();
00280     if (Size != n)
00281       return false;
00282     if (Size == 0 && n == 0)
00283       return true;
00284     return (strncasecmp (Data, iStr.GetData (), Size) == 0);
00285   }
00286 
00288   bool CompareNoCase (const char* iStr) const
00289   { return (strncasecmp (Data ? Data : "", iStr, Size) == 0); }
00290 
00292   csString () : Data (0), Size (0), MaxSize (0), GrowBy (DEFAULT_GROW_BY),
00293     GrowExponentially (false) {}
00294 
00296   csString (size_t iLength) : Data (0), Size (0), MaxSize (0),
00297     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00298   { SetCapacity (iLength); }
00299 
00301   csString (const csString& copy) : Data (0), Size (0), MaxSize (0),
00302     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00303   { Append (copy); }
00304 
00306   csString (const char* copy) : Data (0), Size (0), MaxSize (0),
00307     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00308   { Append (copy); }
00309 
00311   csString (char c) : Data (0), Size (0), MaxSize (0),
00312     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00313   { Append (c); }
00314 
00316   csString (unsigned char c) : Data(0), Size (0), MaxSize (0),
00317     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00318   { Append ((char) c); }
00319 
00321   virtual ~csString ();
00322 
00324   csString Clone () const
00325   { return csString (*this); }
00326 
00328   csString& LTrim();
00329 
00331   csString& RTrim();
00332 
00334   csString& Trim();
00335 
00340   csString& Collapse();
00341 
00347   csString& Format(const char *format, ...) CS_GNUC_PRINTF (2, 3);
00348 
00354   csString& FormatV(const char *format, va_list args);
00355 
00356 
00357 #define STR_FORMAT(TYPE,FMT,SZ) \
00358   static csString Format (TYPE v);
00359   STR_FORMAT(short, %hd, 32)
00360   STR_FORMAT(unsigned short, %hu, 32)
00361   STR_FORMAT(int, %d, 32)
00362   STR_FORMAT(unsigned int, %u, 32)
00363   STR_FORMAT(long, %ld, 32)
00364   STR_FORMAT(unsigned long, %lu, 32)
00365   STR_FORMAT(float, %g, 64)
00366   STR_FORMAT(double, %g, 64)
00367 #undef STR_FORMAT
00368 
00369 #define STR_FORMAT_INT(TYPE,FMT) \
00370   static csString Format (TYPE v, int width, int prec=0);
00371   STR_FORMAT_INT(short, hd)
00372   STR_FORMAT_INT(unsigned short, hu)
00373   STR_FORMAT_INT(int, d)
00374   STR_FORMAT_INT(unsigned int, u)
00375   STR_FORMAT_INT(long, ld)
00376   STR_FORMAT_INT(unsigned long, lu)
00377 #undef STR_FORMAT_INT
00378 
00379 #define STR_FORMAT_FLOAT(TYPE) \
00380   static csString Format (TYPE v, int width, int prec=6);
00381   STR_FORMAT_FLOAT(float)
00382   STR_FORMAT_FLOAT(double)
00383 #undef STR_FORMAT_FLOAT
00384 
00386   csString& PadLeft (size_t iNewSize, char iChar=' ');
00387 
00389   csString AsPadLeft (size_t iNewSize, char iChar=' ');
00390 
00391   // Return a new left-padded string representation of a basic type
00392 #define STR_PADLEFT(TYPE) \
00393   static csString PadLeft (TYPE v, size_t iNewSize, char iChar=' ');
00394   STR_PADLEFT(const csString&)
00395   STR_PADLEFT(const char*)
00396   STR_PADLEFT(char)
00397   STR_PADLEFT(unsigned char)
00398   STR_PADLEFT(short)
00399   STR_PADLEFT(unsigned short)
00400   STR_PADLEFT(int)
00401   STR_PADLEFT(unsigned int)
00402   STR_PADLEFT(long)
00403   STR_PADLEFT(unsigned long)
00404   STR_PADLEFT(float)
00405   STR_PADLEFT(double)
00406 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00407   STR_PADLEFT(bool)
00408 #endif
00409 #undef STR_PADLEFT
00410 
00412   csString& PadRight (size_t iNewSize, char iChar=' ');
00413 
00415   csString AsPadRight (size_t iNewSize, char iChar=' ');
00416 
00417   // Return a new right-padded string representation of a basic type
00418 #define STR_PADRIGHT(TYPE) \
00419   static csString PadRight (TYPE v, size_t iNewSize, char iChar=' ');
00420   STR_PADRIGHT(const csString&)
00421   STR_PADRIGHT(const char*)
00422   STR_PADRIGHT(char)
00423   STR_PADRIGHT(unsigned char)
00424   STR_PADRIGHT(short)
00425   STR_PADRIGHT(unsigned short)
00426   STR_PADRIGHT(int)
00427   STR_PADRIGHT(unsigned int)
00428   STR_PADRIGHT(long)
00429   STR_PADRIGHT(unsigned long)
00430   STR_PADRIGHT(float)
00431   STR_PADRIGHT(double)
00432 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00433   STR_PADRIGHT(bool)
00434 #endif
00435 #undef STR_PADRIGHT
00436 
00438   csString& PadCenter (size_t iNewSize, char iChar=' ');
00439 
00441   csString AsPadCenter (size_t iNewSize, char iChar=' ');
00442 
00443   // Return a new left+right padded string representation of a basic type
00444 #define STR_PADCENTER(TYPE) \
00445   static csString PadCenter (TYPE v, size_t iNewSize, char iChar=' ');
00446   STR_PADCENTER(const csString&)
00447   STR_PADCENTER(const char*)
00448   STR_PADCENTER(char)
00449   STR_PADCENTER(unsigned char)
00450   STR_PADCENTER(short)
00451   STR_PADCENTER(unsigned short)
00452   STR_PADCENTER(int)
00453   STR_PADCENTER(unsigned int)
00454   STR_PADCENTER(long)
00455   STR_PADCENTER(unsigned long)
00456   STR_PADCENTER(float)
00457   STR_PADCENTER(double)
00458 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00459   STR_PADCENTER(bool)
00460 #endif
00461 #undef STR_PADCENTER
00462 
00463   // Assign a string to another
00464 #define STR_ASSIGN(TYPE) \
00465 const csString& operator = (TYPE s) { return Replace (s); }
00466   STR_ASSIGN(const csString&)
00467   STR_ASSIGN(const char*)
00468   STR_ASSIGN(char)
00469   STR_ASSIGN(unsigned char)
00470   STR_ASSIGN(short)
00471   STR_ASSIGN(unsigned short)
00472   STR_ASSIGN(int)
00473   STR_ASSIGN(unsigned int)
00474   STR_ASSIGN(long)
00475   STR_ASSIGN(unsigned long)
00476   STR_ASSIGN(float)
00477   STR_ASSIGN(double)
00478 #ifndef CS_USE_FAKE_BOOL_TYPE
00479   STR_ASSIGN(bool)
00480 #endif
00481 #undef STR_ASSIGN
00482 
00483 #define STR_APPEND(TYPE) csString &operator += (TYPE s) { return Append (s); }
00484   STR_APPEND(const csString&)
00485   STR_APPEND(const char*)
00486   STR_APPEND(char)
00487   STR_APPEND(unsigned char)
00488   STR_APPEND(short)
00489   STR_APPEND(unsigned short)
00490   STR_APPEND(int)
00491   STR_APPEND(unsigned int)
00492   STR_APPEND(long);
00493   STR_APPEND(unsigned long)
00494   STR_APPEND(float)
00495   STR_APPEND(double)
00496 #ifndef CS_USE_FAKE_BOOL_TYPE
00497   STR_APPEND(bool)
00498 #endif
00499 #undef STR_APPEND
00500 
00502   const csString& operator + (const csString &iStr) const
00503   { return Clone ().Append (iStr); }
00504 
00506   operator const char* () const
00507   { return Data; }
00508 
00510   bool operator == (const csString& iStr) const
00511   { return Compare (iStr); }
00512   bool operator == (const char* iStr) const
00513   { return Compare (iStr); }
00514   bool operator != (const csString& iStr) const
00515   { return !Compare (iStr); }
00516   bool operator != (const char* iStr) const
00517   { return !Compare (iStr); }
00518 
00526   char* Detach ()
00527   { char *d = Data; Data = 0; Size = 0; MaxSize = 0; return d; }
00528 
00529   void strlwr()
00530   {
00531     for (char *p = Data; *p; p++)
00532       *p = (char) tolower (*p);
00533   }
00534 };
00535 
00537 inline csString operator + (const char* iStr1, const csString &iStr2)
00538 {
00539   return csString (iStr1).Append (iStr2);
00540 }
00541 
00543 inline csString operator + (const csString &iStr1, const char* iStr2)
00544 {
00545   return iStr1.Clone ().Append (iStr2);
00546 }
00547 
00548 // Handy shift operators.
00549 #define STR_SHIFT(TYPE) \
00550   inline csString &operator << (csString &s, TYPE v) { return s.Append (v); }
00551 STR_SHIFT(const csString&)
00552 STR_SHIFT(const char*)
00553 STR_SHIFT(char)
00554 STR_SHIFT(unsigned char)
00555 STR_SHIFT(short)
00556 STR_SHIFT(unsigned short)
00557 STR_SHIFT(int)
00558 STR_SHIFT(unsigned int)
00559 STR_SHIFT(long);
00560 STR_SHIFT(unsigned long)
00561 STR_SHIFT(float)
00562 STR_SHIFT(double)
00563 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00564 STR_SHIFT(bool)
00565 #endif
00566 #undef STR_SHIFT
00567 
00568 #endif // __CS_CSSTRING_H__

Generated for Crystal Space by doxygen 1.2.14