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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > GDI/图象编程 > 查看源码
atlsimpstr.h
资源名称：CreatBMP.rar　[点击查看]
上传用户：hfwmdy
上传日期：2016-01-14
资源大小：83k
文件大小：25k
源码类别：

GDI/图象编程

开发平台：

Visual C++

atlsimpstr.h：源码内容
  1. // This is a part of the Active Template Library.
  2. // Copyright (C) Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Active Template Library Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Active Template Library product.
  11. #ifndef __ATLSIMPSTR_H__
  12. #define __ATLSIMPSTR_H__
  14. #pragma once
  16. #include <atldef.h>
  17. #include <atlcore.h>
  18. #include <atlexcept.h>
  19. #include <atlmem.h>
  21. extern "C"
  22. {
  23. LONG __cdecl _InterlockedIncrement( LONG volatile * pn );
  24. LONG __cdecl _InterlockedDecrement( LONG volatile * pn );
  25. };
  27. #pragma intrinsic( _InterlockedIncrement )
  28. #pragma intrinsic( _InterlockedDecrement )
  30. #pragma pack(push,_ATL_PACKING)
  31. namespace ATL
  32. {
  34. struct CStringData;
  36. __interface IAtlStringMgr
  37. {
  38. public:
  39. // Allocate a new CStringData
  40. CStringData* Allocate( int nAllocLength, int nCharSize ) throw();
  41. // Free an existing CStringData
  42. void Free( CStringData* pData ) throw();
  43. // Change the size of an existing CStringData
  44. CStringData* Reallocate( CStringData* pData, int nAllocLength, int nCharSize ) throw();
  45. // Get the CStringData for a Nil string
  46. CStringData* GetNilString() throw();
  47. IAtlStringMgr* Clone() throw();
  48. };
  50. #ifdef _M_IX86
  51. #ifndef _M_CEE
  52. #define _AtlInterlockedIncrement _InterlockedIncrement
  53. #define _AtlInterlockedDecrement _InterlockedDecrement
  54. #else
  55. #define _AtlInterlockedIncrement InterlockedIncrement
  56. #define _AtlInterlockedDecrement InterlockedDecrement
  57. /* managed code must use the non-intrinsics */
  58. #ifdef InterlockedIncrement
  59. #undef InterlockedIncrement
  60. #endif
  61. #ifdef InterlockedDecrement
  62. #undef InterlockedDecrement
  63. #endif
  64. #endif  // !_M_CEE
  65. #else
  66. #define _AtlInterlockedIncrement InterlockedIncrement
  67. #define _AtlInterlockedDecrement InterlockedDecrement
  68. #endif  // _M_IX86_
  70. struct CStringData
  71. {
  72. IAtlStringMgr* pStringMgr;  // String manager for this CStringData
  73. int nDataLength;  // Length of currently used data in XCHARs (not including terminating null)
  74. int nAllocLength;  // Length of allocated data in XCHARs (not including terminating null)
  75. long nRefs;     // Reference count: negative == locked
  76. // XCHAR data[nAllocLength+1]  // A CStringData is always followed in memory by the actual array of character data
  78. void* data() throw()
  79. {
  80. return (this+1);
  81. }
  83. void AddRef() throw()
  84. {
  85. ATLASSERT(nRefs > 0);
  86. _AtlInterlockedIncrement(&nRefs);
  87. }
  88. bool IsLocked() const throw()
  89. {
  90. return nRefs < 0;
  91. }
  92. bool IsShared() const throw()
  93. {
  94. return( nRefs > 1 ); 
  95. }
  96. void Lock() throw()
  97. {
  98. ATLASSERT( nRefs <= 1 );
  99. nRefs--;  // Locked buffers can't be shared, so no interlocked operation necessary
  100. if( nRefs == 0 )
  101. {
  102. nRefs = -1;
  103. }
  104. }
  105. void Release() throw()
  106. {
  107. ATLASSERT( nRefs != 0 );
  109. if( _AtlInterlockedDecrement( &nRefs ) <= 0 )
  110. {
  111. pStringMgr->Free( this );
  112. }
  113. }
  114. void Unlock() throw()
  115. {
  116. ATLASSERT( IsLocked() );
  118. if(IsLocked())
  119. {
  120. nRefs++;  // Locked buffers can't be shared, so no interlocked operation necessary
  121. if( nRefs == 0 )
  122. {
  123. nRefs = 1;
  124. }
  125. }
  126. }
  127. };
  129. class CNilStringData :
  130. public CStringData
  131. {
  132. public:
  133. CNilStringData() throw()
  134. {
  135. pStringMgr = NULL;
  136. nRefs = 2;  // Never gets freed by IAtlStringMgr
  137. nDataLength = 0;
  138. nAllocLength = 0;
  139. achNil[0] = 0;
  140. achNil[1] = 0;
  141. }
  143. void SetManager( __in IAtlStringMgr* pMgr ) throw()
  144. {
  145. ATLASSERT( pStringMgr == NULL );
  146. pStringMgr = pMgr;
  147. }
  149. public:
  150. wchar_t achNil[2];
  151. };
  153. template< typename BaseType, const int t_nSize >
  154. class CStaticString
  155. {
  156. public:
  157. CStaticString( __in const BaseType* psz ) :
  158. m_psz( psz )
  159. {
  160. }
  162. operator const BaseType*() const
  163. {
  164. return m_psz;
  165. }
  167. static int __cdecl GetLength() 
  168. {
  169. return (t_nSize/sizeof( BaseType ))-1;
  170. }
  172. private:
  173. const BaseType* m_psz;
  175. private:
  176. CStaticString( const CStaticString& str ) throw();
  177. CStaticString& operator=( const CStaticString& str ) throw();
  178. };
  180. #define _ST( psz ) ATL::CStaticString< TCHAR, sizeof( _T( psz ) ) >( _T( psz ) )
  181. #define _SA( psz ) ATL::CStaticString< char, sizeof( psz ) >( psz )
  182. #define _SW( psz ) ATL::CStaticString< wchar_t, sizeof( L##psz ) >( L##psz )
  183. #define _SO( psz ) _SW( psz )
  185. template< typename BaseType = char >
  186. class ChTraitsBase
  187. {
  188. public:
  189. typedef char XCHAR;
  190. typedef LPSTR PXSTR;
  191. typedef LPCSTR PCXSTR;
  192. typedef wchar_t YCHAR;
  193. typedef LPWSTR PYSTR;
  194. typedef LPCWSTR PCYSTR;
  195. };
  197. template<>
  198. class ChTraitsBase< wchar_t >
  199. {
  200. public:
  201. typedef wchar_t XCHAR;
  202. typedef LPWSTR PXSTR;
  203. typedef LPCWSTR PCXSTR;
  204. typedef char YCHAR;
  205. typedef LPSTR PYSTR;
  206. typedef LPCSTR PCYSTR;
  207. };
  209. template< typename TCharType, bool t_bMFCDLL = false >
  210. class CStrBufT;
  212. template< typename BaseType , bool t_bMFCDLL = false>
  213. class CSimpleStringT
  214. {
  215. public:
  216. typedef typename ChTraitsBase< BaseType >::XCHAR XCHAR;
  217. typedef typename ChTraitsBase< BaseType >::PXSTR PXSTR;
  218. typedef typename ChTraitsBase< BaseType >::PCXSTR PCXSTR;
  219. typedef typename ChTraitsBase< BaseType >::YCHAR YCHAR;
  220. typedef typename ChTraitsBase< BaseType >::PYSTR PYSTR;
  221. typedef typename ChTraitsBase< BaseType >::PCYSTR PCYSTR;
  223. public:
  224. explicit CSimpleStringT( __in IAtlStringMgr* pStringMgr )
  225. {
  226. ATLENSURE( pStringMgr != NULL );
  227. CStringData* pData = pStringMgr->GetNilString();
  228. Attach( pData );
  229. }
  231. CSimpleStringT( __in const CSimpleStringT& strSrc )
  232. {
  233. CStringData* pSrcData = strSrc.GetData();
  234. CStringData* pNewData = CloneData( pSrcData );
  235. Attach( pNewData );
  236. }
  238. CSimpleStringT( __in const CSimpleStringT<BaseType, !t_bMFCDLL>& strSrc )
  239. {
  240. CStringData* pSrcData = strSrc.GetData();
  241. CStringData* pNewData = CloneData( pSrcData );
  242. Attach( pNewData );
  243. }
  245. CSimpleStringT( __in PCXSTR pszSrc, __in IAtlStringMgr* pStringMgr )
  246. {
  247. ATLENSURE( pStringMgr != NULL );
  249. int nLength = StringLength( pszSrc );
  250. CStringData* pData = pStringMgr->Allocate( nLength, sizeof( XCHAR ) );
  251. if( pData == NULL )
  252. {
  253. ThrowMemoryException();
  254. }
  255. Attach( pData );
  256. SetLength( nLength );
  257. #if _SECURE_ATL
  258.         CopyChars( m_pszData, nLength, pszSrc, nLength );
  259. #else
  260.         CopyChars( m_pszData, pszSrc, nLength );
  261. #endif
  262. }
  263. CSimpleStringT( __in_ecount(nLength) const XCHAR* pchSrc, __in int nLength, __in IAtlStringMgr* pStringMgr )
  264. {
  265. ATLENSURE( pStringMgr != NULL );
  267. if(pchSrc == NULL && nLength != 0)
  268. AtlThrow(E_INVALIDARG);
  270. CStringData* pData = pStringMgr->Allocate( nLength, sizeof( XCHAR ) );
  271. if( pData == NULL )
  272. {
  273. ThrowMemoryException();
  274. }
  275. Attach( pData );
  276. SetLength( nLength );
  277. #if _SECURE_ATL
  278.         CopyChars( m_pszData, nLength, pchSrc, nLength );
  279. #else
  280. CopyChars( m_pszData, pchSrc, nLength );
  281. #endif
  282. }
  283. ~CSimpleStringT() throw()
  284. {
  285. CStringData* pData = GetData();
  286. pData->Release();
  287. }
  289. operator CSimpleStringT<BaseType, !t_bMFCDLL>&()
  290. {
  291. return *(CSimpleStringT<BaseType, !t_bMFCDLL>*)this;
  292. }
  294. CSimpleStringT& operator=( __in const CSimpleStringT& strSrc )
  295. {
  296. CStringData* pSrcData = strSrc.GetData();
  297. CStringData* pOldData = GetData();
  298. if( pSrcData != pOldData)
  299. {
  300. if( pOldData->IsLocked() || pSrcData->pStringMgr != pOldData->pStringMgr )
  301. {
  302. SetString( strSrc.GetString(), strSrc.GetLength() );
  303. }
  304. else
  305. {
  306. CStringData* pNewData = CloneData( pSrcData );
  307. pOldData->Release();
  308. Attach( pNewData );
  309. }
  310. }
  312. return( *this );
  313. }
  315. CSimpleStringT& operator=( __in const CSimpleStringT<BaseType, !t_bMFCDLL>& strSrc )
  316. {
  317. CStringData* pSrcData = strSrc.GetData();
  318. CStringData* pOldData = GetData();
  319. if( pSrcData != pOldData)
  320. {
  321. if( pOldData->IsLocked() || pSrcData->pStringMgr != pOldData->pStringMgr )
  322. {
  323. SetString( strSrc.GetString(), strSrc.GetLength() );
  324. }
  325. else
  326. {
  327. CStringData* pNewData = CloneData( pSrcData );
  328. pOldData->Release();
  329. Attach( pNewData );
  330. }
  331. }
  333. return( *this );
  334. }
  336. CSimpleStringT& operator=( __in PCXSTR pszSrc )
  337. {
  338. SetString( pszSrc );
  340. return( *this );
  341. }
  343. CSimpleStringT& operator+=( __in const CSimpleStringT& strSrc )
  344. {
  345. Append( strSrc );
  347. return( *this );
  348. }
  349. template <bool bMFCDLL>
  350. CSimpleStringT& operator+=( __in const CSimpleStringT<BaseType, bMFCDLL>& strSrc )
  351. {
  352. Append( strSrc );
  354. return( *this );
  355. }
  357. CSimpleStringT& operator+=( __in PCXSTR pszSrc )
  358. {
  359. Append( pszSrc );
  361. return( *this );
  362. }
  363. template< int t_nSize >
  364. CSimpleStringT& operator+=( __in const CStaticString< XCHAR, t_nSize >& strSrc )
  365. {
  366. Append( static_cast<const XCHAR *>(strSrc), strSrc.GetLength() );
  368. return( *this );
  369. }
  370. CSimpleStringT& operator+=( __in char ch )
  371. {
  372. AppendChar( XCHAR( ch ) );
  374. return( *this );
  375. }
  376. CSimpleStringT& operator+=( __in unsigned char ch )
  377. {
  378. AppendChar( XCHAR( ch ) );
  380. return( *this );
  381. }
  382. CSimpleStringT& operator+=( __in wchar_t ch )
  383. {
  384. AppendChar( XCHAR( ch ) );
  386. return( *this );
  387. }
  389. XCHAR operator[]( __in int iChar ) const
  390. {
  391. ATLASSERT( (iChar >= 0) && (iChar <= GetLength()) );  // Indexing the '' is OK
  393. if( (iChar < 0) || (iChar > GetLength()) )
  394. AtlThrow(E_INVALIDARG);
  396. return( m_pszData[iChar] );
  397. }
  399. operator PCXSTR() const throw()
  400. {
  401. return( m_pszData );
  402. }
  404. void Append( __in PCXSTR pszSrc )
  405. {
  406. Append( pszSrc, StringLength( pszSrc ) );
  407. }
  408. void Append( __in_ecount(nLength) PCXSTR pszSrc, __in int nLength )
  409. {
  410. // See comment in SetString() about why we do this
  411. UINT_PTR nOffset = pszSrc-GetString();
  413. UINT nOldLength = GetLength();
  414. if (nOldLength < 0)
  415. {
  416. // protects from underflow
  417. nOldLength = 0;
  418. }
  419. int nNewLength = nOldLength+nLength;
  420. PXSTR pszBuffer = GetBuffer( nNewLength );
  421. if( nOffset <= nOldLength )
  422. {
  423. pszSrc = pszBuffer+nOffset;
  424. // No need to call CopyCharsOverlapped, since the destination is
  425. // beyond the end of the original buffer
  426. }
  427. #if _SECURE_ATL
  428.         CopyChars( pszBuffer+nOldLength, nLength, pszSrc, nLength );
  429. #else
  430.         CopyChars( pszBuffer+nOldLength, pszSrc, nLength );
  431. #endif
  432. ReleaseBufferSetLength( nNewLength );
  433. }
  434. void AppendChar( __in XCHAR ch )
  435. {
  436. UINT nOldLength = GetLength();
  437. int nNewLength = nOldLength+1;
  438. PXSTR pszBuffer = GetBuffer( nNewLength );
  439. pszBuffer[nOldLength] = ch;
  440. ReleaseBufferSetLength( nNewLength );
  441. }
  442. void Append( __in const CSimpleStringT& strSrc )
  443. {
  444. Append( strSrc.GetString(), strSrc.GetLength() );
  445. }
  446. template <bool bMFCDLL>
  447. void Append( __in const CSimpleStringT<BaseType, bMFCDLL>& strSrc )
  448. {
  449. Append( strSrc.GetString(), strSrc.GetLength() );
  450. }
  451. void Empty() throw()
  452. {
  453. CStringData* pOldData = GetData();
  454. IAtlStringMgr* pStringMgr = pOldData->pStringMgr;
  455. if( pOldData->nDataLength == 0 )
  456. {
  457. return;
  458. }
  460. if( pOldData->IsLocked() )
  461. {
  462. // Don't reallocate a locked buffer that's shrinking
  463. SetLength( 0 );
  464. }
  465. else
  466. {
  467. pOldData->Release();
  468. CStringData* pNewData = pStringMgr->GetNilString();
  469. Attach( pNewData );
  470. }
  471. }
  472. void FreeExtra()
  473. {
  474. CStringData* pOldData = GetData();
  475. int nLength = pOldData->nDataLength;
  476. IAtlStringMgr* pStringMgr = pOldData->pStringMgr;
  477. if( pOldData->nAllocLength == nLength )
  478. {
  479. return;
  480. }
  482. if( !pOldData->IsLocked() )  // Don't reallocate a locked buffer that's shrinking
  483. {
  484. CStringData* pNewData = pStringMgr->Allocate( nLength, sizeof( XCHAR ) );
  485. if( pNewData == NULL )
  486. {
  487. SetLength( nLength );
  488. return;
  489. }
  491. #if _SECURE_ATL
  492.             CopyChars( PXSTR( pNewData->data() ), nLength, 
  493. PCXSTR( pOldData->data() ), nLength );
  494. #else
  495. CopyChars( PXSTR( pNewData->data() ), PCXSTR( pOldData->data() ), nLength );
  496. #endif
  498. pOldData->Release();
  499. Attach( pNewData );
  500. SetLength( nLength );
  501. }
  502. }
  504. int GetAllocLength() const throw()
  505. {
  506. return( GetData()->nAllocLength );
  507. }
  508. XCHAR GetAt( __in int iChar ) const
  509. {
  510. ATLASSERT( (iChar >= 0) && (iChar <= GetLength()) );  // Indexing the '' is OK
  511. if( (iChar < 0) || (iChar > GetLength()) )
  512. AtlThrow(E_INVALIDARG);
  514. return( m_pszData[iChar] );
  515. }
  516. PXSTR GetBuffer()
  517. {
  518. CStringData* pData = GetData();
  519. if( pData->IsShared() )
  520. {
  521. Fork( pData->nDataLength );
  522. }
  524. return( m_pszData );
  525. }
  526. __out_ecount(nMinBufferLength + 1) PXSTR GetBuffer( __in int nMinBufferLength )
  527. {
  528. return( PrepareWrite( nMinBufferLength ) );
  529. }
  530. __out_ecount(nLength + 1) PXSTR GetBufferSetLength( __in int nLength )
  531. {
  532. PXSTR pszBuffer = GetBuffer( nLength );
  533. SetLength( nLength );
  535. return( pszBuffer );
  536. }
  537. int GetLength() const throw()
  538. {
  539. return( GetData()->nDataLength );
  540. }
  541. IAtlStringMgr* GetManager() const throw()
  542. {
  543. IAtlStringMgr* pStringMgr = GetData()->pStringMgr;
  544. return pStringMgr ? pStringMgr->Clone() : NULL;
  545. }
  547. __out_ecount(m_nLength) PCXSTR GetString() const throw()
  548. {
  549. return( m_pszData );
  550. }
  551. bool IsEmpty() const throw()
  552. {
  553. return( GetLength() == 0 );
  554. }
  555. PXSTR LockBuffer()
  556. {
  557. CStringData* pData = GetData();
  558. if( pData->IsShared() )
  559. {
  560. Fork( pData->nDataLength );
  561. pData = GetData();  // Do it again, because the fork might have changed it
  562. }
  563. pData->Lock();
  565. return( m_pszData );
  566. }
  567. void UnlockBuffer() throw()
  568. {
  569. CStringData* pData = GetData();
  570. pData->Unlock();
  571. }
  572. void Preallocate( __in int nLength )
  573. {
  574. PrepareWrite( nLength );
  575. }
  576. void ReleaseBuffer( __in int nNewLength = -1 )
  577. {
  578. if( nNewLength == -1 )
  579. {
  580. nNewLength = StringLength( m_pszData );
  581. }
  582. SetLength( nNewLength );
  583. }
  584. void ReleaseBufferSetLength( __in int nNewLength )
  585. {
  586. ATLASSERT( nNewLength >= 0 );
  587. SetLength( nNewLength );
  588. }
  589. void Truncate( __in int nNewLength )
  590. {
  591. ATLASSERT( nNewLength <= GetLength() );
  592. GetBuffer( nNewLength );
  593. ReleaseBufferSetLength( nNewLength );
  594. }
  595. void SetAt( __in int iChar, __in XCHAR ch )
  596. {
  597. ATLASSERT( (iChar >= 0) && (iChar < GetLength()) );
  599. if( (iChar < 0) || (iChar >= GetLength()) )
  600. AtlThrow(E_INVALIDARG);
  602. int nLength = GetLength();
  603. PXSTR pszBuffer = GetBuffer();
  604. pszBuffer[iChar] = ch;
  605. ReleaseBufferSetLength( nLength );
  607. }
  608. void SetManager( __in IAtlStringMgr* pStringMgr )
  609. {
  610. ATLASSERT( IsEmpty() );
  612. CStringData* pData = GetData();
  613. pData->Release();
  614. pData = pStringMgr->GetNilString();
  615. Attach( pData );
  616. }
  617. void SetString( __in PCXSTR pszSrc )
  618. {
  619. SetString( pszSrc, StringLength( pszSrc ) );
  620. }
  621. void SetString( __in_ecount(nLength) PCXSTR pszSrc, __in int nLength )
  622. {
  623. if( nLength == 0 )
  624. {
  625. Empty();
  626. }
  627. else
  628. {
  629. // It is possible that pszSrc points to a location inside of our 
  630. // buffer.  GetBuffer() might change m_pszData if (1) the buffer 
  631. // is shared or (2) the buffer is too small to hold the new 
  632. // string.  We detect this aliasing, and modify pszSrc to point
  633. // into the newly allocated buffer instead.
  635. if(pszSrc == NULL)
  636. AtlThrow(E_INVALIDARG);
  638. UINT nOldLength = GetLength();
  639. UINT_PTR nOffset = pszSrc-GetString();
  640. // If 0 <= nOffset <= nOldLength, then pszSrc points into our 
  641. // buffer
  643. PXSTR pszBuffer = GetBuffer( nLength );
  644. if( nOffset <= nOldLength )
  645. {
  646. #if _SECURE_ATL
  647.                 CopyCharsOverlapped( pszBuffer, nLength, 
  648. pszBuffer+nOffset, nLength );
  649. #else
  650. CopyCharsOverlapped( pszBuffer, pszBuffer+nOffset, nLength );
  651. #endif
  652. }
  653. else
  654. {
  655. #if _SECURE_ATL
  656. CopyChars( pszBuffer, nLength, pszSrc, nLength );
  657. #else
  658. CopyChars( pszBuffer, pszSrc, nLength );
  659. #endif
  660. }
  661. ReleaseBufferSetLength( nLength );
  662. }
  663. }
  665. public:
  666. friend CSimpleStringT operator+(
  667. __in const CSimpleStringT& str1,
  668. __in const CSimpleStringT& str2 )
  669. {
  670. CSimpleStringT s( str1.GetManager() );
  672. Concatenate( s, str1, str1.GetLength(), str2, str2.GetLength() );
  674. return( s );
  675. }
  677. friend CSimpleStringT operator+(
  678. __in const CSimpleStringT& str1,
  679. __in PCXSTR psz2 )
  680. {
  681. CSimpleStringT s( str1.GetManager() );
  683. Concatenate( s, str1, str1.GetLength(), psz2, StringLength( psz2 ) );
  685. return( s );
  686. }
  688. friend CSimpleStringT operator+(
  689. __in PCXSTR psz1,
  690. __in const CSimpleStringT& str2 )
  691. {
  692. CSimpleStringT s( str2.GetManager() );
  694. Concatenate( s, psz1, StringLength( psz1 ), str2, str2.GetLength() );
  696. return( s );
  697. }
  699. _ATL_INSECURE_DEPRECATE("CSimpleStringT::CopyChars must be passed a buffer size")
  700. static void __cdecl CopyChars
  701. ( __out_ecount(nChars) XCHAR* pchDest, __in_ecount(nChars) const XCHAR* pchSrc, __in int nChars ) throw()
  702. {
  703. #pragma warning (push)
  704. #pragma warning(disable : 4996)
  705. memcpy( pchDest, pchSrc, nChars*sizeof( XCHAR ) );
  706. #pragma warning (pop)
  707. }
  708. static void __cdecl CopyChars
  709. ( __out_ecount_part(nDestLen,nChars) XCHAR* pchDest, __in size_t nDestLen, __in_ecount(nChars) const XCHAR* pchSrc, __in int nChars ) throw()
  710. {
  711. memcpy_s( pchDest, nDestLen*sizeof( XCHAR ), 
  712. pchSrc, nChars*sizeof( XCHAR ) );
  713. }
  715. _ATL_INSECURE_DEPRECATE("CSimpleStringT::CopyCharsOverlapped must be passed a buffer size")
  716. static void __cdecl CopyCharsOverlapped
  717. ( __out_ecount(nChars) XCHAR* pchDest, __in_ecount(nChars) const XCHAR* pchSrc, __in int nChars ) throw()
  718. {
  719. #pragma warning (push)
  720. #pragma warning(disable : 4996)
  721. memmove( pchDest, pchSrc, nChars*sizeof( XCHAR ) );
  722. #pragma warning (pop)
  723. }
  724. static void __cdecl CopyCharsOverlapped
  725. ( __out_ecount_part(nDestLen, nDestLen) XCHAR* pchDest, __in size_t nDestLen, __in_ecount(nChars) const XCHAR* pchSrc, __in int nChars ) throw()
  726. {
  727. memmove_s( pchDest, nDestLen*sizeof( XCHAR ), 
  728. pchSrc, nChars*sizeof( XCHAR ) );
  729. }
  730. #ifdef _ATL_MIN_CRT
  731. ATL_NOINLINE static int __cdecl StringLength( __in_z_opt PCXSTR psz ) throw()
  732. {
  733. int nLength = 0;
  734. if( psz != NULL )
  735. {
  736. const XCHAR* pch = psz;
  737. while( *pch != 0 )
  738. {
  739. nLength++;
  740. pch++;
  741. }
  742. }
  744. return( nLength );
  745. }
  746. #else
  747. static int __cdecl StringLength( __in_z_opt const char* psz ) throw()
  748. {
  749. if( psz == NULL )
  750. {
  751. return( 0 );
  752. }
  753. return( int( strlen( psz ) ) );
  754. }
  755. static int __cdecl StringLength( __in_z_opt const wchar_t* psz ) throw()
  756. {
  757. if( psz == NULL )
  758. {
  759. return( 0 );
  760. }
  761. return( int( wcslen( psz ) ) );
  762. }
  763. #endif
  765. protected:
  766. static void __cdecl Concatenate( __out CSimpleStringT& strResult, __in_ecount(nLength1) PCXSTR psz1, __in int nLength1, __in_ecount(nLength2) PCXSTR psz2, __in int nLength2 )
  767. {
  768. int nNewLength = nLength1+nLength2;
  769. PXSTR pszBuffer = strResult.GetBuffer( nNewLength );
  770. #if _SECURE_ATL
  771.         CopyChars( pszBuffer, nLength1, psz1, nLength1 );
  772. CopyChars( pszBuffer+nLength1, nLength2, psz2, nLength2 );
  773. #else
  774.         CopyChars( pszBuffer, psz1, nLength1 );
  775. CopyChars( pszBuffer+nLength1, psz2, nLength2 );
  776. #endif
  777. strResult.ReleaseBufferSetLength( nNewLength );
  778. }
  779. ATL_NOINLINE __declspec( noreturn ) static void __cdecl ThrowMemoryException()
  780. {
  781. AtlThrow( E_OUTOFMEMORY );
  782. }
  784. // Implementation
  785. private:
  786. void Attach( __in CStringData* pData ) throw()
  787. {
  788. m_pszData = static_cast< PXSTR >( pData->data() );
  789. }
  790. ATL_NOINLINE void Fork( __in int nLength )
  791. {
  792. CStringData* pOldData = GetData();
  793. int nOldLength = pOldData->nDataLength;
  794. CStringData* pNewData = pOldData->pStringMgr->Clone()->Allocate( nLength, sizeof( XCHAR ) );
  795. if( pNewData == NULL )
  796. {
  797. ThrowMemoryException();
  798. }
  799. int nCharsToCopy = ((nOldLength < nLength) ? nOldLength : nLength)+1;  // Copy ''
  800. #if _SECURE_ATL
  801.         CopyChars( PXSTR( pNewData->data() ), nCharsToCopy, 
  802. PCXSTR( pOldData->data() ), nCharsToCopy );
  803. #else
  804.         CopyChars( PXSTR( pNewData->data() ), PCXSTR( pOldData->data() ), nCharsToCopy );
  805. #endif
  806. pNewData->nDataLength = nOldLength;
  807. pOldData->Release();
  808. Attach( pNewData );
  809. }
  810. CStringData* GetData() const throw()
  811. {
  812. return( reinterpret_cast< CStringData* >( m_pszData )-1 );
  813. }
  814. PXSTR PrepareWrite( __in int nLength )
  815. {
  816. CStringData* pOldData = GetData();
  817. int nShared = 1-pOldData->nRefs;  // nShared < 0 means true, >= 0 means false
  818. int nTooShort = pOldData->nAllocLength-nLength;  // nTooShort < 0 means true, >= 0 means false
  819. if( (nShared|nTooShort) < 0 )  // If either sign bit is set (i.e. either is less than zero), we need to copy data
  820. {
  821. PrepareWrite2( nLength );
  822. }
  824. return( m_pszData );
  825. }
  826. ATL_NOINLINE void PrepareWrite2( __in int nLength )
  827. {
  828. CStringData* pOldData = GetData();
  829. if( pOldData->nDataLength > nLength )
  830. {
  831. nLength = pOldData->nDataLength;
  832. }
  833. if( pOldData->IsShared() )
  834. {
  835. Fork( nLength );
  836. }
  837. else if( pOldData->nAllocLength < nLength )
  838. {
  839. // Grow exponentially, until we hit 1K.
  840. int nNewLength = pOldData->nAllocLength;
  841. if( nNewLength > 1024 )
  842. {
  843. nNewLength += 1024;
  844. }
  845. else
  846. {
  847. nNewLength *= 2;
  848. }
  849. if( nNewLength < nLength )
  850. {
  851. nNewLength = nLength;
  852. }
  853. Reallocate( nNewLength );
  854. }
  855. }
  856. ATL_NOINLINE void Reallocate( __in int nLength )
  857. {
  858. CStringData* pOldData = GetData();
  859. ATLASSERT( pOldData->nAllocLength < nLength );
  860. IAtlStringMgr* pStringMgr = pOldData->pStringMgr;
  861.                 if ( pOldData->nAllocLength >= nLength || nLength <= 0)
  862.                 {
  863. ThrowMemoryException();
  864.                         return;
  865.                 }
  866. CStringData* pNewData = pStringMgr->Reallocate( pOldData, nLength, sizeof( XCHAR ) );
  867. if( pNewData == NULL )
  868. {
  869. ThrowMemoryException();
  870. }
  871. Attach( pNewData );
  872. }
  874. void SetLength( __in int nLength )
  875. {
  876. ATLASSERT( nLength >= 0 );
  877. ATLASSERT( nLength <= GetData()->nAllocLength );
  879. if( nLength < 0 || nLength > GetData()->nAllocLength)
  880. AtlThrow(E_INVALIDARG);
  882. GetData()->nDataLength = nLength;
  883. m_pszData[nLength] = 0;
  884. }
  886. static CStringData* __cdecl CloneData( __in CStringData* pData )
  887. {
  888. CStringData* pNewData = NULL;
  890. IAtlStringMgr* pNewStringMgr = pData->pStringMgr->Clone();
  891. if( !pData->IsLocked() && (pNewStringMgr == pData->pStringMgr) )
  892. {
  893. pNewData = pData;
  894. pNewData->AddRef();
  895. }
  896. else
  897. {
  898. pNewData = pNewStringMgr->Allocate( pData->nDataLength, sizeof( XCHAR ) );
  899. if( pNewData == NULL )
  900. {
  901. ThrowMemoryException();
  902. }
  903. pNewData->nDataLength = pData->nDataLength;
  904. #if _SECURE_ATL
  905.             CopyChars( PXSTR( pNewData->data() ), pData->nDataLength+1,
  906. PCXSTR( pData->data() ), pData->nDataLength+1 );  // Copy ''
  907. #else
  908. CopyChars( PXSTR( pNewData->data() ), PCXSTR( pData->data() ), pData->nDataLength+1 );  // Copy ''
  909. #endif
  910. }
  912. return( pNewData );
  913. }
  915. public :
  916. typedef CStrBufT<BaseType, t_bMFCDLL> CStrBuf;
  917. private:
  918. PXSTR m_pszData;
  920. friend class CSimpleStringT<BaseType, !t_bMFCDLL>;
  921. };
  923. template< typename TCharType, bool t_bMFCDLL >
  924. class CStrBufT
  925. {
  926. public:
  927. typedef CSimpleStringT< TCharType, t_bMFCDLL> StringType;
  928. typedef typename StringType::XCHAR XCHAR;
  929. typedef typename StringType::PXSTR PXSTR;
  930. typedef typename StringType::PCXSTR PCXSTR;
  932. static const DWORD AUTO_LENGTH = 0x01;  // Automatically determine the new length of the string at release.  The string must be null-terminated.
  933. static const DWORD SET_LENGTH = 0x02;  // Set the length of the string object at GetBuffer time
  935. public:
  936. explicit CStrBufT( __in StringType& str ) throw( ... ) :
  937. m_str( str ),
  938. m_pszBuffer( NULL ),
  939. #ifdef _DEBUG
  940. m_nBufferLength( str.GetLength() ),
  941. #endif
  942. m_nLength( str.GetLength() )
  943. {
  944. m_pszBuffer = m_str.GetBuffer();
  945. }
  947. CStrBufT( __in StringType& str, __in int nMinLength, __in DWORD dwFlags = AUTO_LENGTH ) throw( ... ) :
  948. m_str( str ),
  949. m_pszBuffer( NULL ),
  950. #ifdef _DEBUG
  951. m_nBufferLength( nMinLength ),
  952. #endif
  953. m_nLength( (dwFlags&AUTO_LENGTH) ? -1 : nMinLength )
  954. {
  955. if( dwFlags&SET_LENGTH )
  956. {
  957. m_pszBuffer = m_str.GetBufferSetLength( nMinLength );
  958. }
  959. else
  960. {
  961. m_pszBuffer = m_str.GetBuffer( nMinLength );
  962. }
  963. }
  965. ~CStrBufT()
  966. {
  967. m_str.ReleaseBuffer( m_nLength );
  968. }
  970. operator PXSTR() throw()
  971. {
  972. return( m_pszBuffer );
  973. }
  974. operator PCXSTR() const throw()
  975. {
  976. return( m_pszBuffer );
  977. }
  979. void SetLength( __in int nLength )
  980. {
  981. ATLASSERT( nLength >= 0 );
  982. ATLASSERT( nLength <= m_nBufferLength );
  984. if( nLength < 0 )
  985. AtlThrow(E_INVALIDARG);
  987. m_nLength = nLength;
  988. }
  990. // Implementation
  991. private:
  992. StringType& m_str;
  993. PXSTR m_pszBuffer;
  994. int m_nLength;
  995. #ifdef _DEBUG
  996. int m_nBufferLength;
  997. #endif
  999. // Private copy constructor and copy assignment operator to prevent accidental use
  1000. private:
  1001. CStrBufT( const CStrBufT& ) throw();
  1002. CStrBufT& operator=( const CStrBufT& ) throw();
  1003. };
  1005. typedef CSimpleStringT< TCHAR > CSimpleString;
  1006. typedef CSimpleStringT< char > CSimpleStringA;
  1007. typedef CSimpleStringT< wchar_t > CSimpleStringW;
  1008. typedef CStrBufT< TCHAR > CStrBuf;
  1009. typedef CStrBufT< char > CStrBufA;
  1010. typedef CStrBufT< wchar_t > CStrBufW;
  1012. };  // namespace ATL
  1013. #pragma pack(pop)
  1015. #endif  // __ATLSIMPSTR_H__