IMoniker
using System;
using System.CodeDom.Compiler;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Runtime.Versioning;
using Windows.Win32.Foundation;
namespace Windows.Win32.System.Com
{
[Guid("0000000F-0000-0000-C000-000000000046")]
[SupportedOSPlatform("windows5.0")]
[GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
internal struct IMoniker : IVTable<IMoniker, IMoniker.Vtbl>, IVTable, IComIID
{
internal struct Vtbl
{
internal IntPtr QueryInterface_1;
internal IntPtr AddRef_2;
internal IntPtr Release_3;
internal IntPtr GetClassID_4;
internal IntPtr IsDirty_5;
internal IntPtr Load_6;
internal IntPtr Save_7;
internal IntPtr GetSizeMax_8;
internal IntPtr BindToObject_9;
internal IntPtr BindToStorage_10;
internal IntPtr Reduce_11;
internal IntPtr ComposeWith_12;
internal IntPtr Enum_13;
internal IntPtr IsEqual_14;
internal IntPtr Hash_15;
internal IntPtr IsRunning_16;
internal IntPtr GetTimeOfLastChange_17;
internal IntPtr Inverse_18;
internal IntPtr CommonPrefixWith_19;
internal IntPtr RelativePathTo_20;
internal IntPtr GetDisplayName_21;
internal IntPtr ParseDisplayName_22;
internal IntPtr IsSystemMoniker_23;
}
[ComImport]
[Guid("0000000F-0000-0000-C000-000000000046")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
[SupportedOSPlatform("windows5.0")]
internal interface Interface : IPersist.Interface, IPersistStream.Interface
{
[PreserveSig]
new unsafe HRESULT GetClassID(Guid* pClassID);
[PreserveSig]
new HRESULT IsDirty();
[PreserveSig]
new unsafe HRESULT Load(IStream* pStm);
[PreserveSig]
new unsafe HRESULT Save(IStream* pStm, BOOL fClearDirty);
[PreserveSig]
new unsafe HRESULT GetSizeMax(ulong* pcbSize);
[PreserveSig]
unsafe HRESULT BindToObject(IBindCtx* pbc, IMoniker* pmkToLeft = default(IMoniker*), Guid* riidResult, void** ppvResult);
[PreserveSig]
unsafe HRESULT BindToStorage(IBindCtx* pbc, IMoniker* pmkToLeft = default(IMoniker*), Guid* riid, void** ppvObj);
[PreserveSig]
unsafe HRESULT Reduce(IBindCtx* pbc, uint dwReduceHowFar, IMoniker** ppmkToLeft, IMoniker** ppmkReduced);
[PreserveSig]
unsafe HRESULT ComposeWith(IMoniker* pmkRight, BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite);
[PreserveSig]
unsafe HRESULT Enum(BOOL fForward, IEnumMoniker** ppenumMoniker);
[PreserveSig]
unsafe HRESULT IsEqual(IMoniker* pmkOtherMoniker);
[PreserveSig]
unsafe HRESULT Hash(uint* pdwHash);
[PreserveSig]
unsafe HRESULT IsRunning(IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning);
[PreserveSig]
unsafe HRESULT GetTimeOfLastChange(IBindCtx* pbc, IMoniker* pmkToLeft, global::System.Runtime.InteropServices.ComTypes.FILETIME* pFileTime);
[PreserveSig]
unsafe HRESULT Inverse(IMoniker** ppmk);
[PreserveSig]
unsafe HRESULT CommonPrefixWith(IMoniker* pmkOther, IMoniker** ppmkPrefix);
[PreserveSig]
unsafe HRESULT RelativePathTo(IMoniker* pmkOther, IMoniker** ppmkRelPath);
[PreserveSig]
unsafe HRESULT GetDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, PWSTR* ppszDisplayName);
[PreserveSig]
unsafe HRESULT ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, PWSTR pszDisplayName, uint* pchEaten, IMoniker** ppmkOut);
[PreserveSig]
unsafe HRESULT IsSystemMoniker(uint* pdwMksys);
}
private unsafe void** lpVtbl;
internal static readonly Guid IID_Guid = new Guid(15, 0, 0, 192, 0, 0, 0, 0, 0, 0, 70);
[IsReadOnly]
static unsafe ref Guid IComIID.Guid {
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[return: IsReadOnly]
get {
return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(new ReadOnlySpan<byte>(&global::<PrivateImplementationDetails>.2C824C9AF4A9514C5B0DB6DFEF73A866218976D3304E4AA556295FB8FE3BD784, 16)));
}
}
internal unsafe HRESULT QueryInterface([In] [IsReadOnly] ref Guid riid, out void* ppvObject)
{
fixed (void** ppvObject2 = &ppvObject) {
fixed (Guid* riid2 = &riid) {
return QueryInterface(riid2, ppvObject2);
}
}
}
public unsafe HRESULT QueryInterface(Guid* riid, void** ppvObject)
{
IntPtr intPtr = (IntPtr)(*lpVtbl);
return (HRESULT);
}
public unsafe uint AddRef()
{
IntPtr intPtr = (IntPtr)lpVtbl[1];
return (uint);
}
public unsafe uint Release()
{
IntPtr intPtr = (IntPtr)lpVtbl[2];
return (uint);
}
internal unsafe HRESULT GetClassID(out Guid pClassID)
{
fixed (Guid* pClassID2 = &pClassID) {
return GetClassID(pClassID2);
}
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT GetClassID(IMoniker* pThis, Guid* pClassID)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.GetClassID(pClassID);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT GetClassID(Guid* pClassID)
{
IntPtr intPtr = (IntPtr)lpVtbl[3];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT IsDirty(IMoniker* pThis)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.IsDirty();
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT IsDirty()
{
IntPtr intPtr = (IntPtr)lpVtbl[4];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT Load(IMoniker* pThis, IStream* pStm)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.Load(pStm);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT Load(IStream* pStm)
{
IntPtr intPtr = (IntPtr)lpVtbl[5];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT Save(IMoniker* pThis, IStream* pStm, BOOL fClearDirty)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.Save(pStm, fClearDirty);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT Save(IStream* pStm, BOOL fClearDirty)
{
IntPtr intPtr = (IntPtr)lpVtbl[6];
return (HRESULT);
}
internal unsafe HRESULT GetSizeMax(out ulong pcbSize)
{
fixed (ulong* pcbSize2 = &pcbSize) {
return GetSizeMax(pcbSize2);
}
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT GetSizeMax(IMoniker* pThis, ulong* pcbSize)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.GetSizeMax(pcbSize);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT GetSizeMax(ulong* pcbSize)
{
IntPtr intPtr = (IntPtr)lpVtbl[7];
return (HRESULT);
}
internal unsafe HRESULT BindToObject(IBindCtx* pbc, IMoniker* pmkToLeft, [In] [IsReadOnly] ref Guid riidResult, out void* ppvResult)
{
fixed (void** ppvResult2 = &ppvResult) {
fixed (Guid* riidResult2 = &riidResult) {
return BindToObject(pbc, pmkToLeft, riidResult2, ppvResult2);
}
}
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT BindToObject(IMoniker* pThis, IBindCtx* pbc, IMoniker* pmkToLeft = default(IMoniker*), Guid* riidResult, void** ppvResult)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.BindToObject(pbc, pmkToLeft, riidResult, ppvResult);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT BindToObject(IBindCtx* pbc, IMoniker* pmkToLeft = default(IMoniker*), Guid* riidResult, void** ppvResult)
{
IntPtr intPtr = (IntPtr)lpVtbl[8];
return (HRESULT);
}
internal unsafe HRESULT BindToStorage(IBindCtx* pbc, IMoniker* pmkToLeft, [In] [IsReadOnly] ref Guid riid, out void* ppvObj)
{
fixed (void** ppvObj2 = &ppvObj) {
fixed (Guid* riid2 = &riid) {
return BindToStorage(pbc, pmkToLeft, riid2, ppvObj2);
}
}
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT BindToStorage(IMoniker* pThis, IBindCtx* pbc, IMoniker* pmkToLeft = default(IMoniker*), Guid* riid, void** ppvObj)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.BindToStorage(pbc, pmkToLeft, riid, ppvObj);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT BindToStorage(IBindCtx* pbc, IMoniker* pmkToLeft = default(IMoniker*), Guid* riid, void** ppvObj)
{
IntPtr intPtr = (IntPtr)lpVtbl[9];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT Reduce(IMoniker* pThis, IBindCtx* pbc, uint dwReduceHowFar, IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.Reduce(pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT Reduce(IBindCtx* pbc, uint dwReduceHowFar, IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
{
IntPtr intPtr = (IntPtr)lpVtbl[10];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT ComposeWith(IMoniker* pThis, IMoniker* pmkRight, BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.ComposeWith(pmkRight, fOnlyIfNotGeneric, ppmkComposite);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT ComposeWith(IMoniker* pmkRight, BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
{
IntPtr intPtr = (IntPtr)lpVtbl[11];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT Enum(IMoniker* pThis, BOOL fForward, IEnumMoniker** ppenumMoniker)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.Enum(fForward, ppenumMoniker);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT Enum(BOOL fForward, IEnumMoniker** ppenumMoniker)
{
IntPtr intPtr = (IntPtr)lpVtbl[12];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT IsEqual(IMoniker* pThis, IMoniker* pmkOtherMoniker)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.IsEqual(pmkOtherMoniker);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT IsEqual(IMoniker* pmkOtherMoniker)
{
IntPtr intPtr = (IntPtr)lpVtbl[13];
return (HRESULT);
}
internal unsafe HRESULT Hash(out uint pdwHash)
{
fixed (uint* pdwHash2 = &pdwHash) {
return Hash(pdwHash2);
}
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT Hash(IMoniker* pThis, uint* pdwHash)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.Hash(pdwHash);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT Hash(uint* pdwHash)
{
IntPtr intPtr = (IntPtr)lpVtbl[14];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT IsRunning(IMoniker* pThis, IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.IsRunning(pbc, pmkToLeft, pmkNewlyRunning);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT IsRunning(IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning)
{
IntPtr intPtr = (IntPtr)lpVtbl[15];
return (HRESULT);
}
internal unsafe HRESULT GetTimeOfLastChange(IBindCtx* pbc, IMoniker* pmkToLeft, out global::System.Runtime.InteropServices.ComTypes.FILETIME pFileTime)
{
fixed (global::System.Runtime.InteropServices.ComTypes.FILETIME* pFileTime2 = &pFileTime) {
return GetTimeOfLastChange(pbc, pmkToLeft, pFileTime2);
}
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT GetTimeOfLastChange(IMoniker* pThis, IBindCtx* pbc, IMoniker* pmkToLeft, global::System.Runtime.InteropServices.ComTypes.FILETIME* pFileTime)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.GetTimeOfLastChange(pbc, pmkToLeft, pFileTime);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT GetTimeOfLastChange(IBindCtx* pbc, IMoniker* pmkToLeft, global::System.Runtime.InteropServices.ComTypes.FILETIME* pFileTime)
{
IntPtr intPtr = (IntPtr)lpVtbl[16];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT Inverse(IMoniker* pThis, IMoniker** ppmk)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.Inverse(ppmk);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT Inverse(IMoniker** ppmk)
{
IntPtr intPtr = (IntPtr)lpVtbl[17];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT CommonPrefixWith(IMoniker* pThis, IMoniker* pmkOther, IMoniker** ppmkPrefix)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.CommonPrefixWith(pmkOther, ppmkPrefix);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT CommonPrefixWith(IMoniker* pmkOther, IMoniker** ppmkPrefix)
{
IntPtr intPtr = (IntPtr)lpVtbl[18];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT RelativePathTo(IMoniker* pThis, IMoniker* pmkOther, IMoniker** ppmkRelPath)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.RelativePathTo(pmkOther, ppmkRelPath);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT RelativePathTo(IMoniker* pmkOther, IMoniker** ppmkRelPath)
{
IntPtr intPtr = (IntPtr)lpVtbl[19];
return (HRESULT);
}
internal unsafe HRESULT GetDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, out PWSTR ppszDisplayName)
{
fixed (PWSTR* ppszDisplayName2 = &ppszDisplayName) {
return GetDisplayName(pbc, pmkToLeft, ppszDisplayName2);
}
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT GetDisplayName(IMoniker* pThis, IBindCtx* pbc, IMoniker* pmkToLeft, PWSTR* ppszDisplayName)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.GetDisplayName(pbc, pmkToLeft, ppszDisplayName);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT GetDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, PWSTR* ppszDisplayName)
{
IntPtr intPtr = (IntPtr)lpVtbl[20];
return (HRESULT);
}
internal unsafe HRESULT ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, PWSTR pszDisplayName, out uint pchEaten, IMoniker** ppmkOut)
{
fixed (uint* pchEaten2 = &pchEaten) {
return ParseDisplayName(pbc, pmkToLeft, pszDisplayName, pchEaten2, ppmkOut);
}
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT ParseDisplayName(IMoniker* pThis, IBindCtx* pbc, IMoniker* pmkToLeft, PWSTR pszDisplayName, uint* pchEaten, IMoniker** ppmkOut)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.ParseDisplayName(pbc, pmkToLeft, pszDisplayName, pchEaten, ppmkOut);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, PWSTR pszDisplayName, uint* pchEaten, IMoniker** ppmkOut)
{
IntPtr intPtr = (IntPtr)lpVtbl[21];
return (HRESULT);
}
internal unsafe HRESULT IsSystemMoniker(out uint pdwMksys)
{
fixed (uint* pdwMksys2 = &pdwMksys) {
return IsSystemMoniker(pdwMksys2);
}
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT IsSystemMoniker(IMoniker* pThis, uint* pdwMksys)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IMoniker, Interface>(pThis, out object);
if (!result.Failed)
return object.IsSystemMoniker(pdwMksys);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT IsSystemMoniker(uint* pdwMksys)
{
IntPtr intPtr = (IntPtr)lpVtbl[22];
return (HRESULT);
}
internal unsafe HRESULT QueryInterface<[IsUnmanaged] T>(out T* ppv) where T : struct
{
Guid riid = typeof(T).GUID;
void* ppvObject;
HRESULT result = QueryInterface(ref riid, out ppvObject);
if (result.Succeeded)
ppv = (T*)ppvObject;
else
ppv = null;
return result;
}
public unsafe static void PopulateVTable(Vtbl* vtable)
{
vtable->GetClassID_4 = (IntPtr)(void*);
vtable->IsDirty_5 = (IntPtr)(void*);
vtable->Load_6 = (IntPtr)(void*);
vtable->Save_7 = (IntPtr)(void*);
vtable->GetSizeMax_8 = (IntPtr)(void*);
vtable->BindToObject_9 = (IntPtr)(void*);
vtable->BindToStorage_10 = (IntPtr)(void*);
vtable->Reduce_11 = (IntPtr)(void*);
vtable->ComposeWith_12 = (IntPtr)(void*);
vtable->Enum_13 = (IntPtr)(void*);
vtable->IsEqual_14 = (IntPtr)(void*);
vtable->Hash_15 = (IntPtr)(void*);
vtable->IsRunning_16 = (IntPtr)(void*);
vtable->GetTimeOfLastChange_17 = (IntPtr)(void*);
vtable->Inverse_18 = (IntPtr)(void*);
vtable->CommonPrefixWith_19 = (IntPtr)(void*);
vtable->RelativePathTo_20 = (IntPtr)(void*);
vtable->GetDisplayName_21 = (IntPtr)(void*);
vtable->ParseDisplayName_22 = (IntPtr)(void*);
vtable->IsSystemMoniker_23 = (IntPtr)(void*);
}
unsafe void IVTable<IMoniker, Vtbl>.PopulateVTable(Vtbl* vtable)
{
this.PopulateVTable(vtable);
}
}
}