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