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