git.maemo.org Git - physicsfs/blob - lzma/CPP/Common/MyString.h

   1 // Common/String.h
   2
   3 #ifndef __COMMON_STRING_H
   4 #define __COMMON_STRING_H
   5
   6 #include <string.h>
   7 // #include <wchar.h>
   8
   9 #include "MyVector.h"
  10
  11 #ifdef _WIN32
  12 #include "MyWindows.h"
  13 #endif
  14
  15 template <class T>
  16 inline int MyStringLen(const T *s)
  17 {
  18   int i;
  19   for (i = 0; s[i] != '\0'; i++);
  20   return i;
  21 }
  22
  23 template <class T>
  24 inline T * MyStringCopy(T *dest, const T *src)
  25 {
  26   T *destStart = dest;
  27   while((*dest++ = *src++) != 0);
  28   return destStart;
  29 }
  30
  31 inline wchar_t* MyStringGetNextCharPointer(wchar_t *p)
  32   { return (p + 1); }
  33 inline const wchar_t* MyStringGetNextCharPointer(const wchar_t *p)
  34   { return (p + 1); }
  35 inline wchar_t* MyStringGetPrevCharPointer(const wchar_t *, wchar_t *p)
  36   { return (p - 1); }
  37 inline const wchar_t* MyStringGetPrevCharPointer(const wchar_t *, const wchar_t *p)
  38   { return (p - 1); }
  39
  40 #ifdef _WIN32
  41
  42 inline char* MyStringGetNextCharPointer(char *p)
  43   { return CharNextA(p); }
  44 inline const char* MyStringGetNextCharPointer(const char *p)
  45   { return CharNextA(p); }
  46
  47 inline char* MyStringGetPrevCharPointer(char *base, char *p)
  48   { return CharPrevA(base, p); }
  49 inline const char* MyStringGetPrevCharPointer(const char *base, const char *p)
  50   { return CharPrevA(base, p); }
  51
  52 inline char MyCharUpper(char c)
  53   { return (char)(unsigned int)(UINT_PTR)CharUpperA((LPSTR)(UINT_PTR)(unsigned int)(unsigned char)c); }
  54 #ifdef _UNICODE
  55 inline wchar_t MyCharUpper(wchar_t c)
  56   { return (wchar_t)(unsigned int)(UINT_PTR)CharUpperW((LPWSTR)(UINT_PTR)(unsigned int)c); }
  57 #else
  58 wchar_t MyCharUpper(wchar_t c);
  59 #endif
  60
  61 inline char MyCharLower(char c)
  62   { return (char)(unsigned int)(UINT_PTR)CharLowerA((LPSTR)(UINT_PTR)(unsigned int)(unsigned char)c); }
  63 #ifdef _UNICODE
  64 inline wchar_t MyCharLower(wchar_t c)
  65   { return (wchar_t)(unsigned int)(UINT_PTR)CharLowerW((LPWSTR)(UINT_PTR)(unsigned int)c); }
  66 #else
  67 wchar_t MyCharLower(wchar_t c);
  68 #endif
  69
  70 inline char * MyStringUpper(char *s) { return CharUpperA(s); }
  71 #ifdef _UNICODE
  72 inline wchar_t * MyStringUpper(wchar_t *s) { return CharUpperW(s); }
  73 #else
  74 wchar_t * MyStringUpper(wchar_t *s);
  75 #endif
  76
  77 inline char * MyStringLower(char *s) { return CharLowerA(s); }
  78 #ifdef _UNICODE
  79 inline wchar_t * MyStringLower(wchar_t *s) { return CharLowerW(s); }
  80 #else
  81 wchar_t * MyStringLower(wchar_t *s);
  82 #endif
  83
  84 #else // Standard-C
  85 wchar_t MyCharUpper(wchar_t c);
  86 #endif
  87
  88 //////////////////////////////////////
  89 // Compare
  90
  91 /*
  92 #ifndef _WIN32_WCE
  93 int MyStringCollate(const char *s1, const char *s2);
  94 int MyStringCollateNoCase(const char *s1, const char *s2);
  95 #endif
  96 int MyStringCollate(const wchar_t *s1, const wchar_t *s2);
  97 int MyStringCollateNoCase(const wchar_t *s1, const wchar_t *s2);
  98 */
  99
 100 int MyStringCompare(const char *s1, const char  *s2);
 101 int MyStringCompare(const wchar_t *s1, const wchar_t *s2);
 102
 103 #ifdef _WIN32
 104 int MyStringCompareNoCase(const char *s1, const char  *s2);
 105 #endif
 106
 107 int MyStringCompareNoCase(const wchar_t *s1, const wchar_t *s2);
 108
 109 template <class T>
 110 class CStringBase
 111 {
 112   void TrimLeftWithCharSet(const CStringBase &charSet)
 113   {
 114     const T *p = _chars;
 115     while (charSet.Find(*p) >= 0 && (*p != 0))
 116       p = GetNextCharPointer(p);
 117     Delete(0, (int)(p - _chars));
 118   }
 119   void TrimRightWithCharSet(const CStringBase &charSet)
 120   {
 121     const T *p = _chars;
 122     const T *pLast = NULL;
 123     while (*p != 0)
 124     {
 125       if (charSet.Find(*p) >= 0)
 126       {
 127         if (pLast == NULL)
 128           pLast = p;
 129       }
 130       else
 131         pLast = NULL;
 132       p = GetNextCharPointer(p);
 133     }
 134     if(pLast != NULL)
 135     {
 136       int i = (int)(pLast - _chars);
 137       Delete(i, _length - i);
 138     }
 139
 140   }
 141   void MoveItems(int destIndex, int srcIndex)
 142   {
 143     memmove(_chars + destIndex, _chars + srcIndex,
 144         sizeof(T) * (_length - srcIndex + 1));
 145   }
 146
 147   void InsertSpace(int &index, int size)
 148   {
 149     CorrectIndex(index);
 150     GrowLength(size);
 151     MoveItems(index + size, index);
 152   }
 153
 154   static T *GetNextCharPointer(T *p)
 155     { return MyStringGetNextCharPointer(p); }
 156   static const T *GetNextCharPointer(const T *p)
 157     { return MyStringGetNextCharPointer(p); }
 158   static T *GetPrevCharPointer(T *base, T *p)
 159     { return MyStringGetPrevCharPointer(base, p); }
 160   static const T *GetPrevCharPointer(const T *base, const T *p)
 161     { return MyStringGetPrevCharPointer(base, p); }
 162 protected:
 163   T *_chars;
 164   int _length;
 165   int _capacity;
 166
 167   void SetCapacity(int newCapacity)
 168   {
 169     int realCapacity = newCapacity + 1;
 170     if(realCapacity == _capacity)
 171       return;
 172     /*
 173     const int kMaxStringSize = 0x20000000;
 174     #ifndef _WIN32_WCE
 175     if(newCapacity > kMaxStringSize || newCapacity < _length)
 176       throw 1052337;
 177     #endif
 178     */
 179     T *newBuffer = new T[realCapacity];
 180     if(_capacity > 0)
 181     {
 182       for (int i = 0; i < (_length + 1); i++)
 183         newBuffer[i] = _chars[i];
 184       delete []_chars;
 185       _chars = newBuffer;
 186     }
 187     else
 188     {
 189       _chars = newBuffer;
 190       _chars[0] = 0;
 191     }
 192     _capacity = realCapacity;
 193   }
 194
 195   void GrowLength(int n)
 196   {
 197     int freeSize = _capacity - _length - 1;
 198     if (n <= freeSize)
 199       return;
 200     int delta;
 201     if (_capacity > 64)
 202       delta = _capacity / 2;
 203     else if (_capacity > 8)
 204       delta = 16;
 205     else
 206       delta = 4;
 207     if (freeSize + delta < n)
 208       delta = n - freeSize;
 209     SetCapacity(_capacity + delta);
 210   }
 211
 212   void CorrectIndex(int &index) const
 213   {
 214     if (index > _length)
 215       index = _length;
 216   }
 217
 218 public:
 219   CStringBase(): _chars(0), _length(0), _capacity(0)
 220     { SetCapacity(16 - 1); }
 221   CStringBase(T c):  _chars(0), _length(0), _capacity(0)
 222   {
 223     SetCapacity(1);
 224     _chars[0] = c;
 225     _chars[1] = 0;
 226     _length = 1;
 227   }
 228   CStringBase(const T *chars): _chars(0), _length(0), _capacity(0)
 229   {
 230     int length = MyStringLen(chars);
 231     SetCapacity(length);
 232     MyStringCopy(_chars, chars); // can be optimized by memove()
 233     _length = length;
 234   }
 235   CStringBase(const CStringBase &s):  _chars(0), _length(0), _capacity(0)
 236   {
 237     SetCapacity(s._length);
 238     MyStringCopy(_chars, s._chars);
 239     _length = s._length;
 240   }
 241   ~CStringBase() {  delete []_chars; }
 242
 243   operator const T*() const { return _chars;}
 244
 245   // The minimum size of the character buffer in characters.
 246   // This value does not include space for a null terminator.
 247   T* GetBuffer(int minBufLength)
 248   {
 249     if(minBufLength >= _capacity)
 250       SetCapacity(minBufLength + 1);
 251     return _chars;
 252   }
 253   void ReleaseBuffer() { ReleaseBuffer(MyStringLen(_chars)); }
 254   void ReleaseBuffer(int newLength)
 255   {
 256     /*
 257     #ifndef _WIN32_WCE
 258     if(newLength >= _capacity)
 259       throw 282217;
 260     #endif
 261     */
 262     _chars[newLength] = 0;
 263     _length = newLength;
 264   }
 265
 266   CStringBase& operator=(T c)
 267   {
 268     Empty();
 269     SetCapacity(1);
 270     _chars[0] = c;
 271     _chars[1] = 0;
 272     _length = 1;
 273     return *this;
 274   }
 275   CStringBase& operator=(const T *chars)
 276   {
 277     Empty();
 278     int length = MyStringLen(chars);
 279     SetCapacity(length);
 280     MyStringCopy(_chars, chars);
 281     _length = length;
 282     return *this;
 283   }
 284   CStringBase& operator=(const CStringBase& s)
 285   {
 286     if(&s == this)
 287       return *this;
 288     Empty();
 289     SetCapacity(s._length);
 290     MyStringCopy(_chars, s._chars);
 291     _length = s._length;
 292     return *this;
 293   }
 294
 295   CStringBase& operator+=(T c)
 296   {
 297     GrowLength(1);
 298     _chars[_length] = c;
 299     _chars[++_length] = 0;
 300     return *this;
 301   }
 302   CStringBase& operator+=(const T *s)
 303   {
 304     int len = MyStringLen(s);
 305     GrowLength(len);
 306     MyStringCopy(_chars + _length, s);
 307     _length += len;
 308     return *this;
 309   }
 310   CStringBase& operator+=(const CStringBase &s)
 311   {
 312     GrowLength(s._length);
 313     MyStringCopy(_chars + _length, s._chars);
 314     _length += s._length;
 315     return *this;
 316   }
 317   void Empty()
 318   {
 319     _length = 0;
 320     _chars[0] = 0;
 321   }
 322   int Length() const { return _length; }
 323   bool IsEmpty() const { return (_length == 0); }
 324
 325   CStringBase Mid(int startIndex) const
 326     { return Mid(startIndex, _length - startIndex); }
 327   CStringBase Mid(int startIndex, int count ) const
 328   {
 329     if (startIndex + count > _length)
 330       count = _length - startIndex;
 331
 332     if (startIndex == 0 && startIndex + count == _length)
 333       return *this;
 334
 335     CStringBase<T> result;
 336     result.SetCapacity(count);
 337     // MyStringNCopy(result._chars, _chars + startIndex, count);
 338     for (int i = 0; i < count; i++)
 339       result._chars[i] = _chars[startIndex + i];
 340     result._chars[count] = 0;
 341     result._length = count;
 342     return result;
 343   }
 344   CStringBase Left(int count) const
 345     { return Mid(0, count); }
 346   CStringBase Right(int count) const
 347   {
 348     if (count > _length)
 349       count = _length;
 350     return Mid(_length - count, count);
 351   }
 352
 353   void MakeUpper()
 354     { MyStringUpper(_chars); }
 355   void MakeLower()
 356     { MyStringLower(_chars); }
 357
 358   int Compare(const CStringBase& s) const
 359     { return MyStringCompare(_chars, s._chars); }
 360
 361   int Compare(const T *s) const
 362     { return MyStringCompare(_chars, s); }
 363
 364   int CompareNoCase(const CStringBase& s) const
 365     { return MyStringCompareNoCase(_chars, s._chars); }
 366
 367   int CompareNoCase(const T *s) const
 368     { return MyStringCompareNoCase(_chars, s); }
 369
 370   /*
 371   int Collate(const CStringBase& s) const
 372     { return MyStringCollate(_chars, s._chars); }
 373   int CollateNoCase(const CStringBase& s) const
 374     { return MyStringCollateNoCase(_chars, s._chars); }
 375   */
 376
 377   int Find(T c) const { return Find(c, 0); }
 378   int Find(T c, int startIndex) const
 379   {
 380     T *p = _chars + startIndex;
 381     for (;;)
 382     {
 383       if (*p == c)
 384         return (int)(p - _chars);
 385       if (*p == 0)
 386         return -1;
 387       p = GetNextCharPointer(p);
 388     }
 389   }
 390   int Find(const CStringBase &s) const { return Find(s, 0); }
 391   int Find(const CStringBase &s, int startIndex) const
 392   {
 393     if (s.IsEmpty())
 394       return startIndex;
 395     for (; startIndex < _length; startIndex++)
 396     {
 397       int j;
 398       for (j = 0; j < s._length && startIndex + j < _length; j++)
 399         if (_chars[startIndex+j] != s._chars[j])
 400           break;
 401       if (j == s._length)
 402         return startIndex;
 403     }
 404     return -1;
 405   }
 406   int ReverseFind(T c) const
 407   {
 408     if (_length == 0)
 409       return -1;
 410     T *p = _chars + _length - 1;
 411     for (;;)
 412     {
 413       if (*p == c)
 414         return (int)(p - _chars);
 415       if (p == _chars)
 416         return -1;
 417       p = GetPrevCharPointer(_chars, p);
 418     }
 419   }
 420   int FindOneOf(const CStringBase &s) const
 421   {
 422     for(int i = 0; i < _length; i++)
 423       if (s.Find(_chars[i]) >= 0)
 424         return i;
 425       return -1;
 426   }
 427
 428   void TrimLeft(T c)
 429   {
 430     const T *p = _chars;
 431     while (c == *p)
 432       p = GetNextCharPointer(p);
 433     Delete(0, p - _chars);
 434   }
 435   private:
 436   CStringBase GetTrimDefaultCharSet()
 437   {
 438     CStringBase<T> charSet;
 439     charSet += (T)' ';
 440     charSet += (T)'\n';
 441     charSet += (T)'\t';
 442     return charSet;
 443   }
 444   public:
 445
 446   void TrimLeft()
 447   {
 448     TrimLeftWithCharSet(GetTrimDefaultCharSet());
 449   }
 450   void TrimRight()
 451   {
 452     TrimRightWithCharSet(GetTrimDefaultCharSet());
 453   }
 454   void TrimRight(T c)
 455   {
 456     const T *p = _chars;
 457     const T *pLast = NULL;
 458     while (*p != 0)
 459     {
 460       if (*p == c)
 461       {
 462         if (pLast == NULL)
 463           pLast = p;
 464       }
 465       else
 466         pLast = NULL;
 467       p = GetNextCharPointer(p);
 468     }
 469     if(pLast != NULL)
 470     {
 471       int i = pLast - _chars;
 472       Delete(i, _length - i);
 473     }
 474   }
 475   void Trim()
 476   {
 477     TrimRight();
 478     TrimLeft();
 479   }
 480
 481   int Insert(int index, T c)
 482   {
 483     InsertSpace(index, 1);
 484     _chars[index] = c;
 485     _length++;
 486     return _length;
 487   }
 488   int Insert(int index, const CStringBase &s)
 489   {
 490     CorrectIndex(index);
 491     if (s.IsEmpty())
 492       return _length;
 493     int numInsertChars = s.Length();
 494     InsertSpace(index, numInsertChars);
 495     for(int i = 0; i < numInsertChars; i++)
 496       _chars[index + i] = s[i];
 497     _length += numInsertChars;
 498     return _length;
 499   }
 500
 501   // !!!!!!!!!!!!!!! test it if newChar = '\0'
 502   int Replace(T oldChar, T newChar)
 503   {
 504     if (oldChar == newChar)
 505       return 0;
 506     int number  = 0;
 507     int pos  = 0;
 508     while (pos < Length())
 509     {
 510       pos = Find(oldChar, pos);
 511       if (pos < 0)
 512         break;
 513       _chars[pos] = newChar;
 514       pos++;
 515       number++;
 516     }
 517     return number;
 518   }
 519   int Replace(const CStringBase &oldString, const CStringBase &newString)
 520   {
 521     if (oldString.IsEmpty())
 522       return 0;
 523     if (oldString == newString)
 524       return 0;
 525     int oldStringLength = oldString.Length();
 526     int newStringLength = newString.Length();
 527     int number  = 0;
 528     int pos  = 0;
 529     while (pos < _length)
 530     {
 531       pos = Find(oldString, pos);
 532       if (pos < 0)
 533         break;
 534       Delete(pos, oldStringLength);
 535       Insert(pos, newString);
 536       pos += newStringLength;
 537       number++;
 538     }
 539     return number;
 540   }
 541   int Delete(int index, int count = 1 )
 542   {
 543     if (index + count > _length)
 544       count = _length - index;
 545     if (count > 0)
 546     {
 547       MoveItems(index, index + count);
 548       _length -= count;
 549     }
 550     return _length;
 551   }
 552 };
 553
 554 template <class T>
 555 CStringBase<T> operator+(const CStringBase<T>& s1, const CStringBase<T>& s2)
 556 {
 557   CStringBase<T> result(s1);
 558   result += s2;
 559   return result;
 560 }
 561
 562 template <class T>
 563 CStringBase<T> operator+(const CStringBase<T>& s, T c)
 564 {
 565   CStringBase<T> result(s);
 566   result += c;
 567   return result;
 568 }
 569
 570 template <class T>
 571 CStringBase<T> operator+(T c, const CStringBase<T>& s)
 572 {
 573   CStringBase<T> result(c);
 574   result += s;
 575   return result;
 576 }
 577
 578 template <class T>
 579 CStringBase<T> operator+(const CStringBase<T>& s, const T * chars)
 580 {
 581   CStringBase<T> result(s);
 582   result += chars;
 583   return result;
 584 }
 585
 586 template <class T>
 587 CStringBase<T> operator+(const T * chars, const CStringBase<T>& s)
 588 {
 589   CStringBase<T> result(chars);
 590   result += s;
 591   return result;
 592 }
 593
 594 template <class T>
 595 bool operator==(const CStringBase<T>& s1, const CStringBase<T>& s2)
 596   { return (s1.Compare(s2) == 0); }
 597
 598 template <class T>
 599 bool operator<(const CStringBase<T>& s1, const CStringBase<T>& s2)
 600   { return (s1.Compare(s2) < 0); }
 601
 602 template <class T>
 603 bool operator==(const T *s1, const CStringBase<T>& s2)
 604   { return (s2.Compare(s1) == 0); }
 605
 606 template <class T>
 607 bool operator==(const CStringBase<T>& s1, const T *s2)
 608   { return (s1.Compare(s2) == 0); }
 609
 610 template <class T>
 611 bool operator!=(const CStringBase<T>& s1, const CStringBase<T>& s2)
 612   { return (s1.Compare(s2) != 0); }
 613
 614 template <class T>
 615 bool operator!=(const T *s1, const CStringBase<T>& s2)
 616   { return (s2.Compare(s1) != 0); }
 617
 618 template <class T>
 619 bool operator!=(const CStringBase<T>& s1, const T *s2)
 620   { return (s1.Compare(s2) != 0); }
 621
 622 typedef CStringBase<char> AString;
 623 typedef CStringBase<wchar_t> UString;
 624
 625 typedef CObjectVector<AString> AStringVector;
 626 typedef CObjectVector<UString> UStringVector;
 627
 628 #ifdef _UNICODE
 629   typedef UString CSysString;
 630 #else
 631   typedef AString CSysString;
 632 #endif
 633
 634 typedef CObjectVector<CSysString> CSysStringVector;
 635
 636 #endif