Struct Workflow 

pub struct Workflow<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> Workflow<Start, Cur, B, L>

where B: BackendExt,

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

where TaskFn<F, Cur, B::Context, FnArgs>: Service<Task<Cur, B::Context, B::IdType>, 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> Workflow<Start, Cur, B, L>

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

Delay the workflow by a fixed duration

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

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

Delay the workflow by a duration determined by a function

impl<Start, C, L, I: IntoIterator<Item = C>, B: BackendExt> Workflow<Start, I, B, L>

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

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

Adds a filter and map step to the workflow.

impl<Start, C, L, I: IntoIterator<Item = C>, B: BackendExt> Workflow<Start, I, B, L>

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

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

Folds over a collection of items in the workflow.

impl<Start, Backend> Workflow<Start, Start, Backend>

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

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

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

Adds a new step to the workflow pipeline.

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

where S: Step<Cur, B>, L: Layer<S>, B: BackendExt,

Finalizes the workflow by attaching a root step.

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

where B: BackendExt,

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 Workflow<Start, Current, Backend, T>

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

Formats the value using the given formatter.

impl<Input, Output, Current, B, Compact, Err, L> IntoWorkerService<B, WorkflowService<B, Output>, Compact, <B as Backend>::Context> for Workflow<Input, Current, B, L>

where B: BackendExt<Compact = Compact> + Send + Sync + 'static + Sink<Task<Compact, B::Context, B::IdType>, Error = Err> + Unpin + Clone + Backend<Args = Compact, Error = Err>, Err: Error + Send + Sync + 'static, B::Context: MetadataExt<WorkflowContext> + Send + Sync + 'static, B::IdType: Send + 'static + Default + GenerateId, B::Compact: Send + Sync + 'static, <B::Context as MetadataExt<WorkflowContext>>::Error: Into<BoxDynError>, L: Layer<RootStep<Current>>, L::Step: Step<Output, B>,

type Backend = RawDataBackend<B>

The backend type for the worker

fn into_service( self, b: B, ) -> WorkerService<RawDataBackend<B>, WorkflowService<B, Output>>

Build the service from the backend