home *** CD-ROM | disk | FTP | other *** search
/ PC Format (South-Africa) 2001 June / PCFJune.iso / Xenon / C++ / FreeCommandLineTools.exe / Include / refptrcollection.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-31  |  7.8 KB  |  357 lines
  1. #pragma option push -b -a8 -pc -A- /*P_O_Push*/
  2. //
  3. // RefPtrCollection.h -- definition of TRefPointerCollection template
  4. //
  5. // Copyright 1998 - 1999 Microsoft Corporation
  6. //
  7. //
  8. //=================================================================
  9.  
  10. #if _MSC_VER > 1000
  11. #pragma once
  12. #endif
  13.  
  14. #ifndef __REFPTRCOLLECTION_H__
  15. #define __REFPTRCOLLECTION_H__
  16.  
  17. #include <chptrarr.h>
  18.  
  19. // Enumeration helpers
  20. typedef    DWORD    REFPTRCOLLECTION_POSITION;
  21. #define    REFPTRCOLLECTION_START    0xFFFFFFFF;
  22.  
  23. template <class TYPED_PTR> class TRefPointerCollection : public CThreadBase
  24. {
  25. public:
  26.  
  27.     // Construction/Destruction
  28.     TRefPointerCollection();
  29.     ~TRefPointerCollection();
  30.  
  31.     // Allows addition and enumeration of collection
  32.     BOOL    Add( TYPED_PTR* ptr );
  33.  
  34.     BOOL        BeginEnum( REFPTRCOLLECTION_POSITION& pos );
  35.     TYPED_PTR*    GetNext( REFPTRCOLLECTION_POSITION& pos );
  36.     void        EndEnum( void );
  37.  
  38.     void        Empty( void );
  39.     int         GetSize( void ) const;
  40.  
  41. protected:
  42.  
  43.     // Allows easy and quick transference of data (it was =, but
  44.     // because we'll inherit classes off the template, we won't
  45.     // inherit that particular overload (some C++ thingie)
  46.  
  47.     const TRefPointerCollection<TYPED_PTR>& Copy( const TRefPointerCollection<TYPED_PTR>& );
  48.  
  49.  
  50. private:
  51.  
  52.     CHPtrArray        m_ptrArray;
  53.  
  54. };
  55.  
  56. ////////////////////////////////////////////////////////////////////////
  57. //
  58. //    Function:    TRefPointerCollection::TRefPointerCollection
  59. //
  60. //    Class Constructor.
  61. //
  62. //    Inputs:        None.
  63. //
  64. //    Outputs:    None.
  65. //
  66. //    Return:        None.
  67. //
  68. //    Comments:    None.
  69. //
  70. ////////////////////////////////////////////////////////////////////////
  71.  
  72. template <class TYPED_PTR>
  73. TRefPointerCollection<TYPED_PTR>::TRefPointerCollection( void )
  74. :    CThreadBase(),
  75.     m_ptrArray()
  76. {
  77. }
  78.  
  79. ////////////////////////////////////////////////////////////////////////
  80. //
  81. //    Function:    CRefPointerCollection::~CRefPointerCollection
  82. //
  83. //    Class Destructor.
  84. //
  85. //    Inputs:        None.
  86. //
  87. //    Outputs:    None.
  88. //
  89. //    Return:        None.
  90. //
  91. //    Comments:    None.
  92. //
  93. ////////////////////////////////////////////////////////////////////////
  94.  
  95. template <class TYPED_PTR>
  96. TRefPointerCollection<TYPED_PTR>::~TRefPointerCollection( void )
  97. {
  98.     Empty();
  99. }
  100.  
  101. ////////////////////////////////////////////////////////////////////////
  102. //
  103. //    Function:    TRefPointerCollection::Add
  104. //
  105. //    Adds a new referenced pointer to the collection.
  106. //
  107. //    Inputs:        T*                ptr - Pointer to add.
  108. //
  109. //    Outputs:    None.
  110. //
  111. //    Return:        TRUE/FALSE        Success/Failure of Add.
  112. //
  113. //    Comments:    AddRefs the pointer, then adds it to the array.  We
  114. //                will need Write Access to do this.
  115. //
  116. ////////////////////////////////////////////////////////////////////////
  117.  
  118. template <class TYPED_PTR>
  119. BOOL TRefPointerCollection<TYPED_PTR>::Add( TYPED_PTR* ptr )
  120. {
  121.     BOOL    fReturn = FALSE;
  122.  
  123.     if ( NULL != ptr )
  124.     {
  125.         // Get write access
  126.         if ( BeginWrite() )
  127.         {
  128.             // If Add succeeds, the pointer will be released when it
  129.             // is removed.
  130.  
  131.             ptr->AddRef();
  132.  
  133.             if ( m_ptrArray.Add( (void*) ptr ) >= 0 )
  134.             {
  135.                 fReturn = TRUE;
  136.             }
  137.             else
  138.             {
  139.                 ptr->Release();    // Add failed, so Release the AddRef
  140.             }
  141.  
  142.             EndWrite();    // Release the BeginWrite()
  143.         }
  144.     }
  145.  
  146.     return fReturn;
  147. }
  148.  
  149. ////////////////////////////////////////////////////////////////////////
  150. //
  151. //    Function:    TRefPointerCollection::BeginEnum
  152. //
  153. //    Gains Read Access to the collection, then returns an appropriate
  154. //    REFPTRCOLLECTION_POSITION to get the first index in the array.
  155. //
  156. //    Inputs:        None.
  157. //
  158. //    Outputs:    REFPTRCOLLECTION_POSITION&    pos - Position we retrieved.
  159. //
  160. //    Return:        BOOL        TRUE/FALSE - Access was granted
  161. //
  162. //    Comments:    We need Read Access to do this.  This can effectively
  163. //                lock out other threads.
  164. //
  165. ////////////////////////////////////////////////////////////////////////
  166.  
  167. template <class TYPED_PTR>
  168. BOOL TRefPointerCollection<TYPED_PTR>::BeginEnum( REFPTRCOLLECTION_POSITION& pos )
  169. {
  170.     BOOL    fReturn    =    FALSE;
  171.  
  172.     if ( BeginRead() )
  173.     {
  174.         pos = REFPTRCOLLECTION_START;
  175.         fReturn = TRUE;
  176.     }
  177.  
  178.     return fReturn;
  179.  
  180. }
  181.  
  182. ////////////////////////////////////////////////////////////////////////
  183. //
  184. //    Function:    TRefPointerCollection::EndEnum
  185. //
  186. //    Signals the end of an enumeration.
  187. //
  188. //    Inputs:        None.
  189. //
  190. //    Outputs:    None.
  191. //
  192. //    Return:        BOOL        TRUE/FALSE - Access was granted
  193. //
  194. //    Comments:    Ends Read Access granted by calling BeginEnum().
  195. //
  196. ////////////////////////////////////////////////////////////////////////
  197.  
  198. template <class TYPED_PTR>
  199. void TRefPointerCollection<TYPED_PTR>::EndEnum( void )
  200. {
  201.     EndRead();
  202. }
  203.  
  204. ////////////////////////////////////////////////////////////////////////
  205. //
  206. //    Function:    TRefPointerCollection::GetNext
  207. //
  208. //    Uses the REFPTRCOLLECTION_POSITION to get the next index in the
  209. //    collection.
  210. //
  211. //    Inputs:        None.
  212. //
  213. //    Outputs:    REFPTRCOLLECTION_POSITION&    pos - Position we retrieved.
  214. //
  215. //    Return:        T*        NULL if failure.
  216. //
  217. //    Comments:    We need Read Access to do this.  The pointer is AddRef'd
  218. //                on the way out.  User must Release the pointer himself.
  219. //
  220. ////////////////////////////////////////////////////////////////////////
  221.  
  222. template <class TYPED_PTR>
  223. TYPED_PTR* TRefPointerCollection<TYPED_PTR>::GetNext( REFPTRCOLLECTION_POSITION& pos )
  224. {
  225.     TYPED_PTR*    ptr = NULL;
  226.  
  227.     if ( BeginRead() )
  228.     {
  229.         if ( ++pos < (DWORD) m_ptrArray.GetSize() )
  230.         {
  231.             ptr = (TYPED_PTR*) m_ptrArray.GetAt( pos );
  232.  
  233.             if ( NULL != ptr )
  234.             {
  235.                 ptr->AddRef();
  236.             }
  237.         }
  238.  
  239.         EndRead();
  240.     }
  241.  
  242.     return ptr;
  243. }
  244.  
  245. ////////////////////////////////////////////////////////////////////////
  246. //
  247. //    Function:    TRefPointerCollection::Empty
  248. //
  249. //    Empties out the collection, Releasing Pointers as it does do.
  250. //
  251. //    Inputs:        None.
  252. //
  253. //    Outputs:    None.
  254. //
  255. //    Return:        None.
  256. //
  257. //    Comments:    We need Write Access to do this.
  258. //
  259. ////////////////////////////////////////////////////////////////////////
  260.  
  261. template <class TYPED_PTR>
  262. void TRefPointerCollection<TYPED_PTR>::Empty( void )
  263. {
  264.     // By default this is an infinite wait, so it best come back
  265.  
  266.     BeginWrite();
  267.  
  268.     int                nSize    =    m_ptrArray.GetSize();
  269.  
  270.     // Only empty it if it is not empty
  271.     if ( nSize > 0 )
  272.     {
  273.         TYPED_PTR*    ptr        =    NULL;
  274.  
  275.         for ( int nCtr = 0; nCtr < nSize; nCtr++ )
  276.         {
  277.             ptr = (TYPED_PTR*) m_ptrArray[nCtr];
  278.  
  279.             if ( NULL != ptr )
  280.             {
  281.                 ptr->Release();    // AddRef we did when we added it
  282.             }
  283.         }
  284.  
  285.         // Now dump the array
  286.         m_ptrArray.RemoveAll();
  287.  
  288.     }    // IF nSize > 0
  289.  
  290.     EndWrite();
  291. }
  292.  
  293. ////////////////////////////////////////////////////////////////////////
  294. //
  295. //    Function:    TRefPointerCollection::Copy
  296. //
  297. //    Empties out the collection, copies in another one, addrefing
  298. //    pointers as we go.
  299. //
  300. //    Inputs:        const T&    collection
  301. //
  302. //    Outputs:    None.
  303. //
  304. //    Return:        const T&    this
  305. //
  306. //    Comments:    We need Write Access to do this.
  307. //
  308. ////////////////////////////////////////////////////////////////////////
  309.  
  310. template <class TYPED_PTR>
  311. const TRefPointerCollection<TYPED_PTR>& TRefPointerCollection<TYPED_PTR>::Copy( const TRefPointerCollection<TYPED_PTR>& collection )
  312. {
  313.     // By default this is an infinite wait, so it best come back
  314.     BeginWrite();
  315.  
  316.     // Dump out the array
  317.     Empty();
  318.  
  319.     int    nSize = collection.m_ptrArray.GetSize();
  320.  
  321.     for ( int nCount = 0; nCount < nSize; nCount++ )
  322.     {
  323.         TYPED_PTR*    ptr = (TYPED_PTR*) collection.m_ptrArray[nCount];
  324.  
  325.         // Add will automatically AddRef the pointer again.
  326.         Add( ptr );
  327.     }
  328.  
  329.     EndWrite();
  330.  
  331.     return *this;
  332. }
  333.  
  334. ////////////////////////////////////////////////////////////////////////
  335. //
  336. //    Function:    TRefPointerCollection::GetSize
  337. //
  338. //    Inputs:        None.
  339. //
  340. //    Outputs:    Number of elements in the collection
  341. //
  342. //    Return:        None.
  343. //
  344. //    Comments:    None.
  345. //
  346. ////////////////////////////////////////////////////////////////////////
  347.  
  348. template <class TYPED_PTR>
  349. int TRefPointerCollection<TYPED_PTR>::GetSize(void) const
  350. {
  351.     return m_ptrArray.GetSize();
  352. }
  353.  
  354.  
  355. #endif
  356. #pragma option pop /*P_O_Pop*/
  357.