comcoretypes.h

VXWORKS源代码

#ifdef __cplusplus

interface IWindTypes {};

#else

/* C interface definition for IWindTypes */

interface IWindTypes
    {
    const IWindTypesVtbl *  lpVtbl;
    };

#endif /* __cplusplus */

EXTERN_C const IID IID_IWindTypes;

typedef struct
    {
    COM_VTBL_BEGIN
    COM_VTBL_ENTRY (HRESULT, QueryInterface, (IUnknown* pThis, REFIID riid, void** ppvObject));

#define IUnknown_QueryInterface(pThis, riid, ppvObject) pThis->lpVtbl->QueryInterface(COM_ADJUST_THIS(pThis), riid, ppvObject)

    COM_VTBL_ENTRY (ULONG, AddRef, (IUnknown* pThis));

#define IUnknown_AddRef(pThis) pThis->lpVtbl->AddRef(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (ULONG, Release, (IUnknown* pThis));

#define IUnknown_Release(pThis) pThis->lpVtbl->Release(COM_ADJUST_THIS(pThis))

    COM_VTBL_END
    } IUnknownVtbl;

#ifdef __cplusplus

interface IUnknown
{
virtual HRESULT QueryInterface (REFIID riid, void** ppvObject) =0;

virtual ULONG AddRef () =0;

virtual ULONG Release () =0;

};

#else

/* C interface definition for IUnknown */

interface IUnknown
    {
    const IUnknownVtbl *  lpVtbl;
    };

#endif /* __cplusplus */

EXTERN_C const IID IID_IUnknown;

typedef struct
    {
    COM_VTBL_BEGIN
    COM_VTBL_ENTRY (HRESULT, QueryInterface, (IUnknown* pThis, REFIID riid, void** ppvObject));

#define IUnknown_QueryInterface(pThis, riid, ppvObject) pThis->lpVtbl->QueryInterface(COM_ADJUST_THIS(pThis), riid, ppvObject)

    COM_VTBL_ENTRY (ULONG, AddRef, (IUnknown* pThis));

#define IUnknown_AddRef(pThis) pThis->lpVtbl->AddRef(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (ULONG, Release, (IUnknown* pThis));

#define IUnknown_Release(pThis) pThis->lpVtbl->Release(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (HRESULT, CreateInstance, (IClassFactory* pThis, IUnknown* pUnkOuter, REFIID riid, void** ppvObject));

#define IClassFactory_CreateInstance(pThis, pUnkOuter, riid, ppvObject) pThis->lpVtbl->CreateInstance(COM_ADJUST_THIS(pThis), pUnkOuter, riid, ppvObject)

    COM_VTBL_ENTRY (HRESULT, LockServer, (IClassFactory* pThis, BOOL fLock));

#define IClassFactory_LockServer(pThis, fLock) pThis->lpVtbl->LockServer(COM_ADJUST_THIS(pThis), fLock)

    COM_VTBL_END
    } IClassFactoryVtbl;

#ifdef __cplusplus

interface IClassFactory : public IUnknown
{
virtual HRESULT CreateInstance (IUnknown* pUnkOuter, REFIID riid, void** ppvObject) =0;

virtual HRESULT LockServer (BOOL fLock) =0;

};

#else

/* C interface definition for IClassFactory */

interface IClassFactory
    {
    const IClassFactoryVtbl *  lpVtbl;
    };

#endif /* __cplusplus */

EXTERN_C const IID IID_IClassFactory;

typedef struct
    {
    COM_VTBL_BEGIN
    COM_VTBL_ENTRY (HRESULT, QueryInterface, (IUnknown* pThis, REFIID riid, void** ppvObject));

#define IUnknown_QueryInterface(pThis, riid, ppvObject) pThis->lpVtbl->QueryInterface(COM_ADJUST_THIS(pThis), riid, ppvObject)

    COM_VTBL_ENTRY (ULONG, AddRef, (IUnknown* pThis));

#define IUnknown_AddRef(pThis) pThis->lpVtbl->AddRef(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (ULONG, Release, (IUnknown* pThis));

#define IUnknown_Release(pThis) pThis->lpVtbl->Release(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (HRESULT, QueryMultipleInterfaces, (IMultiQI* pThis, ULONG cMQIs, MULTI_QI* pMQIs));

#define IMultiQI_QueryMultipleInterfaces(pThis, cMQIs, pMQIs) pThis->lpVtbl->QueryMultipleInterfaces(COM_ADJUST_THIS(pThis), cMQIs, pMQIs)

    COM_VTBL_END
    } IMultiQIVtbl;

#ifdef __cplusplus

interface IMultiQI : public IUnknown
{
virtual HRESULT QueryMultipleInterfaces (ULONG cMQIs, MULTI_QI* pMQIs) =0;

};

