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
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
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
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
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
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
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__