Struct SplitUntilContinuation 

pub struct SplitUntilContinuation<I: TaskIterator> { /* private fields */ }

Continuation branch from split_collect_until().

Wraps the original iterator, copying items to the observer queue until the predicate is met. When predicate returns true, that item is sent and the queue is closed (observer completes).

Trait Implementations

impl<I> Drop for SplitUntilContinuation<I>

where I: TaskIterator,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<I> TaskIterator for SplitUntilContinuation<I>

where I: TaskIterator, I::Ready: Clone + 'static, I::Pending: Clone + 'static,

type Ready = <I as TaskIterator>::Ready

The type that indicates when a single or partial sequence is what can be considered a intermediate and final result is.

type Pending = <I as TaskIterator>::Pending

The type to indicate pending operation, either can be a time::Duration to communicate time to completion or some other type you wish to allow communication of the state of things before the Done signal is received.

fn next_status( &mut self, ctx: Ctx, ) -> Option<TaskStatus<Self::Ready, Self::Pending>>

Advances the iterator and returns the next value.

fn with_ctx(self, ctx: Ctx) -> TaskAsIterator<Self::Ready, Self::Pending>

where Self: Sized + 'static, Self::Ready: 'static, Self::Pending: 'static,

Wraps this task in the contextual orchestrator, TaskAsIterator, seeding it with ctx.