dlls/ole32/enumx.c

   1 /*
   2  * IEnum* implementation
   3  *
   4  * Copyright 2006 Mike McCormack
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "objbase.h"
  28
  29 #include "enumx.h"
  30
  31 #include "wine/list.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  35
  36 struct tagEnumSTATPROPSETSTG_impl
  37 {
  38     const void *vtbl;
  39     LONG ref;
  40     struct list elements;
  41     struct list *current;
  42     ULONG elem_size;
  43     GUID riid;
  44 };
  45
  46 /************************************************************************
  47  * enumx_QueryInterface
  48  */
  49 HRESULT WINAPI enumx_QueryInterface(
  50     enumx_impl *This,
  51     REFIID riid,
  52     void** ppvObject)
  53 {
  54     if ( (This==0) || (ppvObject==0) )
  55         return E_INVALIDARG;
  56
  57     *ppvObject = 0;
  58
  59     if (IsEqualGUID(&IID_IUnknown, riid) ||
  60         IsEqualGUID(&This->riid, riid))
  61     {
  62         IUnknown_AddRef(((IUnknown*)This));
  63         *ppvObject = This;
  64         return S_OK;
  65     }
  66
  67     return E_NOINTERFACE;
  68 }
  69
  70 /************************************************************************
  71  * enumx_AddRef
  72  */
  73 ULONG WINAPI enumx_AddRef(enumx_impl *This)
  74 {
  75     return InterlockedIncrement(&This->ref);
  76 }
  77
  78 /************************************************************************
  79  * enumx_Release
  80  */
  81 ULONG WINAPI enumx_Release(enumx_impl *This)
  82 {
  83     ULONG ref;
  84
  85     ref = InterlockedDecrement(&This->ref);
  86     if (ref == 0)
  87     {
  88         while (!list_empty(&This->elements))
  89         {
  90              struct list *x = list_head(&This->elements);
  91              list_remove(x);
  92              HeapFree(GetProcessHeap(), 0, x);
  93         }
  94         HeapFree(GetProcessHeap(), 0, This);
  95     }
  96     return ref;
  97 }
  98
  99 /************************************************************************
 100  * enumx_Next
 101  */
 102 HRESULT WINAPI enumx_Next(enumx_impl *This, ULONG celt,
 103                                  void *rgelt, ULONG *pceltFetched)
 104 {
 105     unsigned char *p;
 106     ULONG count = 0;
 107
 108     TRACE("%p %u %p\n", This, celt, pceltFetched);
 109
 110     if (This->current == NULL)
 111         This->current = list_head(&This->elements);
 112     p = rgelt;
 113     while (count < celt && This->current && This->current != &This->elements)
 114     {
 115         memcpy(p, &This->current[1], This->elem_size);
 116         p += This->elem_size;
 117         This->current = This->current->next;
 118         count++;
 119     }
 120     if (pceltFetched)
 121         *pceltFetched = count;
 122     if (count < celt)
 123         return S_FALSE;
 124     return S_OK;
 125 }
 126
 127 /************************************************************************
 128  * enumx_Skip
 129  */
 130 HRESULT WINAPI enumx_Skip(enumx_impl *This, ULONG celt)
 131 {
 132     ULONG count = 0;
 133
 134     TRACE("%p %u\n", This, celt);
 135
 136     if (This->current == NULL)
 137         This->current = list_head(&This->elements);
 138
 139     while (count < celt && This->current && This->current != &This->elements)
 140         count++;
 141
 142     return S_OK;
 143 }
 144
 145 /************************************************************************
 146  * enumx_Reset
 147  */
 148 HRESULT WINAPI enumx_Reset(enumx_impl *This)
 149 {
 150     TRACE("\n");
 151
 152     This->current = NULL;
 153     return S_OK;
 154 }
 155
 156 /************************************************************************
 157  * enumx_fnClone
 158  */
 159 HRESULT WINAPI enumx_Clone(
 160     enumx_impl *iface,
 161     enumx_impl **ppenum)
 162 {
 163     FIXME("\n");
 164     return E_NOTIMPL;
 165 }
 166
 167 /************************************************************************
 168  * enumx_allocate
 169  *
 170  * Allocate a generic enumerator
 171  */
 172 enumx_impl *enumx_allocate(REFIID riid, const void *vtbl, ULONG elem_size)
 173 {
 174     enumx_impl *enumx;
 175
 176     enumx = HeapAlloc(GetProcessHeap(), 0, sizeof *enumx);
 177     if (enumx)
 178     {
 179         enumx->vtbl = vtbl;
 180         enumx->ref = 1;
 181         enumx->current = NULL;
 182         enumx->elem_size = elem_size;
 183         enumx->riid = *riid;
 184         list_init(&enumx->elements);
 185     }
 186
 187     return enumx;
 188 }
 189
 190 /************************************************************************
 191  * enumx_add_element
 192  *
 193  * Add an element to the enumeration.
 194  */
 195 void *enumx_add_element(enumx_impl *enumx, const void *data)
 196 {
 197     struct list *element;
 198
 199     element = HeapAlloc(GetProcessHeap(), 0, sizeof *element + enumx->elem_size);
 200     if (!element)
 201         return NULL;
 202     memcpy(&element[1], data, enumx->elem_size);
 203     list_add_tail(&enumx->elements, element);
 204     return &element[1];
 205 }