Struct ThreadBoundRunner

pub struct ThreadBoundRunner<ThreadState> {
    call_channel_tx: Sender<CallRequest<ThreadState>>,
}

A runner that takes a non-Send, non-Sync state and makes it Send + Sync compatible.

ThreadBoundRunner is designed to safely encapsulate a !Send + !Sync state object by pinning it to a single thread using spawn_local. It provides a Send + Sync API that allows other threads to submit tasks (function pointers or closures) that operate on the thread-bound state.

Tasks are queued via an internal channel and are executed sequentially on the owning thread.

Example

let runner = ThreadBoundRunner::new(my_state);

runner.run_in_thread(|state| async move {
    // do something with `state`
});

This pattern is useful for interacting with APIs or data structures that must remain on the same thread, such as GUI toolkits, WebAssembly contexts, or other thread-bound environments.

Fields

call_channel_tx: Sender<CallRequest<ThreadState>>

Implementations

impl<ThreadState> ThreadBoundRunner<ThreadState>

where ThreadState: 'static,

pub fn new(state: ThreadState) -> Self

pub async fn run_in_thread<F, Fut, Output>( &self, function: F, ) -> Result<Output, CallError>

where F: FnOnce(Rc<ThreadState>) -> Fut + Send + 'static, Fut: Future<Output = Output>, Output: Send + Sync + 'static,

Submit a task to be executed on the thread-bound state.

The provided function is executed on the thread that owns the internal ThreadState, ensuring safe access to !Send + !Sync data. Tasks are dispatched in the order they are received, but because they are asynchronous, multiple tasks may be in-flight and running concurrently if their futures yield.

Returns

A future that resolves to the result of the function once it has been executed.

Trait Implementations

impl<ThreadState: Clone> Clone for ThreadBoundRunner<ThreadState>

fn clone(&self) -> ThreadBoundRunner<ThreadState>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.