Struct LaneControl 

pub struct LaneControl<'a> { /* private fields */ }

A cancellation capability shared by a coordinator and its lanes.

The executor creates one control per run and lends it to the coordinator and to every lane, so cancellation is visible in both directions: a coordinator that stops feeding work cancels the lanes, and an executor that observes a lane failure cancels the coordinator. Cancellation is a request: already running callback code is not stopped.

An adapter bridges its own cancellation state into the control it observes and must treat LaneControl::cancelled as a request to stop feeding work. A backend whose own executor can stop a run without reaching a lane callback (a failed child-session entry, for example) lends the side that waits on cancellation a LaneControl::with_probe view of the same control, so that wait also observes the backend’s stop signal.

Example

use hataori::LaneControl;

let control = LaneControl::new();
assert!(!control.cancelled());
control.cancel();
assert!(control.cancelled());

A probe view shares the same cancellation flag and adds an external signal:

use hataori::LaneControl;
use std::sync::atomic::{AtomicBool, Ordering};

let control = LaneControl::new();
let backend_stopped = AtomicBool::new(false);
let probe = || backend_stopped.load(Ordering::Acquire);
let probed = control.with_probe(&probe);
assert!(!probed.cancelled());
backend_stopped.store(true, Ordering::Release);
assert!(probed.cancelled());
assert!(!control.cancelled(), "the probe is not an own-flag cancellation");
probed.cancel();
assert!(control.cancelled(), "views share one cancellation flag");

Implementations

impl LaneControl<'static>

pub const fn new() -> Self

Creates an un-cancelled control that owns its cancellation flag.

impl<'a> LaneControl<'a>

pub fn with_probe(&'a self, probe: &'a (dyn Fn() -> bool + Sync)) -> Self

Returns a view of this control that also reports probe as cancelled.

The view shares this control’s cancellation flag, so a lane and a coordinator cannot diverge on an ordinary cancel; the probe only adds a stop signal the executor owns. LaneControl::cancelled is evaluated as own flag first and then the probe, so a probe must be cheap and non-blocking.

pub fn cancelled(&self) -> bool

Returns whether cancellation has been requested.

pub fn cancel(&self)

Requests cancellation. This never blocks and never stops running code.

Trait Implementations

impl Debug for LaneControl<'_>

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

Formats the value using the given formatter.

impl Default for LaneControl<'static>

fn default() -> Self

Returns the “default value” for a type.