Struct Stage

pub struct Stage<T: Flows> { /* private fields */ }

Group of data processors sharing a FlowSubscriber.

Implementations

impl<T: Flows> Stage<T>

pub fn flow(&self) -> Flow<T>

Returns a Flow handle connected to the stage.

pub fn add_proc<D>(&mut self, proc: impl Procs<D>)

where T: TryAsFormat<D>,

Adds a new processor to the stage.

proc may accept any data type T which the flow’s data D can be “tried as”. proc will only be invoked for data in the flow which is successfully interperable as D .

pub fn proc(&mut self) -> Result<u64, Error>

Invokes each processor at least once if the flow is active and data is available, returning the number of data processed.

pub async fn proc_loop(self)

Runs Self::proc in an infinite loop.

When the flow is idle, async_support::yield_now will be invoked to temporarily yield execution back to the async runtime. Invoke Self::proc_loop_with_waiter instead of this function to use a different waiter.

pub async fn proc_loop_with_waiter<W, Fut>(self, waiter: W)

where W: Fn() -> Fut, Fut: Future<Output = ()>,

Runs Self::proc in an infinite loop, calling waiter when the flow is idle.

Calling this function with an async runtime’s “native” yield function can improve throughput by ~50% or more (as compared to Self::proc_loop).

On Tokio runtimes, it’s highly recommended to call this function with tokio::task::yield_now.

Trait Implementations

impl<T: Flows> From<FlowSubscriber<T>> for Stage<T>

fn from(value: FlowSubscriber<T>) -> Self

Converts to this type from the input type.