|
csstring.h00001 /* 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 "csutil/snprintf.h" 00024 00029 class csString 00030 { 00031 protected: 00033 char *Data; 00035 size_t Size; 00037 size_t MaxSize; 00038 00039 public: 00045 void SetCapacity (size_t NewSize); 00046 00048 void Free (); 00049 00051 csString &Truncate (size_t iLen); 00052 00054 csString &Reclaim (); 00055 00057 csString& Clear () 00058 { return Truncate (0); } 00059 00064 char* GetData () const 00065 { return Data; } 00066 00068 size_t Length () const 00069 { return Size; } 00070 00072 bool IsEmpty () const 00073 { return (Size == 0); } 00074 00076 char& operator [] (size_t n) 00077 { 00078 CS_ASSERT (n < Size); 00079 return Data [n]; 00080 } 00081 00083 char operator [] (size_t n) const 00084 { 00085 CS_ASSERT (n < Size); 00086 return Data[n]; 00087 } 00088 00093 void SetAt (size_t n, const char c) 00094 { 00095 CS_ASSERT (n < Size); 00096 Data [n] = c; 00097 } 00098 00100 char GetAt (size_t n) const 00101 { 00102 CS_ASSERT (n < Size); 00103 return Data [n]; 00104 } 00105 00107 csString& DeleteAt (size_t iPos, size_t iCount = 1); 00108 00110 csString& Insert (size_t iPos, const csString&); 00111 00113 csString& Insert (size_t iPos, const char); 00114 00116 csString& Overwrite (size_t iPos, const csString&); 00117 00123 csString& Append (const char*, size_t iCount = (size_t)-1); 00124 00129 csString& Append (const csString &iStr, size_t iCount = (size_t)-1); 00130 00132 csString& Append (char c) 00133 { char s[2]; s[0] = c; s[1] = '\0'; return Append(s); } 00135 csString &Append (unsigned char c) 00136 { return Append(char(c)); } 00137 00138 #define STR_APPEND(TYPE,FMT,SZ) csString& Append(TYPE n) \ 00139 { char s[SZ]; cs_snprintf(s, SZ, #FMT, n); return Append(s); } 00140 STR_APPEND(short, %hd, 32) 00141 STR_APPEND(unsigned short, %hu, 32) 00142 STR_APPEND(int, %d, 32) 00143 STR_APPEND(unsigned int, %u, 32) 00144 STR_APPEND(long, %ld, 32) 00145 STR_APPEND(unsigned long, %lu, 32) 00146 STR_APPEND(float, %g, 64) 00147 STR_APPEND(double, %g, 64) 00148 #undef STR_APPEND 00149 00150 #if !defined(CS_USE_FAKE_BOOL_TYPE) 00151 00152 csString& Append (bool b) { return Append (b ? "1" : "0"); } 00153 #endif 00154 00160 csString& Replace (const csString& iStr, size_t iCount = (size_t)-1) 00161 { 00162 Size = 0; 00163 return Append (iStr, iCount); 00164 } 00165 00171 csString& Replace (const char* iStr, size_t iCount = (size_t)-1) 00172 { 00173 Size = 0; 00174 return Append (iStr, iCount); 00175 } 00176 00177 #define STR_REPLACE(TYPE) csString& Replace (TYPE s) { Size = 0; return Append(s); } 00178 STR_REPLACE(char) 00179 STR_REPLACE(unsigned char) 00180 STR_REPLACE(short) 00181 STR_REPLACE(unsigned short) 00182 STR_REPLACE(int) 00183 STR_REPLACE(unsigned int) 00184 STR_REPLACE(long) 00185 STR_REPLACE(unsigned long) 00186 STR_REPLACE(float) 00187 STR_REPLACE(double) 00188 #ifndef CS_USE_FAKE_BOOL_TYPE 00189 STR_REPLACE(bool) 00190 #endif 00191 #undef STR_REPLACE 00192 00194 bool Compare (const csString& iStr) const 00195 { 00196 if (&iStr == this) 00197 return true; 00198 size_t const n = iStr.Length(); 00199 if (Size != n) 00200 return false; 00201 if (Size == 0 && n == 0) 00202 return true; 00203 return (memcmp (Data, iStr.GetData (), Size) == 0); 00204 } 00205 00207 bool Compare (const char* iStr) const 00208 { return (strcmp (Data ? Data : "", iStr) == 0); } 00209 00211 bool CompareNoCase (const csString& iStr) const 00212 { 00213 if (&iStr == this) 00214 return true; 00215 size_t const n = iStr.Length(); 00216 if (Size != n) 00217 return false; 00218 if (Size == 0 && n == 0) 00219 return true; 00220 return (strncasecmp (Data, iStr.GetData (), Size) == 0); 00221 } 00222 00224 bool CompareNoCase (const char* iStr) const 00225 { return (strncasecmp (Data ? Data : "", iStr, Size) == 0); } 00226 00228 csString () : Data (NULL), Size (0), MaxSize (0) {} 00229 00231 csString (size_t iLength) : Data (NULL), Size (0), MaxSize (0) 00232 { SetCapacity (iLength); } 00233 00235 csString (const csString& copy) : Data (NULL), Size (0), MaxSize (0) 00236 { Append (copy); } 00237 00239 csString (const char* copy) : Data (NULL), Size (0), MaxSize (0) 00240 { Append (copy); } 00241 00243 csString (char c) : Data (NULL), Size (0), MaxSize (0) 00244 { Append (c); } 00245 00247 csString (unsigned char c) : Data(NULL), Size (0), MaxSize (0) 00248 { Append ((char) c); } 00249 00251 virtual ~csString (); 00252 00254 csString Clone () const 00255 { return csString (*this); } 00256 00258 csString& LTrim(); 00259 00261 csString& RTrim(); 00262 00264 csString& Trim(); 00265 00270 csString& Collapse(); 00271 00277 csString& Format(const char *format, ...) CS_GNUC_PRINTF (2, 3); 00278 00279 #define STR_FORMAT(TYPE,FMT,SZ) \ 00280 static csString Format (TYPE v); 00281 STR_FORMAT(short, %hd, 32) 00282 STR_FORMAT(unsigned short, %hu, 32) 00283 STR_FORMAT(int, %d, 32) 00284 STR_FORMAT(unsigned int, %u, 32) 00285 STR_FORMAT(long, %ld, 32) 00286 STR_FORMAT(unsigned long, %lu, 32) 00287 STR_FORMAT(float, %g, 64) 00288 STR_FORMAT(double, %g, 64) 00289 #undef STR_FORMAT 00290 00291 #define STR_FORMAT_INT(TYPE,FMT) \ 00292 static csString Format (TYPE v, int width, int prec=0); 00293 STR_FORMAT_INT(short, hd) 00294 STR_FORMAT_INT(unsigned short, hu) 00295 STR_FORMAT_INT(int, d) 00296 STR_FORMAT_INT(unsigned int, u) 00297 STR_FORMAT_INT(long, ld) 00298 STR_FORMAT_INT(unsigned long, lu) 00299 #undef STR_FORMAT_INT 00300 00301 #define STR_FORMAT_FLOAT(TYPE) \ 00302 static csString Format (TYPE v, int width, int prec=6); 00303 STR_FORMAT_FLOAT(float) 00304 STR_FORMAT_FLOAT(double) 00305 #undef STR_FORMAT_FLOAT 00306 00308 csString& PadLeft (size_t iNewSize, char iChar=' '); 00309 00311 csString AsPadLeft (size_t iNewSize, char iChar=' '); 00312 00313 // Return a new left-padded string representation of a basic type 00314 #define STR_PADLEFT(TYPE) \ 00315 static csString PadLeft (TYPE v, size_t iNewSize, char iChar=' '); 00316 STR_PADLEFT(const csString&) 00317 STR_PADLEFT(const char*) 00318 STR_PADLEFT(char) 00319 STR_PADLEFT(unsigned char) 00320 STR_PADLEFT(short) 00321 STR_PADLEFT(unsigned short) 00322 STR_PADLEFT(int) 00323 STR_PADLEFT(unsigned int) 00324 STR_PADLEFT(long) 00325 STR_PADLEFT(unsigned long) 00326 STR_PADLEFT(float) 00327 STR_PADLEFT(double) 00328 #if !defined(CS_USE_FAKE_BOOL_TYPE) 00329 STR_PADLEFT(bool) 00330 #endif 00331 #undef STR_PADLEFT 00332 00334 csString& PadRight (size_t iNewSize, char iChar=' '); 00335 00337 csString AsPadRight (size_t iNewSize, char iChar=' '); 00338 00339 // Return a new right-padded string representation of a basic type 00340 #define STR_PADRIGHT(TYPE) \ 00341 static csString PadRight (TYPE v, size_t iNewSize, char iChar=' '); 00342 STR_PADRIGHT(const csString&) 00343 STR_PADRIGHT(const char*) 00344 STR_PADRIGHT(char) 00345 STR_PADRIGHT(unsigned char) 00346 STR_PADRIGHT(short) 00347 STR_PADRIGHT(unsigned short) 00348 STR_PADRIGHT(int) 00349 STR_PADRIGHT(unsigned int) 00350 STR_PADRIGHT(long) 00351 STR_PADRIGHT(unsigned long) 00352 STR_PADRIGHT(float) 00353 STR_PADRIGHT(double) 00354 #if !defined(CS_USE_FAKE_BOOL_TYPE) 00355 STR_PADRIGHT(bool) 00356 #endif 00357 #undef STR_PADRIGHT 00358 00360 csString& PadCenter (size_t iNewSize, char iChar=' '); 00361 00363 csString AsPadCenter (size_t iNewSize, char iChar=' '); 00364 00365 // Return a new left+right padded string representation of a basic type 00366 #define STR_PADCENTER(TYPE) \ 00367 static csString PadCenter (TYPE v, size_t iNewSize, char iChar=' '); 00368 STR_PADCENTER(const csString&) 00369 STR_PADCENTER(const char*) 00370 STR_PADCENTER(char) 00371 STR_PADCENTER(unsigned char) 00372 STR_PADCENTER(short) 00373 STR_PADCENTER(unsigned short) 00374 STR_PADCENTER(int) 00375 STR_PADCENTER(unsigned int) 00376 STR_PADCENTER(long) 00377 STR_PADCENTER(unsigned long) 00378 STR_PADCENTER(float) 00379 STR_PADCENTER(double) 00380 #if !defined(CS_USE_FAKE_BOOL_TYPE) 00381 STR_PADCENTER(bool) 00382 #endif 00383 #undef STR_PADCENTER 00384 00386 #define STR_ASSIGN(TYPE) const csString& operator = (TYPE s) { return Replace (s); } 00387 STR_ASSIGN(const csString&) 00388 STR_ASSIGN(const char*) 00389 STR_ASSIGN(char) 00390 STR_ASSIGN(unsigned char) 00391 STR_ASSIGN(short) 00392 STR_ASSIGN(unsigned short) 00393 STR_ASSIGN(int) 00394 STR_ASSIGN(unsigned int) 00395 STR_ASSIGN(long) 00396 STR_ASSIGN(unsigned long) 00397 STR_ASSIGN(float) 00398 STR_ASSIGN(double) 00399 #ifndef CS_USE_FAKE_BOOL_TYPE 00400 STR_ASSIGN(bool) 00401 #endif 00402 #undef STR_ASSIGN 00403 00404 #define STR_APPEND(TYPE) csString &operator += (TYPE s) { return Append (s); } 00405 STR_APPEND(const csString&) 00406 STR_APPEND(const char*) 00407 STR_APPEND(char) 00408 STR_APPEND(unsigned char) 00409 STR_APPEND(short) 00410 STR_APPEND(unsigned short) 00411 STR_APPEND(int) 00412 STR_APPEND(unsigned int) 00413 STR_APPEND(long); 00414 STR_APPEND(unsigned long) 00415 STR_APPEND(float) 00416 STR_APPEND(double) 00417 #ifndef CS_USE_FAKE_BOOL_TYPE 00418 STR_APPEND(bool) 00419 #endif 00420 #undef STR_APPEND 00421 00423 const csString& operator + (const csString &iStr) const 00424 { return Clone ().Append (iStr); } 00425 00427 operator const char* () const 00428 { return Data; } 00429 00431 bool operator == (const csString& iStr) const 00432 { return Compare (iStr); } 00433 bool operator == (const char* iStr) const 00434 { return Compare (iStr); } 00435 00443 char* Detach () 00444 { char *d = Data; Data = 0; Size = 0; MaxSize = 0; return d; } 00445 }; 00446 00448 inline csString operator + (const char* iStr1, const csString &iStr2) 00449 { 00450 return csString (iStr1).Append (iStr2); 00451 } 00452 00454 inline csString operator + (const csString &iStr1, const char* iStr2) 00455 { 00456 return iStr1.Clone ().Append (iStr2); 00457 } 00458 00459 // Handy shift operators. 00460 #define STR_SHIFT(TYPE) \ 00461 inline csString &operator << (csString &s, TYPE v) { return s.Append (v); } 00462 STR_SHIFT(const csString&) 00463 STR_SHIFT(const char*) 00464 STR_SHIFT(char) 00465 STR_SHIFT(unsigned char) 00466 STR_SHIFT(short) 00467 STR_SHIFT(unsigned short) 00468 STR_SHIFT(int) 00469 STR_SHIFT(unsigned int) 00470 STR_SHIFT(long); 00471 STR_SHIFT(unsigned long) 00472 STR_SHIFT(float) 00473 STR_SHIFT(double) 00474 #if !defined(CS_USE_FAKE_BOOL_TYPE) 00475 STR_SHIFT(bool) 00476 #endif 00477 #undef STR_SHIFT 00478 00479 #endif // __CS_CSSTRING_H__ Generated for Crystal Space by doxygen 1.2.5 written by Dimitri van Heesch, ©1997-2000 |