Struct StopToken 

pub struct StopToken { /* private fields */ }

A shared-ownership Stop implementation with cheap Clone.

Wraps any Stop in an Arc for shared ownership across threads. Cloning is an atomic increment — no heap allocation.

Indirection Collapsing

StopToken::new() detects when you pass another StopToken and unwraps it instead of double-wrapping. No-op stops (Unstoppable) are stored as None — check() short-circuits without any vtable dispatch.

Example

use almost_enough::{StopToken, Stopper, Stop, StopReason};

let stopper = Stopper::new();
let stop = StopToken::new(stopper.clone());
let stop2 = stop.clone(); // cheap Arc clone

stopper.cancel();
assert!(stop.should_stop());
assert!(stop2.should_stop()); // both see cancellation

Implementations

impl StopToken

pub fn new<T: Stop + 'static>(stop: T) -> Self

Create a new StopToken from any Stop implementation.

If stop is already a StopToken, it is unwrapped instead of double-wrapping (no extra indirection).

pub fn from_arc<T: Stop + 'static>(arc: Arc<T>) -> Self

Create a StopToken from an existing Arc<T> without re-wrapping.

use almost_enough::{StopToken, Stopper, Stop};
use std::sync::Arc;

let stopper = Arc::new(Stopper::new());
let stop = StopToken::from_arc(stopper);
assert!(!stop.should_stop());

Trait Implementations

impl Clone for StopToken

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StopToken

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

Formats the value using the given formatter.

impl From<Stopper> for StopToken

Zero-cost conversion: reuses the Stopper’s Arc. Direct atomic dispatch, no vtable.

fn from(stopper: Stopper) -> Self

Converts to this type from the input type.

impl From<SyncStopper> for StopToken

Zero-cost conversion: reuses the SyncStopper’s Arc. Direct atomic dispatch.

fn from(stopper: SyncStopper) -> Self

Converts to this type from the input type.

impl Stop for StopToken

fn check(&self) -> Result<(), StopReason>

Check if the operation should stop.

fn should_stop(&self) -> bool

Returns true if the operation should stop.

fn may_stop(&self) -> bool

Returns true if this stop can ever signal a stop.