Commit before breaking everything
[matches/honours.git] / research / transmission_spectroscopy / TOF / Win32++ / include / cstring.h
1 // Win32++   Version 7.3\r
2 // Released: 30th November 2011\r
3 //\r
4 //      David Nash\r
5 //      email: [email protected]\r
6 //      url: https://sourceforge.net/projects/win32-framework\r
7 //\r
8 //\r
9 // Copyright (c) 2005-2011  David Nash\r
10 //\r
11 // Permission is hereby granted, free of charge, to\r
12 // any person obtaining a copy of this software and\r
13 // associated documentation files (the "Software"),\r
14 // to deal in the Software without restriction, including\r
15 // without limitation the rights to use, copy, modify,\r
16 // merge, publish, distribute, sublicense, and/or sell\r
17 // copies of the Software, and to permit persons to whom\r
18 // the Software is furnished to do so, subject to the\r
19 // following conditions:\r
20 //\r
21 // The above copyright notice and this permission notice\r
22 // shall be included in all copies or substantial portions\r
23 // of the Software.\r
24 //\r
25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF\r
26 // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\r
27 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\r
28 // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\r
29 // SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR\r
30 // ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
31 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
32 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE\r
33 // OR OTHER DEALINGS IN THE SOFTWARE.\r
34 //\r
35 ////////////////////////////////////////////////////////\r
36 \r
37 \r
38 // Acknowledgements:\r
39 // Thanks to Adam Szulc for his initial CString code.\r
40 \r
41 ////////////////////////////////////////////////////////\r
42 // cstring.h\r
43 //  Declaration of the cstring.h\r
44 \r
45 // This class is intended to provide a simple alternative to the MFC/ATL\r
46 // CString class that ships with Microsoft compilers. The CString class\r
47 // specified here is compatible with other compilers such as Borland 5.5\r
48 // and MinGW.\r
49 \r
50 // Differences between this class and the MFC/ATL CString class\r
51 // ------------------------------------------------------------\r
52 // 1) The constructors for this class accepts both ANSI and Unicode characters and\r
53 //    automatically converts these to TCHAR as required.\r
54 //\r
55 // 2) This class is not reference counted, so these CStrings should be passed as\r
56 //    references or const references when used as function arguments. As a result there\r
57 //    is no need for functions like LockBuffer and UnLockBuffer.\r
58 //\r
59 // 3) The Format functions only accepts POD (Plain Old Data) arguments. It does not\r
60 //    accept arguments which are class or struct objects. In particular it does not\r
61 //    accept CString objects, unless these are cast to LPCTSTR.\r
62 //    This is demonstrates valid and invalid usage:\r
63 //      CString string1(_T("Hello World"));\r
64 //      CString string2;\r
65 //\r
66 //      // This is invalid, and produces undefined behaviour.\r
67 //      string2.Format(_T("String1 is: %s"), string1); // No! you can't do this\r
68 //\r
69 //      // This is ok\r
70 //      string2.Format(_T("String1 is: %s"), (LPCTSTR)string1); // Yes, this is correct\r
71 //\r
72 //    Note: The MFC/ATL CString class uses a non portable hack to make its CString class\r
73 //          behave like a POD. Other compilers (such as the MinGW compiler) specifically\r
74 //          prohibit the use of non POD types for functions with variable argument lists.\r
75 //\r
76 // 4) This class provides a few additional functions:\r
77 //       c_str                  Returns a const TCHAR string. This is an alternative for casting to LPCTSTR.\r
78 //       GetErrorString Assigns CString to the error string for the specified System Error Code\r
79 //                      (from ::GetLastErrror() for example).\r
80 //       GetString              Returns a reference to the underlying std::basic_string<TCHAR>. This\r
81 //                                              reference can be used to modify the string directly.\r
82 \r
83 \r
84 \r
85 #ifndef _WIN32XX_CSTRING_H_\r
86 #define _WIN32XX_CSTRING_H_\r
87 \r
88 \r
89 #include "wincore.h"\r
90 \r
91 \r
92 namespace Win32xx\r
93 {\r
94 \r
95         class CString\r
96         {\r
97                 // friend functions allow the left hand side to be something other than CString\r
98                 friend CString operator + (const CString& string1, const CString& string2);\r
99                 friend CString operator + (const CString& string, LPCTSTR pszText);\r
100                 friend CString operator + (const CString& string, TCHAR ch);\r
101                 friend CString operator + (LPCTSTR pszText, const CString& string);\r
102                 friend CString operator + (TCHAR ch, const CString& string);\r
103                 friend bool    operator < (const CString& string1, const CString& string2);\r
104                 friend bool    operator > (const CString& string1, const CString& string2);\r
105                 friend bool    operator < (const CString& string1, LPCTSTR pszText);\r
106                 friend bool    operator > (const CString& string1, LPCTSTR pszText);\r
107                 friend bool    operator <= (const CString& string1, const CString& string2);\r
108                 friend bool    operator >= (const CString& string1, const CString& string2);\r
109                 friend bool    operator <= (const CString& string1, LPCTSTR pszText);\r
110                 friend bool    operator >= (const CString& string1, LPCTSTR pszText);\r
111 \r
112         public:\r
113                 CString();\r
114                 ~CString();\r
115                 CString(const CString& str);\r
116                 CString(LPCSTR pszText);\r
117                 CString(LPCWSTR pszText);\r
118                 CString(TCHAR ch, int nLength = 1);\r
119                 CString(LPCTSTR pszText, int nLength);\r
120 \r
121                 CString& operator = (const CString& str);\r
122                 CString& operator = (const TCHAR ch);\r
123                 CString& operator = (LPCSTR pszText);\r
124                 CString& operator = (LPCWSTR pszText);\r
125                 bool     operator == (LPCTSTR pszText);\r
126                 bool     operator != (LPCTSTR pszText);\r
127                                  operator LPCTSTR() const;\r
128                 TCHAR&   operator [] (int nIndex);\r
129                 CString& operator += (const CString& str);\r
130                 CString& operator += (LPCSTR szText);\r
131                 CString& operator += (LPCWSTR szText);\r
132 \r
133                 // Attributes\r
134                 LPCTSTR  c_str() const          { return m_str.c_str(); }               // alternative for casting to LPCTSTR\r
135                 tString& GetString()            { return m_str; }                               // returns a reference to the underlying std::basic_string<TCHAR>\r
136                 int      GetLength() const      { return (int)m_str.length(); } // returns the length in characters\r
137 \r
138                 // Operations\r
139                 BSTR     AllocSysString() const;\r
140                 void     AppendFormat(LPCTSTR pszFormat,...);\r
141                 void     AppendFormat(UINT nFormatID, ...);\r
142                 int      Compare(LPCTSTR pszText) const;\r
143                 int      CompareNoCase(LPCTSTR pszText) const;\r
144                 int      Delete(int nIndex, int nCount = 1);\r
145                 int              Find(TCHAR ch, int nIndex = 0 ) const;\r
146                 int      Find(LPCTSTR pszText, int nStart = 0) const;\r
147                 int              FindOneOf(LPCTSTR pszText) const;\r
148                 void     Format(UINT nID, ...);\r
149                 void     Format(LPCTSTR pszFormat,...);\r
150                 void     FormatV(LPCTSTR pszFormat, va_list args);\r
151                 void     FormatMessage(LPCTSTR pszFormat,...);\r
152                 void     FormatMessageV(LPCTSTR pszFormat, va_list args);\r
153                 TCHAR    GetAt(int nIndex) const;\r
154                 LPTSTR   GetBuffer(int nMinBufLength);\r
155                 void     GetErrorString(DWORD dwError);\r
156                 void     Empty();\r
157                 int      Insert(int nIndex, TCHAR ch);\r
158                 int      Insert(int nIndex, const CString& str);\r
159                 bool     IsEmpty() const;\r
160                 CString  Left(int nCount) const;\r
161                 bool     LoadString(UINT nID);\r
162                 void     MakeLower();\r
163                 void     MakeReverse();\r
164                 void     MakeUpper();\r
165                 CString  Mid(int nFirst) const;\r
166                 CString  Mid(int nFirst, int nCount) const;\r
167                 void     ReleaseBuffer( int nNewLength = -1 );\r
168                 int      Remove(LPCTSTR pszText);\r
169                 int      Replace(TCHAR chOld, TCHAR chNew);\r
170                 int      Replace(const LPCTSTR pszOld, LPCTSTR pszNew);\r
171                 int      ReverseFind(LPCTSTR pszText, int nStart = -1) const;\r
172                 CString  Right(int nCount) const;\r
173                 void     SetAt(int nIndex, TCHAR ch);\r
174                 BSTR     SetSysString(BSTR* pBstr) const;\r
175                 CString  SpanExcluding(LPCTSTR pszText) const;\r
176                 CString  SpanIncluding(LPCTSTR pszText) const;\r
177                 CString  Tokenize(LPCTSTR pszTokens, int& iStart) const;\r
178                 void     Trim();\r
179                 void     TrimLeft();\r
180                 void     TrimLeft(TCHAR chTarget);\r
181                 void     TrimLeft(LPCTSTR pszTargets);\r
182                 void     TrimRight();\r
183                 void     TrimRight(TCHAR chTarget);\r
184                 void     TrimRight(LPCTSTR pszTargets);\r
185                 void     Truncate(int nNewLength);\r
186 \r
187 #ifndef _WIN32_WCE\r
188                 int      Collate(LPCTSTR pszText) const;\r
189                 int              CollateNoCase(LPCTSTR pszText) const;\r
190                 bool     GetEnvironmentVariable(LPCTSTR pszVar);\r
191 #endif\r
192 \r
193         private:\r
194                 tString m_str;\r
195                 std::vector<TCHAR> m_buf;\r
196         };\r
197 \r
198         inline CString::CString()\r
199         {\r
200         }\r
201 \r
202         inline CString::~CString()\r
203         {\r
204         }\r
205 \r
206         inline CString::CString(const CString& str)\r
207         {\r
208                 m_str.assign(str);\r
209         }\r
210 \r
211         inline CString::CString(LPCSTR pszText)\r
212         {\r
213                 m_str.assign(A2T(pszText));\r
214         }\r
215 \r
216         inline CString::CString(LPCWSTR pszText)\r
217         {\r
218                 m_str.assign(W2T(pszText));\r
219         }\r
220 \r
221         inline CString::CString(TCHAR ch, int nLength)\r
222         {\r
223                 m_str.assign(nLength, ch);\r
224         }\r
225 \r
226         inline CString::CString(LPCTSTR pszText, int nLength)\r
227         {\r
228                 m_str.assign(pszText, nLength);\r
229         }\r
230 \r
231         inline CString& CString::operator = (const CString& str)\r
232         {\r
233                 m_str.assign(str);\r
234                 return *this;\r
235         }\r
236 \r
237         inline CString& CString::operator = (const TCHAR ch)\r
238         {\r
239                 m_str.assign(1, ch);\r
240                 return *this;\r
241         }\r
242 \r
243         inline CString& CString::operator = (LPCSTR pszText)\r
244         {\r
245                 m_str.assign(A2T(pszText));\r
246                 return *this;\r
247         }\r
248 \r
249         inline CString& CString::operator = (LPCWSTR pszText)\r
250         {\r
251                 m_str.assign(W2T(pszText));\r
252                 return *this;\r
253         }\r
254 \r
255         inline bool CString::operator == (LPCTSTR pszText)\r
256         // Returns TRUE if the strings have the same content\r
257         {\r
258                 assert(pszText);\r
259                 return (0 == Compare(pszText));\r
260         }\r
261 \r
262         inline bool CString::operator != (LPCTSTR pszText)\r
263         // Returns TRUE if the strings have a different content\r
264         {\r
265                 assert(pszText);\r
266         return Compare(pszText) != 0;\r
267         }\r
268 \r
269         inline CString::operator LPCTSTR() const\r
270         {\r
271                 return m_str.c_str();\r
272         }\r
273 \r
274         inline TCHAR& CString::operator [] (int nIndex)\r
275         {\r
276                 assert(nIndex >= 0);\r
277                 assert(nIndex < GetLength());\r
278                 return m_str[nIndex];\r
279         }\r
280 \r
281         inline CString& CString::operator += (const CString& str)\r
282         {\r
283                 m_str.append(str);\r
284                 return *this;\r
285         }\r
286 \r
287         inline CString& CString::operator += (LPCSTR szText)\r
288         {\r
289                 m_str.append(A2T(szText));\r
290                 return *this;\r
291         }\r
292 \r
293         inline CString& CString::operator += (LPCWSTR szText)\r
294         {\r
295                 m_str.append(W2T(szText));\r
296                 return *this;\r
297         }\r
298 \r
299         inline BSTR CString::AllocSysString() const\r
300         // Allocates a BSTR from the CString content.\r
301         {\r
302                 return ::SysAllocStringLen(T2W(m_str.c_str()), (UINT)m_str.size());\r
303         }\r
304 \r
305         inline void CString::AppendFormat(LPCTSTR pszFormat,...)\r
306         // Appends formatted data to an the CString content.\r
307         {\r
308                 CString str;\r
309 \r
310                 va_list args;\r
311                 va_start(args, pszFormat);\r
312                 str.FormatV(pszFormat, args);\r
313                 va_end(args);\r
314 \r
315                 m_str.append(str);\r
316         }\r
317 \r
318         inline void CString::AppendFormat(UINT nFormatID, ...)\r
319         // Appends formatted data to an the CString content.\r
320         {\r
321                 CString str1;\r
322                 CString str2;\r
323 \r
324                 if (str1.LoadString(nFormatID))\r
325                 {\r
326                         va_list args;\r
327                         va_start(args, nFormatID);\r
328                         str2.FormatV(str1.c_str(), args);\r
329                         va_end(args);\r
330 \r
331                         m_str.append(str2);\r
332                 }\r
333         }\r
334 \r
335 #ifndef _WIN32_WCE\r
336         inline int CString::Collate(LPCTSTR pszText) const\r
337         // Performs a case sensitive comparison of the two strings using locale-specific information.\r
338         {\r
339                 assert(pszText);\r
340                 return _tcscoll(m_str.c_str(), pszText);\r
341         }\r
342 \r
343         inline int CString::CollateNoCase(LPCTSTR pszText) const\r
344         // Performs a case insensitive comparison of the two strings using locale-specific information.\r
345         {\r
346                 assert(pszText);\r
347                 return _tcsicoll(m_str.c_str(), pszText);\r
348         }\r
349 #endif  // _WIN32_WCE\r
350 \r
351         inline int CString::Compare(LPCTSTR pszText) const\r
352         // Performs a case sensitive comparison of the two strings.\r
353         {\r
354                 assert(pszText);\r
355                 return _tcscmp(m_str.data(), pszText);\r
356         }\r
357 \r
358         inline int CString::CompareNoCase(LPCTSTR pszText) const\r
359         // Performs a case insensitive comparison of the two strings.\r
360         {\r
361                 assert(pszText);\r
362                 return _tcsicmp(m_str.data(), pszText);\r
363         }\r
364 \r
365         inline int CString::Delete(int nIndex, int nCount /* = 1 */)\r
366         // Deletes a character or characters from the string.\r
367         {\r
368                 assert(nIndex >= 0);\r
369                 assert(nCount >= 0);\r
370 \r
371                 m_str.erase(nIndex, nCount);\r
372                 return (int)m_str.size();\r
373         }\r
374 \r
375         inline void CString::Empty()\r
376         // Erases the contents of the string.\r
377         {\r
378                 m_str.erase();\r
379         }\r
380 \r
381         inline int CString::Find(TCHAR ch, int nIndex /* = 0 */) const\r
382         // Finds a character in the string.\r
383         {\r
384                 assert(nIndex >= 0);\r
385                 return (int)m_str.find(ch, nIndex);\r
386         }\r
387 \r
388         inline int CString::Find(LPCTSTR pszText, int nIndex /* = 0 */) const\r
389         // Finds a substring within the string.\r
390         {\r
391                 assert(pszText);\r
392                 assert(nIndex >= 0);\r
393                 return (int)m_str.find(pszText, nIndex);\r
394         }\r
395 \r
396         inline int CString::FindOneOf(LPCTSTR pszText) const\r
397         // Finds the first matching character from a set.\r
398         {\r
399                 assert(pszText);\r
400                 return (int)m_str.find_first_of(pszText);\r
401         }\r
402 \r
403         inline void CString::Format(LPCTSTR pszFormat,...)\r
404         // Formats the string as sprintf does.\r
405         {\r
406                 va_list args;\r
407                 va_start(args, pszFormat);\r
408                 FormatV(pszFormat, args);\r
409                 va_end(args);\r
410         }\r
411 \r
412         inline void CString::Format(UINT nID, ...)\r
413         // Formats the string as sprintf does.\r
414         {\r
415                 CString str;\r
416                 if (str.LoadString(nID))\r
417                 {\r
418                         va_list args;\r
419                         va_start(args, nID);\r
420                         FormatV(str.c_str(), args);\r
421                         va_end(args);\r
422                 }\r
423         }\r
424 \r
425         inline void CString::FormatV(LPCTSTR pszFormat, va_list args)\r
426         // Formats the string using a variable list of arguments.\r
427         {\r
428                 if (pszFormat)\r
429                 {\r
430                         int nResult = -1, nLength = 256;\r
431 \r
432                         // A vector is used to store the TCHAR array\r
433                         std::vector<TCHAR> vBuffer;( nLength+1, _T('\0') );\r
434 \r
435                         while (-1 == nResult)\r
436                         {\r
437                                 vBuffer.assign( nLength+1, _T('\0') );\r
438                                 nResult = _vsntprintf(&vBuffer[0], nLength, pszFormat, args);\r
439                                 nLength *= 2;\r
440                         }\r
441                         m_str.assign(&vBuffer[0]);\r
442                 }\r
443         }\r
444 \r
445         inline void CString::FormatMessage(LPCTSTR pszFormat,...)\r
446         // Formats a message string.\r
447         {\r
448                 va_list args;\r
449                 va_start(args, pszFormat);\r
450                 FormatMessageV(pszFormat, args);\r
451                 va_end(args);\r
452         }\r
453 \r
454         inline void CString::FormatMessageV(LPCTSTR pszFormat, va_list args)\r
455         // Formats a message string using a variable argument list.\r
456         {\r
457                 LPTSTR pszTemp = 0;\r
458                 if (pszFormat)\r
459                 {\r
460                         DWORD dwResult = ::FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER, pszFormat, 0, 0, pszTemp, 0, &args);\r
461 \r
462                         if (0 == dwResult || 0 == pszTemp )\r
463                                 throw std::bad_alloc();\r
464 \r
465                         m_str = pszTemp;\r
466                         LocalFree(pszTemp);\r
467                 }\r
468         }\r
469 \r
470         inline TCHAR CString::GetAt(int nIndex) const\r
471         // Returns the character at the specified location within the string.\r
472         {\r
473                 assert(nIndex >= 0);\r
474                 assert(nIndex < GetLength());\r
475                 return m_str[nIndex];\r
476         }\r
477 \r
478         inline LPTSTR CString::GetBuffer(int nMinBufLength)\r
479         // Creates a buffer of nMinBufLength charaters (+1 extra for NULL termination) and returns\r
480         // a pointer to this buffer. This buffer can be used by any function which accepts a LPTSTR.\r
481         // Care must be taken not to exceed the length of the buffer. Use ReleaseBuffer to safely\r
482         // copy this buffer back to the CString object.\r
483         //\r
484         // Note: The buffer uses a vector. Vectors are required to be contiguous in memory under\r
485         //       the current standard, whereas std::strings do not have this requirement.\r
486         {\r
487                 assert (nMinBufLength >= 0);\r
488 \r
489                 m_buf.assign(nMinBufLength + 1, _T('\0'));\r
490                 tString::iterator it_end;\r
491 \r
492                 if (m_str.length() >= (size_t)nMinBufLength)\r
493                 {\r
494                         it_end = m_str.begin();\r
495                         std::advance(it_end, nMinBufLength);\r
496                 }\r
497                 else\r
498                         it_end = m_str.end();\r
499 \r
500                 std::copy(m_str.begin(), it_end, m_buf.begin());\r
501 \r
502                 return &m_buf[0];\r
503         }\r
504 \r
505 #ifndef _WIN32_WCE\r
506         inline bool CString::GetEnvironmentVariable(LPCTSTR pszVar)\r
507         // Sets the string to the value of the specified environment variable.\r
508         {\r
509                 assert(pszVar);\r
510                 Empty();\r
511 \r
512                 int nLength = ::GetEnvironmentVariable(pszVar, NULL, 0);\r
513                 if (nLength > 0)\r
514                 {\r
515                         std::vector<TCHAR> vBuffer( nLength+1, _T('\0') );\r
516                         ::GetEnvironmentVariable(pszVar, &vBuffer[0], nLength);\r
517                         m_str = &vBuffer[0];\r
518                 }\r
519 \r
520                 return (nLength != 0);\r
521         }\r
522 #endif // _WIN32_WCE\r
523 \r
524         inline void CString::GetErrorString(DWORD dwError)\r
525         // Returns the error string for the specified System Error Code (e.g from GetLastErrror).\r
526         {\r
527                 m_str.erase();\r
528 \r
529                 if (dwError != 0)\r
530                 {\r
531                         TCHAR* pTemp = 0;\r
532                         DWORD dwFlags = FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS;\r
533                         ::FormatMessage(dwFlags, NULL, dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&pTemp, 1, NULL);\r
534                         m_str.assign(pTemp);\r
535                         ::LocalFree(pTemp);\r
536                 }\r
537         }\r
538 \r
539         inline int CString::Insert(int nIndex, TCHAR ch)\r
540         // Inserts a single character or a substring at the given index within the string.\r
541         {\r
542                 assert(nIndex >= 0);\r
543                 assert(ch);\r
544 \r
545                 m_str.insert(nIndex, &ch, 1);\r
546                 return (int)m_str.size();\r
547         }\r
548 \r
549         inline int CString::Insert(int nIndex, const CString& str)\r
550         // Inserts a single character or a substring at the given index within the string.\r
551         {\r
552                 assert(nIndex >= 0);\r
553 \r
554                 m_str.insert(nIndex, str);\r
555                 return (int)m_str.size();\r
556         }\r
557 \r
558         inline bool CString::IsEmpty() const\r
559         // Returns TRUE if the string is empty\r
560         {\r
561                 return m_str.empty();\r
562         }\r
563 \r
564         inline CString CString::Left(int nCount) const\r
565         // Extracts the left part of a string.\r
566         {\r
567                 assert(nCount >= 0);\r
568 \r
569                 CString str;\r
570                 str.m_str.assign(c_str(), 0, nCount);\r
571                 return str;\r
572         }\r
573 \r
574         inline bool CString::LoadString(UINT nID)\r
575         // Loads the string from a Windows resource.\r
576         {\r
577                 assert (GetApp());\r
578 \r
579                 int nSize = 64;\r
580                 TCHAR* pTCharArray = 0;\r
581                 std::vector<TCHAR> vString;\r
582                 int nTChars = nSize;\r
583 \r
584                 Empty();\r
585 \r
586                 // Increase the size of our array in a loop until we load the entire string\r
587                 // The ANSI and _UNICODE versions of LoadString behave differently. This technique works for both.\r
588                 while ( nSize-1 <= nTChars )\r
589                 {\r
590                         nSize = nSize * 4;\r
591                         vString.assign(nSize+1, _T('\0'));\r
592                         pTCharArray = &vString[0];\r
593                         nTChars = ::LoadString (GetApp()->GetResourceHandle(), nID, pTCharArray, nSize);\r
594                 }\r
595 \r
596                 if (nTChars > 0)\r
597                         m_str.assign(pTCharArray);\r
598 \r
599                 return (nTChars != 0);\r
600         }\r
601 \r
602         inline void CString::MakeLower()\r
603         // Converts all the characters in this string to lowercase characters.\r
604         {\r
605                 std::transform(m_str.begin(), m_str.end(), m_str.begin(), &::tolower);\r
606         }\r
607 \r
608         inline void CString::MakeReverse()\r
609         // Reverses the string.\r
610         {\r
611                 // Error 2285 with Borland 5.5 occurs here unless option -tWM is used instead of -tW\r
612                 std::reverse(m_str.begin(), m_str.end());\r
613         }\r
614 \r
615         inline void CString::MakeUpper()\r
616         // Converts all the characters in this string to uppercase characters.\r
617         {\r
618                 // Error 2285 with Borland 5.5 occurs here unless option -tWM is used instead of -tW\r
619                 std::transform(m_str.begin(), m_str.end(), m_str.begin(), &::toupper);\r
620         }\r
621 \r
622         inline CString CString::Mid(int nFirst) const\r
623         // Extracts the middle part of a string.\r
624         {\r
625                 return Mid(nFirst, GetLength());\r
626         }\r
627 \r
628         inline CString CString::Mid(int nFirst, int nCount) const\r
629         // Extracts the middle part of a string.\r
630         {\r
631                 assert(nFirst >= 0);\r
632                 assert(nCount >= 0);\r
633 \r
634                 CString str;\r
635                 str.m_str.assign(c_str(), nFirst, nFirst + nCount);\r
636                 return str;\r
637         }\r
638 \r
639         inline int CString::ReverseFind(LPCTSTR pszText, int nIndex /* = -1 */) const\r
640         // Search for a substring within the string, starting from the end.\r
641         {\r
642                 assert(pszText);\r
643                 return (int)m_str.rfind(pszText, nIndex);\r
644         }\r
645 \r
646         inline void CString::SetAt(int nIndex, TCHAR ch)\r
647         // Sets the character at the specificed position to the specified value.\r
648         {\r
649                 assert(nIndex >= 0);\r
650                 assert(nIndex < GetLength());\r
651                 m_str[nIndex] = ch;\r
652         }\r
653 \r
654         inline void CString::ReleaseBuffer( int nNewLength /*= -1*/ )\r
655         // This copies the contents of the buffer (acquired by GetBuffer) to this CString,\r
656         // and releases the contents of the buffer. The default length of -1 copies from the\r
657         // buffer until a null terminator is reached. If the buffer doesn't contain a null\r
658         // terminator, you must specify the buffer's length.\r
659         {\r
660                 assert (nNewLength > 0 || -1 == nNewLength);\r
661                 assert (nNewLength < (int)m_buf.size());\r
662 \r
663                 if (-1 == nNewLength)\r
664                         nNewLength = lstrlen(&m_buf[0]);\r
665                 m_str.assign(nNewLength+1, _T('\0'));\r
666 \r
667                 std::vector<TCHAR>::iterator it_end = m_buf.begin();\r
668                 std::advance(it_end, nNewLength);\r
669 \r
670                 std::copy(m_buf.begin(), it_end, m_str.begin());\r
671                 m_buf.clear();\r
672         }\r
673 \r
674         inline int CString::Remove(LPCTSTR pszText)\r
675         // Removes each occurrence of the specified substring from the string.\r
676         {\r
677                 assert(pszText);\r
678 \r
679                 int nCount = 0;\r
680                 size_t pos = 0;\r
681                 while ((pos = m_str.find(pszText, pos)) != std::string::npos)\r
682                 {\r
683                         m_str.erase(pos, lstrlen(pszText));\r
684                         ++nCount;\r
685                 }\r
686                 return nCount;\r
687         }\r
688 \r
689         inline int CString::Replace(TCHAR chOld, TCHAR chNew)\r
690         // Replaces each occurance of the old character with the new character.\r
691         {\r
692                 int nCount = 0;\r
693                 tString::iterator it = m_str.begin();\r
694                 while (it != m_str.end())\r
695                 {\r
696                         if (*it == chOld)\r
697                         {\r
698                                 *it = chNew;\r
699                                 ++nCount;\r
700                         }\r
701                         ++it;\r
702                 }\r
703                 return nCount;\r
704         }\r
705 \r
706         inline int CString::Replace(LPCTSTR pszOld, LPCTSTR pszNew)\r
707         // Replaces each occurance of the old substring with the new substring.\r
708         {\r
709                 assert(pszOld);\r
710                 assert(pszNew);\r
711 \r
712                 int nCount = 0;\r
713                 size_t pos = 0;\r
714                 while ((pos = m_str.find(pszOld, pos)) != std::string::npos)\r
715                 {\r
716                         m_str.replace(pos, lstrlen(pszOld), pszNew);\r
717                         pos += lstrlen(pszNew);\r
718                         ++nCount;\r
719                 }\r
720                 return nCount;\r
721         }\r
722 \r
723         inline CString CString::Right(int nCount) const\r
724         // Extracts the right part of a string.\r
725         {\r
726                 assert(nCount >= 0);\r
727 \r
728                 CString str;\r
729                 str.m_str.assign(c_str(), m_str.size() - nCount, nCount);\r
730                 return str;\r
731         }\r
732 \r
733         inline BSTR CString::SetSysString(BSTR* pBstr) const\r
734         // Sets an existing BSTR object to the string.\r
735         {\r
736                 assert(pBstr);\r
737 \r
738                 if ( !::SysReAllocStringLen(pBstr, T2W(m_str.c_str()), (UINT)m_str.length()) )\r
739                         throw std::bad_alloc();\r
740 \r
741                 return *pBstr;\r
742         }\r
743 \r
744         inline CString CString::SpanExcluding(LPCTSTR pszText) const\r
745         // Extracts characters from the string, starting with the first character,\r
746         // that are not in the set of characters identified by pszCharSet.\r
747         {\r
748                 assert (pszText);\r
749 \r
750                 CString str;\r
751                 size_t pos = 0;\r
752 \r
753                 while ((pos = m_str.find_first_not_of(pszText, pos)) != std::string::npos)\r
754                 {\r
755                         str.m_str.append(1, m_str[pos++]);\r
756                 }\r
757 \r
758                 return str;\r
759         }\r
760 \r
761         inline CString CString::SpanIncluding(LPCTSTR pszText) const\r
762         // Extracts a substring that contains only the characters in a set.\r
763         {\r
764                 assert (pszText);\r
765 \r
766                 CString str;\r
767                 size_t pos = 0;\r
768 \r
769                 while ((pos = m_str.find_first_of(pszText, pos)) != std::string::npos)\r
770                 {\r
771                         str.m_str.append(1, m_str[pos++]);\r
772                 }\r
773 \r
774                 return str;\r
775         }\r
776 \r
777         inline CString CString::Tokenize(LPCTSTR pszTokens, int& iStart) const\r
778         // Extracts specified tokens in a target string.\r
779         {\r
780                 assert(pszTokens);\r
781                 assert(iStart >= 0);\r
782 \r
783                 CString str;\r
784                 size_t pos1 = m_str.find_first_not_of(pszTokens, iStart);\r
785                 size_t pos2 = m_str.find_first_of(pszTokens, pos1);\r
786 \r
787                 iStart = (int)pos2 + 1;\r
788                 if (pos2 == m_str.npos)\r
789                         iStart = -1;\r
790 \r
791                 if (pos1 != m_str.npos)\r
792                         str.m_str = m_str.substr(pos1, pos2-pos1);\r
793 \r
794                 return str;\r
795         }\r
796 \r
797         inline void CString::Trim()\r
798         // Trims all leading and trailing whitespace characters from the string.\r
799         {\r
800                 TrimLeft();\r
801                 TrimRight();\r
802         }\r
803 \r
804         inline void CString::TrimLeft()\r
805         // Trims leading whitespace characters from the string.\r
806         {\r
807                 // This method is supported by the Borland 5.5 compiler\r
808                 tString::iterator iter;\r
809                 for (iter = m_str.begin(); iter < m_str.end(); ++iter)\r
810                 {\r
811                         if (!isspace(*iter))\r
812                                 break;\r
813                 }\r
814 \r
815                 m_str.erase(m_str.begin(), iter);\r
816         }\r
817 \r
818         inline void CString::TrimLeft(TCHAR chTarget)\r
819         // Trims the specified character from the beginning of the string.\r
820         {\r
821                 m_str.erase(0, m_str.find_first_not_of(chTarget));\r
822         }\r
823 \r
824         inline void CString::TrimLeft(LPCTSTR pszTargets)\r
825         // Trims the specified set of characters from the beginning of the string.\r
826         {\r
827                 assert(pszTargets);\r
828                 m_str.erase(0, m_str.find_first_not_of(pszTargets));\r
829         }\r
830 \r
831         inline void CString::TrimRight()\r
832         // Trims trailing whitespace characters from the string.\r
833         {\r
834                 // This method is supported by the Borland 5.5 compiler\r
835                 tString::reverse_iterator riter;\r
836                 for (riter = m_str.rbegin(); riter < m_str.rend(); ++riter)\r
837                 {\r
838                         if (!isspace(*riter))\r
839                                 break;\r
840                 }\r
841 \r
842                 m_str.erase(riter.base(), m_str.end());\r
843         }\r
844 \r
845         inline void CString::TrimRight(TCHAR chTarget)\r
846         // Trims the specified character from the end of the string.\r
847         {\r
848                 size_t pos = m_str.find_last_not_of(chTarget);\r
849                 if (pos != std::string::npos)\r
850                         m_str.erase(++pos);\r
851         }\r
852 \r
853         inline void CString::TrimRight(LPCTSTR pszTargets)\r
854         // Trims the specified set of characters from the end of the string.\r
855         {\r
856                 assert(pszTargets);\r
857 \r
858                 size_t pos = m_str.find_last_not_of(pszTargets);\r
859                 if (pos != std::string::npos)\r
860                         m_str.erase(++pos);\r
861         }\r
862 \r
863         inline void CString::Truncate(int nNewLength)\r
864         // Reduces the length of the string to the specified amount.\r
865         {\r
866                 if (nNewLength < GetLength())\r
867                 {\r
868                         assert(nNewLength >= 0);\r
869                         m_str.erase(nNewLength);\r
870                 }\r
871         }\r
872 \r
873 \r
874         ///////////////////////////////////\r
875         // Global Functions\r
876         //\r
877 \r
878         // friend functions of CString\r
879         inline CString operator + (const CString& string1, const CString& string2)\r
880         {\r
881                 CString str(string1);\r
882                 str.m_str.append(string2.m_str);\r
883                 return str;\r
884         }\r
885 \r
886         inline CString operator + (const CString& string, LPCTSTR pszText)\r
887         {\r
888                 CString str(string);\r
889                 str.m_str.append(pszText);\r
890                 return str;\r
891         }\r
892 \r
893         inline CString operator + (const CString& string, TCHAR ch)\r
894         {\r
895                 CString str(string);\r
896                 str.m_str.append(1, ch);\r
897                 return str;\r
898         }\r
899 \r
900         inline CString operator + (LPCTSTR pszText, const CString& string)\r
901         {\r
902                 CString str(pszText);\r
903                 str.m_str.append(string);\r
904                 return str;\r
905         }\r
906 \r
907         inline CString operator + (TCHAR ch, const CString& string)\r
908         {\r
909                 CString str(ch);\r
910                 str.m_str.append(string);\r
911                 return str;\r
912         }\r
913 \r
914         inline bool operator < (const CString& string1, const CString& string2)\r
915         {\r
916                 return string1.Compare(string2) < 0;\r
917         }\r
918 \r
919         inline bool operator > (const CString& string1, const CString& string2)\r
920         {\r
921                 return string1.Compare(string2) > 0;\r
922         }\r
923 \r
924         inline bool operator <= (const CString& string1, const CString& string2)\r
925         {\r
926                 return string1.Compare(string2) <= 0;\r
927         }\r
928 \r
929         inline bool operator >= (const CString& string1, const CString& string2)\r
930         {\r
931                 return string1.Compare(string2) >= 0;\r
932         }\r
933 \r
934         inline bool     operator < (const CString& string1, LPCTSTR pszText)\r
935         {\r
936                 return string1.Compare(pszText) < 0;\r
937         }\r
938 \r
939         inline bool     operator > (const CString& string1, LPCTSTR pszText)\r
940         {\r
941                 return string1.Compare(pszText) > 0;\r
942         }\r
943 \r
944         inline bool operator <= (const CString& string1, LPCTSTR pszText)\r
945         {\r
946                 return string1.Compare(pszText) <= 0;\r
947         }\r
948         \r
949         inline bool operator >= (const CString& string1, LPCTSTR pszText)\r
950         {\r
951                 return string1.Compare(pszText) >= 0;\r
952         }\r
953 \r
954         // Global LoadString\r
955         inline CString LoadString(UINT nID)\r
956         {\r
957                 CString str;\r
958                 str.LoadString(nID);\r
959                 return str;\r
960         }\r
961 \r
962 \r
963 }       // namespace Win32xx\r
964 \r
965 #endif//_WIN32XX_CSTRING_H_\r

UCC git Repository :: git.ucc.asn.au