mirror of
https://github.com/reactos/reactos.git
synced 2024-08-22 11:22:59 +00:00
218 lines
5.2 KiB
C
218 lines
5.2 KiB
C
/*
|
|
* IEnum* implementation
|
|
*
|
|
* Copyright 2006 Mike McCormack
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#define COBJMACROS
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "objbase.h"
|
|
|
|
#include "enumx.h"
|
|
|
|
#include "wine/list.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(ole);
|
|
|
|
struct tagEnumSTATPROPSETSTG_impl
|
|
{
|
|
const void *vtbl;
|
|
LONG ref;
|
|
struct list elements;
|
|
struct list *current;
|
|
ULONG elem_size;
|
|
GUID riid;
|
|
IUnknown *parent;
|
|
enumx_copy_cb copy_cb;
|
|
};
|
|
|
|
/************************************************************************
|
|
* enumx_QueryInterface
|
|
*/
|
|
HRESULT WINAPI enumx_QueryInterface(
|
|
enumx_impl *This,
|
|
REFIID riid,
|
|
void** ppvObject)
|
|
{
|
|
if ( ppvObject==0 )
|
|
return E_INVALIDARG;
|
|
|
|
*ppvObject = 0;
|
|
|
|
if (IsEqualGUID(&IID_IUnknown, riid) ||
|
|
IsEqualGUID(&This->riid, riid))
|
|
{
|
|
IUnknown_AddRef(((IUnknown*)This));
|
|
*ppvObject = This;
|
|
return S_OK;
|
|
}
|
|
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
/************************************************************************
|
|
* enumx_AddRef
|
|
*/
|
|
ULONG WINAPI enumx_AddRef(enumx_impl *This)
|
|
{
|
|
return InterlockedIncrement(&This->ref);
|
|
}
|
|
|
|
/************************************************************************
|
|
* enumx_Release
|
|
*/
|
|
ULONG WINAPI enumx_Release(enumx_impl *This)
|
|
{
|
|
ULONG ref;
|
|
|
|
ref = InterlockedDecrement(&This->ref);
|
|
if (ref == 0)
|
|
{
|
|
while (!list_empty(&This->elements))
|
|
{
|
|
struct list *x = list_head(&This->elements);
|
|
list_remove(x);
|
|
HeapFree(GetProcessHeap(), 0, x);
|
|
}
|
|
IUnknown_Release(This->parent);
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
}
|
|
return ref;
|
|
}
|
|
|
|
/************************************************************************
|
|
* enumx_Next
|
|
*/
|
|
HRESULT WINAPI enumx_Next(enumx_impl *This, ULONG celt,
|
|
void *rgelt, ULONG *pceltFetched)
|
|
{
|
|
unsigned char *p;
|
|
ULONG count = 0;
|
|
|
|
TRACE("%p %u %p\n", This, celt, pceltFetched);
|
|
|
|
if (This->current == NULL)
|
|
This->current = list_head(&This->elements);
|
|
p = rgelt;
|
|
while (count < celt && This->current && This->current != &This->elements)
|
|
{
|
|
if (This->copy_cb)
|
|
This->copy_cb(This->parent, &This->current[1], p);
|
|
else
|
|
memcpy(p, &This->current[1], This->elem_size);
|
|
p += This->elem_size;
|
|
This->current = This->current->next;
|
|
count++;
|
|
}
|
|
if (pceltFetched)
|
|
*pceltFetched = count;
|
|
if (count < celt)
|
|
return S_FALSE;
|
|
return S_OK;
|
|
}
|
|
|
|
/************************************************************************
|
|
* enumx_Skip
|
|
*/
|
|
HRESULT WINAPI enumx_Skip(enumx_impl *This, ULONG celt)
|
|
{
|
|
ULONG count = 0;
|
|
|
|
TRACE("%p %u\n", This, celt);
|
|
|
|
if (This->current == NULL)
|
|
This->current = list_head(&This->elements);
|
|
|
|
while (count < celt && This->current && This->current != &This->elements)
|
|
count++;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/************************************************************************
|
|
* enumx_Reset
|
|
*/
|
|
HRESULT WINAPI enumx_Reset(enumx_impl *This)
|
|
{
|
|
TRACE("\n");
|
|
|
|
This->current = NULL;
|
|
return S_OK;
|
|
}
|
|
|
|
/************************************************************************
|
|
* enumx_fnClone
|
|
*/
|
|
HRESULT WINAPI enumx_Clone(
|
|
enumx_impl *iface,
|
|
enumx_impl **ppenum)
|
|
{
|
|
FIXME("\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/************************************************************************
|
|
* enumx_allocate
|
|
*
|
|
* Allocate a generic enumerator
|
|
*/
|
|
enumx_impl *enumx_allocate(REFIID riid, const void *vtbl, ULONG elem_size,
|
|
IUnknown *parent, enumx_copy_cb copy_cb)
|
|
{
|
|
enumx_impl *enumx;
|
|
|
|
enumx = HeapAlloc(GetProcessHeap(), 0, sizeof *enumx);
|
|
if (enumx)
|
|
{
|
|
enumx->vtbl = vtbl;
|
|
enumx->ref = 1;
|
|
enumx->current = NULL;
|
|
enumx->elem_size = elem_size;
|
|
enumx->riid = *riid;
|
|
enumx->parent = parent;
|
|
enumx->copy_cb = copy_cb;
|
|
|
|
IUnknown_AddRef(parent);
|
|
|
|
list_init(&enumx->elements);
|
|
}
|
|
|
|
return enumx;
|
|
}
|
|
|
|
/************************************************************************
|
|
* enumx_add_element
|
|
*
|
|
* Add an element to the enumeration.
|
|
*/
|
|
void *enumx_add_element(enumx_impl *enumx, const void *data)
|
|
{
|
|
struct list *element;
|
|
|
|
element = HeapAlloc(GetProcessHeap(), 0, sizeof *element + enumx->elem_size);
|
|
if (!element)
|
|
return NULL;
|
|
memcpy(&element[1], data, enumx->elem_size);
|
|
list_add_tail(&enumx->elements, element);
|
|
return &element[1];
|
|
}
|