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
137
138
139
140
141
142
143
144
145
146
147
148

use std::sync::Arc;

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

#[derive(Debug, Clone)]
pub struct OwnedLibraryFunc<F> {
    pub(crate) ptr: F,
    pub(crate) _library: Arc<Library>,
}

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

impl<F> OwnedLibraryFunc<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_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_shared(self) -> AssertShared<Self> {
        AssertShared { inner: self }
    }
    /// A reference to the library this symbol is from.
    pub fn library(&self) -> &Arc<Library> {
        &self._library
    }
}

#[cfg(feature = "fn_traits")]
macro_rules! make_fn_impls {
    ($($var:ident: $ty:ident),*) => {
        impl<$($ty ,)* R> FnOnce<($($ty,)*)> for AssertShared<OwnedLibraryFunc<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<$($ty ,)* R> FnMut<($($ty,)*)> for AssertShared<OwnedLibraryFunc<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<$($ty ,)* R> Fn<($($ty,)*)> for AssertShared<OwnedLibraryFunc<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<$($ty ,)* R> FnOnce<($($ty,)*)> for AssertUnique<OwnedLibraryFunc<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<$($ty ,)* R> FnMut<($($ty,)*)> for AssertUnique<OwnedLibraryFunc<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<$($ty ,)* R> FnOnce<($($ty,)*)> for AssertShared<OwnedLibraryFunc<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<$($ty ,)* R> FnMut<($($ty,)*)> for AssertShared<OwnedLibraryFunc<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<$($ty ,)* R> Fn<($($ty,)*)> for AssertShared<OwnedLibraryFunc<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<$($ty ,)* R> FnOnce<($($ty,)*)> for AssertUnique<OwnedLibraryFunc<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<$($ty ,)* R> FnMut<($($ty,)*)> for AssertUnique<OwnedLibraryFunc<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);

impl<F: Copy> Leak for OwnedLibraryFunc<F> {
    type Result = crate::ref_func::LibraryFunc<'static, F>;

    fn leak(self) -> Self::Result {
        let OwnedLibraryFunc { ptr, _library } = self;
        let _library = _library.leak();
        crate::ref_func::LibraryFunc { ptr, _library }
    }
}