home *** CD-ROM | disk | FTP | other *** search
/ The Net: Ultimate Internet Guide / WWLCD1.ISO / mac / SiteBldr / AMOVIE / SDK / _SETUP / COMMON.Z / ext_enum.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-02  |  7.7 KB  |  244 lines
  1. //==========================================================================;
  2. //
  3. //  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  4. //  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  5. //  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  6. //  PURPOSE.
  7. //
  8. //  Copyright (c) 1992 - 1996  Microsoft Corporation.  All Rights Reserved.
  9. //
  10. //--------------------------------------------------------------------------;
  11. //
  12. // Ext_Enum.h
  13. //
  14. //
  15. // Contents:
  16. //
  17.  
  18. #ifndef _Ext_Enum_h
  19. #define _Ext_Enum_h
  20.  
  21. #pragma warning( disable : 4514 )
  22.  
  23. // A helper template & macro so that we only release non-null interface
  24. // pointers and we set the pointer to null afterwards so that we don't 
  25. // release it again.
  26. template<class Interface> void SafeRelPtrIPtr( Interface * * ppIUnk )
  27. {
  28.     if ( *ppIUnk )
  29.     {
  30.         (*ppIUnk)->Release();
  31.         (*ppIUnk) = 0;
  32.     }
  33. }
  34.  
  35. #define SafeRelIPtr( pI ) SafeRelPtrIPtr( &(pI) )
  36.  
  37. // A template function for cloning.  We always clone an Implementation, but
  38. // supply a pointer to an Interface.  We need both to parameterize this function.
  39. template<class Implementation, class Interface> 
  40. static inline HRESULT CloneAny( const Implementation & _this, Interface ** ppI)
  41. { 
  42.     HRESULT hr;
  43.  
  44.     if (ppI)
  45.     {
  46.         *ppI = 0;
  47.         // Relies on Implementation having defined this kind of "copy" constructor.
  48.         Implementation *const p = new Implementation( _this, &hr );
  49.         if (p)
  50.         {
  51.             if SUCCEEDED(hr)    *ppI = p;
  52.             else                delete p;
  53.         }
  54.         else hr = E_OUTOFMEMORY;
  55.     }
  56.     else hr = E_POINTER;
  57.     return hr;
  58. }
  59.  
  60. // AnyEnum presents a simple concrete class that can cover any enumerator that conforms to
  61. // the standard COM enumerator interface.  You'll probably never instantiate one of these,
  62. // but it gives us a good foundation from which to build derived enumerators with special
  63. // behaviour.
  64.  
  65. template<class IEnum, class BaseType> class AnyEnum : public IEnum
  66. {
  67. protected:
  68.     long    m_cRef;                             // Local ref count
  69.     IEnum * m_pIEnum;                           // Pointer to a "real" enumarator that will do most of the work
  70.  
  71.     // Protected default constructor, derived classes relying on this must set m_pIEnum themselves.
  72.     AnyEnum()                                   : m_cRef(1), m_pIEnum(0)  {}
  73.  
  74. public:
  75.     virtual ~AnyEnum()                          { SafeRelIPtr( m_pIEnum ); } 
  76.     AnyEnum( const AnyEnum & copy, HRESULT * phr );
  77.  
  78.     // IUnknown interface
  79.     STDMETHODIMP            QueryInterface( REFIID iid, void ** ppv );
  80.     STDMETHODIMP_(ULONG)    AddRef();
  81.     STDMETHODIMP_(ULONG)    Release();
  82.  
  83.     // IEnum interface 
  84.     STDMETHODIMP            Next( ULONG cBase, BaseType ** ppBase, ULONG * pcFetched );
  85.     STDMETHODIMP            Skip( ULONG cBase );
  86.     STDMETHODIMP            Reset( void );
  87.     STDMETHODIMP            Clone( IEnum ** ppEnum );
  88. };
  89.  
  90.  
  91. // ConstrictedEnum
  92. //
  93. // An abstract template class extending AnyEnum by adding a Select() method.
  94. // Derived classes must implement this method.  For each object that our inner
  95. // enumerator passes back to us, we ask Select() if it meets its selection 
  96. // criteria, if it does, we pass the object back to our caller, otherwise we
  97. // ask our inner enumerator for another candidate.
  98. //
  99. // Next() is enhanced to call Select() for each candidate.  Skip() is re-implemented
  100. // since its skip count must now be in terms of objects that meet Select()'s criteria.
  101. // A new Skip() is implemented where we can explicity get a count of the number of
  102. // candidates skipped.
  103.  
  104. template<class IEnum, class BaseType> class ConstrictedEnum : public AnyEnum<IEnum,BaseType>
  105. {
  106. protected:
  107.     ConstrictedEnum()                       {}
  108.  
  109.     // Pure virtual Selector method.
  110.     virtual BOOL Select( BaseType ** ppBase ) =0;
  111.  
  112. public:
  113.     ConstrictedEnum( const ConstrictedEnum & copy, HRESULT * phr )
  114.     : AnyEnum<IEnum,BaseType>( copy, phr )  {}
  115.  
  116.     STDMETHODIMP            Next( ULONG cBase, BaseType ** ppBase, ULONG * pcFetched );
  117.     STDMETHODIMP            Skip( ULONG cBase );
  118.     STDMETHODIMP            Skip( ULONG cBase, ULONG * pcCount );
  119. };
  120.  
  121.  
  122. // CImpIEnumFilters
  123. //
  124. // This class not only restricts ennumeration to IFilters that support a specific interface,
  125. // it also returns pointers to THAT interface, rather than just IFilter pointers.
  126.  
  127. class CImpIEnumFilters : public ConstrictedEnum<IEnumFilters, IFilter> 
  128. {
  129. private:
  130.     REFIID    m_iid;
  131.  
  132. protected:
  133.     CImpIEnumFilters( REFIID iid )                  : m_iid(iid)                {}
  134.     BOOL    Select( IFilter ** ppIFilter );
  135.  
  136. public:
  137.     CImpIEnumFilters( const CImpIEnumFilters & copy, HRESULT * phr )
  138.     : ConstrictedEnum<IEnumFilters,IFilter>( copy, phr ), m_iid( copy.m_iid )   {}
  139.  
  140.     CImpIEnumFilters( IFilterGraph * pIFilterGraph, REFIID iid )
  141.     : m_iid(iid)
  142.     {
  143.         HRESULT hr = pIFilterGraph->EnumFilters( &m_pIEnum );
  144.         ASSERT( SUCCEEDED(hr) );
  145.     }
  146.  
  147.     STDMETHODIMP Clone( IEnumFilters  ** ppEnum );
  148. };
  149.  
  150.  
  151. // CImpIEnumUnconnectedFilters
  152. //
  153. // Enumerates filters over a filter graph, but only returns those who have none of their pins connected
  154.  
  155. class CImpIEnumUnconnectedFilters : public ConstrictedEnum<IEnumFilters, IFilter> 
  156. {
  157. protected:
  158.     BOOL    Select( IFilter ** ppIFilter );
  159.  
  160. public:
  161.     CImpIEnumUnconnectedFilters( const CImpIEnumUnconnectedFilters & copy, HRESULT * phr )
  162.     : ConstrictedEnum<IEnumFilters,IFilter>( copy, phr ) {}
  163.  
  164.     CImpIEnumUnconnectedFilters( IFilterGraph * pIFilterGraph )
  165.     {
  166.         HRESULT hr = pIFilterGraph->EnumFilters( &m_pIEnum );
  167.         ASSERT( SUCCEEDED(hr) );
  168.     }
  169.  
  170.     STDMETHODIMP Clone( IEnumFilters  ** ppEnum );
  171. };
  172.  
  173.  
  174. template<PIN_DIRECTION DIR> class CImpIEnumPins : public ConstrictedEnum<IEnumPins, IPin> 
  175. {
  176. protected:
  177.     CImpIEnumPins()                                                 {}
  178.     BOOL    Select( IPin ** ppIPin );
  179.  
  180. public:
  181.     CImpIEnumPins( const CImpIEnumPins & copy, HRESULT * phr )
  182.     : ConstrictedEnum<IEnumPins, IPin>( copy, phr )                 {}
  183.  
  184.     CImpIEnumPins( IFilter * pIFilter )
  185.     {
  186.         HRESULT hr = pIFilter->EnumPins( &m_pIEnum );
  187.         ASSERT ( SUCCEEDED(hr) );
  188.     }
  189.  
  190.     STDMETHODIMP Clone( IEnumPins  ** ppEnum );
  191. };
  192.  
  193. typedef CImpIEnumPins<PINDIR_INPUT>     CImpIEnumPinsIn;
  194. typedef CImpIEnumPins<PINDIR_OUTPUT>    CImpIEnumPinsOut;
  195. typedef AnyEnum<IEnumPins, IPin>        CImpIEnumPinsBoth;
  196.  
  197. template<class EnumPinClass> class CImpIEnumOverGraph : public EnumPinClass
  198. {
  199. private:
  200.     CImpIEnumOverGraph()            {}
  201. protected:
  202.     HRESULT         m_hr;
  203.     IEnumFilters    * m_pIEnumFilters;
  204.     CCritSec        m_crit_sec;
  205.  
  206.  
  207.     HRESULT NextFilter();           // Iterates us through the filters
  208.  
  209. public:
  210.     ~CImpIEnumOverGraph()           { SafeRelIPtr(m_pIEnumFilters); }
  211.  
  212.     CImpIEnumOverGraph( const CImpIEnumOverGraph & copy, HRESULT * phr )
  213.     : EnumPinClass( copy, phr )
  214.     {
  215.         if SUCCEEDED(*phr)
  216.         {
  217.             *phr = copy.m_pIEnumFilters->Clone( &m_pIEnumFilters );
  218.             m_hr = SUCCEEDED(*phr) ? copy.m_hr : *phr;
  219.         }
  220.         else m_pIEnumFilters = 0;
  221.     }
  222.  
  223.     CImpIEnumOverGraph( IFilterGraph * pIFilterGraph )
  224.     {
  225.         HRESULT hr;
  226.         hr = pIFilterGraph->EnumFilters( &m_pIEnumFilters );
  227.         ASSERT( SUCCEEDED(hr) );
  228.         hr = NextFilter();
  229.         ASSERT( SUCCEEDED(hr) );
  230.     }
  231.  
  232.     STDMETHODIMP Next( ULONG cBase, IPin ** ppBase, ULONG * pcFetched );
  233.     STDMETHODIMP Reset( void );
  234.     STDMETHODIMP Clone( IEnumPins ** ppEnum );
  235. };
  236.  
  237.  
  238. typedef CImpIEnumOverGraph<CImpIEnumPinsIn>     CImpIEnumPinsInOverGraph;
  239. typedef CImpIEnumOverGraph<CImpIEnumPinsOut>    CImpIEnumPinsOutOverGraph;
  240. typedef CImpIEnumOverGraph<CImpIEnumPinsBoth>   CImpIEnumPinsOverGraph;
  241.  
  242. #include "Ext_Enum.inl"
  243.  
  244. #endif