#else

/* C interface definition for IMultiQI */

interface IMultiQI
    {
    const IMultiQIVtbl *  lpVtbl;
    };

#endif /* __cplusplus */

EXTERN_C const IID IID_IMultiQI;

typedef struct
    {
    COM_VTBL_BEGIN
    COM_VTBL_ENTRY (HRESULT, QueryInterface, (IUnknown* pThis, REFIID riid, void** ppvObject));

#define IUnknown_QueryInterface(pThis, riid, ppvObject) pThis->lpVtbl->QueryInterface(COM_ADJUST_THIS(pThis), riid, ppvObject)

    COM_VTBL_ENTRY (ULONG, AddRef, (IUnknown* pThis));

#define IUnknown_AddRef(pThis) pThis->lpVtbl->AddRef(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (ULONG, Release, (IUnknown* pThis));

#define IUnknown_Release(pThis) pThis->lpVtbl->Release(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (HRESULT, RegisterClass, (IRegistry* pThis, REFCLSID clsid, void* pfnGetClassObject));

#define IRegistry_RegisterClass(pThis, clsid, pfnGetClassObject) pThis->lpVtbl->RegisterClass(COM_ADJUST_THIS(pThis), clsid, pfnGetClassObject)

    COM_VTBL_ENTRY (HRESULT, IsClassRegistered, (IRegistry* pThis, REFCLSID clsid));

#define IRegistry_IsClassRegistered(pThis, clsid) pThis->lpVtbl->IsClassRegistered(COM_ADJUST_THIS(pThis), clsid)

    COM_VTBL_ENTRY (HRESULT, CreateInstance, (IRegistry* pThis, REFCLSID clsid, IUnknown* pUnkOuter, DWORD dwClsContext, const char* hint, ULONG cMQIs, MULTI_QI* pMQIs));

#define IRegistry_CreateInstance(pThis, clsid, pUnkOuter, dwClsContext, hint, cMQIs, pMQIs) pThis->lpVtbl->CreateInstance(COM_ADJUST_THIS(pThis), clsid, pUnkOuter, dwClsContext, hint, cMQIs, pMQIs)

    COM_VTBL_ENTRY (HRESULT, GetClassObject, (IRegistry* pThis, REFCLSID clsid, REFIID iid, DWORD dwClsContext, const char* hint, IUnknown** ppClsObj));

#define IRegistry_GetClassObject(pThis, clsid, iid, dwClsContext, hint, ppClsObj) pThis->lpVtbl->GetClassObject(COM_ADJUST_THIS(pThis), clsid, iid, dwClsContext, hint, ppClsObj)

    COM_VTBL_ENTRY (HRESULT, GetClassID, (IRegistry* pThis, DWORD dwIndex, LPCLSID pclsid));

#define IRegistry_GetClassID(pThis, dwIndex, pclsid) pThis->lpVtbl->GetClassID(COM_ADJUST_THIS(pThis), dwIndex, pclsid)

    COM_VTBL_END
    } IRegistryVtbl;

#ifdef __cplusplus

interface IRegistry : public IUnknown
{
virtual HRESULT RegisterClass (REFCLSID clsid, void* pfnGetClassObject) =0;

virtual HRESULT IsClassRegistered (REFCLSID clsid) =0;

virtual HRESULT CreateInstance (REFCLSID clsid, IUnknown* pUnkOuter, DWORD dwClsContext, const char* hint, ULONG cMQIs, MULTI_QI* pMQIs) =0;

virtual HRESULT GetClassObject (REFCLSID clsid, REFIID iid, DWORD dwClsContext, const char* hint, IUnknown** ppClsObj) =0;

virtual HRESULT GetClassID (DWORD dwIndex, LPCLSID pclsid) =0;

};

#else

/* C interface definition for IRegistry */

interface IRegistry
    {
    const IRegistryVtbl *  lpVtbl;
    };

#endif /* __cplusplus */

EXTERN_C const IID IID_IRegistry;

