sdk/lib/atl/cstringt.h

   1 #ifndef __CSTRINGT_H__
   2 #define __CSTRINGT_H__
   3
   4 #pragma once
   5 #include <atlsimpstr.h>
   6 #include <stddef.h>
   7 #include <stdio.h>
   8 #include <wchar.h>
   9 #include <atlmem.h>
  10
  11 namespace ATL
  12 {
  13
  14 inline UINT WINAPI _AtlGetConversionACP() throw()
  15 {
  16 #ifdef _CONVERSION_DONT_USE_THREAD_LOCALE
  17     return CP_ACP;
  18 #else
  19     return CP_THREAD_ACP;
  20 #endif
  21 }
  22
  23
  24 template<typename _CharType = wchar_t>
  25 class ChTraitsCRT : public ChTraitsBase<_CharType>
  26 {
  27 public:
  28
  29     static int __cdecl GetBaseTypeLength(_In_z_ LPCWSTR pszSource) throw()
  30     {
  31         if (pszSource == NULL) return -1;
  32         return static_cast<int>(wcslen(pszSource));
  33     }
  34
  35     static int __cdecl GetBaseTypeLength(_In_z_ LPCSTR pszSource) throw()
  36     {
  37         if (pszSource == NULL) return 0;
  38         return ::MultiByteToWideChar(_AtlGetConversionACP(), 0, pszSource, -1, NULL, 0) - 1;
  39     }
  40
  41     static int __cdecl GetBaseTypeLength(
  42         _In_reads_(nLength) LPCWSTR pszSource,
  43         _In_ int nLength) throw()
  44     {
  45         return nLength;
  46     }
  47
  48     static int __cdecl GetBaseTypeLength(
  49         _In_reads_(nLength) LPCSTR pszSource,
  50         _In_ int nLength) throw()
  51     {
  52         return ::MultiByteToWideChar(_AtlGetConversionACP(), 0, pszSource, nLength, NULL, 0);
  53     }
  54
  55     static void __cdecl ConvertToBaseType(
  56         _Out_writes_(nDestLength) LPWSTR pszDest,
  57         _In_ int nDestLength,
  58         _In_ LPCWSTR pszSrc,
  59         _In_ int nSrcLength = -1)
  60     {
  61         if (nSrcLength == -1)
  62             nSrcLength = 1 + GetBaseTypeLength(pszSrc);
  63
  64         wmemcpy(pszDest, pszSrc, nSrcLength);
  65     }
  66
  67     static void __cdecl ConvertToBaseType(
  68         _Out_writes_(nDestLength) LPWSTR pszDest,
  69         _In_ int nDestLength,
  70         _In_ LPCSTR pszSrc,
  71         _In_ int nSrcLength = -1)
  72     {
  73         if (nSrcLength == -1)
  74             nSrcLength = 1 + GetBaseTypeLength(pszSrc);
  75
  76         ::MultiByteToWideChar(_AtlGetConversionACP(), 0, pszSrc, nSrcLength, pszDest, nDestLength);
  77     }
  78
  79     static void __cdecl MakeLower(
  80         _Out_writes_(nSrcLength) LPWSTR pszSource,
  81         _In_ int nSrcLength)
  82     {
  83         ::CharLowerBuffW(pszSource, nSrcLength);
  84     }
  85
  86     static DWORD GetEnvironmentVariable(
  87         _In_z_ LPCWSTR pszVar,
  88         _Out_writes_opt_(nBufLength) LPWSTR pszBuf,
  89         _In_opt_ int nBufLength)
  90     {
  91         return ::GetEnvironmentVariableW(pszVar, pszBuf, nBufLength);
  92     }
  93
  94     static void __cdecl MakeUpper(
  95         _Out_writes_(nSrcLength) LPWSTR pszSource,
  96         _In_ int nSrcLength)
  97     {
  98         ::CharUpperBuffW(pszSource, nSrcLength);
  99     }
 100
 101     static LPWSTR __cdecl FindString(
 102         _In_z_ LPCWSTR pszSource,
 103         _In_z_ LPCWSTR pszSub)
 104     {
 105         return ::wcsstr(pszSource, pszSub);
 106     }
 107
 108     static LPWSTR __cdecl FindChar(
 109         _In_z_ LPCWSTR pszSource,
 110         _In_ WCHAR ch)
 111     {
 112         return ::wcschr(pszSource, ch);
 113     }
 114
 115     static LPWSTR __cdecl FindCharReverse(
 116         _In_z_ LPCWSTR pszSource,
 117         _In_ WCHAR ch)
 118     {
 119         return ::wcsrchr(pszSource, ch);
 120     }
 121
 122     static LPWSTR __cdecl FindOneOf(
 123         _In_z_ LPCWSTR pszSource,
 124         _In_z_ LPCWSTR pszCharSet)
 125     {
 126         return ::wcspbrk(pszSource, pszCharSet);
 127     }
 128
 129     static int __cdecl Compare(
 130         _In_z_ LPCWSTR psz1,
 131         _In_z_ LPCWSTR psz2)
 132     {
 133         return ::wcscmp(psz1, psz2);
 134     }
 135
 136     static int __cdecl CompareNoCase(
 137         _In_z_ LPCWSTR psz1,
 138         _In_z_ LPCWSTR psz2)
 139     {
 140         return ::_wcsicmp(psz1, psz2);
 141     }
 142
 143     static int __cdecl FormatV(
 144         _In_opt_z_ LPWSTR pszDest,
 145         _In_z_ LPCWSTR pszFormat,
 146         _In_ va_list args)
 147     {
 148         if (pszDest == NULL)
 149             return ::_vscwprintf(pszFormat, args);
 150         return ::vswprintf(pszDest, pszFormat, args);
 151     }
 152
 153     static BSTR __cdecl AllocSysString(
 154         _In_z_ LPCWSTR pszSource,
 155         _In_ int nLength)
 156     {
 157         return ::SysAllocStringLen(pszSource, nLength);
 158     }
 159 };
 160
 161
 162 // Template specialization
 163
 164 template<>
 165 class ChTraitsCRT<char> : public ChTraitsBase<char>
 166 {
 167 public:
 168
 169     static int __cdecl GetBaseTypeLength(_In_z_ LPCWSTR pszSource) throw()
 170     {
 171         return ::WideCharToMultiByte(_AtlGetConversionACP(), 0, pszSource, -1, NULL, 0, NULL, NULL) - 1;
 172     }
 173
 174     static int __cdecl GetBaseTypeLength(_In_z_ LPCSTR pszSource) throw()
 175     {
 176         if (pszSource == NULL) return 0;
 177         return static_cast<int>(strlen(pszSource));
 178     }
 179
 180     static int __cdecl GetBaseTypeLength(
 181         _In_reads_(nLength) LPCWSTR pszSource,
 182         _In_ int nLength) throw()
 183     {
 184         return ::WideCharToMultiByte(_AtlGetConversionACP(), 0, pszSource, nLength, NULL, 0, NULL, NULL);
 185     }
 186
 187     static int __cdecl GetBaseTypeLength(
 188         _In_reads_(nLength) LPCSTR pszSource,
 189         _In_ int nLength) throw()
 190     {
 191         return nLength;
 192     }
 193
 194     static void __cdecl ConvertToBaseType(
 195         _Out_writes_(nDestLength) LPSTR pszDest,
 196         _In_ int nDestLength,
 197         _In_ LPCWSTR pszSrc,
 198         _In_ int nSrcLength = -1)
 199     {
 200         if (nSrcLength == -1)
 201             nSrcLength = 1 + GetBaseTypeLength(pszSrc);
 202
 203         ::WideCharToMultiByte(_AtlGetConversionACP(), 0, pszSrc, nSrcLength, pszDest, nDestLength, NULL, NULL);
 204     }
 205
 206     static void __cdecl ConvertToBaseType(
 207         _Out_writes_(nDestLength) LPSTR pszDest,
 208         _In_ int nDestLength,
 209         _In_ LPCSTR pszSrc,
 210         _In_ int nSrcLength = -1)
 211     {
 212         if (nSrcLength == -1)
 213             nSrcLength = 1 + GetBaseTypeLength(pszSrc);
 214
 215         memcpy(pszDest, pszSrc, nSrcLength);
 216     }
 217
 218     static void __cdecl MakeLower(
 219         _Out_writes_(nSrcLength) LPSTR pszSource,
 220         _In_ int nSrcLength)
 221     {
 222         ::CharLowerBuffA(pszSource, nSrcLength);
 223     }
 224
 225     static DWORD GetEnvironmentVariable(
 226         _In_z_ LPCSTR pszVar,
 227         _Out_writes_opt_(nBufLength) LPSTR pszBuf,
 228         _In_opt_ int nBufLength)
 229     {
 230         return ::GetEnvironmentVariableA(pszVar, pszBuf, nBufLength);
 231     }
 232
 233     static void __cdecl MakeUpper(
 234         _Out_writes_(nSrcLength) LPSTR pszSource,
 235         _In_ int nSrcLength)
 236     {
 237         ::CharUpperBuffA(pszSource, nSrcLength);
 238     }
 239
 240     static LPSTR __cdecl FindString(
 241         _In_z_ LPCSTR pszSource,
 242         _In_z_ LPCSTR pszSub)
 243     {
 244         return ::strstr(pszSource, pszSub);
 245     }
 246
 247     static LPSTR __cdecl FindChar(
 248         _In_z_ LPCSTR pszSource,
 249         _In_ CHAR ch)
 250     {
 251         return ::strchr(pszSource, ch);
 252     }
 253
 254     static LPSTR __cdecl FindCharReverse(
 255         _In_z_ LPCSTR pszSource,
 256         _In_ CHAR ch)
 257     {
 258         return ::strrchr(pszSource, ch);
 259     }
 260
 261     static LPSTR __cdecl FindOneOf(
 262         _In_z_ LPCSTR pszSource,
 263         _In_z_ LPCSTR pszCharSet)
 264     {
 265         return ::strpbrk(pszSource, pszCharSet);
 266     }
 267
 268     static int __cdecl Compare(
 269         _In_z_ LPCSTR psz1,
 270         _In_z_ LPCSTR psz2)
 271     {
 272         return ::strcmp(psz1, psz2);
 273     }
 274
 275     static int __cdecl CompareNoCase(
 276         _In_z_ LPCSTR psz1,
 277         _In_z_ LPCSTR psz2)
 278     {
 279         return ::_stricmp(psz1, psz2);
 280     }
 281
 282     static int __cdecl FormatV(
 283         _In_opt_z_ LPSTR pszDest,
 284         _In_z_ LPCSTR pszFormat,
 285         _In_ va_list args)
 286     {
 287         if (pszDest == NULL)
 288             return ::_vscprintf(pszFormat, args);
 289         return ::vsprintf(pszDest, pszFormat, args);
 290     }
 291
 292     static BSTR __cdecl AllocSysString(
 293         _In_z_ LPCSTR pszSource,
 294         _In_ int nLength)
 295     {
 296         int nLen = ChTraitsCRT<wchar_t>::GetBaseTypeLength(pszSource, nLength);
 297         BSTR bstr = ::SysAllocStringLen(NULL, nLen);
 298         if (bstr)
 299         {
 300             ChTraitsCRT<wchar_t>::ConvertToBaseType(bstr, nLen, pszSource, nLength);
 301         }
 302         return bstr;
 303     }
 304
 305 };
 306
 307
 308 namespace _CSTRING_IMPL_
 309 {
 310     template <typename _CharType, class StringTraits>
 311     struct _MFCDLLTraitsCheck
 312     {
 313         const static bool c_bIsMFCDLLTraits = false;
 314     };
 315 }
 316
 317
 318 // TODO: disable conversion functions when _CSTRING_DISABLE_NARROW_WIDE_CONVERSION is defined.
 319
 320 template <typename BaseType, class StringTraits>
 321 class CStringT :
 322     public CSimpleStringT <BaseType, _CSTRING_IMPL_::_MFCDLLTraitsCheck<BaseType, StringTraits>::c_bIsMFCDLLTraits>
 323 {
 324 public:
 325     typedef CSimpleStringT<BaseType, _CSTRING_IMPL_::_MFCDLLTraitsCheck<BaseType, StringTraits>::c_bIsMFCDLLTraits> CThisSimpleString;
 326     typedef StringTraits StrTraits;
 327     typedef typename CThisSimpleString::XCHAR XCHAR;
 328     typedef typename CThisSimpleString::PXSTR PXSTR;
 329     typedef typename CThisSimpleString::PCXSTR PCXSTR;
 330     typedef typename CThisSimpleString::YCHAR YCHAR;
 331     typedef typename CThisSimpleString::PYSTR PYSTR;
 332     typedef typename CThisSimpleString::PCYSTR PCYSTR;
 333
 334 public:
 335     CStringT() throw() :
 336         CThisSimpleString(StringTraits::GetDefaultManager())
 337     {
 338     }
 339
 340     explicit CStringT( _In_ IAtlStringMgr* pStringMgr) throw() :
 341         CThisSimpleString(pStringMgr)
 342     {
 343     }
 344
 345     static void __cdecl Construct(_In_ CStringT* pString)
 346     {
 347         new(pString) CStringT;
 348     }
 349
 350     CStringT(_In_ const CStringT& strSrc) :
 351         CThisSimpleString(strSrc)
 352     {
 353     }
 354
 355     CStringT(_In_ const CThisSimpleString& strSrc) :
 356         CThisSimpleString(strSrc)
 357     {
 358     }
 359
 360     template<class StringTraits_>
 361     CStringT(_In_ const CStringT<YCHAR, StringTraits_> & strSrc) :
 362         CThisSimpleString(StringTraits::GetDefaultManager())
 363     {
 364         *this = static_cast<const YCHAR*>(strSrc);
 365     }
 366
 367 protected:
 368     /* helper function */
 369     template <typename T_CHAR>
 370     void LoadFromPtr_(_In_opt_z_ const T_CHAR* pszSrc)
 371     {
 372         if (pszSrc == NULL)
 373             return;
 374         if (IS_INTRESOURCE(pszSrc))
 375             LoadString(LOWORD(pszSrc));
 376         else
 377             *this = pszSrc;
 378     }
 379
 380 public:
 381     CStringT(_In_opt_z_ const XCHAR* pszSrc) :
 382         CThisSimpleString(StringTraits::GetDefaultManager())
 383     {
 384         LoadFromPtr_(pszSrc);
 385     }
 386
 387     CStringT(_In_opt_z_ const XCHAR* pszSrc,
 388              _In_ IAtlStringMgr* pStringMgr) : CThisSimpleString(pStringMgr)
 389     {
 390         LoadFromPtr_(pszSrc);
 391     }
 392
 393     CStringT(_In_opt_z_ const YCHAR* pszSrc) :
 394         CThisSimpleString(StringTraits::GetDefaultManager())
 395     {
 396         LoadFromPtr_(pszSrc);
 397     }
 398
 399     CStringT(_In_opt_z_ const YCHAR* pszSrc,
 400              _In_ IAtlStringMgr* pStringMgr) : CThisSimpleString(pStringMgr)
 401     {
 402         LoadFromPtr_(pszSrc);
 403     }
 404
 405     CStringT(_In_reads_z_(nLength) const XCHAR* pch,
 406              _In_ int nLength) :
 407         CThisSimpleString(pch, nLength, StringTraits::GetDefaultManager())
 408     {
 409     }
 410
 411     CStringT(_In_reads_z_(nLength) const YCHAR* pch,
 412              _In_ int nLength) :
 413         CThisSimpleString(pch, nLength, StringTraits::GetDefaultManager())
 414     {
 415     }
 416
 417     CStringT& operator=(_In_ const CStringT& strSrc)
 418     {
 419         CThisSimpleString::operator=(strSrc);
 420         return *this;
 421     }
 422
 423     CStringT& operator=(_In_opt_z_ PCXSTR pszSrc)
 424     {
 425         CThisSimpleString::operator=(pszSrc);
 426         return *this;
 427     }
 428
 429     CStringT& operator=(_In_opt_z_ PCYSTR pszSrc)
 430     {
 431         int length = pszSrc ? StringTraits::GetBaseTypeLength(pszSrc) : 0;
 432         if (length > 0)
 433         {
 434             PXSTR result = CThisSimpleString::GetBuffer(length);
 435             StringTraits::ConvertToBaseType(result, length, pszSrc);
 436             CThisSimpleString::ReleaseBufferSetLength(length);
 437         }
 438         else
 439         {
 440             CThisSimpleString::Empty();
 441         }
 442         return *this;
 443     }
 444
 445     CStringT& operator=(_In_ const CThisSimpleString &strSrc)
 446     {
 447         CThisSimpleString::operator=(strSrc);
 448         return *this;
 449     }
 450
 451     friend bool operator==(const CStringT& str1, const CStringT& str2) throw()
 452     {
 453         return str1.Compare(str2) == 0;
 454     }
 455
 456     friend bool operator==(const CStringT& str1, PCXSTR psz2) throw()
 457     {
 458         return str1.Compare(psz2) == 0;
 459     }
 460
 461     friend bool operator==(const CStringT& str1, PCYSTR psz2) throw()
 462     {
 463         CStringT tmp(psz2, str1.GetManager());
 464         return tmp.Compare(str1) == 0;
 465     }
 466
 467     friend bool operator==(const CStringT& str1, XCHAR ch2) throw()
 468     {
 469         return str1.GetLength() == 1 && str1[0] == ch2;
 470     }
 471
 472     friend bool operator==(PCXSTR psz1, const CStringT& str2) throw()
 473     {
 474         return str2.Compare(psz1) == 0;
 475     }
 476
 477     friend bool operator==(PCYSTR psz1, const CStringT& str2) throw()
 478     {
 479         CStringT tmp(psz1, str2.GetManager());
 480         return tmp.Compare(str2) == 0;
 481     }
 482
 483     friend bool operator==(XCHAR ch1, const CStringT& str2) throw()
 484     {
 485         return str2.GetLength() == 1 && str2[0] == ch1;
 486     }
 487
 488     CStringT& operator+=(_In_ const CThisSimpleString& str)
 489     {
 490         CThisSimpleString::operator+=(str);
 491         return *this;
 492     }
 493
 494     CStringT& operator+=(_In_z_ PCXSTR pszSrc)
 495     {
 496         CThisSimpleString::operator+=(pszSrc);
 497         return *this;
 498     }
 499
 500     CStringT& operator+=(_In_ XCHAR ch)
 501     {
 502         CThisSimpleString::operator+=(ch);
 503         return *this;
 504     }
 505
 506     BOOL LoadString(_In_ UINT nID)
 507     {
 508         return LoadString(_AtlBaseModule.GetResourceInstance(), nID);
 509     }
 510
 511     _Check_return_ BOOL LoadString(_In_ HINSTANCE hInstance,
 512                                    _In_ UINT nID)
 513     {
 514         const ATLSTRINGRESOURCEIMAGE* pImage = AtlGetStringResourceImage(hInstance, nID);
 515         if (pImage == NULL) return FALSE;
 516
 517         int nLength = StringTraits::GetBaseTypeLength(pImage->achString, pImage->nLength);
 518         PXSTR pszBuffer = CThisSimpleString::GetBuffer(nLength);
 519         StringTraits::ConvertToBaseType(pszBuffer, nLength, pImage->achString, pImage->nLength);
 520         CThisSimpleString::ReleaseBufferSetLength(nLength);
 521
 522         return TRUE;
 523     }
 524
 525     BOOL GetEnvironmentVariable(_In_z_ PCXSTR pszVar)
 526     {
 527         int nLength = StringTraits::GetEnvironmentVariable(pszVar, NULL, 0);
 528
 529         if (nLength > 0)
 530         {
 531             PXSTR pszBuffer = CThisSimpleString::GetBuffer(nLength);
 532             StringTraits::GetEnvironmentVariable(pszVar, pszBuffer, nLength);
 533             CThisSimpleString::ReleaseBuffer();
 534             return TRUE;
 535         }
 536
 537         CThisSimpleString::Empty();
 538         return FALSE;
 539     }
 540
 541     CStringT& MakeLower()
 542     {
 543         int nLength = CThisSimpleString::GetLength();
 544         PXSTR pszBuffer = CThisSimpleString::GetBuffer(nLength);
 545
 546         StringTraits::MakeLower(pszBuffer, nLength);
 547         CThisSimpleString::ReleaseBufferSetLength(nLength);
 548
 549         return *this;
 550     }
 551
 552     CStringT& MakeUpper()
 553     {
 554         int nLength = CThisSimpleString::GetLength();
 555         PXSTR pszBuffer = CThisSimpleString::GetBuffer(nLength);
 556
 557         StringTraits::MakeUpper(pszBuffer, nLength);
 558         CThisSimpleString::ReleaseBufferSetLength(nLength);
 559
 560         return *this;
 561     }
 562
 563     int Find(_In_ PCXSTR pszSub, _In_opt_ int iStart = 0) const throw()
 564     {
 565         int nLength = CThisSimpleString::GetLength();
 566
 567         if (iStart >= nLength || iStart < 0)
 568             return -1;
 569
 570         PCXSTR pszString = CThisSimpleString::GetString();
 571         PCXSTR pszResult = StringTraits::FindString(pszString + iStart, pszSub);
 572
 573         return pszResult ? ((int)(pszResult - pszString)) : -1;
 574     }
 575
 576     int Find(_In_ XCHAR ch, _In_opt_ int iStart = 0) const throw()
 577     {
 578         int nLength = CThisSimpleString::GetLength();
 579
 580         if (iStart >= nLength || iStart < 0)
 581             return -1;
 582
 583         PCXSTR pszString = CThisSimpleString::GetString();
 584         PCXSTR pszResult = StringTraits::FindChar(pszString + iStart, ch);
 585
 586         return pszResult ? ((int)(pszResult - pszString)) : -1;
 587     }
 588
 589     int FindOneOf(_In_ PCXSTR pszCharSet) const throw()
 590     {
 591         PCXSTR pszString = CThisSimpleString::GetString();
 592         PCXSTR pszResult = StringTraits::FindOneOf(pszString, pszCharSet);
 593
 594         return pszResult ? ((int)(pszResult - pszString)) : -1;
 595     }
 596
 597     int ReverseFind(_In_ XCHAR ch) const throw()
 598     {
 599         PCXSTR pszString = CThisSimpleString::GetString();
 600         PCXSTR pszResult = StringTraits::FindCharReverse(pszString, ch);
 601
 602         return pszResult ? ((int)(pszResult - pszString)) : -1;
 603     }
 604
 605     int Compare(_In_z_ PCXSTR psz) const
 606     {
 607         return StringTraits::Compare(CThisSimpleString::GetString(), psz);
 608     }
 609
 610     int CompareNoCase(_In_z_ PCXSTR psz) const
 611     {
 612         return StringTraits::CompareNoCase(CThisSimpleString::GetString(), psz);
 613     }
 614
 615     CStringT Mid(int iFirst, int nCount) const
 616     {
 617         int nLength = CThisSimpleString::GetLength();
 618
 619         if (iFirst < 0)
 620             iFirst = 0;
 621         if (nCount < 0)
 622             nCount = 0;
 623         if (iFirst > nLength)
 624             iFirst = nLength;
 625         if (iFirst + nCount > nLength)
 626             nCount = nLength - iFirst;
 627
 628         return CStringT(CThisSimpleString::GetString() + iFirst, nCount);
 629     }
 630
 631     CStringT Mid(int iFirst) const
 632     {
 633         int nLength = CThisSimpleString::GetLength();
 634
 635         if (iFirst < 0)
 636             iFirst = 0;
 637         if (iFirst > nLength)
 638             iFirst = nLength;
 639
 640         return CStringT(CThisSimpleString::GetString() + iFirst, nLength - iFirst);
 641     }
 642
 643     CStringT Left(int nCount) const
 644     {
 645         int nLength = CThisSimpleString::GetLength();
 646
 647         if (nCount < 0)
 648             nCount = 0;
 649         if (nCount > nLength)
 650             nCount = nLength;
 651
 652         return CStringT(CThisSimpleString::GetString(), nCount);
 653     }
 654
 655     CStringT Right(int nCount) const
 656     {
 657         int nLength = CThisSimpleString::GetLength();
 658
 659         if (nCount < 0)
 660             nCount = 0;
 661         if (nCount > nLength)
 662             nCount = nLength;
 663
 664         return CStringT(CThisSimpleString::GetString() + nLength - nCount, nCount);
 665     }
 666
 667
 668     void __cdecl Format(UINT nFormatID, ...)
 669     {
 670         va_list args;
 671         va_start(args, nFormatID);
 672         CStringT formatString;
 673         if (formatString.LoadString(nFormatID))
 674             FormatV(formatString, args);
 675         va_end(args);
 676     }
 677
 678     void __cdecl Format(PCXSTR pszFormat, ...)
 679     {
 680         va_list args;
 681         va_start(args, pszFormat);
 682         FormatV(pszFormat, args);
 683         va_end(args);
 684     }
 685
 686     void FormatV(PCXSTR pszFormat, va_list args)
 687     {
 688         int nLength = StringTraits::FormatV(NULL, pszFormat, args);
 689
 690         PXSTR pszBuffer = CThisSimpleString::GetBuffer(nLength);
 691         StringTraits::FormatV(pszBuffer, pszFormat, args);
 692         CThisSimpleString::ReleaseBufferSetLength(nLength);
 693     }
 694
 695
 696     int Replace(PCXSTR pszOld, PCXSTR pszNew)
 697     {
 698         PCXSTR pszString = CThisSimpleString::GetString();
 699
 700         const int nLength = CThisSimpleString::GetLength();
 701         const int nOldLen = StringTraits::GetBaseTypeLength(pszOld);
 702         const int nNewLen = StringTraits::GetBaseTypeLength(pszNew);
 703         const int nDiff = nNewLen - nOldLen;
 704         int nResultLength = nLength;
 705
 706         PCXSTR pszFound;
 707         while ((pszFound = StringTraits::FindString(pszString, pszOld)))
 708         {
 709             nResultLength += nDiff;
 710             pszString = pszFound + nOldLen;
 711         }
 712
 713         if (pszString == CThisSimpleString::GetString())
 714             return 0;
 715
 716         PXSTR pszResult = CThisSimpleString::GetBuffer(nResultLength);
 717         PXSTR pszNext;
 718         int nCount = 0, nRemaining = nLength;
 719         while (nRemaining && (pszNext = StringTraits::FindString(pszResult, pszOld)))
 720         {
 721             nRemaining -= (pszNext - pszResult);
 722             nRemaining -= nOldLen;
 723             if (nRemaining > 0)
 724                 CThisSimpleString::CopyCharsOverlapped(pszNext + nNewLen, nRemaining + 1, pszNext + nOldLen, nRemaining + 1);
 725             CThisSimpleString::CopyCharsOverlapped(pszNext, nNewLen, pszNew, nNewLen);
 726             pszResult = pszNext + nNewLen;
 727             nCount++;
 728         }
 729
 730         CThisSimpleString::ReleaseBufferSetLength(nResultLength);
 731
 732         return nCount;
 733     }
 734
 735     int Replace(XCHAR chOld, XCHAR chNew)
 736     {
 737         PCXSTR pszString = CThisSimpleString::GetString();
 738         PXSTR pszFirst = StringTraits::FindChar(pszString, chOld);
 739         if (!pszFirst)
 740             return 0;
 741
 742         int nLength = CThisSimpleString::GetLength();
 743         int nCount = 0;
 744
 745         PXSTR pszBuffer = CThisSimpleString::GetBuffer(nLength);
 746         pszFirst = pszBuffer + (pszFirst - pszString);
 747         do {
 748             *pszFirst = chNew;
 749             ++nCount;
 750         } while ((pszFirst = StringTraits::FindChar(pszFirst + 1, chOld)));
 751
 752         CThisSimpleString::ReleaseBufferSetLength(nLength);
 753         return nCount;
 754     }
 755
 756
 757     static PCXSTR DefaultTrimChars()
 758     {
 759         static XCHAR str[] = { ' ', '\t', '\r', '\n', 0 };
 760         return str;
 761     }
 762
 763
 764     CStringT& TrimLeft()
 765     {
 766         return TrimLeft(DefaultTrimChars());
 767     }
 768
 769     CStringT& TrimLeft(XCHAR chTarget)
 770     {
 771         XCHAR str[2] = { chTarget, 0 };
 772         return TrimLeft(str);
 773     }
 774
 775     CStringT& TrimLeft(PCXSTR pszTargets)
 776     {
 777         int nLength = CThisSimpleString::GetLength();
 778         PXSTR pszBuffer = CThisSimpleString::GetBuffer(nLength);
 779         int nCount = 0;
 780
 781         while (nCount < nLength && StringTraits::FindChar(pszTargets, pszBuffer[nCount]))
 782             nCount++;
 783
 784         if (nCount > 0)
 785         {
 786             CThisSimpleString::CopyCharsOverlapped(pszBuffer, nLength - nCount, pszBuffer + nCount, nLength - nCount);
 787             nLength -= nCount;
 788         }
 789         CThisSimpleString::ReleaseBufferSetLength(nLength);
 790
 791         return *this;
 792     }
 793
 794
 795     CStringT& TrimRight()
 796     {
 797         return TrimRight(DefaultTrimChars());
 798     }
 799
 800     CStringT& TrimRight(XCHAR chTarget)
 801     {
 802         XCHAR str[2] = { chTarget, 0 };
 803         return TrimRight(str);
 804     }
 805
 806     CStringT& TrimRight(PCXSTR pszTargets)
 807     {
 808         int nLength = CThisSimpleString::GetLength();
 809         PXSTR pszBuffer = CThisSimpleString::GetBuffer(nLength);
 810
 811         while (nLength > 0 && StringTraits::FindChar(pszTargets, pszBuffer[nLength-1]))
 812             nLength--;
 813
 814         CThisSimpleString::ReleaseBufferSetLength(nLength);
 815
 816         return *this;
 817     }
 818
 819
 820     CStringT& Trim()
 821     {
 822         return Trim(DefaultTrimChars());
 823     }
 824
 825     CStringT& Trim(XCHAR chTarget)
 826     {
 827         XCHAR str[2] = { chTarget, 0 };
 828         return Trim(str);
 829     }
 830
 831     CStringT& Trim(PCXSTR pszTargets)
 832     {
 833         return TrimRight(pszTargets).TrimLeft(pszTargets);
 834     }
 835
 836
 837     BSTR AllocSysString() const
 838     {
 839         return StringTraits::AllocSysString(CThisSimpleString::GetString(), CThisSimpleString::GetLength());
 840     }
 841
 842
 843 };
 844
 845 } //namespace ATL
 846
 847 #endif