CrystalSpace

Public API Reference

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

csutil/csstring.h

Go to the documentation of this 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 
00026 #include <stdarg.h>
00027 #include <ctype.h>
00028 #include "csextern.h"
00029 #include "snprintf.h"
00030 
00054 class CS_CSUTIL_EXPORT csString
00055 {
00056 protected:
00057   // Default number of bytes by which allocation should grow.
00058   // *** IMPORTANT *** This must be a power of two (i.e. 8, 16, 32, 64, etc.).
00059   enum { DEFAULT_GROW_BY = 64 };
00060 
00061   // String buffer.
00062   char* Data;
00063   // Length of string; not including null terminator.
00064   size_t Size;
00065   // Size in bytes of allocated string buffer.
00066   size_t MaxSize;
00067   // Size in bytes by which allocated buffer is increased when needed.
00068   size_t GrowBy;
00069   // Controls if allocated buffer grows exponentially (overrides GrowBy).
00070   bool GrowExponentially;
00071 
00072   // If necessary, increase the buffer capacity enough to hold NewSize bytes.
00073   // Buffer capacity is increased in GrowBy increments or exponentially
00074   // depending upon configuration.
00075   void ExpandIfNeeded(size_t NewSize);
00076 
00077 public:
00086   void SetCapacity (size_t NewSize);
00087 
00089   size_t GetCapacity() const
00090   { return MaxSize; }
00091 
00099   void SetGrowsBy(size_t);
00100 
00102   size_t GetGrowsBy() const
00103   { return GrowBy; }
00104 
00109   void SetGrowsExponentially(bool b)
00110   { GrowExponentially = b; }
00111 
00113   bool GetGrowsExponentially() const
00114   { return GrowExponentially; }
00115 
00122   void Free ();
00123 
00140   csString& Truncate (size_t Len);
00141 
00151   csString& Reclaim ();
00152 
00159   csString& Clear ()
00160   { return Truncate (0); }
00161 
00169   char const* GetData () const
00170   { return Data; }
00171 
00181   char* GetData ()
00182   { return Data; }
00183 
00193    char const* GetDataSafe() const
00194    { return Data != 0 ? Data : ""; }
00195 
00201   size_t Length () const
00202   { return Size; }
00203 
00209   bool IsEmpty () const
00210   { return (Size == 0); }
00211 
00213   char& operator [] (size_t n)
00214   {
00215     CS_ASSERT (n < Size);
00216     return Data [n];
00217   }
00218 
00220   char operator [] (size_t n) const
00221   {
00222     CS_ASSERT (n < Size);
00223     return Data[n];
00224   }
00225 
00232   void SetAt (size_t n, const char c)
00233   {
00234     CS_ASSERT (n < Size);
00235     Data [n] = c;
00236   }
00237 
00239   char GetAt (size_t n) const
00240   {
00241     CS_ASSERT (n < Size);
00242     return Data [n];
00243   }
00244 
00251   csString& DeleteAt (size_t Pos, size_t Count = 1);
00252 
00259   csString& Insert (size_t Pos, const csString& Str);
00260 
00267   csString& Insert (size_t Pos, const char* Str);
00268 
00275   csString& Insert (size_t Pos, char C);
00276 
00285   csString& Overwrite (size_t Pos, const csString& Str);
00286 
00294   csString& Append (const char* Str, size_t Count = (size_t)-1);
00295 
00303   csString& Append (const csString& Str, size_t Count = (size_t)-1);
00304 
00309   csString& Append (char c)
00310   { char s[2]; s[0] = c; s[1] = '\0'; return Append(s); }
00311 
00316   csString& Append (unsigned char c)
00317   { return Append(char(c)); }
00318 
00325   csString Slice (size_t start, size_t len) const;
00326 
00337   void SubString (csString& sub, size_t start, size_t len) const;
00338 
00345   size_t FindFirst (char c, size_t p = 0) const;
00346 
00354   size_t FindLast (char c, size_t p = (size_t)-1) const;
00355 
00356 #define STR_APPEND(TYPE,FMT,SZ) csString& Append(TYPE n) \
00357   { char s[SZ]; cs_snprintf(s, SZ, FMT, n); return Append(s); }
00358 
00362   STR_APPEND(short, "%hd", 32)
00363   STR_APPEND(unsigned short, "%hu", 32)
00364   STR_APPEND(int, "%d", 32)
00365   STR_APPEND(unsigned int, "%u", 32)
00366   STR_APPEND(long, "%ld", 32)
00367   STR_APPEND(unsigned long, "%lu", 32)
00368   STR_APPEND(float, "%g", 64)
00369   STR_APPEND(double, "%g", 64)
00370 #undef STR_APPEND
00373 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00374 
00375   csString& Append (bool b) { return Append (b ? "1" : "0"); }
00376 #endif
00377 
00387   csString& Replace (const csString& Str, size_t Count = (size_t)-1);
00388 
00398   csString& Replace (const char* Str, size_t Count = (size_t)-1);
00399 
00400 #define STR_REPLACE(TYPE) \
00401 csString& Replace (TYPE s) { Size = 0; return Append(s); }
00402 
00407   STR_REPLACE(char)
00408   STR_REPLACE(unsigned char)
00409   STR_REPLACE(short)
00410   STR_REPLACE(unsigned short)
00411   STR_REPLACE(int)
00412   STR_REPLACE(unsigned int)
00413   STR_REPLACE(long)
00414   STR_REPLACE(unsigned long)
00415   STR_REPLACE(float)
00416   STR_REPLACE(double)
00417 #ifndef CS_USE_FAKE_BOOL_TYPE
00418   STR_REPLACE(bool)
00419 #endif
00420 #undef STR_REPLACE
00421 
00429   bool Compare (const csString& iStr) const
00430   {
00431     if (&iStr == this)
00432       return true;
00433     size_t const n = iStr.Length();
00434     if (Size != n)
00435       return false;
00436     if (Size == 0 && n == 0)
00437       return true;
00438     return (memcmp (Data, iStr.GetData (), Size) == 0);
00439   }
00440 
00447   bool Compare (const char* iStr) const
00448   { return (strcmp (Data ? Data : "", iStr) == 0); }
00449 
00456   bool CompareNoCase (const csString& iStr) const
00457   {
00458     if (&iStr == this)
00459       return true;
00460     size_t const n = iStr.Length();
00461     if (Size != n)
00462       return false;
00463     if (Size == 0 && n == 0)
00464       return true;
00465     return (strncasecmp (Data, iStr.GetData (), Size) == 0);
00466   }
00467 
00474   bool CompareNoCase (const char* iStr) const
00475   { return (strncasecmp (Data ? Data : "", iStr, Size) == 0); }
00476 
00481   csString () : Data (0), Size (0), MaxSize (0), GrowBy (DEFAULT_GROW_BY),
00482     GrowExponentially (false) {}
00483 
00489   csString (size_t Length) : Data (0), Size (0), MaxSize (0),
00490     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00491   { SetCapacity (Length); }
00492 
00498   csString (const csString& copy) : Data (0), Size (0), MaxSize (0),
00499     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00500   { Append (copy); }
00501 
00507   csString (const char* src) : Data (0), Size (0), MaxSize (0),
00508     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00509   { Append (src); }
00510 
00512   csString (char c) : Data (0), Size (0), MaxSize (0),
00513     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00514   { Append (c); }
00515 
00517   csString (unsigned char c) : Data(0), Size (0), MaxSize (0),
00518     GrowBy (DEFAULT_GROW_BY), GrowExponentially(false)
00519   { Append ((char) c); }
00520 
00522   virtual ~csString ();
00523 
00529   csString Clone () const
00530   { return csString (*this); }
00531 
00539   csString& LTrim();
00540 
00548   csString& RTrim();
00549 
00555   csString& Trim();
00556 
00562   csString& Collapse();
00563 
00570   csString& Format(const char* format, ...) CS_GNUC_PRINTF (2, 3);
00571 
00578   csString& FormatV(const char* format, va_list args);
00579 
00580 #define STR_FORMAT(TYPE) \
00581   static csString Format (TYPE v);
00582 
00586   STR_FORMAT(short)
00587   STR_FORMAT(unsigned short)
00588   STR_FORMAT(int)
00589   STR_FORMAT(unsigned int)
00590   STR_FORMAT(long)
00591   STR_FORMAT(unsigned long)
00592   STR_FORMAT(float)
00593   STR_FORMAT(double)
00594 #undef STR_FORMAT
00595 
00596 #define STR_FORMAT_INT(TYPE) \
00597   static csString Format (TYPE v, int width, int prec=0);
00598   STR_FORMAT_INT(short)
00599   STR_FORMAT_INT(unsigned short)
00600   STR_FORMAT_INT(int)
00601   STR_FORMAT_INT(unsigned int)
00602   STR_FORMAT_INT(long)
00603   STR_FORMAT_INT(unsigned long)
00604 #undef STR_FORMAT_INT
00605 
00606 #define STR_FORMAT_FLOAT(TYPE) \
00607   static csString Format (TYPE v, int width, int prec=6);
00608   STR_FORMAT_FLOAT(float)
00609   STR_FORMAT_FLOAT(double)
00610 #undef STR_FORMAT_FLOAT
00621   csString& PadLeft (size_t NewSize, char PadChar = ' ');
00622 
00624   csString AsPadLeft (size_t NewSize, char PadChar = ' ') const;
00625 
00626 #define STR_PADLEFT(TYPE) \
00627   static csString PadLeft (TYPE v, size_t iNewSize, char iChar=' ');
00628 
00632   STR_PADLEFT(const csString&)
00633   STR_PADLEFT(const char*)
00634   STR_PADLEFT(char)
00635   STR_PADLEFT(unsigned char)
00636   STR_PADLEFT(short)
00637   STR_PADLEFT(unsigned short)
00638   STR_PADLEFT(int)
00639   STR_PADLEFT(unsigned int)
00640   STR_PADLEFT(long)
00641   STR_PADLEFT(unsigned long)
00642   STR_PADLEFT(float)
00643   STR_PADLEFT(double)
00644 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00645   STR_PADLEFT(bool)
00646 #endif
00647 #undef STR_PADLEFT
00648 
00658   csString& PadRight (size_t NewSize, char PadChar = ' ');
00659 
00661   csString AsPadRight (size_t NewSize, char PadChar = ' ') const;
00662 
00663 #define STR_PADRIGHT(TYPE) \
00664   static csString PadRight (TYPE v, size_t iNewSize, char iChar=' ');
00665 
00669   STR_PADRIGHT(const csString&)
00670   STR_PADRIGHT(const char*)
00671   STR_PADRIGHT(char)
00672   STR_PADRIGHT(unsigned char)
00673   STR_PADRIGHT(short)
00674   STR_PADRIGHT(unsigned short)
00675   STR_PADRIGHT(int)
00676   STR_PADRIGHT(unsigned int)
00677   STR_PADRIGHT(long)
00678   STR_PADRIGHT(unsigned long)
00679   STR_PADRIGHT(float)
00680   STR_PADRIGHT(double)
00681 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00682   STR_PADRIGHT(bool)
00683 #endif
00684 #undef STR_PADRIGHT
00685 
00698   csString& PadCenter (size_t NewSize, char PadChar = ' ');
00699 
00701   csString AsPadCenter (size_t NewSize, char PadChar = ' ') const;
00702 
00703 #define STR_PADCENTER(TYPE) \
00704   static csString PadCenter (TYPE v, size_t iNewSize, char iChar=' ');
00705 
00709   STR_PADCENTER(const csString&)
00710   STR_PADCENTER(const char*)
00711   STR_PADCENTER(char)
00712   STR_PADCENTER(unsigned char)
00713   STR_PADCENTER(short)
00714   STR_PADCENTER(unsigned short)
00715   STR_PADCENTER(int)
00716   STR_PADCENTER(unsigned int)
00717   STR_PADCENTER(long)
00718   STR_PADCENTER(unsigned long)
00719   STR_PADCENTER(float)
00720   STR_PADCENTER(double)
00721 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00722   STR_PADCENTER(bool)
00723 #endif
00724 #undef STR_PADCENTER
00725 
00727 #define STR_ASSIGN(TYPE) \
00728 const csString& operator = (TYPE s) { return Replace (s); }
00729 
00733   STR_ASSIGN(const csString&)
00734   STR_ASSIGN(const char*)
00735   STR_ASSIGN(char)
00736   STR_ASSIGN(unsigned char)
00737   STR_ASSIGN(short)
00738   STR_ASSIGN(unsigned short)
00739   STR_ASSIGN(int)
00740   STR_ASSIGN(unsigned int)
00741   STR_ASSIGN(long)
00742   STR_ASSIGN(unsigned long)
00743   STR_ASSIGN(float)
00744   STR_ASSIGN(double)
00745 #ifndef CS_USE_FAKE_BOOL_TYPE
00746   STR_ASSIGN(bool)
00747 #endif
00748 #undef STR_ASSIGN
00749 
00751 #define STR_OP_APPEND(TYPE) \
00752   csString &operator += (TYPE s) { return Append (s); }
00753 
00757   STR_OP_APPEND(const csString&)
00758   STR_OP_APPEND(const char*)
00759   STR_OP_APPEND(char)
00760   STR_OP_APPEND(unsigned char)
00761   STR_OP_APPEND(short)
00762   STR_OP_APPEND(unsigned short)
00763   STR_OP_APPEND(int)
00764   STR_OP_APPEND(unsigned int)
00765   STR_OP_APPEND(long)
00766   STR_OP_APPEND(unsigned long)
00767   STR_OP_APPEND(float)
00768   STR_OP_APPEND(double)
00769 #ifndef CS_USE_FAKE_BOOL_TYPE
00770   STR_OP_APPEND(bool)
00771 #endif
00772 #undef STR_OP_APPEND
00773 
00775 
00776   csString operator + (const csString &iStr) const
00777   { return Clone ().Append (iStr); }
00778 
00786   operator const char* () const
00787   { return Data; }
00788 
00795   bool operator == (const csString& Str) const
00796   { return Compare (Str); }
00803   bool operator == (const char* Str) const
00804   { return Compare (Str); }
00811   bool operator != (const csString& Str) const
00812   { return !Compare (Str); }
00819   bool operator != (const char* Str) const
00820   { return !Compare (Str); }
00821 
00826   csString& Downcase();
00831   csString& Upcase();
00832 
00843   char* Detach ()
00844   { char* d = Data; Data = 0; Size = 0; MaxSize = 0; return d; }
00845 };
00846 
00848 inline csString operator + (const char* iStr1, const csString &iStr2)
00849 {
00850   return csString (iStr1).Append (iStr2);
00851 }
00852 
00854 inline csString operator + (const csString& iStr1, const char* iStr2)
00855 {
00856   return iStr1.Clone ().Append (iStr2);
00857 }
00858 
00859 #define STR_SHIFT(TYPE) \
00860   inline csString &operator << (csString &s, TYPE v) { return s.Append (v); }
00861 
00869 STR_SHIFT(const csString&)
00870 STR_SHIFT(const char*)
00871 STR_SHIFT(char)
00872 STR_SHIFT(unsigned char)
00873 STR_SHIFT(short)
00874 STR_SHIFT(unsigned short)
00875 STR_SHIFT(int)
00876 STR_SHIFT(unsigned int)
00877 STR_SHIFT(long);
00878 STR_SHIFT(unsigned long)
00879 STR_SHIFT(float)
00880 STR_SHIFT(double)
00881 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00882 STR_SHIFT(bool)
00883 #endif
00884 #undef STR_SHIFT
00885 
00887 #endif // __CS_CSSTRING_H__

Generated for Crystal Space by doxygen 1.2.18