clroxide 1.1.1

A library that allows you to host the CLR and execute dotnet binaries.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use crate::primitives::{IUnknown, IUnknownVtbl, Interface, GUID, HRESULT};
use std::{ffi::c_void, ops::Deref};

#[repr(C)]
pub struct IEnumUnknown {
    pub vtable: *const IEnumUnknownVtbl,
}

#[repr(C)]
pub struct IEnumUnknownVtbl {
    pub parent: IUnknownVtbl,
    pub Next: unsafe extern "system" fn(
        this: *mut c_void,
        celt: u32,
        rgelt: *mut *mut IUnknown,
        pceltFetched: *mut u32,
    ) -> HRESULT,
    pub Skip: unsafe extern "system" fn(this: *mut c_void, celt: u32) -> HRESULT,
    pub Reset: unsafe extern "system" fn(this: *mut c_void) -> HRESULT,
    pub Clone:
        unsafe extern "system" fn(this: *mut c_void, ppenum: *mut *mut IEnumUnknown) -> HRESULT,
}

impl IEnumUnknown {
    #[inline]
    pub unsafe fn Next(
        &self,
        celt: u32,
        rgelt: *mut *mut IUnknown,
        pceltFetched: *mut u32,
    ) -> HRESULT {
        ((*self.vtable).Next)(self as *const _ as *mut _, celt, rgelt, pceltFetched)
    }

    #[inline]
    pub unsafe fn Skip(&self, celt: u32) -> HRESULT {
        ((*self.vtable).Skip)(self as *const _ as *mut _, celt)
    }

    #[inline]
    pub unsafe fn Reset(&self) -> HRESULT {
        ((*self.vtable).Reset)(self as *const _ as *mut _)
    }

    #[inline]
    pub unsafe fn Clone(&self, ppenum: *mut *mut IEnumUnknown) -> HRESULT {
        ((*self.vtable).Clone)(self as *const _ as *mut _, ppenum)
    }
}

impl Interface for IEnumUnknown {
    const IID: GUID = GUID::from_values(
        0x00000100,
        0x0000,
        0x0000,
        [0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46],
    );

    fn vtable(&self) -> *const c_void {
        self.vtable as *const _ as *const c_void
    }
}

impl Deref for IEnumUnknown {
    type Target = IUnknown;

    #[inline]
    fn deref(&self) -> &IUnknown {
        unsafe { &*(self as *const IEnumUnknown as *const IUnknown) }
    }
}