rnet 0.3.1

Easily call into Rust from C# or other .net langauges.
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
72
73
74
75

use crate::{
    none_ty,
    types::{GeneratorContext, TypeDesc},
    Net,
};

/// # Safety
/// This trait is implemented for Rust types which can be received
/// from .net code.
pub unsafe trait FromNet: Net + for<'a> FromNetArg<'a> {
    #[doc(hidden)]
    const FROM_DESC: &'static TypeDesc = &TypeDesc {
        marshal_in: Some(Self::gen_marshal),
        ..*Self::DESC
    };
    #[doc(hidden)]
    fn gen_marshal(ctx: &mut GeneratorContext, arg: &str) -> Box<str>;
    #[doc(hidden)]
    unsafe fn from_raw(arg: Self::Raw) -> Self;
}

/// # Safety
/// This trait is implemented for Rust types which can be used as arguments
/// to exported functions. This is a superset of types which implement
/// `FromNet`, and allows passing types with lifetime arguments, like `&str`.
pub unsafe trait FromNetArg<'a>: 'a {
    #[doc(hidden)]
    type Owned: FromNet;
    #[doc(hidden)]
    fn borrow_or_take(src: &'a mut Option<Self::Owned>) -> Self;
}

unsafe impl<'a, T: FromNet> FromNetArg<'a> for T {
    type Owned = Self;
    fn borrow_or_take(src: &'a mut Option<Self::Owned>) -> Self {
        // Safety: the two types are identical, but rustc doesn't realise it...
        let src: &'a mut Option<Self> = unsafe { std::mem::transmute(src) };
        src.take().unwrap()
    }
}

/// # Safety
/// This trait is implemented for Rust types which can be returned from
/// .net delegates. This is a superset of types which implement `FromNet`,
/// and allows returning eg. the unit `()` type, whose .net equivalent
/// `void` cannot be used as a normal type.
pub unsafe trait FromNetReturn: 'static {
    #[doc(hidden)]
    const RETURN_DESC: &'static TypeDesc;
    #[doc(hidden)]
    type RawReturn;
    #[doc(hidden)]
    unsafe fn from_raw_return(arg: Self::RawReturn) -> Self;
}

unsafe impl<T: FromNet> FromNetReturn for T {
    const RETURN_DESC: &'static TypeDesc = T::FROM_DESC;
    type RawReturn = <Self as Net>::Raw;
    unsafe fn from_raw_return(arg: Self::RawReturn) -> Self {
        Self::from_raw(arg)
    }
}

unsafe impl FromNetReturn for () {
    const RETURN_DESC: &'static TypeDesc = &TypeDesc {
        net_ty: none_ty,
        base_ty: none_ty,
        raw_ty: none_ty,
        marshal_in: Some(|_, arg| arg.into()),
        marshal_out: None,
    };
    type RawReturn = ();

    unsafe fn from_raw_return(_arg: Self::RawReturn) -> Self {}
}