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