loader 0.2.1

You probably want to use libloading
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
130
131
132
133
134
135
136

use crate::{AsPtr, AssertShared, AssertUnique, Library};

#[derive(Debug, Clone, Copy)]
pub struct LibraryFunc<'a, F> {
    pub(crate) ptr: F,
    pub(crate) _library: &'a Library,
}

impl<'a, F: Copy> AsPtr for LibraryFunc<'a, F> {
    type Pointer = F;
    unsafe fn as_ptr(&self) -> Self::Pointer {
        self.ptr
    }
}

impl<'a, F> LibraryFunc<'a, F> {
    /// Asserts that this is safely callable with the "C" calling convention,
    /// and that this symbol points to the correct type, and
    /// that it is the only pointer to its symbol.
    /// The function may be non-reentrant.
    pub unsafe fn assert_callable_unique(self) -> AssertUnique<Self> {
        AssertUnique { inner: self }
    }
    /// Asserts that this is safely callable with the "C" calling convention,
    /// and that this symbol points to the correct type, and
    /// that there are no unique pointers to this symbol.
    /// The function must be reentrant.
    pub unsafe fn assert_callable_shared(self) -> AssertShared<Self> {
        AssertShared { inner: self }
    }
    /// A reference to the library this symbol is from.
    pub fn library(&self) -> &'a Library {
        self._library
    }
}

#[cfg(feature = "fn_traits")]
macro_rules! make_fn_impls {
    ($($var:ident: $ty:ident),*) => {
        impl<'a, $($ty ,)* R> FnOnce<($($ty,)*)> for AssertShared<LibraryFunc<'a, unsafe extern "C" fn($($ty,)*) -> R>> {
            type Output = R;
            extern "rust-call" fn call_once(self, ($($var,)*): ($($ty,)*)) -> Self::Output {
                // SAFETY: self's lifetime will not end before the called function completes.
                let f = unsafe { self.as_ptr() };
                unsafe { f($($var,)*) }
            }
        }
        impl<'a, $($ty ,)* R> FnMut<($($ty,)*)> for AssertShared<LibraryFunc<'a, unsafe extern "C" fn($($ty,)*) -> R>> {
            extern "rust-call" fn call_mut(&mut self, ($($var,)*): ($($ty,)*)) -> Self::Output {
                // SAFETY: self's lifetime will not end before the called function completes.
                let f = unsafe { self.as_ptr() };
                unsafe { f($($var,)*) }
            }
        }
        impl<'a, $($ty ,)* R> Fn<($($ty,)*)> for AssertShared<LibraryFunc<'a, unsafe extern "C" fn($($ty,)*) -> R>> {
            extern "rust-call" fn call(&self, ($($var,)*): ($($ty,)*)) -> Self::Output {
                // SAFETY: self's lifetime will not end before the called function completes.
                let f = unsafe { self.as_ptr() };
                unsafe { f($($var,)*) }
            }
        }

        impl<'a, $($ty ,)* R> FnOnce<($($ty,)*)> for AssertUnique<LibraryFunc<'a, unsafe extern "C" fn($($ty,)*) -> R>> {
            type Output = R;
            extern "rust-call" fn call_once(self, ($($var,)*): ($($ty,)*)) -> Self::Output {
                // SAFETY: self's lifetime will not end before the called function completes.
                let f = unsafe { self.as_ptr() };
                unsafe { f($($var,)*) }
            }
        }
        impl<'a, $($ty ,)* R> FnMut<($($ty,)*)> for AssertUnique<LibraryFunc<'a, unsafe extern "C" fn($($ty,)*) -> R>> {
            extern "rust-call" fn call_mut(&mut self, ($($var,)*): ($($ty,)*)) -> Self::Output {
                // SAFETY: self's lifetime will not end before the called function completes.
                let f = unsafe { self.as_ptr() };
                unsafe { f($($var,)*) }
            }
        }


        impl<'a, $($ty ,)* R> FnOnce<($($ty,)*)> for AssertShared<LibraryFunc<'a, extern "C" fn($($ty,)*) -> R>> {
            type Output = R;
            extern "rust-call" fn call_once(self, ($($var,)*): ($($ty,)*)) -> Self::Output {
                // SAFETY: self's lifetime will not end before the called function completes.
                let f = unsafe { self.as_ptr() };
                { f($($var,)*) }
            }
        }
        impl<'a, $($ty ,)* R> FnMut<($($ty,)*)> for AssertShared<LibraryFunc<'a, extern "C" fn($($ty,)*) -> R>> {
            extern "rust-call" fn call_mut(&mut self, ($($var,)*): ($($ty,)*)) -> Self::Output {
                // SAFETY: self's lifetime will not end before the called function completes.
                let f = unsafe { self.as_ptr() };
                { f($($var,)*) }
            }
        }
        impl<'a, $($ty ,)* R> Fn<($($ty,)*)> for AssertShared<LibraryFunc<'a, extern "C" fn($($ty,)*) -> R>> {
            extern "rust-call" fn call(&self, ($($var,)*): ($($ty,)*)) -> Self::Output {
                // SAFETY: self's lifetime will not end before the called function completes.
                let f = unsafe { self.as_ptr() };
                { f($($var,)*) }
            }
        }

        impl<'a, $($ty ,)* R> FnOnce<($($ty,)*)> for AssertUnique<LibraryFunc<'a, extern "C" fn($($ty,)*) -> R>> {
            type Output = R;
            extern "rust-call" fn call_once(self, ($($var,)*): ($($ty,)*)) -> Self::Output {
                // SAFETY: self's lifetime will not end before the called function completes.
                let f = unsafe { self.as_ptr() };
                { f($($var,)*) }
            }
        }
        impl<'a, $($ty ,)* R> FnMut<($($ty,)*)> for AssertUnique<LibraryFunc<'a, extern "C" fn($($ty,)*) -> R>> {
            extern "rust-call" fn call_mut(&mut self, ($($var,)*): ($($ty,)*)) -> Self::Output {
                // SAFETY: self's lifetime will not end before the called function completes.
                let f = unsafe { self.as_ptr() };
                { f($($var,)*) }
            }
        }
    };
}

#[cfg(not(feature = "fn_traits"))]
macro_rules! make_fn_impls {
    ($($_:tt)*) => {};
}

make_fn_impls!();
make_fn_impls!(a: A);
make_fn_impls!(a: A, b: B);
make_fn_impls!(a: A, b: B, c: C);
make_fn_impls!(a: A, b: B, c: C, d: D);
make_fn_impls!(a: A, b: B, c: C, d: D, e: E);
make_fn_impls!(a: A, b: B, c: C, d: D, e: E, f: F);
make_fn_impls!(a: A, b: B, c: C, d: D, e: E, f: F, g: G);
make_fn_impls!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H);
make_fn_impls!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I);
make_fn_impls!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J);