typedef struct
    {
    COM_VTBL_BEGIN
    COM_VTBL_ENTRY (HRESULT, QueryInterface, (IUnknown* pThis, REFIID riid, void** ppvObject));

#define IUnknown_QueryInterface(pThis, riid, ppvObject) pThis->lpVtbl->QueryInterface(COM_ADJUST_THIS(pThis), riid, ppvObject)

    COM_VTBL_ENTRY (ULONG, AddRef, (IUnknown* pThis));

#define IUnknown_AddRef(pThis) pThis->lpVtbl->AddRef(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (ULONG, Release, (IUnknown* pThis));

#define IUnknown_Release(pThis) pThis->lpVtbl->Release(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (HRESULT, Next, (IEnumGUID* pThis, ULONG celt, GUID* rgelt, ULONG* pceltFetched));

#define IEnumGUID_Next(pThis, celt, rgelt, pceltFetched) pThis->lpVtbl->Next(COM_ADJUST_THIS(pThis), celt, rgelt, pceltFetched)

    COM_VTBL_ENTRY (HRESULT, Skip, (IEnumGUID* pThis, ULONG celt));

#define IEnumGUID_Skip(pThis, celt) pThis->lpVtbl->Skip(COM_ADJUST_THIS(pThis), celt)

    COM_VTBL_ENTRY (HRESULT, Reset, (IEnumGUID* pThis));

#define IEnumGUID_Reset(pThis) pThis->lpVtbl->Reset(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (HRESULT, Clone, (IEnumGUID* pThis, IEnumGUID** ppenum));

#define IEnumGUID_Clone(pThis, ppenum) pThis->lpVtbl->Clone(COM_ADJUST_THIS(pThis), ppenum)

    COM_VTBL_END
    } IEnumGUIDVtbl;

#ifdef __cplusplus

interface IEnumGUID : public IUnknown
{
virtual HRESULT Next (ULONG celt, GUID* rgelt, ULONG* pceltFetched) =0;

virtual HRESULT Skip (ULONG celt) =0;

virtual HRESULT Reset () =0;

virtual HRESULT Clone (IEnumGUID** ppenum) =0;

};

#else

/* C interface definition for IEnumGUID */

interface IEnumGUID
    {
    const IEnumGUIDVtbl *  lpVtbl;
    };

#endif /* __cplusplus */

EXTERN_C const IID IID_IEnumGUID;

typedef struct
    {
    COM_VTBL_BEGIN
    COM_VTBL_ENTRY (HRESULT, QueryInterface, (IUnknown* pThis, REFIID riid, void** ppvObject));

#define IUnknown_QueryInterface(pThis, riid, ppvObject) pThis->lpVtbl->QueryInterface(COM_ADJUST_THIS(pThis), riid, ppvObject)

    COM_VTBL_ENTRY (ULONG, AddRef, (IUnknown* pThis));

#define IUnknown_AddRef(pThis) pThis->lpVtbl->AddRef(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (ULONG, Release, (IUnknown* pThis));

#define IUnknown_Release(pThis) pThis->lpVtbl->Release(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (HRESULT, Next, (IEnumString* pThis, ULONG celt, LPOLESTR* rgelt, ULONG* pceltFetched));

#define IEnumString_Next(pThis, celt, rgelt, pceltFetched) pThis->lpVtbl->Next(COM_ADJUST_THIS(pThis), celt, rgelt, pceltFetched)

    COM_VTBL_ENTRY (HRESULT, Skip, (IEnumString* pThis, ULONG celt));

#define IEnumString_Skip(pThis, celt) pThis->lpVtbl->Skip(COM_ADJUST_THIS(pThis), celt)

    COM_VTBL_ENTRY (HRESULT, Reset, (IEnumString* pThis));

#define IEnumString_Reset(pThis) pThis->lpVtbl->Reset(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (HRESULT, Clone, (IEnumString* pThis, IEnumString** ppenum));

#define IEnumString_Clone(pThis, ppenum) pThis->lpVtbl->Clone(COM_ADJUST_THIS(pThis), ppenum)

    COM_VTBL_END
    } IEnumStringVtbl;

#ifdef __cplusplus

interface IEnumString : public IUnknown
{
virtual HRESULT Next (ULONG celt, LPOLESTR* rgelt, ULONG* pceltFetched) =0;

virtual HRESULT Skip (ULONG celt) =0;

virtual HRESULT Reset () =0;

virtual HRESULT Clone (IEnumString** ppenum) =0;

};

#else

/* C interface definition for IEnumString */

interface IEnumString
    {
    const IEnumStringVtbl *  lpVtbl;
    };

#endif /* __cplusplus */

EXTERN_C const IID IID_IEnumString;

