Main Page   Class Hierarchy   Compound List   File List   Compound 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 
00020 #ifndef __CS_CSSTRING_H__
00021 #define __CS_CSSTRING_H__
00022 
00023 #include <stdarg.h>
00024 
00025 #define STR_FATAL(s) \
00026 { \
00027   printf s; \
00028   abort (); \
00029 }
00030 
00035 class csString
00036 {
00037   char *Data;
00038   size_t Size, MaxSize;
00039 
00040 public:
00042   void SetCapacity (size_t NewSize);
00043 
00045   void Free ()
00046   {
00047     if (Data)
00048     {
00049       free (Data);
00050       Data = NULL;
00051       Size = MaxSize = 0;
00052     }
00053   }
00054 
00056   csString &Truncate (size_t iPos);
00057 
00059   csString &Reclaim ()
00060   { SetCapacity (Size); return *this; }
00061 
00063   csString& Clear ()
00064   { return Truncate (0); }
00065 
00067   char *GetData () const
00068   { return Data; }
00069 
00071   size_t Length () const
00072   { return Size; }
00073 
00075   bool IsEmpty () const
00076   { return !Size; }
00077 
00079   inline char &operator [] (size_t iPos)
00080   {
00081 #ifdef CS_DEBUG
00082     if (iPos > Size)
00083       STR_FATAL(("Trying to access string `%s' at position %lu\n",
00084         Data, (unsigned long)iPos))
00085 #endif
00086     return Data [iPos];
00087   }
00088 
00090   void SetAt (size_t iPos, const char iChar)
00091   {
00092 #ifdef CS_DEBUG
00093     if (iPos > Size)
00094       STR_FATAL (("Trying to do `%s'.SetAt (%lu)\n",
00095         Data, (unsigned long)iPos))
00096 #endif
00097     Data [iPos] = iChar;
00098   }
00099 
00101   char GetAt (size_t iPos) const
00102   {
00103 #ifdef CS_DEBUG
00104     if (iPos > Size)
00105       STR_FATAL (("Trying to do `%s'.GetAt (%lu)\n",
00106         Data, (unsigned long)iPos));
00107 #endif
00108     return Data [iPos];
00109   }
00110 
00112   csString &DeleteAt (size_t iPos, size_t iCount = 1);
00113 
00115   csString &Insert (size_t iPos, const csString &iStr);
00116 
00118   csString &Insert (size_t iPos, const char iChar);
00119 
00121   csString &Overwrite (size_t iPos, const csString &iStr);
00122 
00125   csString &Append (const char *iStr, size_t iCount = (size_t)-1);
00126 
00128   csString &Append (const csString &iStr, size_t iCount = (size_t)-1);
00129 
00131   csString &Append (char c){ char s[2]; s[0] = c; s[1] = 0; return Append(s); }
00132   csString &Append (unsigned char c){ return Append(char(c)); }
00133 
00134 #define STR_APPEND(TYPE,FMT,SZ) csString &Append(TYPE n) \
00135   { char s[SZ]; sprintf(s, #FMT, n); return Append(s); }
00136   STR_APPEND(short, %hd, 32)
00137   STR_APPEND(unsigned short, %hu, 32)
00138   STR_APPEND(int, %d, 32)
00139   STR_APPEND(unsigned int, %u, 32)
00140   STR_APPEND(long, %ld, 32)
00141   STR_APPEND(unsigned long, %lu, 32)
00142   STR_APPEND(float, %g, 64)
00143   STR_APPEND(double, %g, 64)
00144 #undef STR_APPEND
00145 
00146 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00147 
00148   csString &Append (bool b) { return Append (b ? "1" : "0"); }
00149 #endif
00150 
00152   csString &Replace (const csString &iStr, size_t iCount = (size_t)-1)
00153   {
00154     Size = 0;
00155     return Append (iStr, iCount);
00156   }
00157 
00159   bool Compare (const csString &iStr) const
00160   {
00161     if (Size != iStr.Length ())
00162       return false;
00163 
00164     return (memcmp (Data, iStr.GetData (), Size) == 0);
00165   }
00166 
00168   bool Compare (const char *iStr) const
00169   { return (strcmp (Data, iStr) == 0); }
00170 
00172   bool CompareNoCase (const csString &iStr) const
00173   {
00174     if (Size != iStr.Length ())
00175       return false;
00176     return (strncasecmp (Data, iStr.GetData (), Size) == 0);
00177   }
00178 
00180   bool CompareNoCase (const char *iStr) const
00181   { return (strncasecmp (Data, iStr, Size) == 0); }
00182 
00184   csString () : Data (NULL), Size (0), MaxSize (0) {}
00185 
00187   csString (size_t iLength) : Data (NULL), Size (0), MaxSize (0)
00188   { SetCapacity (iLength); }
00189 
00191   csString (const csString &copy) : Data (NULL), Size (0), MaxSize (0)
00192   { Append (copy); }
00193 
00195   csString (const char *copy) : Data (NULL), Size (0), MaxSize (0)
00196   { Append (copy); }
00197 
00199   csString (char c) : Data (NULL), Size (0), MaxSize (0)
00200   { Append (c); }
00201 
00203   virtual ~csString ();
00204 
00206   csString Clone () const
00207   { return csString (*this); }
00208 
00210   csString &LTrim();
00211 
00213   csString &RTrim();
00214 
00216   csString &Trim();
00217 
00219   csString &Collapse();
00220 
00221   csString &Format(const char *format, ...);
00222 
00223 #define STR_FORMAT(TYPE,FMT,SZ) \
00224   static csString Format (TYPE v);
00225   STR_FORMAT(short, %hd, 32)
00226   STR_FORMAT(unsigned short, %hu, 32)
00227   STR_FORMAT(int, %d, 32)
00228   STR_FORMAT(unsigned int, %u, 32)
00229   STR_FORMAT(long, %ld, 32)
00230   STR_FORMAT(unsigned long, %lu, 32)
00231   STR_FORMAT(float, %g, 64)
00232   STR_FORMAT(double, %g, 64)
00233 #undef STR_FORMAT
00234 
00235 #define STR_FORMAT_INT(TYPE,FMT) \
00236  static csString Format (TYPE v, int width, int prec=0);
00237   STR_FORMAT_INT(short, hd)
00238   STR_FORMAT_INT(unsigned short, hu)
00239   STR_FORMAT_INT(int, d)
00240   STR_FORMAT_INT(unsigned int, u)
00241   STR_FORMAT_INT(long, ld)
00242   STR_FORMAT_INT(unsigned long, lu)
00243 #undef STR_FORMAT_INT
00244 
00245 #define STR_FORMAT_FLOAT(TYPE) \
00246   static csString Format (TYPE v, int width, int prec=6);
00247   STR_FORMAT_FLOAT(float)
00248   STR_FORMAT_FLOAT(double)
00249 #undef STR_FORMAT_FLOAT
00250 
00252   csString& PadLeft (size_t iNewSize, char iChar=' ');
00253 
00255   csString AsPadLeft (size_t iNewSize, char iChar=' ');
00256 
00258 #define STR_PADLEFT(TYPE) \
00259   static csString PadLeft (TYPE v, size_t iNewSize, char iChar=' ');
00260   STR_PADLEFT(const csString&)
00261   STR_PADLEFT(const char*)
00262   STR_PADLEFT(char)
00263   STR_PADLEFT(unsigned char)
00264   STR_PADLEFT(short)
00265   STR_PADLEFT(unsigned short)
00266   STR_PADLEFT(int)
00267   STR_PADLEFT(unsigned int)
00268   STR_PADLEFT(long)
00269   STR_PADLEFT(unsigned long)
00270   STR_PADLEFT(float)
00271   STR_PADLEFT(double)
00272 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00273   STR_PADLEFT(bool)
00274 #endif
00275 #undef STR_PADLEFT
00276 
00278   csString& PadRight (size_t iNewSize, char iChar=' ');
00279 
00281   csString AsPadRight (size_t iNewSize, char iChar=' ');
00282 
00284 #define STR_PADRIGHT(TYPE) \
00285   static csString PadRight (TYPE v, size_t iNewSize, char iChar=' ');
00286   STR_PADRIGHT(const csString&)
00287   STR_PADRIGHT(const char*)
00288   STR_PADRIGHT(char)
00289   STR_PADRIGHT(unsigned char)
00290   STR_PADRIGHT(short)
00291   STR_PADRIGHT(unsigned short)
00292   STR_PADRIGHT(int)
00293   STR_PADRIGHT(unsigned int)
00294   STR_PADRIGHT(long)
00295   STR_PADRIGHT(unsigned long)
00296   STR_PADRIGHT(float)
00297   STR_PADRIGHT(double)
00298 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00299   STR_PADRIGHT(bool)
00300 #endif
00301 #undef STR_PADRIGHT
00302 
00304   csString& PadCenter (size_t iNewSize, char iChar=' ');
00305 
00307   csString AsPadCenter (size_t iNewSize, char iChar=' ');
00308 
00310 #define STR_PADCENTER(TYPE) \
00311   static csString PadCenter (TYPE v, size_t iNewSize, char iChar=' ');
00312   STR_PADCENTER(const csString&)
00313   STR_PADCENTER(const char*)
00314   STR_PADCENTER(char)
00315   STR_PADCENTER(unsigned char)
00316   STR_PADCENTER(short)
00317   STR_PADCENTER(unsigned short)
00318   STR_PADCENTER(int)
00319   STR_PADCENTER(unsigned int)
00320   STR_PADCENTER(long)
00321   STR_PADCENTER(unsigned long)
00322   STR_PADCENTER(float)
00323   STR_PADCENTER(double)
00324 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00325   STR_PADCENTER(bool)
00326 #endif
00327 #undef STR_PADCENTER
00328 
00330   csString &operator = (const csString &iStr)
00331   { return Replace (iStr); }
00332 
00333 #define STR_APPEND(TYPE) csString &operator += (TYPE s) { return Append (s); }
00334   STR_APPEND(const csString&)
00335   STR_APPEND(const char*)
00336   STR_APPEND(char)
00337   STR_APPEND(unsigned char)
00338   STR_APPEND(short)
00339   STR_APPEND(unsigned short)
00340   STR_APPEND(int)
00341   STR_APPEND(unsigned int)
00342   STR_APPEND(long);
00343   STR_APPEND(unsigned long)
00344   STR_APPEND(float)
00345   STR_APPEND(double)
00346 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00347   STR_APPEND(bool)
00348 #endif
00349 #undef STR_APPEND
00350 
00352   csString operator + (const csString &iStr) const
00353   { return Clone ().Append (iStr); }
00354 
00356   operator const char * () const
00357   { return Data ? Data : ""; }
00358 
00360   bool operator == (const csString &iStr) const
00361   { return Compare (iStr); }
00362 
00364   char *Detach ()
00365   { char *d = Data; Data = NULL; Size = MaxSize = 0; return d; }
00366 };
00367 
00369 inline csString operator + (const char* iStr1, const csString &iStr2)
00370 {
00371   return csString (iStr1).Append (iStr2);
00372 }
00373 
00375 inline csString operator + (const csString &iStr1, const char* iStr2)
00376 {
00377   return iStr1.Clone ().Append (iStr2);
00378 }
00379 
00381 #define STR_SHIFT(TYPE) \
00382   inline csString &operator << (csString &s, TYPE v) { return s.Append (v); }
00383 STR_SHIFT(const csString&)
00384 STR_SHIFT(const char*)
00385 STR_SHIFT(char)
00386 STR_SHIFT(unsigned char)
00387 STR_SHIFT(short)
00388 STR_SHIFT(unsigned short)
00389 STR_SHIFT(int)
00390 STR_SHIFT(unsigned int)
00391 STR_SHIFT(long);
00392 STR_SHIFT(unsigned long)
00393 STR_SHIFT(float)
00394 STR_SHIFT(double)
00395 #if !defined(CS_USE_FAKE_BOOL_TYPE)
00396 STR_SHIFT(bool)
00397 #endif
00398 #undef STR_SHIFT
00399 
00400 #endif // __CS_CSSTRING_H__

Generated for Crystal Space by doxygen 1.2.5 written by Dimitri van Heesch, ©1997-2000