00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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
00034
00035 enum { DEFAULT_GROW_BY = 64 };
00036
00037
00038 char *Data;
00039
00040 size_t Size;
00041
00042 size_t MaxSize;
00043
00044 size_t GrowBy;
00045
00046 bool GrowExponentially;
00047
00048
00049
00050
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
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
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
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
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
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__