typedef struct
    {
    COM_VTBL_BEGIN
    COM_VTBL_ENTRY (HRESULT, QueryInterface, (IUnknown* pThis, REFIID riid, void** ppvObject));

#define IUnknown_QueryInterface(pThis, riid, ppvObject) pThis->lpVtbl->QueryInterface(COM_ADJUST_THIS(pThis), riid, ppvObject)

    COM_VTBL_ENTRY (ULONG, AddRef, (IUnknown* pThis));

#define IUnknown_AddRef(pThis) pThis->lpVtbl->AddRef(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (ULONG, Release, (IUnknown* pThis));

#define IUnknown_Release(pThis) pThis->lpVtbl->Release(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (HRESULT, Next, (IEnumUnknown* pThis, ULONG celt, IUnknown** rgelt, ULONG* pceltFetched));

#define IEnumUnknown_Next(pThis, celt, rgelt, pceltFetched) pThis->lpVtbl->Next(COM_ADJUST_THIS(pThis), celt, rgelt, pceltFetched)

    COM_VTBL_ENTRY (HRESULT, Skip, (IEnumUnknown* pThis, ULONG celt));

#define IEnumUnknown_Skip(pThis, celt) pThis->lpVtbl->Skip(COM_ADJUST_THIS(pThis), celt)

    COM_VTBL_ENTRY (HRESULT, Reset, (IEnumUnknown* pThis));

#define IEnumUnknown_Reset(pThis) pThis->lpVtbl->Reset(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (HRESULT, Clone, (IEnumUnknown* pThis, IEnumUnknown** ppenum));

#define IEnumUnknown_Clone(pThis, ppenum) pThis->lpVtbl->Clone(COM_ADJUST_THIS(pThis), ppenum)

    COM_VTBL_END
    } IEnumUnknownVtbl;

#ifdef __cplusplus

interface IEnumUnknown : public IUnknown
{
virtual HRESULT Next (ULONG celt, IUnknown** rgelt, ULONG* pceltFetched) =0;

virtual HRESULT Skip (ULONG celt) =0;

virtual HRESULT Reset () =0;

virtual HRESULT Clone (IEnumUnknown** ppenum) =0;

};

#else

/* C interface definition for IEnumUnknown */

interface IEnumUnknown
    {
    const IEnumUnknownVtbl *  lpVtbl;
    };

#endif /* __cplusplus */

EXTERN_C const IID IID_IEnumUnknown;

typedef struct
    {
    COM_VTBL_BEGIN
    COM_VTBL_ENTRY (HRESULT, QueryInterface, (IUnknown* pThis, REFIID riid, void** ppvObject));

#define IUnknown_QueryInterface(pThis, riid, ppvObject) pThis->lpVtbl->QueryInterface(COM_ADJUST_THIS(pThis), riid, ppvObject)

    COM_VTBL_ENTRY (ULONG, AddRef, (IUnknown* pThis));

#define IUnknown_AddRef(pThis) pThis->lpVtbl->AddRef(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (ULONG, Release, (IUnknown* pThis));

#define IUnknown_Release(pThis) pThis->lpVtbl->Release(COM_ADJUST_THIS(pThis))

    COM_VTBL_ENTRY (void*, Alloc, (IMalloc* pThis, ULONG cb));

#define IMalloc_Alloc(pThis, cb) pThis->lpVtbl->Alloc(COM_ADJUST_THIS(pThis), cb)

    COM_VTBL_ENTRY (void*, Realloc, (IMalloc* pThis, void* pv, ULONG cb));

#define IMalloc_Realloc(pThis, pv, cb) pThis->lpVtbl->Realloc(COM_ADJUST_THIS(pThis), pv, cb)

    COM_VTBL_ENTRY (void, Free, (IMalloc* pThis, void* pv));

#define IMalloc_Free(pThis, pv) pThis->lpVtbl->Free(COM_ADJUST_THIS(pThis), pv)

    COM_VTBL_ENTRY (ULONG, GetSize, (IMalloc* pThis, void* pv));

#define IMalloc_GetSize(pThis, pv) pThis->lpVtbl->GetSize(COM_ADJUST_THIS(pThis), pv)

    COM_VTBL_ENTRY (int, DidAlloc, (IMalloc* pThis, void* pv));

#define IMalloc_DidAlloc(pThis, pv) pThis->lpVtbl->DidAlloc(COM_ADJUST_THIS(pThis), pv)

    COM_VTBL_ENTRY (void, HeapMinimize, (IMalloc* pThis));

#define IMalloc_HeapMinimize(pThis) pThis->lpVtbl->HeapMinimize(COM_ADJUST_THIS(pThis))

    COM_VTBL_END
    } IMallocVtbl;

#ifdef __cplusplus

interface IMalloc : public IUnknown
{
virtual void* Alloc (ULONG cb) =0;

virtual void* Realloc (void* pv, ULONG cb) =0;

virtual void Free (void* pv) =0;

virtual ULONG GetSize (void* pv) =0;

virtual int DidAlloc (void* pv) =0;

virtual void HeapMinimize () =0;

};

#else

/* C interface definition for IMalloc */

interface IMalloc
    {
    const IMallocVtbl *  lpVtbl;
    };

#endif /* __cplusplus */

EXTERN_C const IID IID_IMalloc;

#ifdef __cplusplus
}
#endif



#endif /* __INCcomCoreTypes_h */