dome_cloomnik 0.1.4

A framework for building DOME plugins using 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

use libc::{c_char, c_int};

use super::wren;

pub(crate) const API_VERSION: c_int = 0;

#[repr(C)]
pub(crate) struct FakeContext {
    _private: [u8; 0],
}
pub(crate) type Context = *mut FakeContext;

#[repr(C)]
pub(crate) enum Result {
    Success,
    Failure,
    #[allow(unused)]
    Unknown,
}

impl From<std::result::Result<(), ()>> for Result {
    fn from(value: std::result::Result<(), ()>) -> Self {
        if value.is_ok() {
            Self::Success
        } else {
            Self::Failure
        }
    }
}

impl From<Result> for std::result::Result<(), ()> {
    fn from(value: Result) -> Self {
        if let Result::Success = value {
            Ok(())
        } else {
            Err(())
        }
    }
}

pub(crate) type ForeignFn = wren::ForeignMethodFn;
pub(crate) type FinalizerFn = wren::FinalizerFn;

#[repr(C)]
#[derive(Debug)]
pub(crate) struct ApiV0 {
    pub(crate) register_module:
        extern "C" fn(ctx: Context, name: *const c_char, source: *const c_char) -> Result,
    pub(crate) register_fn: extern "C" fn(
        ctx: Context,
        name: *const c_char,
        signature: *const c_char,
        method: ForeignFn,
    ) -> Result,
    pub(crate) register_class: extern "C" fn(
        ctx: Context,
        module_name: *const c_char,
        class_name: *const c_char,
        allocate: ForeignFn,
        finalize: Option<FinalizerFn>,
    ) -> Result,
    pub(crate) lock_module: extern "C" fn(ctx: Context, name: *const c_char),
    pub(crate) get_context: extern "C" fn(vm: wren::VM) -> Context,
    pub(crate) log: unsafe extern "C" fn(ctx: Context, text: *const c_char, ...),
}