Mercurial > vba-clojure

     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; i++)

   183         newBuffer[i] = _chars[i];

   184       delete []_chars;

   185     }

   186     _chars = newBuffer;

   187     _chars[_length] = 0;

   188     _capacity = realCapacity;

   189   }

   190 

   191   void GrowLength(int n)

   192   {

   193     int freeSize = _capacity - _length - 1;

   194     if (n <= freeSize)

   195       return;

   196     int delta;

   197     if (_capacity > 64)

   198       delta = _capacity / 2;

   199     else if (_capacity > 8)

   200       delta = 16;

   201     else

   202       delta = 4;

   203     if (freeSize + delta < n)

   204       delta = n - freeSize;

   205     SetCapacity(_capacity + delta);

   206   }

   207 

   208   void CorrectIndex(int &index) const

   209   {

   210     if (index > _length)

   211       index = _length;

   212   }

   213 

   214 public:

   215   CStringBase(): _chars(0), _length(0), _capacity(0) { SetCapacity(3); }

   216   CStringBase(T c):  _chars(0), _length(0), _capacity(0)

   217   {

   218     SetCapacity(1);

   219     _chars[0] = c;

   220     _chars[1] = 0;

   221     _length = 1;

   222   }

   223   CStringBase(const T *chars): _chars(0), _length(0), _capacity(0)

   224   {

   225     int length = MyStringLen(chars);

   226     SetCapacity(length);

   227     MyStringCopy(_chars, chars); // can be optimized by memove()

   228     _length = length;

   229   }

   230   CStringBase(const CStringBase &s):  _chars(0), _length(0), _capacity(0)

   231   {

   232     SetCapacity(s._length);

   233     MyStringCopy(_chars, s._chars);

   234     _length = s._length;

   235   }

   236   ~CStringBase() {  delete []_chars; }

   237 

   238   operator const T*() const { return _chars;}

   239 

   240   // The minimum size of the character buffer in characters.

   241   // This value does not include space for a null terminator.

   242   T* GetBuffer(int minBufLength)

   243   {

   244     if (minBufLength >= _capacity)

   245       SetCapacity(minBufLength);

   246     return _chars;

   247   }

   248   void ReleaseBuffer() { ReleaseBuffer(MyStringLen(_chars)); }

   249   void ReleaseBuffer(int newLength)

   250   {

   251     /*

   252     #ifndef _WIN32_WCE

   253     if (newLength >= _capacity)

   254       throw 282217;

   255     #endif

   256     */

   257     _chars[newLength] = 0;

   258     _length = newLength;

   259   }

   260 

   261   CStringBase& operator=(T c)

   262   {

   263     Empty();

   264     SetCapacity(1);

   265     _chars[0] = c;

   266     _chars[1] = 0;

   267     _length = 1;

   268     return *this;

   269   }

   270   CStringBase& operator=(const T *chars)

   271   {

   272     Empty();

   273     int length = MyStringLen(chars);

   274     SetCapacity(length);

   275     MyStringCopy(_chars, chars);

   276     _length = length;

   277     return *this;

   278   }

   279   CStringBase& operator=(const CStringBase& s)

   280   {

   281     if (&s == this)

   282       return *this;

   283     Empty();

   284     SetCapacity(s._length);

   285     MyStringCopy(_chars, s._chars);

   286     _length = s._length;

   287     return *this;

   288   }

   289   

   290   CStringBase& operator+=(T c)

   291   {

   292     GrowLength(1);

   293     _chars[_length] = c;

   294     _chars[++_length] = 0;

   295     return *this;

   296   }

   297   CStringBase& operator+=(const T *s)

   298   {

   299     int len = MyStringLen(s);

   300     GrowLength(len);

   301     MyStringCopy(_chars + _length, s);

   302     _length += len;

   303     return *this;

   304   }

   305   CStringBase& operator+=(const CStringBase &s)

   306   {

   307     GrowLength(s._length);

   308     MyStringCopy(_chars + _length, s._chars);

   309     _length += s._length;

   310     return *this;

   311   }

   312   void Empty()

   313   {

   314     _length = 0;

   315     _chars[0] = 0;

   316   }

   317   int Length() const { return _length; }

   318   bool IsEmpty() const { return (_length == 0); }

   319 

   320   CStringBase Mid(int startIndex) const

   321     { return Mid(startIndex, _length - startIndex); }

   322   CStringBase Mid(int startIndex, int count ) const

   323   {

   324     if (startIndex + count > _length)

   325       count = _length - startIndex;

   326     

   327     if (startIndex == 0 && startIndex + count == _length)

   328       return *this;

   329     

   330     CStringBase<T> result;

   331     result.SetCapacity(count);

   332     // MyStringNCopy(result._chars, _chars + startIndex, count);

   333     for (int i = 0; i < count; i++)

   334       result._chars[i] = _chars[startIndex + i];

   335     result._chars[count] = 0;

   336     result._length = count;

   337     return result;

   338   }

   339   CStringBase Left(int count) const

   340     { return Mid(0, count); }

   341   CStringBase Right(int count) const

   342   {

   343     if (count > _length)

   344       count = _length;

   345     return Mid(_length - count, count);

   346   }

   347 

   348   void MakeUpper()

   349     { MyStringUpper(_chars); }

   350   void MakeLower()

   351     { MyStringLower(_chars); }

   352 

   353   int Compare(const CStringBase& s) const

   354     { return MyStringCompare(_chars, s._chars); }

   355 

   356   int Compare(const T *s) const

   357     { return MyStringCompare(_chars, s); }

   358 

   359   int CompareNoCase(const CStringBase& s) const

   360     { return MyStringCompareNoCase(_chars, s._chars); }

   361 

   362   int CompareNoCase(const T *s) const

   363     { return MyStringCompareNoCase(_chars, s); }

   364 

   365   /*

   366   int Collate(const CStringBase& s) const

   367     { return MyStringCollate(_chars, s._chars); }

   368   int CollateNoCase(const CStringBase& s) const

   369     { return MyStringCollateNoCase(_chars, s._chars); }

   370   */

   371 

   372   int Find(T c) const { return Find(c, 0); }

   373   int Find(T c, int startIndex) const

   374   {

   375     T *p = _chars + startIndex;

   376     for (;;)

   377     {

   378       if (*p == c)

   379         return (int)(p - _chars);

   380       if (*p == 0)

   381         return -1;

   382       p = GetNextCharPointer(p);

   383     }

   384   }

   385   int Find(const CStringBase &s) const { return Find(s, 0); }

   386   int Find(const CStringBase &s, int startIndex) const

   387   {

   388     if (s.IsEmpty())

   389       return startIndex;

   390     for (; startIndex < _length; startIndex++)

   391     {

   392       int j;

   393       for (j = 0; j < s._length && startIndex + j < _length; j++)

   394         if (_chars[startIndex+j] != s._chars[j])

   395           break;

   396       if (j == s._length)

   397         return startIndex;

   398     }

   399     return -1;

   400   }

   401   int ReverseFind(T c) const

   402   {

   403     if (_length == 0)

   404       return -1;

   405     T *p = _chars + _length - 1;

   406     for (;;)

   407     {

   408       if (*p == c)

   409         return (int)(p - _chars);

   410       if (p == _chars)

   411         return -1;

   412       p = GetPrevCharPointer(_chars, p);

   413     }

   414   }

   415   int FindOneOf(const CStringBase &s) const

   416   {

   417     for (int i = 0; i < _length; i++)

   418       if (s.Find(_chars[i]) >= 0)

   419         return i;

   420       return -1;

   421   }

   422 

   423   void TrimLeft(T c)

   424   {

   425     const T *p = _chars;

   426     while (c == *p)

   427       p = GetNextCharPointer(p);

   428     Delete(0, p - _chars);

   429   }

   430   private:

   431   CStringBase GetTrimDefaultCharSet()

   432   {

   433     CStringBase<T> charSet;

   434     charSet += (T)' ';

   435     charSet += (T)'\n';

   436     charSet += (T)'\t';

   437     return charSet;

   438   }

   439   public:

   440 

   441   void TrimLeft()

   442   {

   443     TrimLeftWithCharSet(GetTrimDefaultCharSet());

   444   }

   445   void TrimRight()

   446   {

   447     TrimRightWithCharSet(GetTrimDefaultCharSet());

   448   }

   449   void TrimRight(T c)

   450   {

   451     const T *p = _chars;

   452     const T *pLast = NULL;

   453     while (*p != 0)

   454     {

   455       if (*p == c)

   456       {

   457         if (pLast == NULL)

   458           pLast = p;

   459       }

   460       else

   461         pLast = NULL;

   462       p = GetNextCharPointer(p);

   463     }

   464     if (pLast != NULL)

   465     {

   466       int i = pLast - _chars;

   467       Delete(i, _length - i);

   468     }

   469   }

   470   void Trim()

   471   {

   472     TrimRight();

   473     TrimLeft();

   474   }

   475 

   476   int Insert(int index, T c)

   477   {

   478     InsertSpace(index, 1);

   479     _chars[index] = c;

   480     _length++;

   481     return _length;

   482   }

   483   int Insert(int index, const CStringBase &s)

   484   {

   485     CorrectIndex(index);

   486     if (s.IsEmpty())

   487       return _length;

   488     int numInsertChars = s.Length();

   489     InsertSpace(index, numInsertChars);

   490     for (int i = 0; i < numInsertChars; i++)

   491       _chars[index + i] = s[i];

   492     _length += numInsertChars;

   493     return _length;

   494   }

   495 

   496   // !!!!!!!!!!!!!!! test it if newChar = '\0'

   497   int Replace(T oldChar, T newChar)

   498   {

   499     if (oldChar == newChar)

   500       return 0;

   501     int number  = 0;

   502     int pos  = 0;

   503     while (pos < Length())

   504     {

   505       pos = Find(oldChar, pos);

   506       if (pos < 0)

   507         break;

   508       _chars[pos] = newChar;

   509       pos++;

   510       number++;

   511     }

   512     return number;

   513   }

   514   int Replace(const CStringBase &oldString, const CStringBase &newString)

   515   {

   516     if (oldString.IsEmpty())

   517       return 0;

   518     if (oldString == newString)

   519       return 0;

   520     int oldStringLength = oldString.Length();

   521     int newStringLength = newString.Length();

   522     int number  = 0;

   523     int pos  = 0;

   524     while (pos < _length)

   525     {

   526       pos = Find(oldString, pos);

   527       if (pos < 0)

   528         break;

   529       Delete(pos, oldStringLength);

   530       Insert(pos, newString);

   531       pos += newStringLength;

   532       number++;

   533     }

   534     return number;

   535   }

   536   int Delete(int index, int count = 1 )

   537   {

   538     if (index + count > _length)

   539       count = _length - index;

   540     if (count > 0)

   541     {

   542       MoveItems(index, index + count);

   543       _length -= count;

   544     }

   545     return _length;

   546   }

   547 };

   548 

   549 template <class T>

   550 CStringBase<T> operator+(const CStringBase<T>& s1, const CStringBase<T>& s2)

   551 {

   552   CStringBase<T> result(s1);

   553   result += s2;

   554   return result;

   555 }

   556 

   557 template <class T>

   558 CStringBase<T> operator+(const CStringBase<T>& s, T c)

   559 {

   560   CStringBase<T> result(s);

   561   result += c;

   562   return result;

   563 }

   564 

   565 template <class T>

   566 CStringBase<T> operator+(T c, const CStringBase<T>& s)

   567 {

   568   CStringBase<T> result(c);

   569   result += s;

   570   return result;

   571 }

   572 

   573 template <class T>

   574 CStringBase<T> operator+(const CStringBase<T>& s, const T * chars)

   575 {

   576   CStringBase<T> result(s);

   577   result += chars;

   578   return result;

   579 }

   580 

   581 template <class T>

   582 CStringBase<T> operator+(const T * chars, const CStringBase<T>& s)

   583 {

   584   CStringBase<T> result(chars);

   585   result += s;

   586   return result;

   587 }

   588 

   589 template <class T>

   590 bool operator==(const CStringBase<T>& s1, const CStringBase<T>& s2)

   591   { return (s1.Compare(s2) == 0); }

   592 

   593 template <class T>

   594 bool operator<(const CStringBase<T>& s1, const CStringBase<T>& s2)

   595   { return (s1.Compare(s2) < 0); }

   596 

   597 template <class T>

   598 bool operator==(const T *s1, const CStringBase<T>& s2)

   599   { return (s2.Compare(s1) == 0); }

   600 

   601 template <class T>

   602 bool operator==(const CStringBase<T>& s1, const T *s2)

   603   { return (s1.Compare(s2) == 0); }

   604 

   605 template <class T>

   606 bool operator!=(const CStringBase<T>& s1, const CStringBase<T>& s2)

   607   { return (s1.Compare(s2) != 0); }

   608 

   609 template <class T>

   610 bool operator!=(const T *s1, const CStringBase<T>& s2)

   611   { return (s2.Compare(s1) != 0); }

   612 

   613 template <class T>

   614 bool operator!=(const CStringBase<T>& s1, const T *s2)

   615   { return (s1.Compare(s2) != 0); }

   616 

   617 typedef CStringBase<char> AString;

   618 typedef CStringBase<wchar_t> UString;

   619 

   620 typedef CObjectVector<AString> AStringVector;

   621 typedef CObjectVector<UString> UStringVector;

   622 

   623 #ifdef _UNICODE

   624   typedef UString CSysString;

   625 #else

   626   typedef AString CSysString;

   627 #endif

   628 

   629 typedef CObjectVector<CSysString> CSysStringVector;

   630 

   631 #endif
author	Robert McIntyre <rlm@mit.edu>
date	Sat, 03 Mar 2012 10:31:27 -0600
parents
children