core/include/fxcrt/fx_string.h

   1 // Copyright 2014 PDFium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
   6
   7 #ifndef _FX_STRING_H_
   8 #define _FX_STRING_H_
   9 class CFX_ByteStringC;
  10 class CFX_ByteString;
  11 class CFX_WideStringC;
  12 class CFX_WideString;
  13 struct CFX_CharMap;
  14 class CFX_BinaryBuf;
  15 typedef int FX_STRSIZE;
  16 class CFX_ByteStringL;
  17 class CFX_WideStringL;
  18
  19 // An immutable string with caller-provided storage which must outlive the
  20 // string itself.
  21 class CFX_ByteStringC : public CFX_Object
  22 {
  23 public:
  24     typedef FX_CHAR value_type;
  25
  26     CFX_ByteStringC()
  27     {
  28         m_Ptr = NULL;
  29         m_Length = 0;
  30     }
  31
  32     CFX_ByteStringC(FX_LPCBYTE ptr, FX_STRSIZE size)
  33     {
  34         m_Ptr = ptr;
  35         m_Length = size;
  36     }
  37
  38     CFX_ByteStringC(FX_LPCSTR ptr)
  39     {
  40         m_Ptr = (FX_LPCBYTE)ptr;
  41         m_Length = ptr ? (FX_STRSIZE)FXSYS_strlen(ptr) : 0;
  42     }
  43
  44     // |ch| must be an lvalue that outlives the the CFX_ByteStringC. However,
  45     // the use of char rvalues are not caught at compile time.  They are
  46     // implicitly promoted to CFX_ByteString (see below) and then the
  47     // CFX_ByteStringC is constructed from the CFX_ByteString via the alternate
  48     // constructor below. The CFX_ByteString then typically goes out of scope
  49     // and |m_Ptr| may be left pointing to invalid memory. Beware.
  50     // TODO(tsepez): Mark single-argument string constructors as explicit.
  51     CFX_ByteStringC(FX_CHAR& ch)
  52     {
  53         m_Ptr = (FX_LPCBYTE)&ch;
  54         m_Length = 1;
  55     }
  56
  57     CFX_ByteStringC(FX_LPCSTR ptr, FX_STRSIZE len)
  58     {
  59         m_Ptr = (FX_LPCBYTE)ptr;
  60         if (len == -1) {
  61             m_Length = (FX_STRSIZE)FXSYS_strlen(ptr);
  62         } else {
  63             m_Length = len;
  64         }
  65     }
  66
  67     CFX_ByteStringC(const CFX_ByteStringC& src)
  68     {
  69         m_Ptr = src.m_Ptr;
  70         m_Length = src.m_Length;
  71     }
  72
  73     CFX_ByteStringC(const CFX_ByteString& src);
  74
  75     CFX_ByteStringC& operator = (FX_LPCSTR src)
  76     {
  77         m_Ptr = (FX_LPCBYTE)src;
  78         m_Length = m_Ptr ? (FX_STRSIZE)FXSYS_strlen(src) : 0;
  79         return *this;
  80     }
  81
  82     CFX_ByteStringC& operator = (const CFX_ByteStringC& src)
  83     {
  84         m_Ptr = src.m_Ptr;
  85         m_Length = src.m_Length;
  86         return *this;
  87     }
  88
  89     CFX_ByteStringC& operator = (const CFX_ByteString& src);
  90
  91     bool                        operator == (const CFX_ByteStringC& str) const
  92     {
  93         return  str.m_Length == m_Length && FXSYS_memcmp32(str.m_Ptr, m_Ptr, m_Length) == 0;
  94     }
  95
  96     bool                        operator != (const CFX_ByteStringC& str) const
  97     {
  98         return  str.m_Length != m_Length || FXSYS_memcmp32(str.m_Ptr, m_Ptr, m_Length) != 0;
  99     }
 100 #define FXBSTR_ID(c1, c2, c3, c4) ((c1 << 24) | (c2 << 16) | (c3 << 8) | (c4))
 101
 102     FX_DWORD            GetID(FX_STRSIZE start_pos = 0) const;
 103
 104     FX_LPCBYTE          GetPtr() const
 105     {
 106         return m_Ptr;
 107     }
 108
 109     FX_LPCSTR           GetCStr() const
 110     {
 111         return (FX_LPCSTR)m_Ptr;
 112     }
 113
 114     FX_STRSIZE          GetLength() const
 115     {
 116         return m_Length;
 117     }
 118
 119     bool                        IsEmpty() const
 120     {
 121         return m_Length == 0;
 122     }
 123
 124     operator            FX_LPCBYTE() const
 125     {
 126         return m_Ptr;
 127     }
 128
 129     FX_BYTE                     GetAt(FX_STRSIZE index) const
 130     {
 131         return m_Ptr[index];
 132     }
 133
 134     CFX_ByteStringC     Mid(FX_STRSIZE index, FX_STRSIZE count = -1) const
 135     {
 136         if (index < 0) {
 137             index = 0;
 138         }
 139         if (index > m_Length) {
 140             return CFX_ByteStringC();
 141         }
 142         if (count < 0 || count > m_Length - index) {
 143             count = m_Length - index;
 144         }
 145         return CFX_ByteStringC(m_Ptr + index, count);
 146     }
 147 protected:
 148
 149     FX_LPCBYTE          m_Ptr;
 150
 151     FX_STRSIZE          m_Length;
 152 private:
 153
 154     void*                       operator new (size_t) throw()
 155     {
 156         return NULL;
 157     }
 158 };
 159 typedef const CFX_ByteStringC& FX_BSTR;
 160 #define FX_BSTRC(str) CFX_ByteStringC(str, sizeof str-1)
 161 struct CFX_StringData {
 162
 163     long                m_nRefs;
 164
 165     FX_STRSIZE  m_nDataLength;
 166
 167     FX_STRSIZE  m_nAllocLength;
 168
 169     FX_CHAR             m_String[1];
 170 };
 171 class CFX_ByteString : public CFX_Object
 172 {
 173 public:
 174     typedef FX_CHAR value_type;
 175
 176     CFX_ByteString()
 177     {
 178         m_pData = NULL;
 179     }
 180
 181     CFX_ByteString(const CFX_ByteString& str);
 182
 183     CFX_ByteString(char ch);
 184
 185     CFX_ByteString(FX_LPCSTR ptr, FX_STRSIZE len = -1);
 186
 187     CFX_ByteString(FX_LPCBYTE ptr, FX_STRSIZE len);
 188
 189     CFX_ByteString(FX_BSTR bstrc);
 190
 191     CFX_ByteString(FX_BSTR bstrc1, FX_BSTR bstrc2);
 192
 193     ~CFX_ByteString();
 194
 195     static CFX_ByteString       FromUnicode(FX_LPCWSTR ptr, FX_STRSIZE len = -1);
 196
 197     static CFX_ByteString       FromUnicode(const CFX_WideString& str);
 198
 199     // Explicit conversion to raw string
 200     FX_LPCSTR c_str() const
 201     {
 202         return m_pData ? m_pData->m_String : "";
 203     }
 204
 205     // Implicit conversion to C-style string -- deprecated
 206     operator                            FX_LPCSTR() const
 207     {
 208         return m_pData ? m_pData->m_String : "";
 209     }
 210
 211     operator                            FX_LPCBYTE() const
 212     {
 213         return m_pData ? (FX_LPCBYTE)m_pData->m_String : NULL;
 214     }
 215
 216     FX_STRSIZE                          GetLength() const
 217     {
 218         return m_pData ? m_pData->m_nDataLength : 0;
 219     }
 220
 221     bool                                        IsEmpty() const
 222     {
 223         return !GetLength();
 224     }
 225
 226     int                                         Compare(FX_BSTR str) const;
 227
 228
 229     bool                                        Equal(FX_BSTR str) const;
 230
 231
 232     bool                                        EqualNoCase(FX_BSTR str) const;
 233
 234     bool                                        operator == (FX_LPCSTR str) const
 235     {
 236         return Equal(str);
 237     }
 238
 239     bool                                        operator == (FX_BSTR str) const
 240     {
 241         return Equal(str);
 242     }
 243
 244     bool                                        operator == (const CFX_ByteString& str) const;
 245
 246     bool                                        operator != (FX_LPCSTR str) const
 247     {
 248         return !Equal(str);
 249     }
 250
 251     bool                                        operator != (FX_BSTR str) const
 252     {
 253         return !Equal(str);
 254     }
 255
 256     bool                                        operator != (const CFX_ByteString& str) const
 257     {
 258         return !operator==(str);
 259     }
 260
 261     void                                        Empty();
 262
 263     const CFX_ByteString&       operator = (FX_LPCSTR str);
 264
 265     const CFX_ByteString&       operator = (FX_BSTR bstrc);
 266
 267     const CFX_ByteString&       operator = (const CFX_ByteString& stringSrc);
 268
 269     const CFX_ByteString&       operator = (const CFX_BinaryBuf& buf);
 270
 271     void                                        Load(FX_LPCBYTE str, FX_STRSIZE len);
 272
 273     const CFX_ByteString&       operator += (FX_CHAR ch);
 274
 275     const CFX_ByteString&       operator += (FX_LPCSTR str);
 276
 277     const CFX_ByteString&       operator += (const CFX_ByteString& str);
 278
 279     const CFX_ByteString&       operator += (FX_BSTR bstrc);
 280
 281     FX_BYTE                                     GetAt(FX_STRSIZE nIndex) const
 282     {
 283         return m_pData ? m_pData->m_String[nIndex] : 0;
 284     }
 285
 286     FX_BYTE                                     operator[](FX_STRSIZE nIndex) const
 287     {
 288         return m_pData ? m_pData->m_String[nIndex] : 0;
 289     }
 290
 291     void                                        SetAt(FX_STRSIZE nIndex, FX_CHAR ch);
 292
 293     FX_STRSIZE                          Insert(FX_STRSIZE index, FX_CHAR ch);
 294
 295     FX_STRSIZE                          Delete(FX_STRSIZE index, FX_STRSIZE count = 1);
 296
 297
 298     void                                        Format(FX_LPCSTR lpszFormat, ... );
 299
 300     void                                        FormatV(FX_LPCSTR lpszFormat, va_list argList);
 301
 302
 303     void                                        Reserve(FX_STRSIZE len);
 304
 305     FX_LPSTR                            GetBuffer(FX_STRSIZE len);
 306
 307     FX_LPSTR                            LockBuffer();
 308
 309     void                                        ReleaseBuffer(FX_STRSIZE len = -1);
 310
 311     CFX_ByteString                      Mid(FX_STRSIZE first) const;
 312
 313     CFX_ByteString                      Mid(FX_STRSIZE first, FX_STRSIZE count) const;
 314
 315     CFX_ByteString                      Left(FX_STRSIZE count) const;
 316
 317     CFX_ByteString                      Right(FX_STRSIZE count) const;
 318
 319     FX_STRSIZE                          Find(FX_BSTR lpszSub, FX_STRSIZE start = 0) const;
 320
 321     FX_STRSIZE                          Find(FX_CHAR ch, FX_STRSIZE start = 0) const;
 322
 323     FX_STRSIZE                          ReverseFind(FX_CHAR ch) const;
 324
 325     void                                        MakeLower();
 326
 327     void                                        MakeUpper();
 328
 329     void                                        TrimRight();
 330
 331     void                                        TrimRight(FX_CHAR chTarget);
 332
 333     void                                        TrimRight(FX_BSTR lpszTargets);
 334
 335     void                                        TrimLeft();
 336
 337     void                                        TrimLeft(FX_CHAR chTarget);
 338
 339     void                                        TrimLeft(FX_BSTR lpszTargets);
 340
 341     FX_STRSIZE                          Replace(FX_BSTR lpszOld, FX_BSTR lpszNew);
 342
 343     FX_STRSIZE                          Remove(FX_CHAR ch);
 344
 345     CFX_WideString                      UTF8Decode() const;
 346
 347     void                                        ConvertFrom(const CFX_WideString& str, CFX_CharMap* pCharMap = NULL);
 348
 349     FX_DWORD                            GetID(FX_STRSIZE start_pos = 0) const;
 350
 351 #define FXFORMAT_SIGNED                 1
 352 #define FXFORMAT_HEX                    2
 353 #define FXFORMAT_CAPITAL                4
 354
 355     static CFX_ByteString       FormatInteger(int i, FX_DWORD flags = 0);
 356
 357     static CFX_ByteString       FormatFloat(FX_FLOAT f, int precision = 0);
 358 protected:
 359
 360     struct CFX_StringData*      m_pData;
 361     void                                        AllocCopy(CFX_ByteString& dest, FX_STRSIZE nCopyLen, FX_STRSIZE nCopyIndex) const;
 362     void                                        AssignCopy(FX_STRSIZE nSrcLen, FX_LPCSTR lpszSrcData);
 363     void                                        ConcatCopy(FX_STRSIZE nSrc1Len, FX_LPCSTR lpszSrc1Data, FX_STRSIZE nSrc2Len, FX_LPCSTR lpszSrc2Data);
 364     void                                        ConcatInPlace(FX_STRSIZE nSrcLen, FX_LPCSTR lpszSrcData);
 365     void                                        CopyBeforeWrite();
 366     void                                        AllocBeforeWrite(FX_STRSIZE nLen);
 367 };
 368 inline CFX_ByteStringC::CFX_ByteStringC(const CFX_ByteString& src)
 369 {
 370     m_Ptr = (FX_LPCBYTE)src;
 371     m_Length = src.GetLength();
 372 }
 373 inline CFX_ByteStringC& CFX_ByteStringC::operator = (const CFX_ByteString& src)
 374 {
 375     m_Ptr = (FX_LPCBYTE)src;
 376     m_Length = src.GetLength();
 377     return *this;
 378 }
 379
 380 inline CFX_ByteString operator + (FX_BSTR str1, FX_BSTR str2)
 381 {
 382     return CFX_ByteString(str1, str2);
 383 }
 384 inline CFX_ByteString operator + (FX_BSTR str1, FX_LPCSTR str2)
 385 {
 386     return CFX_ByteString(str1, str2);
 387 }
 388 inline CFX_ByteString operator + (FX_LPCSTR str1, FX_BSTR str2)
 389 {
 390     return CFX_ByteString(str1, str2);
 391 }
 392 inline CFX_ByteString operator + (FX_BSTR str1, FX_CHAR ch)
 393 {
 394     return CFX_ByteString(str1, CFX_ByteStringC(ch));
 395 }
 396 inline CFX_ByteString operator + (FX_CHAR ch, FX_BSTR str2)
 397 {
 398     return CFX_ByteString(ch, str2);
 399 }
 400 inline CFX_ByteString operator + (const CFX_ByteString& str1, const CFX_ByteString& str2)
 401 {
 402     return CFX_ByteString(str1, str2);
 403 }
 404 inline CFX_ByteString operator + (const CFX_ByteString& str1, FX_CHAR ch)
 405 {
 406     return CFX_ByteString(str1, CFX_ByteStringC(ch));
 407 }
 408 inline CFX_ByteString operator + (FX_CHAR ch, const CFX_ByteString& str2)
 409 {
 410     return CFX_ByteString(ch, str2);
 411 }
 412 inline CFX_ByteString operator + (const CFX_ByteString& str1, FX_LPCSTR str2)
 413 {
 414     return CFX_ByteString(str1, str2);
 415 }
 416 inline CFX_ByteString operator + (FX_LPCSTR str1, const CFX_ByteString& str2)
 417 {
 418     return CFX_ByteString(str1, str2);
 419 }
 420 inline CFX_ByteString operator + (const CFX_ByteString& str1, FX_BSTR str2)
 421 {
 422     return CFX_ByteString(str1, str2);
 423 }
 424 inline CFX_ByteString operator + (FX_BSTR str1, const CFX_ByteString& str2)
 425 {
 426     return CFX_ByteString(str1, str2);
 427 }
 428 class CFX_StringBufBase : public CFX_Object
 429 {
 430 public:
 431
 432     CFX_StringBufBase(FX_STRSIZE limit)
 433     {
 434         m_Size = 0;
 435         m_Limit = limit;
 436     }
 437
 438     FX_CHAR*    GetPtr() const
 439     {
 440         return (FX_CHAR*)(this + 1);
 441     }
 442
 443     FX_STRSIZE  GetSize() const
 444     {
 445         return m_Size;
 446     }
 447
 448     void                Empty()
 449     {
 450         m_Size = 0;
 451     }
 452
 453     void                Copy(FX_BSTR str);
 454
 455     void                Append(FX_BSTR str);
 456
 457     void                Append(int i, FX_DWORD flags = 0);
 458
 459     CFX_ByteStringC             GetStringC() const
 460     {
 461         return CFX_ByteStringC((FX_CHAR*)(this + 1), m_Size);
 462     }
 463
 464     CFX_ByteString              GetString() const
 465     {
 466         return CFX_ByteString((FX_CHAR*)(this + 1), m_Size);
 467     }
 468 protected:
 469
 470     FX_STRSIZE  m_Limit;
 471
 472     FX_STRSIZE  m_Size;
 473 };
 474 template<FX_STRSIZE limit>
 475 class CFX_StringBufTemplate : public CFX_StringBufBase
 476 {
 477 public:
 478
 479     CFX_StringBufTemplate() : CFX_StringBufBase(limit) {}
 480
 481     FX_CHAR             m_Buffer[limit];
 482 };
 483 typedef CFX_StringBufTemplate<256> CFX_StringBuf256;
 484 class CFX_WideStringC : public CFX_Object
 485 {
 486 public:
 487     typedef FX_WCHAR value_type;
 488
 489     CFX_WideStringC()
 490     {
 491         m_Ptr = NULL;
 492         m_Length = 0;
 493     }
 494
 495     CFX_WideStringC(FX_LPCWSTR ptr)
 496     {
 497         m_Ptr = ptr;
 498         m_Length = ptr ? (FX_STRSIZE)FXSYS_wcslen(ptr) : 0;
 499     }
 500
 501     CFX_WideStringC(FX_WCHAR& ch)
 502     {
 503         m_Ptr = &ch;
 504         m_Length = 1;
 505     }
 506
 507     CFX_WideStringC(FX_LPCWSTR ptr, FX_STRSIZE len)
 508     {
 509         m_Ptr = ptr;
 510         if (len == -1) {
 511             m_Length = (FX_STRSIZE)FXSYS_wcslen(ptr);
 512         } else {
 513             m_Length = len;
 514         }
 515     }
 516
 517     CFX_WideStringC(const CFX_WideStringC& src)
 518     {
 519         m_Ptr = src.m_Ptr;
 520         m_Length = src.m_Length;
 521     }
 522
 523     CFX_WideStringC(const CFX_WideString& src);
 524
 525     CFX_WideStringC& operator = (FX_LPCWSTR src)
 526     {
 527         m_Ptr = src;
 528         m_Length = (FX_STRSIZE)FXSYS_wcslen(src);
 529         return *this;
 530     }
 531
 532     CFX_WideStringC& operator = (const CFX_WideStringC& src)
 533     {
 534         m_Ptr = src.m_Ptr;
 535         m_Length = src.m_Length;
 536         return *this;
 537     }
 538
 539     CFX_WideStringC& operator = (const CFX_WideString& src);
 540
 541     bool                        operator == (const CFX_WideStringC& str) const
 542     {
 543         return  str.m_Length == m_Length && FXSYS_memcmp32(str.m_Ptr, m_Ptr, m_Length * sizeof(FX_WCHAR)) == 0;
 544     }
 545
 546     bool                        operator != (const CFX_WideStringC& str) const
 547     {
 548         return  str.m_Length != m_Length || FXSYS_memcmp32(str.m_Ptr, m_Ptr, m_Length * sizeof(FX_WCHAR)) != 0;
 549     }
 550
 551     FX_LPCWSTR          GetPtr() const
 552     {
 553         return m_Ptr;
 554     }
 555
 556     FX_STRSIZE          GetLength() const
 557     {
 558         return m_Length;
 559     }
 560
 561     bool                        IsEmpty() const
 562     {
 563         return m_Length == 0;
 564     }
 565
 566     FX_WCHAR            GetAt(FX_STRSIZE index) const
 567     {
 568         return m_Ptr[index];
 569     }
 570
 571     CFX_WideStringC     Left(FX_STRSIZE count) const
 572     {
 573         if (count < 1) {
 574             return CFX_WideStringC();
 575         }
 576         if (count > m_Length) {
 577             count = m_Length;
 578         }
 579         return CFX_WideStringC(m_Ptr, count);
 580     }
 581
 582     CFX_WideStringC     Mid(FX_STRSIZE index, FX_STRSIZE count = -1) const
 583     {
 584         if (index < 0) {
 585             index = 0;
 586         }
 587         if (index > m_Length) {
 588             return CFX_WideStringC();
 589         }
 590         if (count < 0 || count > m_Length - index) {
 591             count = m_Length - index;
 592         }
 593         return CFX_WideStringC(m_Ptr + index, count);
 594     }
 595
 596     CFX_WideStringC     Right(FX_STRSIZE count) const
 597     {
 598         if (count < 1) {
 599             return CFX_WideStringC();
 600         }
 601         if (count > m_Length) {
 602             count = m_Length;
 603         }
 604         return CFX_WideStringC(m_Ptr + m_Length - count, count);
 605     }
 606 protected:
 607
 608     FX_LPCWSTR          m_Ptr;
 609
 610     FX_STRSIZE          m_Length;
 611 private:
 612
 613     void*                       operator new (size_t) throw()
 614     {
 615         return NULL;
 616     }
 617 };
 618 typedef const CFX_WideStringC&  FX_WSTR;
 619 #define FX_WSTRC(wstr) CFX_WideStringC(wstr, FX_ArraySize(wstr) - 1)
 620 struct CFX_StringDataW {
 621
 622     long                m_nRefs;
 623
 624     FX_STRSIZE  m_nDataLength;
 625
 626     FX_STRSIZE  m_nAllocLength;
 627
 628     FX_WCHAR    m_String[1];
 629 };
 630 class CFX_WideString : public CFX_Object
 631 {
 632 public:
 633     typedef FX_WCHAR value_type;
 634
 635     CFX_WideString()
 636     {
 637         m_pData = NULL;
 638     }
 639
 640     CFX_WideString(const CFX_WideString& str);
 641
 642     CFX_WideString(FX_LPCWSTR ptr, FX_STRSIZE len = -1)
 643     {
 644         InitStr(ptr, len);
 645     }
 646
 647     CFX_WideString(FX_WCHAR ch);
 648
 649     CFX_WideString(const CFX_WideStringC& str);
 650
 651     CFX_WideString(const CFX_WideStringC& str1, const CFX_WideStringC& str2);
 652
 653     ~CFX_WideString();
 654
 655     static CFX_WideString       FromLocal(const char* str, FX_STRSIZE len = -1);
 656
 657     static CFX_WideString       FromUTF8(const char* str, FX_STRSIZE len);
 658
 659     static CFX_WideString       FromUTF16LE(const unsigned short* str, FX_STRSIZE len);
 660
 661     static FX_STRSIZE       WStringLength(const unsigned short* str);
 662
 663     // Explicit conversion to raw string
 664     FX_LPCWSTR c_str() const
 665     {
 666         return m_pData ? m_pData->m_String : L"";
 667     }
 668
 669     // Implicit conversion to C-style wide string -- deprecated
 670     operator FX_LPCWSTR() const
 671     {
 672         return m_pData ? m_pData->m_String : L"";
 673     }
 674
 675     void                                        Empty();
 676
 677
 678     FX_BOOL                                     IsEmpty() const
 679     {
 680         return !GetLength();
 681     }
 682
 683     FX_STRSIZE                          GetLength() const
 684     {
 685         return m_pData ? m_pData->m_nDataLength : 0;
 686     }
 687
 688     const CFX_WideString&       operator = (FX_LPCWSTR str);
 689
 690     const CFX_WideString&       operator =(const CFX_WideString& stringSrc);
 691
 692     const CFX_WideString&       operator =(const CFX_WideStringC& stringSrc);
 693
 694     const CFX_WideString&       operator += (FX_LPCWSTR str);
 695
 696     const CFX_WideString&       operator += (FX_WCHAR ch);
 697
 698     const CFX_WideString&       operator += (const CFX_WideString& str);
 699
 700     const CFX_WideString&       operator += (const CFX_WideStringC& str);
 701
 702     FX_WCHAR                            GetAt(FX_STRSIZE nIndex) const
 703     {
 704         return m_pData ? m_pData->m_String[nIndex] : 0;
 705     }
 706
 707     FX_WCHAR                            operator[](FX_STRSIZE nIndex) const
 708     {
 709         return m_pData ? m_pData->m_String[nIndex] : 0;
 710     }
 711
 712     void                                        SetAt(FX_STRSIZE nIndex, FX_WCHAR ch);
 713
 714     int                                         Compare(FX_LPCWSTR str) const;
 715
 716     int                                         Compare(const CFX_WideString& str) const;
 717
 718     int                                         CompareNoCase(FX_LPCWSTR str) const;
 719
 720     bool                                        Equal(const CFX_WideStringC& str) const;
 721
 722     CFX_WideString                      Mid(FX_STRSIZE first) const;
 723
 724     CFX_WideString                      Mid(FX_STRSIZE first, FX_STRSIZE count) const;
 725
 726     CFX_WideString                      Left(FX_STRSIZE count) const;
 727
 728     CFX_WideString                      Right(FX_STRSIZE count) const;
 729
 730     FX_STRSIZE                          Insert(FX_STRSIZE index, FX_WCHAR ch);
 731
 732     FX_STRSIZE                          Delete(FX_STRSIZE index, FX_STRSIZE count = 1);
 733
 734     void                                        Format(FX_LPCWSTR lpszFormat, ... );
 735
 736     void                                        FormatV(FX_LPCWSTR lpszFormat, va_list argList);
 737
 738     void                                        MakeLower();
 739
 740     void                                        MakeUpper();
 741
 742     void                                        TrimRight();
 743
 744     void                                        TrimRight(FX_WCHAR chTarget);
 745
 746     void                                        TrimRight(FX_LPCWSTR lpszTargets);
 747
 748     void                                        TrimLeft();
 749
 750     void                                        TrimLeft(FX_WCHAR chTarget);
 751
 752     void                                        TrimLeft(FX_LPCWSTR lpszTargets);
 753
 754     void                                        Reserve(FX_STRSIZE len);
 755
 756     FX_LPWSTR                           GetBuffer(FX_STRSIZE len);
 757
 758     FX_LPWSTR                           LockBuffer();
 759
 760     void                                        ReleaseBuffer(FX_STRSIZE len = -1);
 761
 762     int                                         GetInteger() const;
 763
 764     FX_FLOAT                            GetFloat() const;
 765
 766     FX_STRSIZE                          Find(FX_LPCWSTR lpszSub, FX_STRSIZE start = 0) const;
 767
 768     FX_STRSIZE                          Find(FX_WCHAR ch, FX_STRSIZE start = 0) const;
 769
 770     FX_STRSIZE                          Replace(FX_LPCWSTR lpszOld, FX_LPCWSTR lpszNew);
 771
 772     FX_STRSIZE                          Remove(FX_WCHAR ch);
 773
 774     CFX_ByteString                      UTF8Encode() const;
 775
 776     CFX_ByteString                      UTF16LE_Encode() const;
 777
 778     void                                        ConvertFrom(const CFX_ByteString& str, CFX_CharMap* pCharMap = NULL);
 779 protected:
 780     void                                        InitStr(FX_LPCWSTR ptr, int len);
 781
 782     CFX_StringDataW*            m_pData;
 783     void                                        CopyBeforeWrite();
 784     void                                        AllocBeforeWrite(FX_STRSIZE nLen);
 785     void                                        ConcatInPlace(FX_STRSIZE nSrcLen, FX_LPCWSTR lpszSrcData);
 786     void                                        ConcatCopy(FX_STRSIZE nSrc1Len, FX_LPCWSTR lpszSrc1Data, FX_STRSIZE nSrc2Len, FX_LPCWSTR lpszSrc2Data);
 787     void                                        AssignCopy(FX_STRSIZE nSrcLen, FX_LPCWSTR lpszSrcData);
 788     void                                        AllocCopy(CFX_WideString& dest, FX_STRSIZE nCopyLen, FX_STRSIZE nCopyIndex) const;
 789 };
 790 inline CFX_WideStringC::CFX_WideStringC(const CFX_WideString& src)
 791 {
 792     m_Ptr = src.c_str();
 793     m_Length = src.GetLength();
 794 }
 795 inline CFX_WideStringC& CFX_WideStringC::operator = (const CFX_WideString& src)
 796 {
 797     m_Ptr = src.c_str();
 798     m_Length = src.GetLength();
 799     return *this;
 800 }
 801
 802 inline CFX_WideString operator + (const CFX_WideStringC& str1, const CFX_WideStringC& str2)
 803 {
 804     return CFX_WideString(str1, str2);
 805 }
 806 inline CFX_WideString operator + (const CFX_WideStringC& str1, FX_LPCWSTR str2)
 807 {
 808     return CFX_WideString(str1, str2);
 809 }
 810 inline CFX_WideString operator + (FX_LPCWSTR str1, const CFX_WideStringC& str2)
 811 {
 812     return CFX_WideString(str1, str2);
 813 }
 814 inline CFX_WideString operator + (const CFX_WideStringC& str1, FX_WCHAR ch)
 815 {
 816     return CFX_WideString(str1, CFX_WideStringC(ch));
 817 }
 818 inline CFX_WideString operator + (FX_WCHAR ch, const CFX_WideStringC& str2)
 819 {
 820     return CFX_WideString(ch, str2);
 821 }
 822 inline CFX_WideString operator + (const CFX_WideString& str1, const CFX_WideString& str2)
 823 {
 824     return CFX_WideString(str1, str2);
 825 }
 826 inline CFX_WideString operator + (const CFX_WideString& str1, FX_WCHAR ch)
 827 {
 828     return CFX_WideString(str1, CFX_WideStringC(ch));
 829 }
 830 inline CFX_WideString operator + (FX_WCHAR ch, const CFX_WideString& str2)
 831 {
 832     return CFX_WideString(ch, str2);
 833 }
 834 inline CFX_WideString operator + (const CFX_WideString& str1, FX_LPCWSTR str2)
 835 {
 836     return CFX_WideString(str1, str2);
 837 }
 838 inline CFX_WideString operator + (FX_LPCWSTR str1, const CFX_WideString& str2)
 839 {
 840     return CFX_WideString(str1, str2);
 841 }
 842 inline CFX_WideString operator + (const CFX_WideString& str1, const CFX_WideStringC& str2)
 843 {
 844     return CFX_WideString(str1, str2);
 845 }
 846 inline CFX_WideString operator + (const CFX_WideStringC& str1, const CFX_WideString& str2)
 847 {
 848     return CFX_WideString(str1, str2);
 849 }
 850
 851 bool operator==(const CFX_WideString& s1, const CFX_WideString& s2);
 852 bool operator==(const CFX_WideString& s1, const CFX_WideStringC& s2);
 853 bool operator==(const CFX_WideStringC& s1, const CFX_WideString& s2);
 854 bool operator== (const CFX_WideString& s1, FX_LPCWSTR s2);
 855 bool operator==(FX_LPCWSTR s1, const CFX_WideString& s2);
 856 bool operator!=(const CFX_WideString& s1, const CFX_WideString& s2);
 857 bool operator!=(const CFX_WideString& s1, const CFX_WideStringC& s2);
 858 bool operator!=(const CFX_WideStringC& s1, const CFX_WideString& s2);
 859 bool operator!= (const CFX_WideString& s1, FX_LPCWSTR s2);
 860 bool operator!=(FX_LPCWSTR s1, const CFX_WideString& s2);
 861 FX_FLOAT FX_atof(FX_BSTR str);
 862 void FX_atonum(FX_BSTR str, FX_BOOL& bInteger, void* pData);
 863 FX_STRSIZE FX_ftoa(FX_FLOAT f, FX_LPSTR buf);
 864 CFX_ByteString  FX_UTF8Encode(FX_LPCWSTR pwsStr, FX_STRSIZE len);
 865 inline CFX_ByteString   FX_UTF8Encode(FX_WSTR wsStr)
 866 {
 867     return FX_UTF8Encode(wsStr.GetPtr(), wsStr.GetLength());
 868 }
 869 inline CFX_ByteString   FX_UTF8Encode(const CFX_WideString &wsStr)
 870 {
 871     return FX_UTF8Encode(wsStr.c_str(), wsStr.GetLength());
 872 }
 873 #endif