Struct WorkerPump 

pub struct WorkerPump<T> {
    capacity: usize,
    drain_logs_each_tick: bool,
    _marker: PhantomData<fn() -> T>,
}

Runs a worker thread in parallel with a main-thread pump loop.

See the module documentation for the longjmp-safety contract and a usage example.

Fields

capacity: usize

Capacity of the bounded MPSC channel between worker and pump.

drain_logs_each_tick: bool

Whether to drain the cross-thread log queue on every pump tick.

_marker: PhantomData<fn() -> T>

Implementations

impl<T: Send + 'static> WorkerPump<T>

pub fn new() -> Self

Create a new WorkerPump with default settings.

Defaults:

• channel capacity: 64
• drain_logs_each_tick: true

pub fn channel_capacity(self, n: usize) -> Self

Set the capacity of the bounded MPSC channel.

The default is 64. A larger capacity allows the worker to get further ahead of the pump; a capacity of 0 makes every send synchronous (rendezvous channel).

When the channel is full the worker blocks on tx.send until the pump drains a slot. If the pump panics or a longjmp fires, rx is dropped as part of scope unwinding, which unblocks tx.send with an Err and lets the worker exit cleanly.

pub fn drain_logs_each_tick(self, on: bool) -> Self

Control whether the cross-thread log queue is drained on every pump tick.

Default: true. Set to false if the consumer manages its own log drain cadence (e.g. it calls drain_log_queue() explicitly at coarser granularity).

Has no effect when the log feature is disabled.

pub fn run<R, W, P>(self, worker: W, pump: P) -> Result<R, WorkerError>

where R: Send, W: FnOnce(SyncSender<T>) -> Result<R, WorkerError> + Send, P: FnMut(T),

Run the worker/pump pair and return the worker’s result.

• worker runs on a scoped background thread. It receives a SyncSender<T> and sends messages to the pump. When worker returns (success or error) it should drop tx; the pump’s receive loop then terminates naturally.
• pump is called on the current (main R) thread for every message the worker sends.

run returns Ok(R) on success, or Err if the worker returned an error or panicked.

Panics

If the worker thread panics, run returns Err("WorkerPump worker panicked").

If the pump closure panics, the panic propagates normally through thread::scope’s Drop (which joins the worker), and then out of run. When called from inside an #[miniextendr] body the outer R_UnwindProtect catches it and converts it to an R error.

Trait Implementations

impl<T: Send + 'static> Default for WorkerPump<T>

fn default() -> Self

Returns the “default value” for a type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes