Struct WithStop 

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

Adds or replaces a pulse’s checkpoint policy, including through descendants.

Borrowed policies need no allocation and accept a local &dyn Stop. They cannot outlive that borrow: Pulse::share returns PlanError::NotShareable. Use an owned policy with Self::new or Self::replacing for spawned workers. Scoped workers can borrow this adapter directly.

Replacement bypasses the inner check entirely, including its callbacks. Reporting, planning, ownership and completion still reach the inner pulse. Combining is usually appropriate when adding a library-local cancellation source.

Implementations

impl<'a> WithStop<'a>

pub fn new(inner: &'a dyn Pulse, stop: impl Stop + 'static) -> Self

Check the inner policy, then stop. Both remain attached to descendants.

pub fn borrowed(inner: &'a dyn Pulse, stop: &'a dyn Stop) -> Self

Combine policies without owning or allocating the additional stop source.

pub fn replacing(inner: &'a dyn Pulse, stop: impl Stop + 'static) -> Self

Use only stop for checkpoints, bypassing the inner stop and callbacks.

pub fn replacing_borrowed(inner: &'a dyn Pulse, stop: &'a dyn Stop) -> Self

Replace checkpoints with a borrowed policy; see Self::replacing.

Trait Implementations

impl ChildPulse for WithStop<'_>

fn complete_inferred(self: Box<Self>, outcome: Outcome)

Resolve an untouched phase from its enclosing result. The default uses ordinary completion; trackers can retain the inference as evidence.

fn complete_as(self: Box<Self>, outcome: Outcome)

Complete best-effort observation. Trackers may infer untouched descendants from this result; the default preserves older implementors’ finish logic.

fn finish(self: Box<Self>, outcome: Outcome) -> Result<(), PlanError>

Publish this child’s terminal outcome.

impl Pulse for WithStop<'_>

fn record_issue(&self, error: PlanError)

Record a reporting-protocol problem for optional diagnostics. This never changes cancellation or the operation’s return value. Ordinary sinks may ignore it; diagnostic wrappers retain bounded evidence.

fn split( &self, e: Execution, parts: &[PhaseSpec<'_>], ) -> Result<Vec<Child<'_>>, PlanError>

Split this phase into weighted children, in declared order.

fn share(&self) -> Result<SharedPulse, PlanError>

Share all pulse capabilities with owned work, but never completion rights.

fn start(&self) -> Result<(), PlanError>

Mark this phase running, without counting or ending planning. Implementations without lifecycle observations may ignore this.

fn set_total(&self, total: Total) -> Result<(), PlanError>

Revise a leaf’s denominator without changing completed units or weights. Unsupported implementations return an error instead of losing the update.

impl Report for WithStop<'_>

fn advance(&self, n: u64)

Add completed finished units.

fn may_report(&self) -> bool

Whether reports have any effect.

impl Stop for WithStop<'_>

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

Check if the operation should stop.

fn may_stop(&self) -> bool

Returns true if this stop can ever signal a stop.

fn should_stop(&self) -> bool

Returns true if the operation should stop.