Struct CallbackOnce

pub struct CallbackOnce<T: 'static>(/* private fields */);

Type-erased one-shot callback.

Use this to wrap an FnOnce closure into a data structure that may be passed via a c_void pointer as user data to an external library. Later, when this extern callback is run with that data, we may unwrap it and can thus call our initial closure.

The implementation uses associated methods:

• CallbackOnce::prepare() to wrap the closure and get the c_void pointer
• CallbackOnce::execute() to unwrap the c_void pointer and call the closure

Examples

use open62541::CallbackOnce;
use std::{cell::Cell, rc::Rc};

let cell = Rc::new(Cell::new(0));

// Turn `tx` into type-erased void pointer for FFI.
let raw_data: *mut c_void = CallbackOnce::<u32>::prepare({
    let cell = Rc::clone(&cell);
    move |value| {
        cell.set(value);
    }
});

// Use type-erased pointer to call closure.
unsafe { CallbackOnce::<u32>::execute(raw_data, 123); }

// Value has been received.
assert_eq!(cell.get(), 123);

Implementations

impl<T> CallbackOnce<T>

pub fn prepare<F>(f: F) -> *mut c_void

where F: FnOnce(T) + 'static,

Prepares closure for later call.

This allocates memory. To prevent memory leaks, call execute() on the returned pointer exactly once.

pub unsafe fn execute(data: *mut c_void, payload: T)

Unwraps c_void pointer and calls closure.

Safety

The given pointer must have been returned from prepare() and must not have been passed into execute() yet.

The value type T must be the same as in prepare().

Trait Implementations

impl<T: Debug + 'static> Debug for CallbackOnce<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.