[go: up one dir, main page]

windows-core 0.50.0

Rust for Windows
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use super::*;

#[doc(hidden)]
pub trait TypeKind {
    type TypeKind;
}

#[doc(hidden)]
pub struct ReferenceType;

#[doc(hidden)]
pub struct ValueType;

#[doc(hidden)]
pub struct CopyType;

#[doc(hidden)]
pub trait Type<T: TypeKind, C = <T as TypeKind>::TypeKind>: TypeKind + Sized {
    type Abi;
    type Default;

    fn abi(&self) -> Self::Abi {
        unsafe { std::mem::transmute_copy(self) }
    }

    /// # Safety
    unsafe fn from_abi(abi: Self::Abi) -> Result<Self>;
    fn from_default(default: &Self::Default) -> Result<Self>;

    // TODO: this only used by ManuallyDrop
    /// # Safety
    unsafe fn from_abi_ref(abi: &Self::Abi) -> Option<&Self>;
}

impl<T> Type<T, ReferenceType> for T
where
    T: TypeKind<TypeKind = ReferenceType> + Clone,
{
    type Abi = *mut std::ffi::c_void;
    type Default = Option<Self>;

    unsafe fn from_abi(abi: Self::Abi) -> Result<Self> {
        if !abi.is_null() {
            Ok(std::mem::transmute_copy(&abi))
        } else {
            Err(Error::OK)
        }
    }

    unsafe fn from_abi_ref(abi: &Self::Abi) -> Option<&Self> {
        if !abi.is_null() {
            Some(std::mem::transmute(abi))
        } else {
            None
        }
    }

    fn from_default(default: &Self::Default) -> Result<Self> {
        default.as_ref().cloned().ok_or(Error::OK)
    }
}

impl<T> Type<T, ValueType> for T
where
    T: TypeKind<TypeKind = ValueType> + Clone,
{
    type Abi = std::mem::MaybeUninit<Self>;
    type Default = Self;

    unsafe fn from_abi(abi: std::mem::MaybeUninit<Self>) -> Result<Self> {
        Ok(abi.assume_init())
    }

    unsafe fn from_abi_ref(abi: &Self::Abi) -> Option<&Self> {
        Some(std::mem::transmute(abi))
    }

    fn from_default(default: &Self::Default) -> Result<Self> {
        Ok(default.clone())
    }
}

impl<T> Type<T, CopyType> for T
where
    T: TypeKind<TypeKind = CopyType> + Clone,
{
    type Abi = Self;
    type Default = Self;

    unsafe fn from_abi(abi: Self) -> Result<Self> {
        Ok(abi)
    }

    unsafe fn from_abi_ref(abi: &Self::Abi) -> Option<&Self> {
        Some(abi)
    }

    fn from_default(default: &Self) -> Result<Self> {
        Ok(default.clone())
    }
}

impl<T: Interface> TypeKind for T {
    type TypeKind = ReferenceType;
}

impl<T> TypeKind for *mut T {
    type TypeKind = CopyType;
}

macro_rules! primitives {
    ($($t:ty),+) => {
        $(
            impl TypeKind for $t {
                type TypeKind = CopyType;
            }
        )*
    };
}

primitives!(bool, i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, usize, isize);

#[doc(hidden)]
pub type AbiType<T> = <T as Type<T>>::Abi;

#[doc(hidden)]
pub unsafe fn from_abi<T: Type<T>>(abi: T::Abi) -> Result<T> {
    T::from_abi(abi)
}