home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / activexcontrol / basectl / framewrk / stdenum.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-10-05  |  6.6 KB  |  240 lines
  1. //=--------------------------------------------------------------------------=
  2. // StdEnum.Cpp
  3. //=--------------------------------------------------------------------------=
  4. // Copyright 1995-1997 Microsoft Corporation.  All Rights Reserved.
  5. //
  6. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF 
  7. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
  8. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A 
  9. // PARTICULAR PURPOSE.
  10. //=--------------------------------------------------------------------------=
  11. //
  12. // implementation of a generic enumerator object.
  13. //
  14. #include "IPServer.H"
  15. #include "StdEnum.H"
  16. #include "Globals.H"
  17.  
  18. SZTHISFILE
  19.  
  20. //=--------------------------------------------------------------------------=
  21. // CStandardEnum::CStandardEnum
  22. //=--------------------------------------------------------------------------=
  23. // create the object and initialize the refcount
  24. //
  25. // Parameters:
  26. //    REFCLSID        - [in] type of enumerator that we are
  27. //    int             - [in] number of elements in the enumeration
  28. //    int             - [in] size of each element
  29. //    void *          - [in] pointer to element data
  30. //    void (WINAPI *pfnCopyElement)(void *, const void *, DWORD)
  31. //                    - [in] copying function
  32. //
  33. // Notes:
  34. //
  35. #pragma warning(disable:4355)  // using 'this' in constructor
  36. CStandardEnum::CStandardEnum
  37. (
  38.     REFCLSID rclsid,
  39.     int      cElements,
  40.     int      cbElementSize,
  41.     void    *rgElements,
  42.     void (WINAPI *pfnCopyElement)(void *, const void *, DWORD)
  43. )
  44. : CUnknownObject(NULL, (IEnumGeneric *)this),
  45.   m_iid(rclsid),
  46.   m_cElements(cElements),
  47.   m_cbElementSize(cbElementSize),
  48.   m_iCurrent(0),
  49.   m_rgElements(rgElements),
  50.   m_pfnCopyElement(pfnCopyElement)
  51. {
  52.     m_pEnumClonedFrom = NULL;
  53. }
  54. #pragma warning(default:4355)  // using 'this' in constructor
  55.  
  56.  
  57. //=--------------------------------------------------------------------------=
  58. // CStandardEnum::CStandardEnum
  59. //=--------------------------------------------------------------------------=
  60. // "it is not death, but dying, which is terrible."
  61. //    - Henry Fielding (1707-54)
  62. //
  63. // Notes:
  64. //
  65. CStandardEnum::~CStandardEnum ()
  66. {
  67.     // if we're a cloned object, then just release our parent object and
  68.     // we're done. otherwise, free up the allocated memory we were given
  69.     //
  70.     if (m_pEnumClonedFrom)
  71.         m_pEnumClonedFrom->Release();
  72.     else {
  73.         if (m_rgElements) HeapFree(g_hHeap, 0, m_rgElements);
  74.     }
  75. }
  76.  
  77. //=--------------------------------------------------------------------------=
  78. // CStandardEnum::InternalQueryInterface
  79. //=--------------------------------------------------------------------------=
  80. // we support our internal iid, and that's all
  81. //
  82. // Parameters:
  83. //    REFIID        - [in]  interface they want
  84. //    void **       - [out] where they want to put the resulting object ptr.
  85. //
  86. // Output:
  87. //    HRESULT       - S_OK, E_NOINTERFACE
  88. //
  89. // Notes:
  90. //
  91. HRESULT CStandardEnum::InternalQueryInterface
  92. (
  93.     REFIID riid,
  94.     void **ppvObjOut
  95. )
  96. {
  97.     if (DO_GUIDS_MATCH(riid, m_iid)) {
  98.         ExternalAddRef();
  99.         *ppvObjOut = (IEnumGeneric *)this;
  100.         return S_OK;
  101.     }
  102.  
  103.     return E_NOINTERFACE;
  104. }
  105.  
  106. //=--------------------------------------------------------------------------=
  107. // CStandardEnum::Next
  108. //=--------------------------------------------------------------------------=
  109. // returns the next dude in our iteration
  110. //
  111. // Parameters:
  112. //    unsigned long     - [in]  count of elements requested
  113. //    void    *         - [out] array of slots to put values in.
  114. //    unsigned long *   - [out] actual number fetched
  115. //
  116. // Output:
  117. //    HRESULT           - S_OK, E_INVALIDARG, S_FALSE
  118. //
  119. // Notes:
  120. //
  121. STDMETHODIMP CStandardEnum::Next
  122. (
  123.     unsigned long  cElm,
  124.     void          *rgDest,
  125.     unsigned long *pcElmOut
  126. )
  127. {
  128.     unsigned long cElementsFetched = 0;
  129.     void         *pElementDest = rgDest;
  130.     const void   *pElementSrc = (const BYTE *)m_rgElements + (m_cbElementSize * m_iCurrent);
  131.  
  132.     while (cElementsFetched < cElm) {
  133.  
  134.         // if we hit EOF, break out
  135.         //
  136.         if (m_iCurrent >= m_cElements)
  137.             break;
  138.  
  139.         // copy the element out for them
  140.         //
  141.         m_pfnCopyElement(pElementDest, pElementSrc, m_cbElementSize);
  142.  
  143.         // increase the counters
  144.         //
  145.         pElementDest = (LPBYTE)pElementDest + m_cbElementSize;
  146.         pElementSrc  = (const BYTE *)pElementSrc + m_cbElementSize;
  147.         m_iCurrent++;
  148.         cElementsFetched++;
  149.     }
  150.  
  151.     if (pcElmOut)
  152.         *pcElmOut = cElementsFetched;
  153.  
  154.     return (cElementsFetched < cElm)? S_FALSE : S_OK;
  155. }
  156.  
  157. //=--------------------------------------------------------------------------=
  158. // CStandardEnum::Skip
  159. //=--------------------------------------------------------------------------=
  160. // skips the requested number of rows.
  161. //
  162. // Parameters:
  163. //    unsigned long     - [in] number to skip
  164. //
  165. // Output:
  166. //    HRESULT           - S_OK, S_FALSE
  167. //
  168. // Notes:
  169. //
  170. STDMETHODIMP CStandardEnum::Skip
  171. (
  172.     unsigned long cSkip
  173. )
  174. {
  175.     // handle running off the end
  176.     //
  177.     if (m_iCurrent + (int)cSkip > m_cElements) {
  178.         m_iCurrent = m_cElements;
  179.         return S_FALSE;
  180.     }
  181.  
  182.     m_iCurrent += cSkip;
  183.     return S_OK;
  184. }
  185.  
  186. //=--------------------------------------------------------------------------=
  187. // CStandardEnum::Reset
  188. //=--------------------------------------------------------------------------=
  189. // reset the counter.
  190. //
  191. // Output:
  192. //    HRESULT        - S_OK
  193. //
  194. // Notes:
  195. //
  196. STDMETHODIMP CStandardEnum::Reset
  197. (
  198.     void
  199. )
  200. {
  201.     m_iCurrent = 0;
  202.     return S_OK;
  203. }
  204.  
  205.  
  206. //=--------------------------------------------------------------------------=
  207. // CStandardEnum::Clone
  208. //=--------------------------------------------------------------------------=
  209. // clones the object and gives the new one the same position
  210. //
  211. // Parameters:
  212. //    IEnumVARIANT **    - [out] where to put the new object.
  213. //
  214. // Output;
  215. //    HRESULT            - S_OK, E_OUTOFMEMORY
  216. //
  217. // Notes:
  218. //
  219. STDMETHODIMP CStandardEnum::Clone
  220. (
  221.     IEnumGeneric **ppEnumClone
  222. )
  223. {
  224.     CStandardEnum *pNewEnum;
  225.  
  226.     pNewEnum = new CStandardEnum(m_iid, m_cElements, m_cbElementSize, m_rgElements, m_pfnCopyElement);
  227.     RETURN_ON_NULLALLOC(pNewEnum);
  228.  
  229.     // hold on to who we were cloned from so m_rgElements stays alive, and we don't
  230.     // have to copy it.
  231.     //
  232.     pNewEnum->m_pEnumClonedFrom = this;
  233.  
  234.     // AddRef() ourselves on their behalf.
  235.     //
  236.     AddRef();
  237.     *ppEnumClone = (IEnumGeneric *)pNewEnum;
  238.     return S_OK;
  239. }
  240.