IStream
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using Windows.Win32.Foundation;
namespace Windows.Win32.System.Com
{
[Guid("0000000C-0000-0000-C000-000000000046")]
[SupportedOSPlatform("windows5.0")]
[GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
internal struct IStream : IVTable<IStream, IStream.Vtbl>, IVTable, IComIID
{
internal struct Vtbl
{
internal IntPtr QueryInterface_1;
internal IntPtr AddRef_2;
internal IntPtr Release_3;
internal IntPtr Read_4;
internal IntPtr Write_5;
internal IntPtr Seek_6;
internal IntPtr SetSize_7;
internal IntPtr CopyTo_8;
internal IntPtr Commit_9;
internal IntPtr Revert_10;
internal IntPtr LockRegion_11;
internal IntPtr UnlockRegion_12;
internal IntPtr Stat_13;
internal IntPtr Clone_14;
}
[ComImport]
[Guid("0000000C-0000-0000-C000-000000000046")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
[SupportedOSPlatform("windows5.0")]
internal interface Interface : ISequentialStream.Interface
{
[PreserveSig]
new unsafe HRESULT Read(void* pv, uint cb, uint* pcbRead = default(uint*));
[PreserveSig]
new unsafe HRESULT Write(void* pv, uint cb, uint* pcbWritten = default(uint*));
[PreserveSig]
unsafe HRESULT Seek(long dlibMove, SeekOrigin dwOrigin, ulong* plibNewPosition = default(ulong*));
[PreserveSig]
HRESULT SetSize(ulong libNewSize);
[PreserveSig]
unsafe HRESULT CopyTo(IStream* pstm, ulong cb, ulong* pcbRead = default(ulong*), ulong* pcbWritten = default(ulong*));
[PreserveSig]
HRESULT Commit(uint grfCommitFlags);
[PreserveSig]
HRESULT Revert();
[PreserveSig]
HRESULT LockRegion(ulong libOffset, ulong cb, uint dwLockType);
[PreserveSig]
HRESULT UnlockRegion(ulong libOffset, ulong cb, uint dwLockType);
[PreserveSig]
unsafe HRESULT Stat(STATSTG* pstatstg, uint grfStatFlag);
[PreserveSig]
unsafe HRESULT Clone(IStream** ppstm);
}
private unsafe void** lpVtbl;
internal static readonly Guid IID_Guid = new Guid(12, 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>.B7A5F1B43761BC643A756AD0CE1734B854F59A8AC350D0C8A6487A9B51EC60BB, 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);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT Read(IStream* pThis, void* pv, uint cb, uint* pcbRead = default(uint*))
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IStream, Interface>(pThis, out object);
if (!result.Failed)
return object.Read(pv, cb, pcbRead);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT Read(void* pv, uint cb, uint* pcbRead = default(uint*))
{
IntPtr intPtr = (IntPtr)lpVtbl[3];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT Write(IStream* pThis, void* pv, uint cb, uint* pcbWritten = default(uint*))
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IStream, Interface>(pThis, out object);
if (!result.Failed)
return object.Write(pv, cb, pcbWritten);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT Write(void* pv, uint cb, uint* pcbWritten = default(uint*))
{
IntPtr intPtr = (IntPtr)lpVtbl[4];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT Seek(IStream* pThis, long dlibMove, SeekOrigin dwOrigin, ulong* plibNewPosition = default(ulong*))
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IStream, Interface>(pThis, out object);
if (!result.Failed)
return object.Seek(dlibMove, dwOrigin, plibNewPosition);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT Seek(long dlibMove, SeekOrigin dwOrigin, ulong* plibNewPosition = default(ulong*))
{
IntPtr intPtr = (IntPtr)lpVtbl[5];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT SetSize(IStream* pThis, ulong libNewSize)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IStream, Interface>(pThis, out object);
if (!result.Failed)
return object.SetSize(libNewSize);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT SetSize(ulong libNewSize)
{
IntPtr intPtr = (IntPtr)lpVtbl[6];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT CopyTo(IStream* pThis, IStream* pstm, ulong cb, ulong* pcbRead = default(ulong*), ulong* pcbWritten = default(ulong*))
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IStream, Interface>(pThis, out object);
if (!result.Failed)
return object.CopyTo(pstm, cb, pcbRead, pcbWritten);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT CopyTo(IStream* pstm, ulong cb, ulong* pcbRead = default(ulong*), ulong* pcbWritten = default(ulong*))
{
IntPtr intPtr = (IntPtr)lpVtbl[7];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT Commit(IStream* pThis, uint grfCommitFlags)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IStream, Interface>(pThis, out object);
if (!result.Failed)
return object.Commit(grfCommitFlags);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT Commit(uint grfCommitFlags)
{
IntPtr intPtr = (IntPtr)lpVtbl[8];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT Revert(IStream* pThis)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IStream, Interface>(pThis, out object);
if (!result.Failed)
return object.Revert();
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT Revert()
{
IntPtr intPtr = (IntPtr)lpVtbl[9];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT LockRegion(IStream* pThis, ulong libOffset, ulong cb, uint dwLockType)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IStream, Interface>(pThis, out object);
if (!result.Failed)
return object.LockRegion(libOffset, cb, dwLockType);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT LockRegion(ulong libOffset, ulong cb, uint dwLockType)
{
IntPtr intPtr = (IntPtr)lpVtbl[10];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT UnlockRegion(IStream* pThis, ulong libOffset, ulong cb, uint dwLockType)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IStream, Interface>(pThis, out object);
if (!result.Failed)
return object.UnlockRegion(libOffset, cb, dwLockType);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT UnlockRegion(ulong libOffset, ulong cb, uint dwLockType)
{
IntPtr intPtr = (IntPtr)lpVtbl[11];
return (HRESULT);
}
internal unsafe HRESULT Stat(out STATSTG pstatstg, uint grfStatFlag)
{
fixed (STATSTG* pstatstg2 = &pstatstg) {
return Stat(pstatstg2, grfStatFlag);
}
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT Stat(IStream* pThis, STATSTG* pstatstg, uint grfStatFlag)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IStream, Interface>(pThis, out object);
if (!result.Failed)
return object.Stat(pstatstg, grfStatFlag);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT Stat(STATSTG* pstatstg, uint grfStatFlag)
{
IntPtr intPtr = (IntPtr)lpVtbl[12];
return (HRESULT);
}
[UnmanagedCallersOnly(CallConvs = new Type[] {
typeof(CallConvStdcall)
})]
private unsafe static HRESULT Clone(IStream* pThis, IStream** ppstm)
{
try {
Interface object;
HRESULT result = ComHelpers.UnwrapCCW<IStream, Interface>(pThis, out object);
if (!result.Failed)
return object.Clone(ppstm);
return result;
} catch (Exception ex) {
return (HRESULT)ex.HResult;
}
}
public unsafe HRESULT Clone(IStream** ppstm)
{
IntPtr intPtr = (IntPtr)lpVtbl[13];
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->Read_4 = (IntPtr)(void*);
vtable->Write_5 = (IntPtr)(void*);
vtable->Seek_6 = (IntPtr)(void*);
vtable->SetSize_7 = (IntPtr)(void*);
vtable->CopyTo_8 = (IntPtr)(void*);
vtable->Commit_9 = (IntPtr)(void*);
vtable->Revert_10 = (IntPtr)(void*);
vtable->LockRegion_11 = (IntPtr)(void*);
vtable->UnlockRegion_12 = (IntPtr)(void*);
vtable->Stat_13 = (IntPtr)(void*);
vtable->Clone_14 = (IntPtr)(void*);
}
unsafe void IVTable<IStream, Vtbl>.PopulateVTable(Vtbl* vtable)
{
this.PopulateVTable(vtable);
}
}
}