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