开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
ExtMfcSafeNativeTCHAR.h
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：143k
源码类别：

界面编程

开发平台：

Visual C++

ExtMfcSafeNativeTCHAR.h：源码内容
  1. }
  2. CExtSafeStringT & operator = ( const CExtSafeStringT & strSrc )
  3. {
  4. CThisSimpleString::operator = ( strSrc );
  5. return ( *this );
  6. }
  7. CExtSafeStringT & operator = ( const CThisSimpleString& strSrc )
  8. {
  9. CThisSimpleString::operator = ( strSrc );
  10. return ( *this );
  11. }
  12. CExtSafeStringT & operator = ( PCXSTR pszSrc )
  13. {
  14. CThisSimpleString::operator = ( pszSrc );
  15. return ( *this );
  16. }
  17. CExtSafeStringT & operator = ( PCYSTR pszSrc )
  18. {
  19. int nDestLength = (pszSrc != NULL) ? StringTraits::GetBaseTypeLength( pszSrc ) : 0;
  20. if( nDestLength > 0 )
  21. {
  22. PXSTR pszBuffer = GetBuffer( nDestLength );
  23. StringTraits::ConvertToBaseType( pszBuffer, nDestLength, pszSrc );
  24. ReleaseBufferSetLength( nDestLength );
  25. }
  26. else
  27. {
  28. Empty();
  29. }
  30. return ( *this );
  31. }
  32. CExtSafeStringT & operator = ( const unsigned char* pszSrc )
  33. {
  34. return ( operator = ( reinterpret_cast < const char * > ( pszSrc ) ) );
  35. }
  36. CExtSafeStringT & operator = ( char ch )
  37. {
  38. char ach[2] = { ch, 0 };
  39. return ( operator = ( ach ) );
  40. }
  41. CExtSafeStringT & operator = ( wchar_t ch )
  42. {
  43. wchar_t ach[2] = { ch, 0 };
  44. return ( operator = ( ach ) );
  45. }
  46. // CExtSafeStringT & operator = ( const VARIANT& var );
  47. CExtSafeStringT & operator += ( const CThisSimpleString& str )
  48. {
  49. CThisSimpleString::operator += ( str );
  50. return ( *this );
  51. }
  52. CExtSafeStringT & operator += ( PCXSTR pszSrc )
  53. {
  54. CThisSimpleString::operator += ( pszSrc );
  55. return ( *this );
  56. }
  57. template < int t_nSize >
  58. CExtSafeStringT & operator += ( const CStaticString < XCHAR, t_nSize > & strSrc )
  59. {
  60. CThisSimpleString::operator += ( strSrc );
  61. return ( *this );
  62. }
  63. CExtSafeStringT & operator += ( PCYSTR pszSrc )
  64. {
  65. CExtSafeStringT str( pszSrc, GetManager() );
  66. return ( operator += ( str ) );
  67. }
  68. CExtSafeStringT & operator += ( char ch )
  69. {
  70. CThisSimpleString::operator += ( ch );
  71. return ( *this );
  72. }
  73. CExtSafeStringT & operator += ( unsigned char ch )
  74. {
  75. CThisSimpleString::operator += ( ch );
  76. return ( *this );
  77. }
  78. CExtSafeStringT & operator += ( wchar_t ch )
  79. {
  80. CThisSimpleString::operator += ( ch );
  81. return ( *this );
  82. }
  83. // CExtSafeStringT & operator += ( const VARIANT& var );
  84. int Compare( PCXSTR psz ) const throw()
  85. {
  86. ATLASSERT( AtlIsValidString( ((LPCWSTR)psz) ) );
  87. return ( StringTraits::StringCompare( GetString(), psz ) );
  88. }
  89. int CompareNoCase( PCXSTR psz ) const throw()
  90. {
  91. ATLASSERT( AtlIsValidString( ((LPCWSTR)psz) ) );
  92. return ( StringTraits::StringCompareIgnore( GetString(), psz ) );
  93. }
  94. int Collate( PCXSTR psz ) const throw()
  95. {
  96. ATLASSERT( AtlIsValidString( ((LPCWSTR)psz) ) );
  97. return ( StringTraits::StringCollate( GetString(), psz ) );
  98. }
  99. int CollateNoCase( PCXSTR psz ) const throw()
  100. {
  101. ATLASSERT( AtlIsValidString( ((LPCWSTR)psz) ) );
  102. return ( StringTraits::StringCollateIgnore( GetString(), psz ) );
  103. }
  104. int Delete( int iIndex, int nCount = 1 )
  105. {
  106. ATLASSERT( iIndex >= 0 );
  107. ATLASSERT( nCount >= 0 );
  108. int nLength = GetLength();
  109. if( (nCount+iIndex) > nLength )
  110. {
  111. nCount = nLength-iIndex;
  112. }
  113. if( nCount > 0 )
  114. {
  115. int nNewLength = nLength-nCount;
  116. int nXCHARsToCopy = nLength-(iIndex+nCount)+1;
  117. PXSTR pszBuffer = GetBuffer();
  118. UINT nSizeInBytes = 
  119. nXCHARsToCopy * sizeof(XCHAR);
  120. __EXT_MFC_MEMMOVE(
  121. pszBuffer + iIndex, 
  122. nSizeInBytes,
  123. pszBuffer + iIndex + nCount, 
  124. nSizeInBytes 
  125. );
  126. ReleaseBufferSetLength( nNewLength );
  127. }
  128. return ( GetLength() );
  129. }
  130. int Insert( int iIndex, XCHAR ch )
  131. {
  132. ATLASSERT( iIndex >= 0 );
  133. if( iIndex > GetLength() )
  134. {
  135. iIndex = GetLength();
  136. }
  137. int nNewLength = GetLength()+1;
  138. PXSTR pszBuffer = GetBuffer( nNewLength );
  139. UINT nSizeInBytes = 
  140. ( nNewLength - iIndex ) * sizeof(XCHAR);
  141. __EXT_MFC_MEMMOVE(
  142. pszBuffer + iIndex + 1, 
  143. nSizeInBytes,
  144. pszBuffer + iIndex, 
  145. nSizeInBytes 
  146. );
  147. pszBuffer[iIndex] = ch;
  148. ReleaseBufferSetLength( nNewLength );
  149. return ( nNewLength );
  150. }
  151. int Insert( int iIndex, PCXSTR psz )
  152. {
  153. ATLASSERT( iIndex >= 0 );
  154. if( iIndex > GetLength() )
  155. {
  156. iIndex = GetLength();
  157. }
  158. int nInsertLength = StringTraits::SafeStringLen( psz );
  159. int nNewLength = GetLength();
  160. if( nInsertLength > 0 )
  161. {
  162. nNewLength += nInsertLength;
  163. PXSTR pszBuffer = GetBuffer( nNewLength );
  164. UINT nSizeInBytes = 
  165. ( nNewLength - iIndex - nInsertLength + 1 ) * sizeof(XCHAR);
  166. __EXT_MFC_MEMMOVE(
  167. pszBuffer + iIndex + nInsertLength,
  168. nSizeInBytes,
  169. pszBuffer + iIndex, 
  170. nSizeInBytes 
  171. );
  172. __EXT_MFC_MEMCPY(
  173. pszBuffer + iIndex, 
  174. nInsertLength * sizeof(XCHAR),
  175. psz, 
  176. nInsertLength * sizeof(XCHAR) 
  177. );
  178. ReleaseBufferSetLength( nNewLength );
  179. }
  180. return ( nNewLength );
  181. }
  182. int Replace( XCHAR chOld, XCHAR chNew )
  183. {
  184. int nCount = 0;
  185. if( chOld != chNew )
  186. {
  187. bool bCopied = false;
  188. PXSTR pszBuffer = const_cast < PXSTR > ( GetString() );
  189. int nLength = GetLength();
  190. int iChar = 0;
  191. while( iChar < nLength )
  192. {
  193. if( pszBuffer[iChar] == chOld )
  194. {
  195. if( !bCopied )
  196. {
  197. bCopied = true;
  198. pszBuffer = GetBuffer( nLength );
  199. }
  200. pszBuffer[iChar] = chNew;
  201. nCount++;
  202. }
  203. iChar = int( StringTraits::CharNext( pszBuffer+iChar )-pszBuffer );
  204. }
  205. if( bCopied )
  206. {
  207. ReleaseBufferSetLength( nLength );
  208. }
  209. }
  210. return ( nCount );
  211. }
  212. int Replace( PCXSTR pszOld, PCXSTR pszNew )
  213. {
  214. int nSourceLen = StringTraits::SafeStringLen( pszOld );
  215. if( nSourceLen == 0 )
  216. return ( 0 );
  217. int nReplacementLen = StringTraits::SafeStringLen( pszNew );
  218. int nCount = 0;
  219. {
  220. PCXSTR pszStart = GetString();
  221. PCXSTR pszEnd = pszStart+GetLength();
  222. while( pszStart < pszEnd )
  223. {
  224. PCXSTR pszTarget;
  225. while( (pszTarget = StringTraits::StringFindString( pszStart, pszOld ) ) != NULL)
  226. {
  227. nCount++;
  228. pszStart = pszTarget+nSourceLen;
  229. }
  230. pszStart += StringTraits::SafeStringLen( pszStart )+1;
  231. }
  232. }
  233. if( nCount > 0 )
  234. {
  235. int nOldLength = GetLength();
  236. int nNewLength = nOldLength+(nReplacementLen-nSourceLen)*nCount;
  238. PXSTR pszBuffer = GetBuffer( max( nNewLength, nOldLength ) );
  240. PXSTR pszStart = pszBuffer;
  241. PXSTR pszEnd = pszStart+nOldLength;
  242. while( pszStart < pszEnd )
  243. {
  244. PXSTR pszTarget;
  245. while( (pszTarget = StringTraits::StringFindString( pszStart, pszOld ) ) != NULL )
  246. {
  247. int nBalance = nOldLength-int(pszTarget-pszBuffer+nSourceLen);
  248. UINT nSizeInBytes = 
  249. nBalance * sizeof(XCHAR);
  250. __EXT_MFC_MEMMOVE(
  251. pszTarget + nReplacementLen, 
  252. nSizeInBytes,
  253. pszTarget + nSourceLen, 
  254. nSizeInBytes
  255. );
  256. __EXT_MFC_MEMCPY(
  257. pszTarget, 
  258. nReplacementLen * sizeof(XCHAR),
  259. pszNew, 
  260. nReplacementLen * sizeof(XCHAR) 
  261. );
  262. pszStart = pszTarget+nReplacementLen;
  263. pszTarget[nReplacementLen+nBalance] = 0;
  264. nOldLength += (nReplacementLen-nSourceLen);
  265. }
  266. pszStart += StringTraits::SafeStringLen( pszStart )+1;
  267. }
  268. ATLASSERT( pszBuffer[nNewLength] == 0 );
  269. ReleaseBufferSetLength( nNewLength );
  270. }
  271. return ( nCount );
  272. }
  273. int Remove( XCHAR chRemove )
  274. {
  275. int nLength = GetLength();
  276. PXSTR pszBuffer = GetBuffer( nLength );
  277. PXSTR pszSource = pszBuffer;
  278. PXSTR pszDest = pszBuffer;
  279. PXSTR pszEnd = pszBuffer+nLength;
  280. while( pszSource < pszEnd )
  281. {
  282. PXSTR pszNewSource = StringTraits::CharNext( pszSource );
  283. if( *pszSource != chRemove )
  284. {
  285. PXSTR pszNewDest = pszDest+(pszNewSource-pszSource);
  286. while( pszDest != pszNewDest )
  287. {
  288. *pszDest = *pszSource;
  289. pszSource++;
  290. pszDest++;
  291. }
  292. }
  293. pszSource = pszNewSource;
  294. }
  295. *pszDest = 0;
  296. int nCount = int( pszSource-pszDest );
  297. ReleaseBufferSetLength( nLength-nCount );
  298. return ( nCount );
  299. }
  300. CExtSafeStringT Tokenize( PCXSTR pszTokens, int& iStart ) const
  301. {
  302. ATLASSERT( iStart >= 0 );
  303. if( pszTokens == NULL )
  304. {
  305. return ( *this );
  306. }
  307. PCXSTR pszPlace = GetString()+iStart;
  308. PCXSTR pszEnd = GetString()+GetLength();
  309. if( pszPlace < pszEnd )
  310. {
  311. int nIncluding =
  312. StringTraits::StringSpanIncluding( pszPlace, pszTokens );
  313. if( (pszPlace+nIncluding) < pszEnd )
  314. {
  315. pszPlace += nIncluding;
  316. int nExcluding = StringTraits::StringSpanExcluding( pszPlace, pszTokens );
  317. int iFrom = iStart+nIncluding;
  318. int nUntil = nExcluding;
  319. iStart = iFrom+nUntil+1;
  320. return ( Mid( iFrom, nUntil ) );
  321. }
  322. }
  323. iStart = -1;
  324. return ( CExtSafeStringT( GetManager() ) );
  325. }
  326. int Find( XCHAR ch, int iStart = 0 ) const throw()
  327. {
  328. ATLASSERT( iStart >= 0 );
  329. int nLength = GetLength();
  330. if( iStart >= nLength)
  331. {
  332. return ( -1 );
  333. }
  334. PCXSTR psz = StringTraits::StringFindChar( GetString()+iStart, ch );
  335. return ( (psz == NULL) ? -1 : int( psz-GetString() ) );
  336. }
  337. int Find( PCXSTR pszSub, int iStart = 0 ) const throw()
  338. {
  339. ATLASSERT( iStart >= 0 );
  340. ATLASSERT( AtlIsValidString( ((LPCWSTR)pszSub) ) );
  341. int nLength = GetLength();
  342. if( iStart > nLength )
  343. {
  344. return ( -1 );
  345. }
  346. PCXSTR psz = StringTraits::StringFindString( GetString()+iStart, pszSub );
  347. return ( (psz == NULL) ? -1 : int( psz-GetString() ) );
  348. }
  349. int FindOneOf( PCXSTR pszCharSet ) const throw()
  350. {
  351. ATLASSERT( AtlIsValidString( ((LPCWSTR)pszCharSet) ) );
  352. PCXSTR psz = StringTraits::StringScanSet( GetString(), pszCharSet );
  353. return ( (psz == NULL) ? -1 : int( psz-GetString() ) );
  354. }
  355. int ReverseFind( XCHAR ch ) const throw()
  356. {
  357. PCXSTR psz = StringTraits::StringFindCharRev( GetString(), ch );
  358. return ( (psz == NULL) ? -1 : int( psz-GetString() ) );
  359. }
  360. CExtSafeStringT & MakeUpper()
  361. {
  362. int nLength = GetLength();
  363. PXSTR pszBuffer = GetBuffer( nLength );
  364. StringTraits::StringUppercase( pszBuffer );
  365. ReleaseBufferSetLength( nLength );
  366. return ( *this );
  367. }
  368. CExtSafeStringT & MakeLower()
  369. {
  370. int nLength = GetLength();
  371. PXSTR pszBuffer = GetBuffer( nLength );
  372. StringTraits::StringLowercase( pszBuffer );
  373. ReleaseBufferSetLength( nLength );
  374. return ( *this );
  375. }
  376. CExtSafeStringT & MakeReverse()
  377. {
  378. int nLength = GetLength();
  379. PXSTR pszBuffer = GetBuffer( nLength );
  380. StringTraits::StringReverse( pszBuffer );
  381. ReleaseBufferSetLength( nLength );
  382. return ( *this );
  383. }
  384. CExtSafeStringT & TrimRight()
  385. {
  386. PCXSTR psz = GetString();
  387. PCXSTR pszLast = NULL;
  388. while( *psz != 0 )
  389. {
  390. if( StringTraits::IsSpace( *psz ) )
  391. {
  392. if( pszLast == NULL )
  393. pszLast = psz;
  394. }
  395. else
  396. {
  397. pszLast = NULL;
  398. }
  399. psz = StringTraits::CharNext( psz );
  400. }
  401. if( pszLast != NULL )
  402. {
  403. int iLast = int( pszLast-GetString() );
  405. Truncate( iLast );
  406. }
  407. return ( *this );
  408. }
  409. CExtSafeStringT & TrimLeft()
  410. {
  411. PCXSTR psz = GetString();
  412. while( StringTraits::IsSpace( *psz ) )
  413. {
  414. psz = StringTraits::CharNext( psz );
  415. }
  416. if( psz != GetString() )
  417. {
  418. int iFirst = int( psz-GetString() );
  419. PXSTR pszBuffer = GetBuffer( GetLength() );
  420. psz = pszBuffer+iFirst;
  421. int nDataLength = GetLength()-iFirst;
  422. UINT nSizeInBytes = 
  423. ( nDataLength + 1 ) * sizeof(XCHAR);
  424. __EXT_MFC_MEMMOVE(
  425. pszBuffer,
  426. nSizeInBytes,
  427. psz, 
  428. nSizeInBytes
  429. );
  430. ReleaseBufferSetLength( nDataLength );
  431. }
  432. return ( *this );
  433. }
  434. CExtSafeStringT & Trim()
  435. {
  436. return ( TrimRight().TrimLeft() );
  437. }
  438. CExtSafeStringT & Trim( XCHAR chTarget )
  439. {
  440. return ( TrimRight( chTarget ).TrimLeft( chTarget ) );
  441. }
  442. CExtSafeStringT & Trim( PCXSTR pszTargets )
  443. {
  444. return ( TrimRight( pszTargets ).TrimLeft( pszTargets ) );
  445. }
  446. CExtSafeStringT & TrimRight( XCHAR chTarget )
  447. {
  448. PCXSTR psz = GetString();
  449. PCXSTR pszLast = NULL;
  450. while( *psz != 0 )
  451. {
  452. if( *psz == chTarget )
  453. {
  454. if( pszLast == NULL )
  455. {
  456. pszLast = psz;
  457. }
  458. }
  459. else
  460. {
  461. pszLast = NULL;
  462. }
  463. psz = StringTraits::CharNext( psz );
  464. }
  465. if( pszLast != NULL )
  466. {
  467. int iLast = int( pszLast-GetString() );
  468. Truncate( iLast );
  469. }
  470. return ( *this );
  471. }
  472. CExtSafeStringT & TrimRight( PCXSTR pszTargets )
  473. {
  474. if( (pszTargets == NULL) || (*pszTargets == 0) )
  475. {
  476. return ( *this );
  477. }
  478. PCXSTR psz = GetString();
  479. PCXSTR pszLast = NULL;
  480. while( *psz != 0 )
  481. {
  482. if( StringTraits::StringFindChar( pszTargets, *psz ) != NULL )
  483. {
  484. if( pszLast == NULL )
  485. {
  486. pszLast = psz;
  487. }
  488. }
  489. else
  490. {
  491. pszLast = NULL;
  492. }
  493. psz = StringTraits::CharNext( psz );
  494. }
  495. if( pszLast != NULL )
  496. {
  497. int iLast = int( pszLast-GetString() );
  498. Truncate( iLast );
  499. }
  500. return ( *this );
  501. }
  502. CExtSafeStringT & TrimLeft( XCHAR chTarget )
  503. {
  504. PCXSTR psz = GetString();
  505. while( chTarget == *psz )
  506. {
  507. psz = StringTraits::CharNext( psz );
  508. }
  509. if( psz != GetString() )
  510. {
  511. int iFirst = int( psz-GetString() );
  512. PXSTR pszBuffer = GetBuffer( GetLength() );
  513. psz = pszBuffer+iFirst;
  514. int nDataLength = GetLength()-iFirst;
  515. UINT nSizeInBytes = 
  516. ( nDataLength + 1 ) * sizeof(XCHAR);
  517. __EXT_MFC_MEMMOVE(
  518. pszBuffer,
  519. nSizeInBytes,
  520. psz, 
  521. nSizeInBytes
  522. );
  523. ReleaseBufferSetLength( nDataLength );
  524. }
  525. return ( *this );
  526. }
  527. CExtSafeStringT & TrimLeft( PCXSTR pszTargets )
  528. {
  529. if( (pszTargets == NULL) || (*pszTargets == 0) )
  530. {
  531. return ( *this );
  532. }
  533. PCXSTR psz = GetString();
  534. while( (*psz != 0) && (StringTraits::StringFindChar( pszTargets, *psz ) != NULL) )
  535. {
  536. psz = StringTraits::CharNext( psz );
  537. }
  538. if( psz != GetString() )
  539. {
  540. int iFirst = int( psz-GetString() );
  541. PXSTR pszBuffer = GetBuffer( GetLength() );
  542. psz = pszBuffer+iFirst;
  543. int nDataLength = GetLength()-iFirst;
  544. UINT nSizeInBytes = 
  545. ( nDataLength + 1 ) * sizeof(XCHAR);
  546. __EXT_MFC_MEMMOVE(
  547. pszBuffer,
  548. nSizeInBytes,
  549. psz, 
  550. nSizeInBytes
  551. );
  552. ReleaseBufferSetLength( nDataLength );
  553. }
  554. return ( *this );
  555. }
  556. __if_exists( StringTraits::ConvertToOem )
  557. {
  558. void AnsiToOem()
  559. {
  560. int nLength = GetLength();
  561. PXSTR pszBuffer = GetBuffer( nLength );
  562. StringTraits::ConvertToOem( pszBuffer );
  563. ReleaseBufferSetLength( nLength );
  564. }
  565. }
  566. __if_exists( StringTraits::ConvertToAnsi )
  567. {
  568. void OemToAnsi()
  569. {
  570. int nLength = GetLength();
  571. PXSTR pszBuffer = GetBuffer( nLength );
  572. StringTraits::ConvertToAnsi( pszBuffer );
  573. ReleaseBufferSetLength( nLength );
  574. }
  575. }
  576. CExtSafeStringT Mid( int iFirst ) const
  577. {
  578. return ( Mid( iFirst, GetLength()-iFirst ) );
  579. }
  580. CExtSafeStringT Mid( int iFirst, int nCount ) const
  581. {
  582. ATLASSERT( iFirst >= 0 );
  583. ATLASSERT( nCount >= 0 );
  584. if( (iFirst+nCount) > GetLength() )
  585. {
  586. nCount = GetLength()-iFirst;
  587. }
  588. if( iFirst > GetLength() )
  589. {
  590. nCount = 0;
  591. }
  592. ATLASSERT( (nCount == 0) || ((iFirst+nCount) <= GetLength()) );
  593. if( (iFirst == 0) && ((iFirst+nCount) == GetLength()) )
  594. {
  595. return ( *this );
  596. }
  597. return ( CExtSafeStringT( GetString()+iFirst, nCount, GetManager() ) );
  598. }
  599. CExtSafeStringT Right( int nCount ) const
  600. {
  601. ATLASSERT( nCount >= 0 );
  602. int nLength = GetLength();
  603. if( nCount >= nLength )
  604. {
  605. return ( *this );
  606. }
  607. return ( CExtSafeStringT( GetString()+nLength-nCount, nCount, GetManager() ) );
  608. }
  609. CExtSafeStringT Left( int nCount ) const
  610. {
  611. ATLASSERT( nCount >= 0 );
  612. int nLength = GetLength();
  613. if( nCount >= nLength )
  614. {
  615. return ( *this );
  616. }
  617. return ( CExtSafeStringT( GetString(), nCount, GetManager() ) );
  618. }
  619. CExtSafeStringT SpanIncluding( PCXSTR pszCharSet ) const
  620. {
  621. ATLASSERT( AtlIsValidString( ((LPCWSTR)pszCharSet) ) );
  622. return ( Left( StringTraits::StringSpanIncluding( GetString(), pszCharSet ) ) );
  623. }
  624. CExtSafeStringT SpanExcluding( PCXSTR pszCharSet ) const
  625. {
  626. ATLASSERT( AtlIsValidString( ((LPCWSTR)pszCharSet) ) );
  627. return ( Left( StringTraits::StringSpanExcluding( GetString(), pszCharSet ) ) );
  628.   }
  629. void __cdecl Format( PCXSTR pszFormat, ... )
  630. {
  631. ATLASSERT( AtlIsValidString( ((LPCWSTR)pszFormat) ) );
  632. va_list argList;
  633. va_start( argList, pszFormat );
  634. FormatV( pszFormat, argList );
  635. va_end( argList );
  636. }
  637. void __cdecl Format( UINT nFormatID, ... )
  638. {
  639. CExtSafeStringT strFormat( GetManager() );
  640. ATLVERIFY( strFormat.LoadString( nFormatID ) );
  641. va_list argList;
  642. va_start( argList, nFormatID );
  643. FormatV( strFormat, argList );
  644. va_end( argList );
  645. }
  646. void __cdecl AppendFormat( UINT nFormatID, ... )
  647. {
  648. va_list argList;
  649. va_start( argList, nFormatID );
  650. CExtSafeStringT strFormat( GetManager() );
  651. ATLVERIFY( strFormat.LoadString( nFormatID ) ); 
  652. AppendFormatV( strFormat, argList );
  653. va_end( argList );
  654. }
  655. void __cdecl AppendFormat( PCXSTR pszFormat, ... )
  656. {
  657. ATLASSERT( AtlIsValidString( ((LPCWSTR)pszFormat) ) );
  658. va_list argList;
  659. va_start( argList, pszFormat );
  660. AppendFormatV( pszFormat, argList );
  661. va_end( argList );
  662. }
  663. void AppendFormatV( PCXSTR pszFormat, va_list args )
  664. {
  665. ATLASSERT( AtlIsValidString( ((LPCWSTR)pszFormat) ) );
  666. int nCurrentLength = GetLength();
  667. int nAppendLength = StringTraits::GetFormattedLength( pszFormat, args );
  668. PXSTR pszBuffer = GetBuffer( nCurrentLength+nAppendLength );
  669. StringTraits::Format( pszBuffer+nCurrentLength, pszFormat, args );
  670. ReleaseBufferSetLength( nCurrentLength+nAppendLength );
  671. }
  672. void FormatV( PCXSTR pszFormat, va_list args )
  673. {
  674. ATLASSERT( AtlIsValidString( ((LPCWSTR)pszFormat) ) );
  675. int nLength = StringTraits::GetFormattedLength( pszFormat, args );
  676. PXSTR pszBuffer = GetBuffer( nLength );
  677. StringTraits::Format( pszBuffer, pszFormat, args );
  678. ReleaseBufferSetLength( nLength );
  679. }
  680. __if_exists(StringTraits::FormatMessage)
  681. {
  682. void __cdecl FormatMessage( PCXSTR pszFormat, ... )
  683. {
  684. va_list argList;
  685. va_start( argList, pszFormat );
  687. FormatMessageV( pszFormat, &argList );
  689. va_end( argList );
  690. }
  691. void __cdecl FormatMessage( UINT nFormatID, ... )
  692. {
  693. CExtSafeStringT strFormat( GetManager() );
  694. ATLVERIFY( strFormat.LoadString( nFormatID ) );
  695. va_list argList;
  696. va_start( argList, nFormatID );
  697. FormatMessageV( strFormat, &argList );
  698. va_end( argList );
  699. }
  700. }
  701. BSTR AllocSysString() const
  702. {
  703. BSTR bstrResult = StringTraits::AllocSysString( GetString(), 
  704. GetLength() );
  705. if( bstrResult == NULL )
  706. {
  707. ThrowMemoryException();
  708. }
  709. return ( bstrResult );
  710. }
  711. BSTR SetSysString( BSTR* pbstr ) const
  712. {
  713. ATLASSERT( AtlIsValidAddress( pbstr, sizeof(BSTR) ) );
  714. if( !StringTraits::ReAllocSysString( GetString(), pbstr,
  715. GetLength() ) )
  716. {
  717. ThrowMemoryException();
  718. }
  719. ATLASSERT( *pbstr != NULL );
  720. return ( *pbstr );
  721. }
  722. BOOL GetEnvironmentVariable( PCXSTR pszVar )
  723. {
  724. ULONG nLength = StringTraits::GetEnvironmentVariable( pszVar, NULL, 0 );
  725. BOOL bRetVal = FALSE;
  726. if( nLength == 0 )
  727. {
  728. Empty();
  729. }
  730. else
  731. {
  732. PXSTR pszBuffer = GetBuffer( nLength );
  733. StringTraits::GetEnvironmentVariable( pszVar, pszBuffer, nLength );
  734. ReleaseBuffer();
  735. bRetVal = TRUE;
  736. }
  737. return ( bRetVal );
  738. }
  739. BOOL LoadString( UINT nID )
  740. {
  741. HINSTANCE hInst = StringTraits::FindStringResourceInstance( nID );
  742. if( hInst == NULL )
  743. {
  744. return ( FALSE );
  745. }
  746. return ( LoadString( hInst, nID ) );
  747. }
  748. BOOL LoadString( HINSTANCE hInstance, UINT nID )
  749. {
  750. const ATLSTRINGRESOURCEIMAGE* pImage = AtlGetStringResourceImage( hInstance, nID );
  751. if( pImage == NULL )
  752. {
  753. return ( FALSE );
  754. }
  755. int nLength = StringTraits::GetBaseTypeLength(
  756. (PCXSTR)pImage->achString,
  757. pImage->nLength
  758. );
  759. PXSTR pszBuffer = GetBuffer( nLength );
  760. StringTraits::ConvertToBaseType(
  761. pszBuffer,
  762. nLength,
  763. (PCXSTR)pImage->achString,
  764. pImage->nLength
  765. );
  766. ReleaseBufferSetLength( nLength );
  767. return ( TRUE );
  768. }
  769. BOOL LoadString( HINSTANCE hInstance, UINT nID, WORD wLanguageID )
  770. {
  771. const ATLSTRINGRESOURCEIMAGE* pImage = AtlGetStringResourceImage( hInstance, nID, wLanguageID );
  772. if( pImage == NULL )
  773. {
  774. return ( FALSE );
  775. }
  776. int nLength = StringTraits::GetBaseTypeLength( pImage->achString, pImage->nLength );
  777. PXSTR pszBuffer = GetBuffer( nLength );
  778. StringTraits::ConvertToBaseType(
  779. pszBuffer,
  780. nLength,
  781. (StringTraits::PCXSTR)pImage->achString,
  782. pImage->nLength
  783. );
  784. ReleaseBufferSetLength( nLength );
  785. return ( TRUE );
  786. }
  787. friend CExtSafeStringT operator + ( const CExtSafeStringT & str1, const CExtSafeStringT & str2 )
  788. {
  789. CExtSafeStringT strResult( str1.GetManager() );
  790. Concatenate( strResult, str1, str1.GetLength(), str2, str2.GetLength() );
  791. return ( strResult );
  792. }
  793. friend CExtSafeStringT operator + ( const CExtSafeStringT & str1, PCXSTR psz2 )
  794. {
  795. CExtSafeStringT strResult( str1.GetManager() );
  796. Concatenate( strResult, str1, str1.GetLength(), psz2, StringLength( psz2 ) );
  797. return ( strResult );
  798. }
  799. friend CExtSafeStringT operator + ( PCXSTR psz1, const CExtSafeStringT & str2 )
  800. {
  801. CExtSafeStringT strResult( str2.GetManager() );
  802. Concatenate( strResult, psz1, StringLength( psz1 ), str2, str2.GetLength() );
  803. return ( strResult );
  804. }
  805. friend CExtSafeStringT operator + ( const CExtSafeStringT & str1, wchar_t ch2 )
  806. {
  807. CExtSafeStringT strResult( str1.GetManager() );
  808. XCHAR chTemp = XCHAR( ch2 );
  809. Concatenate( strResult, str1, str1.GetLength(), &chTemp, 1 );
  810. return ( strResult );
  811. }
  812. friend CExtSafeStringT operator + ( const CExtSafeStringT & str1, char ch2 )
  813. {
  814. CExtSafeStringT strResult( str1.GetManager() );
  815. XCHAR chTemp = XCHAR( ch2 );
  816. Concatenate( strResult, str1, str1.GetLength(), &chTemp, 1 );
  817. return ( strResult );
  818. }
  819. friend CExtSafeStringT operator + ( wchar_t ch1, const CExtSafeStringT & str2 )
  820. {
  821. CExtSafeStringT strResult( str2.GetManager() );
  822. XCHAR chTemp = XCHAR( ch1 );
  823. Concatenate( strResult, &chTemp, 1, str2, str2.GetLength() );
  824. return ( strResult );
  825. }
  826. friend CExtSafeStringT operator + ( char ch1, const CExtSafeStringT & str2 )
  827. {
  828. CExtSafeStringT strResult( str2.GetManager() );
  829. XCHAR chTemp = XCHAR( ch1 );
  830. Concatenate( strResult, &chTemp, 1, str2, str2.GetLength() );
  831. return ( strResult );
  832. }
  833. friend bool operator == ( const CExtSafeStringT & str1, const CExtSafeStringT & str2 ) throw()
  834. {
  835. return ( str1.Compare( str2 ) == 0 );
  836. }
  837. friend bool operator == (
  838. const CExtSafeStringT & str1, PCXSTR psz2 ) throw()
  839. {
  840. return ( str1.Compare( psz2 ) == 0 );
  841. }
  842. friend bool operator == (
  843. PCXSTR psz1, const CExtSafeStringT & str2 ) throw()
  844. {
  845. return ( str2.Compare( psz1 ) == 0 );
  846. }
  847. friend bool operator == (
  848. const CExtSafeStringT & str1, PCYSTR psz2 ) throw( ... )
  849. {
  850. CExtSafeStringT str2( psz2, str1.GetManager() );
  851. return ( str1 == str2 );
  852. }
  853. friend bool operator == (
  854. PCYSTR psz1, const CExtSafeStringT & str2 ) throw( ... )
  855. {
  856. CExtSafeStringT str1( psz1, str2.GetManager() );
  857. return ( str1 == str2 );
  858. }
  859. friend bool operator != (
  860. const CExtSafeStringT & str1, const CExtSafeStringT & str2 ) throw()
  861. {
  862. return ( str1.Compare( str2 ) != 0 );
  863. }
  864. friend bool operator != (
  865. const CExtSafeStringT & str1, PCXSTR psz2 ) throw()
  866. {
  867. return ( str1.Compare( psz2 ) != 0 );
  868. }
  869. friend bool operator != (
  870. PCXSTR psz1, const CExtSafeStringT & str2 ) throw()
  871. {
  872. return ( str2.Compare( psz1 ) != 0 );
  873. }
  874. friend bool operator != (
  875. const CExtSafeStringT & str1, PCYSTR psz2 ) throw( ... )
  876. {
  877. CExtSafeStringT str2( psz2, str1.GetManager() );
  878. return ( str1 != str2 );
  879. }
  880. friend bool operator != (
  881. PCYSTR psz1, const CExtSafeStringT & str2 ) throw( ... )
  882. {
  883. CExtSafeStringT str1( psz1, str2.GetManager() );
  884. return ( str1 != str2 );
  885. }
  886. friend bool operator < ( const CExtSafeStringT & str1, const CExtSafeStringT & str2 ) throw()
  887. {
  888. return ( str1.Compare( str2 ) < 0 );
  889. }
  890. friend bool operator < ( const CExtSafeStringT & str1, PCXSTR psz2 ) throw()
  891. {
  892. return ( str1.Compare( psz2 ) < 0 );
  893. }
  894. friend bool operator < ( PCXSTR psz1, const CExtSafeStringT & str2 ) throw()
  895. {
  896. return ( str2.Compare( psz1 ) >= 0 );
  897. }
  898. friend bool operator > ( const CExtSafeStringT & str1, const CExtSafeStringT & str2 ) throw()
  899. {
  900. return ( str1.Compare( str2 ) > 0 );
  901. }
  902. friend bool operator > ( const CExtSafeStringT & str1, PCXSTR psz2 ) throw()
  903. {
  904. return ( str1.Compare( psz2 ) > 0 );
  905. }
  906. friend bool operator > ( PCXSTR psz1, const CExtSafeStringT & str2 ) throw()
  907. {
  908. return ( str2.Compare( psz1 ) <= 0 );
  909. }
  910. friend bool operator <= ( const CExtSafeStringT & str1, const CExtSafeStringT & str2 ) throw()
  911. {
  912. return ( str1.Compare( str2 ) <= 0 );
  913. }
  914. friend bool operator <= ( const CExtSafeStringT & str1, PCXSTR psz2 ) throw()
  915. {
  916. return ( str1.Compare( psz2 ) <= 0 );
  917. }
  918. friend bool operator <= ( PCXSTR psz1, const CExtSafeStringT & str2 ) throw()
  919. {
  920. return ( str2.Compare( psz1 ) > 0 );
  921. }
  922. friend bool operator >= ( const CExtSafeStringT & str1, const CExtSafeStringT & str2 ) throw()
  923. {
  924. return ( str1.Compare( str2 ) >= 0 );
  925. }
  926. friend bool operator >= ( const CExtSafeStringT & str1, PCXSTR psz2 ) throw()
  927. {
  928. return ( str1.Compare( psz2 ) >= 0 );
  929. }
  930. friend bool operator >= ( PCXSTR psz1, const CExtSafeStringT & str2 ) throw()
  931. {
  932. return ( str2.Compare( psz1 ) < 0 );
  933. }
  934. friend bool operator == ( XCHAR ch1, const CExtSafeStringT & str2 ) throw()
  935. {
  936. return ( (str2.GetLength() == 1) && (str2[0] == ch1) );
  937. }
  938. friend bool operator == ( const CExtSafeStringT & str1, XCHAR ch2 ) throw()
  939. {
  940. return ( (str1.GetLength() == 1) && (str1[0] == ch2) );
  941. }
  942. friend bool operator != ( XCHAR ch1, const CExtSafeStringT & str2 ) throw()
  943. {
  944. return ( (str2.GetLength() != 1) || (str2[0] != ch1) );
  945. }
  946. friend bool operator != ( const CExtSafeStringT & str1, XCHAR ch2 ) throw()
  947. {
  948. return ( (str1.GetLength() != 1) || (str1[0] != ch2) );
  949. }
  950. private:
  951. bool CheckImplicitLoad( const void* pv )
  952. {
  953. bool bRet = false;
  954. if( (pv != NULL) && IS_INTRESOURCE( pv ) )
  955. {
  956. UINT nID = LOWORD( reinterpret_cast < DWORD_PTR > ( pv ) );
  957. if( !LoadString( nID ) )
  958. {
  959. ATLTRACE( atlTraceString, 2, _T( "Warning: implicit LoadString(%u) failedn" ), nID );
  960. }
  961. bRet = true;
  962. }
  963. return ( bRet );
  964. }
  965. __if_exists( StringTraits::FormatMessage )
  966. {
  967. void FormatMessageV( PCXSTR pszFormat, va_list* pArgList )
  968. {
  969. CHeapPtr< XCHAR, CLocalAllocator > pszTemp;
  970. DWORD dwResult = StringTraits::FormatMessage( FORMAT_MESSAGE_FROM_STRING|
  971. FORMAT_MESSAGE_ALLOCATE_BUFFER, pszFormat, 0, 0, reinterpret_cast < PXSTR > ( &pszTemp ),
  972. 0, pArgList );
  973. if( dwResult == 0 )
  974. {
  975. ThrowMemoryException();
  976. }
  978. *this = pszTemp;
  979. }
  980. }
  981. }; // class CExtSafeStringT
  983. template < typename BaseType, class StringTraits >
  984. inline
  985. CArchive & operator << (
  986. CArchive& ar,
  987. const CExtSafeStringT < BaseType, StringTraits > & str
  988. )
  989. {
  990. AfxWriteStringLength(
  991. ar,
  992. str.GetLength(),
  993. sizeof(BaseType) == sizeof(wchar_t)
  994. );
  995. ar.Write(
  996. str,
  997. str.GetLength() * sizeof(BaseType)
  998. );
  999. return ar;
  1000. }
  1002. template < typename BaseType, class StringTraits >
  1003. inline
  1004. CArchive & operator >> (
  1005. CArchive& ar,
  1006. CExtSafeStringT < BaseType, StringTraits > & str
  1007. )
  1008. {
  1009. int nCharSize;
  1010. UINT nLength = UINT( AfxReadStringLength( ar, nCharSize ) );
  1011. if( nCharSize == sizeof(char) )
  1012. {
  1013. ATL::CTempBuffer < char > pszBufferA( nLength + 1 );
  1014. pszBufferA[ nLength ] = '';
  1015. UINT nBytesRead =
  1016. ar.Read(
  1017. pszBufferA,
  1018. nLength * sizeof(char)
  1019. );
  1020. if( nBytesRead != ( nLength * sizeof(char) ) )
  1021. AfxThrowArchiveException( CArchiveException::endOfFile );
  1022. str = pszBufferA;
  1023. }
  1024. else
  1025. {
  1026. ASSERT( nCharSize == sizeof(wchar_t) );
  1027. ATL::CTempBuffer< wchar_t > pszBufferW( nLength+1 );
  1028. pszBufferW[ nLength ] = L'';
  1029. UINT nBytesRead =
  1030. ar.Read(
  1031. pszBufferW,
  1032. nLength * sizeof(wchar_t)
  1033. );
  1034. if( nBytesRead != ( nLength * sizeof(wchar_t) ) )
  1035. AfxThrowArchiveException( CArchiveException::endOfFile );
  1036. str = (BaseType *)(wchar_t *)pszBufferW;
  1037. }
  1038. return ar;
  1039. }
  1041. typedef
  1042. CExtSafeStrTraitMFC <
  1043. __prof_uis_used_wchar_t,
  1044. CExtSafeChTraitsCRT< __prof_uis_used_wchar_t >
  1045. >
  1046. __prof_uis_used_StrTraitMFC;
  1047. typedef
  1048. CExtSafeStringT <
  1049. __prof_uis_used_wchar_t,
  1050. __prof_uis_used_StrTraitMFC
  1051. >
  1052. __prof_uis_used_CStringT;
  1054. typedef
  1055. CExtSafeStrTraitMFC <
  1056. __prof_uis_converted_wchar_t,
  1057. CExtSafeChTraitsCRT< __prof_uis_used_wchar_t >
  1058. >
  1059. __prof_uis_converted_StrTraitMFC;
  1060. typedef
  1061. CExtSafeStringT <
  1062. __prof_uis_converted_wchar_t,
  1063. __prof_uis_converted_StrTraitMFC
  1064. >
  1065. __prof_uis_converted_CStringT;
  1067. #if (defined _MSC_EXTENSIONS)
  1068. #define __EXT_MFC_TEMPLATED_WCHAR_T_ADAPTOR_NO_VTABLE __declspec(novtable)
  1069. #else
  1070. #define __EXT_MFC_TEMPLATED_WCHAR_T_ADAPTOR_NO_VTABLE
  1071. #endif
  1073. template < class _c_, class _n_ >
  1074. class __EXT_MFC_TEMPLATED_WCHAR_T_ADAPTOR_NO_VTABLE CExtNWCT
  1075. {
  1076. protected:
  1077. _c_ m_data;
  1078. public:
  1079. typedef CExtNWCT < _c_, _n_ > _Myt;
  1080. CExtNWCT( _c_ data )
  1081. : m_data( data )
  1082. {
  1083. }
  1084. CExtNWCT( _n_ data )
  1085. : m_data( * ( ( _c_ * ) ( &data ) ) )
  1086. {
  1087. }
  1088. CExtNWCT( const int _the_null_val = NULL )
  1089. // : m_data( reinterpret_cast < _c_ > ( _the_null_val ) )
  1090. // : m_data( _c_( *((_c_*)LPVOID(&_the_null_val)) ) )
  1091. : m_data( ( _c_ ) ( _the_null_val ) )
  1092. {
  1093. _the_null_val;
  1094. }
  1095. CExtNWCT( const _Myt & other )
  1096. : m_data( other.m_data )
  1097. {
  1098. }
  1099. operator _c_ ()
  1100. {
  1101. return m_data;
  1102. }
  1103. operator _n_ ()
  1104. {
  1105. return * ( ( _n_ * ) ( &m_data ) );
  1106. }
  1107. operator const _c_ () const
  1108. {
  1109. return m_data;
  1110. }
  1111. operator const _n_ () const
  1112. {
  1113. return * ( ( _n_ * ) ( &m_data ) );
  1114. }
  1115. _Myt & operator = ( const _Myt & other )
  1116. {
  1117. m_data = other.m_data;
  1118. return (*this);
  1119. }
  1120. _Myt & operator = ( _c_ data )
  1121. {
  1122. m_data = data;
  1123. return (*this);
  1124. }
  1125. _Myt & operator = ( _n_ data )
  1126. {
  1127. m_data = * ( ( _c_ * ) ( &data ) );
  1128. return (*this);
  1129. }
  1130. _Myt & operator = ( const int _the_null_val )
  1131. {
  1132. m_data = ( reinterpret_cast < _c_ > ( _the_null_val ) );
  1133. return (*this);
  1134. }
  1135. bool operator == ( const _Myt & other ) const
  1136. {
  1137. return (m_data == other.m_data) ? true : false;
  1138. }
  1139. bool operator == ( const _c_ & data ) const
  1140. {
  1141. return (m_data == data) ? true : false;
  1142. }
  1143. bool operator == ( const _n_ & data ) const
  1144. {
  1145. return (m_data == ( * ( ( _c_ * ) ( &data ) ) )) ? true : false;
  1146. }
  1147. bool operator == ( const int _the_null_val ) const
  1148. {
  1149. return (m_data == ( reinterpret_cast < _c_ > ( _the_null_val ) ) ) ? true : false;
  1150. }
  1151. bool operator != ( const _Myt & other ) const
  1152. {
  1153. return (m_data != other.m_data) ? true : false;
  1154. }
  1155. bool operator != ( const _c_ & data ) const
  1156. {
  1157. return (m_data != data) ? true : false;
  1158. }
  1159. bool operator != ( const _n_ & data ) const
  1160. {
  1161. return (m_data != ( * ( ( _c_ * ) ( &data ) ) )) ? true : false;
  1162. }
  1163. bool operator != ( const int _the_null_val ) const
  1164. {
  1165. // return (m_data != ( reinterpret_cast < _c_ > ( _the_null_val ) ) ) ? true : false;
  1166. return (m_data != ( (_c_) (int) ( _the_null_val ) ) ) ? true : false;
  1167. }
  1168. bool operator <= ( const _Myt & other ) const
  1169. {
  1170. return (m_data <= other.m_data) ? true : false;
  1171. }
  1172. bool operator <= ( const _c_ & data ) const
  1173. {
  1174. return (m_data <= data) ? true : false;
  1175. }
  1176. bool operator <= ( const _n_ & data ) const
  1177. {
  1178. return (m_data <= ( * ( ( _c_ * ) ( &data ) ) )) ? true : false;
  1179. }
  1180. bool operator >= ( const _Myt & other ) const
  1181. {
  1182. return (m_data >= other.m_data) ? true : false;
  1183. }
  1184. bool operator >= ( const _c_ & data ) const
  1185. {
  1186. return (m_data >= data) ? true : false;
  1187. }
  1188. bool operator >= ( const _n_ & data ) const
  1189. {
  1190. return (m_data >= ( * ( ( _c_ * ) ( &data ) ) )) ? true : false;
  1191. }
  1192. bool operator < ( const _Myt & other ) const
  1193. {
  1194. return (m_data < other.m_data) ? true : false;
  1195. }
  1196. bool operator < ( const _c_ & data ) const
  1197. {
  1198. return (m_data < data) ? true : false;
  1199. }
  1200. bool operator < ( const _n_ & data ) const
  1201. {
  1202. return (m_data < ( * ( ( _c_ * ) ( &data ) ) )) ? true : false;
  1203. }
  1204. bool operator > ( const _Myt & other ) const
  1205. {
  1206. return (m_data > other.m_data) ? true : false;
  1207. }
  1208. bool operator > ( const _c_ & data ) const
  1209. {
  1210. return (m_data > data) ? true : false;
  1211. }
  1212. bool operator > ( const _n_ & data ) const
  1213. {
  1214. return (m_data > ( * ( ( _c_ * ) ( &data ) ) )) ? true : false;
  1215. }
  1217. operator bool () const
  1218. {
  1219. return (m_data == reinterpret_cast < _c_ > ( NULL )) ? false : true;
  1220. }
  1221. // operator int () const
  1222. // {
  1223. // return (int)m_data;
  1224. // }
  1225. // operator long () const
  1226. // {
  1227. // return (long)m_data;
  1228. // }
  1229. // operator unsigned int () const
  1230. // {
  1231. // return (unsigned int)m_data;
  1232. // }
  1233. // operator unsigned long () const
  1234. // {
  1235. // return (unsigned long)m_data;
  1236. // }
  1237. }; // class CExtNWCT
  1239. template < class _c_, class _n_, class _a_ >
  1240. class __EXT_MFC_TEMPLATED_WCHAR_T_ADAPTOR_NO_VTABLE CExtNWCTA
  1241. : public CExtNWCT < _c_, _n_ >
  1242. {
  1243. public:
  1244. typedef CExtNWCTA < _c_, _n_, _a_ > _Myt;
  1245. typedef CExtNWCT < _c_, _n_ > _Mybt;
  1246. CExtNWCTA( _c_ data )
  1247. : _Mybt( data )
  1248. {
  1249. }
  1250. CExtNWCTA( _n_ data )
  1251. : _Mybt( data )
  1252. {
  1253. }
  1254. CExtNWCTA( const int _the_null_val = NULL )
  1255. : _Mybt( _the_null_val )
  1256. {
  1257. }
  1258. CExtNWCTA( const _Myt & other )
  1259. : _Mybt( other )
  1260. {
  1261. }
  1263. CExtNWCTA( const __prof_uis_used_CStringT & other )
  1264. : _Mybt( ( _i_ )( other.GetString() ) )
  1265. {
  1266. }
  1267. CExtNWCTA( const __prof_uis_converted_CStringT & other )
  1268. : _Mybt( ( _i_ )( other.GetString() ) )
  1269. {
  1270. }
  1272. // _Myt & operator = ( const __prof_uis_used_CStringT & other )
  1273. // {
  1274. // return _Mybt::operator = ( ( _i_ )( other.GetString() ) );
  1275. // }
  1276. // _Myt & operator = ( const __prof_uis_converted_CStringT & other )
  1277. // {
  1278. // return _Mybt::operator = ( ( _i_ )( other.GetString() ) );
  1279. // }
  1281. operator __prof_uis_used_CStringT () const
  1282. {
  1283. return __prof_uis_used_CStringT( (__prof_uis_used_CStringT::XCHAR *)m_data );
  1284. }
  1285. operator __prof_uis_converted_CStringT () const
  1286. {
  1287. return __prof_uis_converted_CStringT( (__prof_uis_converted_CStringT::XCHAR *)m_data );
  1288. }
  1290. _a_ operator [] ( int nIndex ) const
  1291. {
  1292. return ( ( _a_ ) ( m_data[ nIndex ] ) );
  1293. }
  1294. }; // class CExtNWCTA
  1296. template < class _c_, class _i_, class _n_ >
  1297. class __EXT_MFC_TEMPLATED_WCHAR_T_ADAPTOR_NO_VTABLE CExtNWCTC
  1298. {
  1299. protected:
  1300. _i_ m_data;
  1301. public:
  1302. typedef CExtNWCTC < _c_, _i_, _n_ > _Myt;
  1303. CExtNWCTC( _c_ data )
  1304. : m_data( const_cast < _i_ > ( data ) )
  1305. {
  1306. }
  1307. CExtNWCTC( _n_ data )
  1308. : m_data( * ( ( _i_ * ) ( &data ) ) )
  1309. {
  1310. }
  1311. CExtNWCTC( const int _the_null_val = NULL )
  1312. // : m_data( reinterpret_cast < _i_ > ( _the_null_val ) )
  1313. // : m_data( _i_( *((_i_*)LPVOID(&_the_null_val)) ) )
  1314. : m_data( reinterpret_cast < _i_ > ( _the_null_val ) )
  1315. {
  1316. _the_null_val;
  1317. }
  1318. CExtNWCTC( const _Myt & other )
  1319. : m_data( other.m_data )
  1320. {
  1321. }
  1322. operator _c_ () const
  1323. {
  1324. return m_data;
  1325. }
  1326. operator _n_ () const
  1327. {
  1328. return * ( ( _n_ * ) ( &m_data ) );
  1329. }
  1330. _Myt & operator = ( const _Myt & other )
  1331. {
  1332. m_data = other.m_data;
  1333. return (*this);
  1334. }
  1335. _Myt & operator = ( _c_ data  )
  1336. {
  1337. m_data = const_cast < _i_ > ( data );
  1338. return (*this);
  1339. }
  1340. _Myt & operator = ( _n_ data )
  1341. {
  1342. m_data = * ( ( _i_ * ) ( &data ) );
  1343. return (*this);
  1344. }
  1345. _Myt & operator = ( const int _the_null_val )
  1346. {
  1347. m_data = ( reinterpret_cast < _i_ > ( _the_null_val ) );
  1348. return (*this);
  1349. }
  1350. bool operator == ( const _Myt & other ) const
  1351. {
  1352. return (m_data == other.m_data) ? true : false;
  1353. }
  1354. bool operator == ( _c_ & data  ) const
  1355. {
  1356. return (m_data == ( const_cast < _i_ > ( data ) ) ) ? true : false;
  1357. }
  1358. bool operator == ( _n_ & data ) const
  1359. {
  1360. return (m_data == ( * ( ( _i_ * ) ( &data ) )) ) ? true : false;
  1361. }
  1362. bool operator == ( const int _the_null_val ) const
  1363. {
  1364. return (m_data == ( reinterpret_cast < _i_ > ( _the_null_val ) ) ) ? true : false;
  1365. }
  1366. bool operator != ( const _Myt & other ) const
  1367. {
  1368. return (m_data != other.m_data) ? true : false;
  1369. }
  1370. bool operator != ( _c_ & data  ) const
  1371. {
  1372. return (m_data != ( const_cast < _i_ > ( data ) ) ) ? true : false;
  1373. }
  1374. bool operator != ( _n_ & data ) const
  1375. {
  1376. return (m_data != ( * ( ( _i_ * ) ( &data ) )) ) ? true : false;
  1377. }
  1378. bool operator != ( const int _the_null_val ) const
  1379. {
  1380. // return (m_data != ( reinterpret_cast < _i_ > ( _the_null_val ) ) ) ? true : false;
  1381. return (m_data != ( (_c_) (int) ( _the_null_val ) ) ) ? true : false;
  1382. }
  1383. bool operator <= ( const _Myt & other ) const
  1384. {
  1385. return (m_data <= other.m_data) ? true : false;
  1386. }
  1387. bool operator <= ( _c_ & data  ) const
  1388. {
  1389. return (m_data <= ( const_cast < _i_ > ( data ) ) ) ? true : false;
  1390. }
  1391. bool operator <= ( _n_ & data ) const
  1392. {
  1393. return (m_data <= ( * ( ( _i_ * ) ( &data ) )) ) ? true : false;
  1394. }
  1395. bool operator >= ( const _Myt & other ) const
  1396. {
  1397. return (m_data >= other.m_data) ? true : false;
  1398. }
  1399. bool operator >= ( _c_ & data  ) const
  1400. {
  1401. return (m_data >= ( const_cast < _i_ > ( data ) ) ) ? true : false;
  1402. }
  1403. bool operator >= ( _n_ & data ) const
  1404. {
  1405. return (m_data >= ( * ( ( _i_ * ) ( &data ) )) ) ? true : false;
  1406. }
  1407. bool operator < ( const _Myt & other ) const
  1408. {
  1409. return (m_data < other.m_data) ? true : false;
  1410. }
  1411. bool operator < ( _c_ & data  ) const
  1412. {
  1413. return (m_data < ( const_cast < _i_ > ( data ) ) ) ? true : false;
  1414. }
  1415. bool operator < ( _n_ & data ) const
  1416. {
  1417. return (m_data < ( * ( ( _i_ * ) ( &data ) )) ) ? true : false;
  1418. }
  1419. bool operator > ( const _Myt & other ) const
  1420. {
  1421. return (m_data > other.m_data) ? true : false;
  1422. }
  1423. bool operator > ( _c_ & data  ) const
  1424. {
  1425. return (m_data > ( const_cast < _i_ > ( data ) ) ) ? true : false;
  1426. }
  1427. bool operator > ( _n_ & data ) const
  1428. {
  1429. return (m_data > ( * ( ( _i_ * ) ( &data ) )) ) ? true : false;
  1430. }
  1432. operator bool () const
  1433. {
  1434. return (m_data == reinterpret_cast < _i_ > ( NULL )) ? false : true;
  1435. }
  1436. // operator int () const
  1437. // {
  1438. // return (int)m_data;
  1439. // }
  1440. // operator long () const
  1441. // {
  1442. // return (long)m_data;
  1443. // }
  1444. // operator unsigned int () const
  1445. // {
  1446. // return (unsigned int)m_data;
  1447. // }
  1448. // operator unsigned long () const
  1449. // {
  1450. // return (unsigned long)m_data;
  1451. // }
  1452. }; // class CExtNWCTC
  1454. template < class _c_, class _i_, class _n_, class _a_ >
  1455. class __EXT_MFC_TEMPLATED_WCHAR_T_ADAPTOR_NO_VTABLE CExtNWCTCA
  1456. : public CExtNWCTC < _c_, _i_, _n_ >
  1457. {
  1458. public:
  1459. typedef CExtNWCTCA < _c_, _i_, _n_, _a_ > _Myt;
  1460. typedef CExtNWCTC < _c_, _i_, _n_ > _Mybt;
  1461. CExtNWCTCA( _c_ data )
  1462. : _Mybt( data )
  1463. {
  1464. }
  1465. CExtNWCTCA( _n_ data )
  1466. : _Mybt( data )
  1467. {
  1468. }
  1469. CExtNWCTCA( const int _the_null_val = NULL )
  1470. : _Mybt( _the_null_val )
  1471. {
  1472. }
  1473. CExtNWCTCA( const _Myt & other )
  1474. : _Mybt( other )
  1475. {
  1476. }
  1478. CExtNWCTCA( const __prof_uis_used_CStringT & other )
  1479. : _Mybt( ( _i_ )( other.GetString() ) )
  1480. {
  1481. }
  1482. CExtNWCTCA( const __prof_uis_converted_CStringT & other )
  1483. : _Mybt( ( _i_ )( other.GetString() ) )
  1484. {
  1485. }
  1487. // _Myt & operator = ( const __prof_uis_used_CStringT & other )
  1488. // {
  1489. // return _Mybt::operator = ( ( _i_ )( other.GetString() ) );
  1490. // }
  1491. // _Myt & operator = ( const __prof_uis_converted_CStringT & other )
  1492. // {
  1493. // return _Mybt::operator = ( ( _i_ )( other.GetString() ) );
  1494. // }
  1496. operator __prof_uis_used_CStringT () const
  1497. {
  1498. return __prof_uis_used_CStringT( (__prof_uis_used_CStringT::PCXSTR)m_data );
  1499. }
  1500. operator __prof_uis_converted_CStringT () const
  1501. {
  1502. return __prof_uis_converted_CStringT( (__prof_uis_converted_CStringT::PCXSTR)m_data );
  1503. }
  1505. _a_ operator [] ( int nIndex ) const
  1506. {
  1507. return ( ( _a_ ) ( m_data[ nIndex ] ) );
  1508. }
  1509. }; // CExtNWCTCA
  1511. typedef CExtNWCT   <       unsigned short     ,                            __wchar_t                               > __EXT_MFC_SAFE_TCHAR;
  1512. typedef CExtNWCTC  < const unsigned short     , unsigned short     , const __wchar_t                               > __EXT_MFC_SAFE_CONST_TCHAR;
  1513. typedef CExtNWCTA  <       unsigned short *   ,                            __wchar_t *   , __prof_uis_used_wchar_t > __EXT_MFC_SAFE_LPTSTR;
  1514. typedef CExtNWCTCA < const unsigned short *   , unsigned short *   , const __wchar_t *   , __prof_uis_used_wchar_t > __EXT_MFC_SAFE_LPCTSTR;
  1515. typedef CExtNWCT   <       unsigned short   & ,                            __wchar_t   &                           > __EXT_MFC_SAFE_TCHAR_REF;
  1516. typedef CExtNWCTC  < const unsigned short   & , unsigned short   & , const __wchar_t   &                           > __EXT_MFC_SAFE_CONST_TCHAR_REF;
  1517. typedef CExtNWCTA  <       unsigned short * & ,                            __wchar_t * & , __prof_uis_used_wchar_t > __EXT_MFC_SAFE_LPTSTR_REF;
  1518. typedef CExtNWCTCA < const unsigned short * & , unsigned short * & , const __wchar_t * & , __prof_uis_used_wchar_t > __EXT_MFC_SAFE_LPCTSTR_REF;
  1520. typedef CStringA CExtSafeStringA; // allways same as MFC's
  1522. class CExtSafeStringW : public __prof_uis_used_CStringT
  1523. {
  1524. public:
  1525. CExtSafeStringW()
  1526. {
  1527. }
  1528. // CExtSafeStringW( __EXT_MFC_SAFE_LPTSTR pszSrc )
  1529. // {
  1530. // const __prof_uis_used_wchar_t * ptr = pszSrc;
  1531. // (*this) = ptr;
  1532. // }
  1533. CExtSafeStringW( __EXT_MFC_SAFE_LPCTSTR pszSrc )
  1534. {
  1535. const __prof_uis_used_wchar_t * ptr = pszSrc;
  1536. (*this) = ptr;
  1537. }
  1538. explicit CExtSafeStringW( IAtlStringMgr * pStringMgr ) throw()
  1539. : __prof_uis_used_CStringT( pStringMgr )
  1540. {
  1541. }
  1542. // CExtSafeStringW( const VARIANT & varSrc )
  1543. // : __prof_uis_used_CStringT(  varSrc )
  1544. // {
  1545. // }
  1546. // CExtSafeStringW( const VARIANT & varSrc, IAtlStringMgr * pStringMgr )
  1547. // : __prof_uis_used_CStringT( varSrc, pStringMgr )
  1548. // {
  1549. // }
  1550. CExtSafeStringW( const CExtSafeStringW & strSrc )
  1551. : __prof_uis_used_CStringT( strSrc )
  1552. {
  1553. }
  1554. CExtSafeStringW( const __prof_uis_used_CStringT & strSrc )
  1555. : __prof_uis_used_CStringT( strSrc )
  1556. {
  1557. }
  1558. CExtSafeStringW( const XCHAR * pszSrc )
  1559. : __prof_uis_used_CStringT( pszSrc )
  1560. {
  1561. }
  1562. CExtSafeStringW( LPCSTR pszSrc, IAtlStringMgr * pStringMgr )
  1563. : __prof_uis_used_CStringT( pszSrc, pStringMgr )
  1564. {
  1565. }
  1566. CSTRING_EXPLICIT CExtSafeStringW( const YCHAR * pszSrc )
  1567. : __prof_uis_used_CStringT( pszSrc )
  1568. {
  1569. }
  1570. CExtSafeStringW( LPCWSTR pszSrc, IAtlStringMgr * pStringMgr )
  1571. : __prof_uis_used_CStringT( pszSrc, pStringMgr )
  1572. {
  1573. }
  1574. CSTRING_EXPLICIT CExtSafeStringW( const unsigned char * pszSrc )
  1575. : __prof_uis_used_CStringT( pszSrc )
  1576. {
  1577. }
  1578. CExtSafeStringW( const unsigned char * pszSrc, IAtlStringMgr * pStringMgr )
  1579. : __prof_uis_used_CStringT( pszSrc, pStringMgr )
  1580. {
  1581. }
  1582. CSTRING_EXPLICIT CExtSafeStringW( char ch, int nLength = 1 )
  1583. : __prof_uis_used_CStringT( ch, nLength )
  1584. {
  1585. }
  1586. CSTRING_EXPLICIT CExtSafeStringW( __prof_uis_used_wchar_t ch, int nLength = 1 )
  1587. : __prof_uis_used_CStringT( ((XCHAR *)(&ch)), nLength )
  1588. {
  1589. }
  1590. CSTRING_EXPLICIT CExtSafeStringW( __prof_uis_converted_wchar_t ch, int nLength = 1 )
  1591. : __prof_uis_used_CStringT( ((XCHAR *)(&ch)), nLength )
  1592. {
  1593. }
  1594. CExtSafeStringW( const XCHAR * pch, int nLength )
  1595. : __prof_uis_used_CStringT( pch, nLength )
  1596. {
  1597. }
  1598. CExtSafeStringW( const XCHAR * pch, int nLength, IAtlStringMgr * pStringMgr )
  1599. : __prof_uis_used_CStringT( pch, nLength, pStringMgr )
  1600. {
  1601. }
  1602. CExtSafeStringW( const YCHAR * pch, int nLength )
  1603. : __prof_uis_used_CStringT( pch, nLength )
  1604. {
  1605. }
  1606. CExtSafeStringW( const YCHAR * pch, int nLength, IAtlStringMgr * pStringMgr )
  1607. : __prof_uis_used_CStringT( pch, nLength, pStringMgr )
  1608. {
  1609. }
  1611. operator __prof_uis_converted_wchar_t * ()
  1612. {
  1613. LPVOID pData = (LPVOID)GetString();
  1614. return ( (__prof_uis_converted_wchar_t *) pData );
  1615. }
  1616. operator const __prof_uis_converted_wchar_t * () const
  1617. {
  1618. LPVOID pData = (LPVOID)GetString();
  1619. return ( (__prof_uis_converted_wchar_t *) pData );
  1620. }
  1622. operator __prof_uis_used_wchar_t * ()
  1623. {
  1624. LPVOID pData = (LPVOID)GetString();
  1625. return ( (__prof_uis_used_wchar_t *) pData );
  1626. }
  1627. operator const __prof_uis_used_wchar_t * () const
  1628. {
  1629. LPVOID pData = (LPVOID)GetString();
  1630. return ( (__prof_uis_used_wchar_t *) pData );
  1631. }
  1633. operator __EXT_MFC_SAFE_LPTSTR ()
  1634. {
  1635. LPVOID pData = (LPVOID)GetString();
  1636. return __EXT_MFC_SAFE_LPTSTR( (__prof_uis_used_wchar_t *) pData );
  1637. }
  1638. operator __EXT_MFC_SAFE_LPCTSTR () const
  1639. {
  1640. LPVOID pData = (LPVOID)GetString();
  1641. return __EXT_MFC_SAFE_LPCTSTR( (__prof_uis_used_wchar_t *) pData );
  1642. }
  1644. operator __prof_uis_converted_CStringT & ()
  1645. {
  1646. return * ( ( __prof_uis_converted_CStringT * ) ( this ) );
  1647. }
  1648. operator const __prof_uis_converted_CStringT & () const
  1649. {
  1650. return * ( ( __prof_uis_converted_CStringT * ) ( this ) );
  1651. }
  1653. CExtSafeStringW & operator = (
  1654. const __prof_uis_used_wchar_t * other
  1655. )
  1656. {
  1657. __prof_uis_used_CStringT::operator = ( other );
  1658. return (*this);
  1659. }
  1660. CExtSafeStringW & operator = (
  1661. const __prof_uis_converted_wchar_t * other
  1662. )
  1663. {
  1664. return ( operator = ( (__prof_uis_used_wchar_t *)other ) );
  1665. }
  1666. CExtSafeStringW & operator = ( __prof_uis_converted_wchar_t ch )
  1667. {
  1668. __prof_uis_used_wchar_t ach[2] = { ((__prof_uis_used_wchar_t)ch), 0 };
  1669. return ( operator = ( reinterpret_cast < PCXSTR > ( ach ) ) );
  1670. }
  1671. CExtSafeStringW & operator = ( __prof_uis_used_wchar_t ch )
  1672. {
  1673. __prof_uis_used_wchar_t ach[2] = { ((__prof_uis_used_wchar_t)ch), 0 };
  1674. return ( operator=( reinterpret_cast < PCXSTR > ( ach ) ) );
  1675. }
  1677. CExtSafeStringW & operator = ( const __prof_uis_used_CStringT & other )
  1678. {
  1679. return ( operator = ( reinterpret_cast < PCXSTR > ( other.GetString() ) ) );
  1680. }
  1681. CExtSafeStringW & operator = ( const __prof_uis_converted_CStringT & other )
  1682. {
  1683. return ( operator = ( reinterpret_cast < PCXSTR > ( other.GetString() ) ) );
  1684. }
  1686. CExtSafeStringW & operator = (
  1687. __EXT_MFC_SAFE_LPTSTR s
  1688. )
  1689. {
  1690. return ( operator = ( ( const __prof_uis_used_wchar_t * ) ( s ) ) );
  1691. }
  1692. CExtSafeStringW & operator = (
  1693. __EXT_MFC_SAFE_LPCTSTR s
  1694. )
  1695. {
  1696. return ( operator = ( ( const __prof_uis_used_wchar_t * ) ( s ) ) );
  1697. }
  1699. friend CExtSafeStringW operator + (
  1700. const __prof_uis_used_CStringT & str1,
  1701. __prof_uis_converted_wchar_t * psz2
  1702. )
  1703. {
  1704. return
  1705. // disable warning 4675
  1706. #pragma warning( push )
  1707. #pragma warning ( disable : 4675 )
  1708. operator + (
  1709. str1,
  1710. reinterpret_cast < PCXSTR > ( psz2 )
  1711. );
  1712. // rollback warning 4675
  1713. #pragma warning( pop )
  1714. }
  1715. friend CExtSafeStringW operator + (
  1716. __prof_uis_converted_wchar_t * psz1,
  1717. const __prof_uis_used_CStringT & str2
  1718. )
  1719. {
  1720. // disable warning 4675
  1721. #pragma warning( push )
  1722. #pragma warning ( disable : 4675 )
  1723. return
  1724. operator + (
  1725. reinterpret_cast < PCXSTR > ( psz1 ),
  1726. str2
  1727. );
  1728. // rollback warning 4675
  1729. #pragma warning( pop )
  1730. }
  1731. CExtSafeStringW & operator += ( const char * pszSrc )
  1732. {
  1733. __prof_uis_used_CStringT::operator += ( pszSrc );
  1734. return (*this);
  1735. }
  1736. CExtSafeStringW & operator += ( const __prof_uis_converted_wchar_t * pszSrc )
  1737. {
  1738. __prof_uis_used_CStringT::operator += ( reinterpret_cast < PCXSTR > ( pszSrc ) );
  1739. return (*this);
  1740. }
  1741. CExtSafeStringW & operator += ( const CExtSafeStringW & s )
  1742. {
  1743. __prof_uis_used_CStringT::operator += ( s );
  1744. return (*this);
  1745. }
  1746. CExtSafeStringW & operator += ( char ch )
  1747. {
  1748. __prof_uis_used_CStringT::operator += ( ch );
  1749. return (*this);
  1750. }
  1751. CExtSafeStringW & operator += ( __prof_uis_used_wchar_t ch )
  1752. {
  1753. __prof_uis_used_CStringT::operator += ( (unsigned char)ch );
  1754. return (*this);
  1755. }
  1756. CExtSafeStringW & operator += ( __prof_uis_converted_wchar_t ch )
  1757. {
  1758. __prof_uis_used_CStringT::operator += ( (unsigned char)ch );
  1759. return (*this);
  1760. }
  1762. friend CExtSafeStringW operator + (
  1763. const __prof_uis_used_CStringT & str1,
  1764. const char * psz2
  1765. )
  1766. {
  1767. // disable warning 4675
  1768. #pragma warning( push )
  1769. #pragma warning ( disable : 4675 )
  1770. return
  1771. operator + (
  1772. str1,
  1773. CExtSafeStringW( psz2 )
  1774. );
  1775. // rollback warning 4675
  1776. #pragma warning( pop )
  1777. }
  1778. friend CExtSafeStringW operator + (
  1779. const __prof_uis_used_CStringT & str1,
  1780. const __prof_uis_converted_wchar_t * psz2
  1781. )
  1782. {
  1783. // disable warning 4675
  1784. #pragma warning( push )
  1785. #pragma warning ( disable : 4675 )
  1786. return
  1787. operator + (
  1788. str1,
  1789. reinterpret_cast < PCXSTR > ( psz2 )
  1790. );
  1791. // rollback warning 4675
  1792. #pragma warning( pop )
  1793. }
  1794. friend CExtSafeStringW operator + (
  1795. const char * psz1,
  1796. const __prof_uis_used_CStringT & str2
  1797. )
  1798. {
  1799. return
  1800. operator + (
  1801. CExtSafeStringW( psz1 ),
  1802. str2
  1803. );
  1804. }
  1805. friend CExtSafeStringW operator + (
  1806. const __prof_uis_converted_wchar_t * psz1,
  1807. const __prof_uis_used_CStringT & str2
  1808. )
  1809. {
  1810. return
  1811. operator + (
  1812. reinterpret_cast < PCXSTR > ( psz1 ),
  1813. str2
  1814. );
  1815. }
  1816. // friend CExtSafeStringW operator + (
  1817. // const __prof_uis_used_CStringT & str1,
  1818. // __prof_uis_converted_wchar_t ch2
  1819. // )
  1820. // {
  1821. // return
  1822. // operator + (
  1823. // str1,
  1824. // * ( reinterpret_cast < XCHAR * > ( &ch2 ) )
  1825. // );
  1826. // }
  1827. // friend CExtSafeStringW operator + (
  1828. // __prof_uis_converted_wchar_t ch1,
  1829. // const __prof_uis_used_CStringT & str2
  1830. // )
  1831. // {
  1832. // return
  1833. // operator + (
  1834. // * ( reinterpret_cast < XCHAR * > ( &ch1 ) ),
  1835. // str2
  1836. // );
  1837. // }
  1838. friend bool operator == (
  1839. const __prof_uis_used_CStringT & str1,
  1840. const __prof_uis_converted_wchar_t * psz2
  1841. ) throw()
  1842. {
  1843. return ( str1.Compare( reinterpret_cast < PCXSTR > ( psz2 ) ) == 0 );
  1844. }
  1845. friend bool operator == (
  1846. const __prof_uis_converted_wchar_t * psz1,
  1847. const __prof_uis_used_CStringT & str2
  1848. ) throw()
  1849. {
  1850. return ( str2.Compare( reinterpret_cast < PCXSTR > ( psz1 ) ) == 0 );
  1851. }
  1852. friend bool operator != (
  1853. const __prof_uis_used_CStringT & str1,
  1854. const __prof_uis_converted_wchar_t * psz2
  1855. ) throw()
  1856. {
  1857. return ( str1.Compare( reinterpret_cast < PCXSTR > ( psz2 ) ) != 0 );
  1858. }
  1859. friend bool operator != (
  1860. const __prof_uis_converted_wchar_t * psz1,
  1861. const __prof_uis_used_CStringT & str2
  1862. ) throw()
  1863. {
  1864. return ( str2.Compare( reinterpret_cast < PCXSTR > ( psz1 ) ) != 0 );
  1865. }
  1866. friend bool operator < (
  1867. const __prof_uis_used_CStringT & str1,
  1868. const __prof_uis_converted_wchar_t * psz2
  1869. ) throw()
  1870. {
  1871. return ( str1.Compare( reinterpret_cast < PCXSTR > ( psz2 ) ) < 0 );
  1872. }
  1873. friend bool operator < (
  1874. const __prof_uis_converted_wchar_t * psz1,
  1875. const __prof_uis_used_CStringT & str2
  1876. ) throw()
  1877. {
  1878. return ( str2.Compare( reinterpret_cast < PCXSTR > ( psz1 ) ) >= 0 );
  1879. }
  1880. friend bool operator > (
  1881. const __prof_uis_used_CStringT & str1,
  1882. const __prof_uis_converted_wchar_t * psz2
  1883. ) throw()
  1884. {
  1885. return ( str1.Compare( reinterpret_cast < PCXSTR > ( psz2 ) ) > 0 );
  1886. }
  1887. friend bool operator > (
  1888. const __prof_uis_converted_wchar_t * psz1,
  1889. const __prof_uis_used_CStringT & str2
  1890. ) throw()
  1891. {
  1892. return ( str2.Compare( reinterpret_cast < PCXSTR > ( psz1 ) ) <= 0 );
  1893. }
  1894. friend bool operator <= (
  1895. const __prof_uis_used_CStringT & str1,
  1896. const __prof_uis_converted_wchar_t * psz2
  1897. ) throw()
  1898. {
  1899. return ( str1.Compare( reinterpret_cast < PCXSTR > ( psz2 ) ) <= 0 );
  1900. }
  1901. friend bool operator <= (
  1902. const __prof_uis_converted_wchar_t * psz1, 
  1903. const __prof_uis_used_CStringT & str2
  1904. ) throw()
  1905. {
  1906. return ( str2.Compare( reinterpret_cast < PCXSTR > ( psz1 ) ) > 0 );
  1907. }
  1908. friend bool operator >= (
  1909. const __prof_uis_used_CStringT & str1,
  1910. const __prof_uis_converted_wchar_t * psz2
  1911. ) throw()
  1912. {
  1913. return ( str1.Compare( reinterpret_cast < PCXSTR > ( psz2 ) ) >= 0 );
  1914. }
  1915. friend bool operator >= (
  1916. const __prof_uis_converted_wchar_t * psz1,
  1917. const __prof_uis_used_CStringT & str2
  1918. ) throw()
  1919. {
  1920. return ( str2.Compare( reinterpret_cast < PCXSTR > ( psz1 ) ) < 0 );
  1921. }
  1922. friend bool operator == (
  1923. __prof_uis_converted_wchar_t ch1,
  1924. const __prof_uis_used_CStringT & str2
  1925. ) throw()
  1926. {
  1927. return ( (str2.GetLength() == 1) && (str2[0] == ( * ( reinterpret_cast < XCHAR * > ( &ch1 ) ) )) );
  1928. }
  1929. friend bool operator == (
  1930. const __prof_uis_used_CStringT & str1,
  1931. __prof_uis_converted_wchar_t ch2
  1932. ) throw()
  1933. {
  1934. return ( (str1.GetLength() == 1) && (str1[0] == ( * ( reinterpret_cast < XCHAR * > ( &ch2 ) ) )) );
  1935. }
  1936. friend bool operator != (
  1937. __prof_uis_converted_wchar_t ch1,
  1938. const __prof_uis_used_CStringT & str2
  1939. ) throw()
  1940. {
  1941. return ( (str2.GetLength() != 1) || (str2[0] != ( * ( reinterpret_cast < XCHAR * > ( &ch1 ) ) )) );
  1942. }
  1943. friend bool operator != (
  1944. const __prof_uis_used_CStringT & str1,
  1945. __prof_uis_converted_wchar_t ch2
  1946. ) throw()
  1947. {
  1948. return ( (str1.GetLength() != 1) || (str1[0] != ( * ( reinterpret_cast < XCHAR * > ( &ch2 ) ) )) );
  1949. }
  1950. void __cdecl Format( const __prof_uis_converted_wchar_t * pszFormat, ... )
  1951. {
  1952. ATLASSERT( AtlIsValidString( ((LPCWSTR)pszFormat) ) );
  1953. va_list argList;
  1954. va_start( argList, pszFormat );
  1955. FormatV( ((PCXSTR)pszFormat), argList );
  1956. va_end( argList );
  1957. }
  1958. void __cdecl Format( const __prof_uis_used_wchar_t * pszFormat, ... )
  1959. {
  1960. ATLASSERT( AtlIsValidString( ((LPCWSTR)pszFormat) ) );
  1961. va_list argList;
  1962. va_start( argList, pszFormat );
  1963. FormatV( ((PCXSTR)pszFormat), argList );
  1964. va_end( argList );
  1965. }
  1966. }; // class CExtSafeStringW
  1968. typedef CExtSafeStringW CExtSafeString;
  1970. class CExtSafeStringArray : public CStringArray
  1971. {
  1972. public:
  1973. const CExtSafeString & GetAt( INT_PTR nIndex ) const
  1974. {
  1975. const CString & s = CStringArray::GetAt( nIndex );
  1976. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  1977. }
  1978. void SetAt(
  1979. INT_PTR nIndex,
  1980. __EXT_MFC_SAFE_LPCTSTR newElement
  1981. )
  1982. {
  1983. CStringArray::SetAt(
  1984. nIndex,
  1985. (LPCTSTR)newElement
  1986. );
  1987. }
  1988. void SetAt(
  1989. INT_PTR nIndex,
  1990. const CExtSafeString & newElement
  1991. )
  1992. {
  1993. const CString & s = * ( ( CString * ) ( & newElement ) ); // Xtra-dirty-cast
  1994. CStringArray::SetAt(
  1995. nIndex,
  1996. s
  1997. );
  1998. }
  1999. CExtSafeString & ElementAt( INT_PTR nIndex )
  2000. {
  2001. CString & s = CStringArray::ElementAt( nIndex );
  2002. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2003. }
  2004. const CExtSafeString * GetData() const
  2005. {
  2006. const CString * s = CStringArray::GetData();
  2007. return ( ( CExtSafeString * ) (  s ) ); // Xtra-dirty-cast
  2008. }
  2009. CExtSafeString * GetData()
  2010. {
  2011. CString * s = CStringArray::GetData();
  2012. return ( ( CExtSafeString * ) (  s ) ); // Xtra-dirty-cast
  2013. }
  2014. void SetAtGrow(
  2015. INT_PTR nIndex,
  2016. __EXT_MFC_SAFE_LPCTSTR newElement
  2017. )
  2018. {
  2019. CStringArray::SetAtGrow(
  2020. nIndex,
  2021. (LPCTSTR)newElement
  2022. );
  2023. }
  2024. void SetAtGrow(
  2025. INT_PTR nIndex,
  2026. const CExtSafeString & newElement
  2027. )
  2028. {
  2029. CStringArray::SetAtGrow(
  2030. nIndex,
  2031. * ( ( CString * ) ( & newElement ) ) // Xtra-dirty-cast
  2032. );
  2033. }
  2034. INT_PTR Add( __EXT_MFC_SAFE_LPCTSTR newElement )
  2035. {
  2036. return
  2037. CStringArray::Add(
  2038. (LPCTSTR)newElement
  2039. );
  2040. }
  2041. INT_PTR Add( const CExtSafeString & newElement )
  2042. {
  2043. return
  2044. CStringArray::Add(
  2045. * ( ( CString * ) ( & newElement ) ) // Xtra-dirty-cast
  2046. );
  2047. }
  2048. const CExtSafeString & operator [] ( INT_PTR nIndex ) const
  2049. {
  2050. const CString & s = CStringArray::operator [] ( nIndex );
  2051. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2052. }
  2053. CExtSafeString & operator [] ( INT_PTR nIndex )
  2054. {
  2055. CString & s = CStringArray::operator [] ( nIndex );
  2056. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2057. }
  2058. void InsertAt(
  2059. INT_PTR nIndex,
  2060. __EXT_MFC_SAFE_LPCTSTR newElement,
  2061. INT_PTR nCount = 1
  2062. )
  2063. {
  2064. CStringArray::InsertAt(
  2065. nIndex,
  2066. (LPCTSTR)newElement,
  2067. nCount
  2068. );
  2069. }
  2070. void InsertAt(
  2071. INT_PTR nIndex,
  2072. const CString & newElement,
  2073. INT_PTR nCount = 1
  2074. )
  2075. {
  2076. CStringArray::InsertAt(
  2077. nIndex,
  2078. * ( ( CString * ) ( & newElement ) ), // Xtra-dirty-cast
  2079. nCount
  2080. );
  2081. }
  2082. }; // class CExtSafeStringArray
  2084. class CExtSafeStringList : public CStringList
  2085. {
  2086. public:
  2087. CExtSafeStringList( INT_PTR nBlockSize = 10 )
  2088. : CStringList( nBlockSize )
  2089. {
  2090. }
  2091. CExtSafeString & GetHead()
  2092. {
  2093. CString & s = CStringList::GetHead();
  2094. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2095. }
  2096. const CExtSafeString & GetHead() const
  2097. {
  2098. const CString & s = CStringList::GetHead();
  2099. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2100. }
  2101. CExtSafeString & GetTail()
  2102. {
  2103. CString & s = CStringList::GetTail();
  2104. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2105. }
  2106. const CExtSafeString & GetTail() const
  2107. {
  2108. const CString & s = CStringList::GetTail();
  2109. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2110. }
  2111. CExtSafeString RemoveHead()
  2112. {
  2113. return CExtSafeString( (LPCTSTR)CStringList::RemoveHead() );
  2114. }
  2115. CExtSafeString RemoveTail()
  2116. {
  2117. return CExtSafeString( (LPCTSTR)CStringList::RemoveTail() );
  2118. }
  2119. POSITION AddHead( __EXT_MFC_SAFE_LPCTSTR newElement )
  2120. {
  2121. return CStringList::AddHead( (LPCTSTR)newElement );
  2122. }
  2123. POSITION AddTail( __EXT_MFC_SAFE_LPCTSTR newElement )
  2124. {
  2125. return CStringList::AddTail( (LPCTSTR)newElement );
  2126. }
  2127. POSITION AddHead( const CExtSafeString & newElement )
  2128. {
  2129. return CStringList::AddHead( (LPCTSTR)newElement );
  2130. }
  2131. void AddHead( CExtSafeStringList * pNewList )
  2132. {
  2133. CStringList::AddHead( (CStringList *)pNewList );
  2134. }
  2135. POSITION AddTail( const CExtSafeString & newElement )
  2136. {
  2137. return CStringList::AddTail( (LPCTSTR)newElement );
  2138. }
  2139. void AddTail( CExtSafeStringList * pNewList )
  2140. {
  2141. CStringList::AddTail( (CStringList *)pNewList );
  2142. }
  2143. CExtSafeString & GetNext( POSITION & rPosition )
  2144. {
  2145. CString & s = CStringList::GetNext( rPosition );
  2146. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2147. }
  2148. const CExtSafeString & GetNext( POSITION & rPosition ) const
  2149. {
  2150. const CString & s = CStringList::GetNext( rPosition );
  2151. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2152. }
  2153. CExtSafeString & GetPrev( POSITION & rPosition )
  2154. {
  2155. CString & s = CStringList::GetPrev( rPosition );
  2156. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2157. }
  2158. const CExtSafeString & GetPrev( POSITION & rPosition ) const
  2159. {
  2160. const CString & s = CStringList::GetPrev( rPosition );
  2161. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2162. }
  2163. CExtSafeString & GetAt( POSITION position )
  2164. {
  2165. CString & s = CStringList::GetAt( position );
  2166. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2167. }
  2168. const CExtSafeString & GetAt( POSITION position ) const
  2169. {
  2170. const CString & s = CStringList::GetAt( position );
  2171. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2172. }
  2173. void SetAt( POSITION pos, __EXT_MFC_SAFE_LPCTSTR newElement )
  2174. {
  2175. CStringList::SetAt( pos, (LPCTSTR)newElement );
  2176. }
  2177. void SetAt( POSITION pos, const CExtSafeString & newElement )
  2178. {
  2179. CStringList::SetAt( pos, (LPCTSTR)newElement );
  2180. }
  2181. POSITION InsertBefore( POSITION position, __EXT_MFC_SAFE_LPCTSTR newElement )
  2182. {
  2183. return CStringList::InsertBefore( position, (LPCTSTR)newElement );
  2184. }
  2185. POSITION InsertAfter( POSITION position, __EXT_MFC_SAFE_LPCTSTR newElement )
  2186. {
  2187. return CStringList::InsertAfter( position, (LPCTSTR)newElement );
  2188. }
  2189. POSITION InsertBefore( POSITION position, const CExtSafeString & newElement )
  2190. {
  2191. return CStringList::InsertBefore( position, (LPCTSTR)newElement );
  2192. }
  2193. POSITION InsertAfter( POSITION position, const CExtSafeString & newElement )
  2194. {
  2195. return CStringList::InsertAfter( position, (LPCTSTR)newElement );
  2196. }
  2197. POSITION Find( __EXT_MFC_SAFE_LPCTSTR searchValue, POSITION startAfter = NULL ) const
  2198. {
  2199. return CStringList::Find( searchValue, startAfter );
  2200. }
  2201. }; // class CExtSafeStringList
  2203. class CExtSafeMapStringToPtr : public CMapStringToPtr
  2204. {
  2205. public:
  2206. CExtSafeMapStringToPtr(
  2207. INT_PTR nBlockSize = 10
  2208. )
  2209. : CMapStringToPtr( nBlockSize )
  2210. {
  2211. }
  2212. BOOL Lookup(
  2213. __EXT_MFC_SAFE_LPCTSTR key,
  2214. void * & rValue
  2215. ) const
  2216. {
  2217. return
  2218. CMapStringToPtr::Lookup(
  2219. key,
  2220. rValue
  2221. );
  2222. }
  2223. BOOL LookupKey(
  2224. __EXT_MFC_SAFE_LPCTSTR key,
  2225. __EXT_MFC_SAFE_LPCTSTR & rKey
  2226. ) const
  2227. {
  2228. return
  2229. CMapStringToPtr::LookupKey(
  2230. key,
  2231. (LPCTSTR &) rKey
  2232. );
  2233. }
  2234. void * & operator [] (
  2235. __EXT_MFC_SAFE_LPCTSTR key
  2236. )
  2237. {
  2238. return CMapStringToPtr::operator []( key );
  2239. }
  2240. void SetAt(
  2241. __EXT_MFC_SAFE_LPCTSTR key,
  2242. void * newValue
  2243. )
  2244. {
  2245. CMapStringToPtr::SetAt(
  2246. key,
  2247. newValue
  2248. );
  2249. }
  2250. BOOL RemoveKey(
  2251. __EXT_MFC_SAFE_LPCTSTR key
  2252. )
  2253. {
  2254. return CMapStringToPtr::RemoveKey( key );
  2255. }
  2256. void GetNextAssoc(
  2257. POSITION & rNextPosition,
  2258. CExtSafeString & rKey,
  2259. void * & rValue
  2260. ) const
  2261. {
  2262. CMapStringToPtr::GetNextAssoc(
  2263. rNextPosition,
  2264. (CString&) rKey, // Xtra-dirty-cast
  2265. rValue
  2266. );
  2267. }
  2268. UINT HashKey(
  2269. __EXT_MFC_SAFE_LPCTSTR key
  2270. ) const
  2271. {
  2272. return CMapStringToPtr::HashKey( key );
  2273. }
  2274. }; // class CExtSafeMapStringToPtr
  2276. class CExtSafeMapStringToOb : public CMapStringToOb
  2277. {
  2278. public:
  2279. CExtSafeMapStringToOb( INT_PTR nBlockSize = 10 )
  2280. : CMapStringToOb( nBlockSize )
  2281. {
  2282. }
  2283. BOOL Lookup(
  2284. __EXT_MFC_SAFE_LPCTSTR key,
  2285. CObject * & rValue
  2286. ) const
  2287. {
  2288. return
  2289. CMapStringToOb::Lookup(
  2290. key,
  2291. rValue
  2292. );
  2293. }
  2294. BOOL LookupKey(
  2295. __EXT_MFC_SAFE_LPCTSTR key,
  2296. __EXT_MFC_SAFE_LPCTSTR & rKey
  2297. ) const
  2298. {
  2299. return
  2300. CMapStringToOb::LookupKey(
  2301. key,
  2302. (LPCTSTR &) rKey
  2303. );
  2304. }
  2305. CObject * & operator [] ( __EXT_MFC_SAFE_LPCTSTR key )
  2306. {
  2307. return CMapStringToOb::operator [] ( key );
  2308. }
  2309. void SetAt(
  2310. __EXT_MFC_SAFE_LPCTSTR key,
  2311. CObject * newValue
  2312. )
  2313. {
  2314. CMapStringToOb::SetAt(
  2315. key,
  2316. newValue
  2317. );
  2318. }
  2319. BOOL RemoveKey( __EXT_MFC_SAFE_LPCTSTR key )
  2320. {
  2321. return CMapStringToOb::RemoveKey( key );
  2322. }
  2323. void GetNextAssoc(
  2324. POSITION & rNextPosition,
  2325. CExtSafeString & rKey,
  2326. CObject * & rValue
  2327. ) const
  2328. {
  2329. CMapStringToOb::GetNextAssoc(
  2330. rNextPosition,
  2331. (CString&) rKey, // Xtra-dirty-cast
  2332. rValue
  2333. );
  2334. }
  2335. UINT HashKey( __EXT_MFC_SAFE_LPCTSTR key ) const
  2336. {
  2337. return CMapStringToOb::HashKey( key );
  2338. }
  2339. }; // class CExtSafeMapStringToOb
  2341. class CExtSafeMapStringToString : public CMapStringToString
  2342. {
  2343. public:
  2344. CExtSafeMapStringToString( INT_PTR nBlockSize = 10 )
  2345. : CMapStringToString( nBlockSize )
  2346. {
  2347. }
  2348. BOOL Lookup(
  2349. __EXT_MFC_SAFE_LPCTSTR key,
  2350. CExtSafeString & rValue
  2351. ) const
  2352. {
  2353. return
  2354. CMapStringToString::Lookup(
  2355. key,
  2356. (CString &) rValue // Xtra-dirty-cast
  2357. );
  2358. }
  2359. const CPair * PLookup( __EXT_MFC_SAFE_LPCTSTR key ) const
  2360. {
  2361. return CMapStringToString::PLookup( key );
  2362. }
  2363. CPair * PLookup( __EXT_MFC_SAFE_LPCTSTR key )
  2364. {
  2365. return CMapStringToString::PLookup( key );
  2366. }
  2367. BOOL LookupKey(
  2368. __EXT_MFC_SAFE_LPCTSTR key,
  2369. __EXT_MFC_SAFE_LPCTSTR & rKey
  2370. ) const
  2371. {
  2372. return
  2373. CMapStringToString::LookupKey(
  2374. key,
  2375. (LPCTSTR &) rKey
  2376. );
  2377. }
  2378. CExtSafeString & operator [] ( __EXT_MFC_SAFE_LPCTSTR key )
  2379. {
  2380. CString & s = CMapStringToString::operator [] ( key );
  2381. return * ( ( CExtSafeString * ) ( & s ) ); // Xtra-dirty-cast
  2382. }
  2383. void SetAt(
  2384. __EXT_MFC_SAFE_LPCTSTR key,
  2385. __EXT_MFC_SAFE_LPCTSTR newValue
  2386. )
  2387. {
  2388. CMapStringToString::SetAt(
  2389. key,
  2390. newValue
  2391. );
  2392. }
  2393. BOOL RemoveKey(
  2394. __EXT_MFC_SAFE_LPCTSTR key
  2395. )
  2396. {
  2397. return
  2398. CMapStringToString::RemoveKey(
  2399. key
  2400. );
  2401. }
  2402. void GetNextAssoc(
  2403. POSITION & rNextPosition,
  2404. CExtSafeString & rKey,
  2405. CExtSafeString & rValue
  2406. ) const
  2407. {
  2408. CMapStringToString::GetNextAssoc(
  2409. rNextPosition,
  2410. (CString &) rKey, // Xtra-dirty-cast
  2411. (CString &) rValue // Xtra-dirty-cast
  2412. );
  2413. }
  2414. UINT HashKey(__EXT_MFC_SAFE_LPCTSTR key) const
  2415. {
  2416. return CMapStringToString::HashKey( key );
  2417. }
  2418. }; // class CExtSafeMapStringToString
  2420. #define __EXT_MFC_SAFE_ON_WM_DEVMODECHANGE() 
  2421. { WM_DEVMODECHANGE, 0, 0, 0, AfxSig_vs, 
  2422. (AFX_PMSG)(AFX_PMSGW) 
  2423. (static_cast < void (AFX_MSG_CALL CWnd::*)(__EXT_MFC_SAFE_LPTSTR) > (OnDevModeChange)) },
  2424. #define __EXT_MFC_SAFE_ON_WM_ASKCBFORMATNAME() 
  2425. { WM_ASKCBFORMATNAME, 0, 0, 0, AfxSig_vwl, 
  2426. (AFX_PMSG)(AFX_PMSGW) 
  2427. (static_cast < void (AFX_MSG_CALL CWnd::*)(UINT, __EXT_MFC_SAFE_LPTSTR) > (OnAskCbFormatName)) },
  2428. #define __EXT_MFC_SAFE_ON_WM_SETTINGCHANGE() 
  2429. { WM_SETTINGCHANGE, 0, 0, 0, AfxSig_vws, 
  2430. (AFX_PMSG)(AFX_PMSGW) 
  2431. (static_cast < void (AFX_MSG_CALL CWnd::*)(UINT, __EXT_MFC_SAFE_LPCTSTR) > (OnSettingChange)) },
  2432. #define __EXT_MFC_SAFE_ON_WM_WININICHANGE() 
  2433. { WM_WININICHANGE, 0, 0, 0, AfxSig_vs, 
  2434. (AFX_PMSG)(AFX_PMSGW) 
  2435. (static_cast < void (AFX_MSG_CALL CWnd::*)(__EXT_MFC_SAFE_LPCTSTR) > (OnWinIniChange)) },
  2437. #else // if - (defined __EXT_MFC_ENABLE_TEMPLATED_CHARS)
  2438. #pragma message("   Prof-UIS native unicode character type support:")
  2439. #pragma message("      disabled (symbol __EXT_MFC_ENABLE_TEMPLATED_CHARS is not defined)")
  2440. #endif // if not - (defined __EXT_MFC_ENABLE_TEMPLATED_CHARS)
  2442. #endif // (defined _UNICODE) && (defined _WCHAR_T_DEFINED) && (defined __EXT_MFC_ENABLE_TEMPLATED_CHARS)
  2443. #endif // #if _MFC_VER >= 0x700
  2446. #if (!defined __EXT_MFC_TEMPLATED_CHARS_IMPLEMENTED)
  2448. typedef         TCHAR   __EXT_MFC_SAFE_TCHAR;
  2449. typedef const   TCHAR   __EXT_MFC_SAFE_CONST_TCHAR;
  2450. typedef LPTSTR          __EXT_MFC_SAFE_LPTSTR;
  2451. typedef LPCTSTR         __EXT_MFC_SAFE_LPCTSTR;
  2452. typedef         TCHAR & __EXT_MFC_SAFE_TCHAR_REF;
  2453. typedef const   TCHAR & __EXT_MFC_SAFE_CONST_TCHAR_REF;
  2454. typedef LPTSTR        & __EXT_MFC_SAFE_LPTSTR_REF;
  2455. typedef LPCTSTR       & __EXT_MFC_SAFE_LPCTSTR_REF;
  2457. typedef TCHAR __prof_uis_used_wchar_t;
  2458. typedef TCHAR __prof_uis_converted_wchar_t;
  2460. typedef CString CExtSafeString;
  2462. #if _MFC_VER >= 0x700
  2463. typedef CStringA CExtSafeStringA; // allways same as MFC's
  2464. typedef CStringW CExtSafeStringW;
  2465. #endif // #if _MFC_VER >= 0x700
  2467. typedef CStringArray          CExtSafeStringArray;
  2468. typedef CStringList           CExtSafeStringList;
  2470. typedef CMapStringToPtr       CExtSafeMapStringToPtr;
  2471. typedef CMapStringToOb        CExtSafeMapStringToOb;
  2472. typedef CMapStringToString    CExtSafeMapStringToString;
  2474. #define  __EXT_MFC_SAFE_ON_WM_DEVMODECHANGE() 
  2475. ON_WM_DEVMODECHANGE()
  2476. #define  __EXT_MFC_SAFE_ON_WM_ASKCBFORMATNAME() 
  2477. ON_WM_ASKCBFORMATNAME()
  2478. #define  __EXT_MFC_SAFE_ON_WM_SETTINGCHANGE() 
  2479. ON_WM_SETTINGCHANGE()
  2480. #define  __EXT_MFC_SAFE_ON_WM_WININICHANGE() 
  2481. ON_WM_WININICHANGE()
  2483. #endif (!defined __EXT_MFC_TEMPLATED_CHARS_IMPLEMENTED)
  2485. #if _MFC_VER >= 0x800
  2486. // rollback warning 4201
  2487. #pragma warning( pop )
  2488. #endif // _MFC_VER >= 0x800
  2490. #endif // __ExtMfcSafeNativeTCHAR_H