Struct SteppedFlow 

pub struct SteppedFlow<Start, Current, Backend, T = Identity> { /* private fields */ }

A workflow represents a sequence of steps to be executed in order.

Implementations

impl<Start, Cur, B, L> SteppedFlow<Start, Cur, B, L>

where B: Backend,

pub fn and_then<F, O, FnArgs>( self, and_then: F, ) -> SteppedFlow<Start, O, B, Stack<AndThen<TaskFn<F, Cur, FnArgs>>, L>>

where TaskFn<F, Cur, FnArgs>: Service<Task<Cur>, Response = O>,

Adds a transformation step to the workflow that processes the output of the previous step.

The and_then method allows you to chain operations by providing a function that takes the result of the current workflow step and transforms it into the input for the next step. This enables building complex processing pipelines with type-safe transformations between steps.

Example

workflow
    .and_then(extract)
    .and_then(transform)
    .and_then(load);

impl<Start, Cur, B, L> SteppedFlow<Start, Cur, B, L>

pub fn delay_for( self, delay: Duration, ) -> SteppedFlow<Start, Cur, B, Stack<DelayFor, L>>

Delay the workflow by a fixed duration

impl<Start, Cur, B, L> SteppedFlow<Start, Cur, B, L>

pub fn delay_with<F>( self, f: F, ) -> SteppedFlow<Start, Cur, B, Stack<DelayWith<F, B, Cur>, L>>

where F: FnMut(Task<Cur>) -> Duration + Send + 'static,

Delay the workflow by a duration determined by a function

impl<Start, C, L, I: IntoIterator<Item = C>, B: Backend> SteppedFlow<Start, I, B, L>

pub fn filter_map<F, Output, FnArgs>( self, filter_map: F, ) -> SteppedFlow<Start, Vec<Output>, B, Stack<FilterMap<TaskFn<F, C, FnArgs>, I>, L>>

where TaskFn<F, C, FnArgs>: Service<Task<C>, Response = Option<Output>>,

Adds a filter and map step to the workflow.

impl<Start, C, L, I: IntoIterator<Item = C>, B: Backend> SteppedFlow<Start, I, B, L>

pub fn fold<F, Output, FnArgs, Init>( self, fold: F, ) -> SteppedFlow<Start, Output, B, Stack<Fold<TaskFn<F, (Init, C), FnArgs>, Init>, L>>

where TaskFn<F, (Init, C), FnArgs>: Service<Task<(Init, C)>, Response = Output>,

Folds over a collection of items in the workflow.

impl<Start, L, Input, B: Backend> SteppedFlow<Start, Input, B, L>

pub fn repeat_until<F, Output, FnArgs>( self, repeater: F, ) -> SteppedFlow<Start, Output, B, Stack<RepeatUntil<TaskFn<F, Input, FnArgs>, Input, Output>, L>>

where TaskFn<F, Input, FnArgs>: Service<Task<Input>, Response = Option<Output>>,

Folds over a collection of items in the workflow.

impl<Start, Backend> SteppedFlow<Start, Start, Backend>

pub fn new(name: &str) -> Self

impl<Start, Cur, B, L> SteppedFlow<Start, Cur, B, L>

pub fn add_step<S, Output>( self, step: S, ) -> SteppedFlow<Start, Output, B, Stack<S, L>>

Adds a new step to the workflow pipeline.

This method should be used with caution, as it allows adding arbitrary steps and manipulating types. It is recommended to use higher-level abstractions for common workflow patterns.

pub fn finalize<S>(self, root: S) -> SteppedFlow<Start, Cur, B, L::Step>

where S: Step<Cur, B>, L: Layer<S>, B: Backend + WireFormatBackend,

Finalizes the workflow by attaching a root step.

impl<Start, Cur, B, L> SteppedFlow<Start, Cur, B, L>

where B: Backend,

pub fn build<N>(self) -> L::Step

where L: Layer<RootStep<N>>,

Builds the workflow by layering the root step.

Trait Implementations

impl<Start: Debug, Current: Debug, Backend: Debug, T: Debug> Debug for SteppedFlow<Start, Current, Backend, T>

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

Formats the value using the given formatter.

impl<Input, Output, Current, B, Compact, L, Err> IntoWorkerService<B, WorkflowService<B, Input, Output>> for SteppedFlow<Input, Current, B, L>

where B: Backend<Task = Task<Compact>, Error = Err> + WireFormatBackend<Compact = Compact> + BackendConfig<Args = Input> + Send + Sync + 'static + Sink<Task<Compact>, Error = Err> + Clone + Unpin, B::Id: Send + 'static + Default + GenerateId, L: Layer<RootStep<Current>>, L::Step: Step<Output, B>, B::Codec: Clone, Err: Error + Send + Sync + 'static, Compact: Send + 'static,

type Task = Task<Compact>

The task type processed by the worker.

type Backend = WorkflowBackend<B>

The backend type used by the worker service.

fn into_service( self, backend: B, ) -> WorkerService<Self::Backend, WorkflowService<B, Input, Output>>

Builds a worker service from the provided backend.