pluginator 1.0.1

Utilities for easier creation of plugins in Rust
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

use std::{
    mem::ManuallyDrop,
    ops::{Deref, DerefMut},
};

use libloading::Library;

#[macro_export]
macro_rules! plugin_trait {
    ($plugin_trait:path) => {
        pub unsafe fn load_plugin<Path: AsRef<std::path::Path>>(
            path: Path,
        ) -> Result<$crate::LoadedPlugin<dyn $plugin_trait>, $crate::plugin::LoadingError> {
            unsafe { $crate::plugin::load(path) }
        }
    };
}

#[macro_export]
macro_rules! plugin_implementation {
    ($plugin_trait:path, $initializer:expr) => {
        #[no_mangle]
        pub extern "C" fn get_interface() -> *mut dyn $plugin_trait {
            Box::into_raw(Box::new($initializer))
        }
    };
}

pub struct LoadedPlugin<Plugin: ?Sized> {
    library: ManuallyDrop<Library>,
    plugin: ManuallyDrop<Box<Plugin>>,
}

impl<Plugin: ?Sized> Drop for LoadedPlugin<Plugin> {
    fn drop(&mut self) {
        unsafe {
            ManuallyDrop::drop(&mut self.plugin);
            ManuallyDrop::drop(&mut self.library);
        }
    }
}

impl<Plugin: ?Sized> Deref for LoadedPlugin<Plugin> {
    type Target = Plugin;

    fn deref(&self) -> &Self::Target {
        self.plugin.as_ref()
    }
}

impl<Plugin: ?Sized> DerefMut for LoadedPlugin<Plugin> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.plugin.as_mut()
    }
}

pub mod plugin {
    use std::mem::ManuallyDrop;

    use super::LoadedPlugin;

    use libloading::{Library, Symbol};

    #[derive(Debug)]
    pub enum LoadingError {
        OpeningError(libloading::Error),
        InterfaceGettingError(libloading::Error),
    }

    pub unsafe fn load<Path: AsRef<std::path::Path>, Plugin: ?Sized>(
        path: Path,
    ) -> Result<LoadedPlugin<Plugin>, LoadingError> {
        let library =
            unsafe { Library::new(path.as_ref()) }.map_err(|e| LoadingError::OpeningError(e))?;
        let get_interface: Symbol<fn() -> *mut Plugin> =
            unsafe { library.get(b"get_interface") }
                .map_err(|e| LoadingError::InterfaceGettingError(e))?;
        let plugin = unsafe { Box::from_raw(get_interface()) };
        Ok(LoadedPlugin {
            plugin: ManuallyDrop::new(plugin),
            library: ManuallyDrop::new(library),
        })
    }
}