boltffi_core 0.22.1

Core runtime types for BoltFFI - high-performance FFI bindings generator
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

extern crate self as boltffi_core;

#[cfg(feature = "fast-alloc")]
#[global_allocator]
static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;

pub mod callback;
pub mod custom_ffi;
pub mod handle;
pub mod passable;
pub mod ringbuffer;
pub mod runtime;
pub mod safety;
pub mod status;
pub mod types;
pub mod wasm;
pub mod wire;

pub use boltffi_macros::{
    Data, FfiType, custom_ffi, custom_type, data, default, error, export, ffi_class, ffi_export,
    ffi_stream, ffi_trait, name, skip,
};
#[cfg(target_arch = "wasm32")]
pub use callback::WasmCallbackOwner;
pub use callback::{CallbackForeignType, CallbackHandle, FromCallbackHandle};
pub use custom_ffi::CustomFfiConvertible;
pub use handle::HandleBox;
pub use passable::{Passable, Seal, VecTransport, WirePassable};
pub use ringbuffer::SpscRingBuffer;
pub use runtime::async_callback;
pub use runtime::async_callback::{
    AsyncCallback, AsyncCallbackCompletion, AsyncCallbackCompletionCode,
    AsyncCallbackCompletionResult, AsyncCallbackRegistry, AsyncCallbackRequestGuard,
    AsyncCallbackRequestId, AsyncCallbackString, AsyncCallbackVoid,
};
pub use runtime::future as rustfuture;
pub use runtime::future::{
    RustFuture, RustFutureContinuationCallback, RustFutureHandle, RustFuturePoll,
};
#[cfg(target_arch = "wasm32")]
pub use runtime::future::{WasmPollStatus, rust_future_panic_message, rust_future_poll_sync};
pub use runtime::pending;
pub use runtime::pending::{CancellationToken, PendingHandle};
pub use runtime::subscription;
pub use runtime::subscription::{
    EventSubscription, StreamContinuationCallback, StreamPollResult, StreamProducer,
    SubscriptionHandle, WaitResult,
};
pub use safety::catch_ffi_panic;
pub use status::{FfiStatus, clear_last_error, set_last_error, take_last_error};

pub use types::{FfiBuf, FfiError, FfiOption, FfiSlice, FfiSpan, FfiString};
pub use wasm::WASM_ABI_VERSION;
#[cfg(target_arch = "wasm32")]
pub use wasm::WasmCallbackOutBuf;
#[cfg(target_arch = "wasm32")]
pub use wasm::write_return_slot;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UnexpectedFfiCallbackError(pub String);

impl UnexpectedFfiCallbackError {
    pub fn new(message: impl Into<String>) -> Self {
        Self(message.into())
    }

    pub fn message(&self) -> &str {
        &self.0
    }
}

impl std::fmt::Display for UnexpectedFfiCallbackError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "unexpected ffi callback error: {}", self.0)
    }
}

impl std::error::Error for UnexpectedFfiCallbackError {}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CustomTypeConversionError;

impl std::fmt::Display for CustomTypeConversionError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "custom type conversion failed")
    }
}

impl std::error::Error for CustomTypeConversionError {}

pub const VERSION_MAJOR: u32 = 0;
pub const VERSION_MINOR: u32 = 1;
pub const VERSION_PATCH: u32 = 0;

#[unsafe(no_mangle)]
pub extern "C" fn boltffi_version_major() -> u32 {
    VERSION_MAJOR
}

#[unsafe(no_mangle)]
pub extern "C" fn boltffi_version_minor() -> u32 {
    VERSION_MINOR
}

#[unsafe(no_mangle)]
pub extern "C" fn boltffi_version_patch() -> u32 {
    VERSION_PATCH
}

#[unsafe(no_mangle)]
pub extern "C" fn boltffi_free_string(string: FfiString) {
    drop(string);
}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn boltffi_last_error_message(out: *mut FfiString) -> FfiStatus {
    if out.is_null() {
        return FfiStatus::NULL_POINTER;
    }

    match take_last_error() {
        Some(message) => {
            unsafe { *out = FfiString::from(message) };
            FfiStatus::OK
        }
        None => {
            unsafe { *out = FfiString::from("") };
            FfiStatus::OK
        }
    }
}

#[unsafe(no_mangle)]
pub extern "C" fn boltffi_clear_last_error() {
    clear_last_error();
}

pub fn fail_with_error(status: FfiStatus, message: impl Into<String>) -> FfiStatus {
    set_last_error(message);
    status
}