00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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 ©) : 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 <rim();
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__