Trait Step 

pub trait Step<Input, B>
where
    B: BackendExt,
{
    type Response;
    type Error;

    // Required method
    fn register(
        &mut self,
        router: &mut WorkflowRouter<B>,
    ) -> Result<(), BoxDynError>;
}

A workflow step

A single unit of work in a workflow pipeline.

Required Associated Types

type Response

The response type produced by the step.

type Error

The error type produced by the step.

Required Methods

fn register( &mut self, router: &mut WorkflowRouter<B>, ) -> Result<(), BoxDynError>

Register the step with the workflow router.

Implementors

impl<F, Input, S, B, CodecError, SinkError> Step<Input, B> for AndThenStep<F, S>

where B: BackendExt<Error = SinkError> + Send + Sync + 'static + Clone + Sink<Task<B::Compact, B::Context, B::IdType>, Error = SinkError> + Unpin, F: Service<Task<Input, B::Context, B::IdType>, Error = BoxDynError> + Send + 'static + Clone, S: Step<F::Response, B>, Input: Send + 'static, F::Future: Send + 'static, F::Error: Into<BoxDynError> + Send + 'static, B::Codec: Codec<F::Response, Error = CodecError, Compact = B::Compact> + Codec<Input, Error = CodecError, Compact = B::Compact> + Codec<S::Response, Error = CodecError, Compact = B::Compact> + 'static, CodecError: Error + Send + Sync + 'static, B::IdType: GenerateId + Send + 'static, S::Response: Send + 'static, B::Compact: Send + 'static, B::Context: Send + MetadataExt<WorkflowContext> + 'static, SinkError: Error + Send + Sync + 'static, F::Response: Send + 'static,

type Response = <F as Service<Task<Input, <B as Backend>::Context, <B as Backend>::IdType>>>::Response

type Error = <F as Service<Task<Input, <B as Backend>::Context, <B as Backend>::IdType>>>::Error

impl<F, Input, S, B, CodecError, SinkError, I, Output, MetaErr, IdType> Step<I, B> for FilterMapStep<F, S, I>

where I: IntoIterator<Item = Input> + Send + 'static, B: BackendExt<Error = SinkError, IdType = IdType> + Send + Sync + 'static + Clone + Sink<Task<B::Compact, B::Context, IdType>, Error = SinkError> + WaitForCompletion<GoTo<StepResult<B::Compact, IdType>>> + Unpin, F: Service<Task<Input, B::Context, IdType>, Error = BoxDynError, Response = Option<Output>> + Send + 'static + Clone, S: Step<Vec<Output>, B>, Input: Send + 'static, F::Future: Send + 'static, F::Error: Into<BoxDynError> + Send + 'static, B::Codec: Codec<F::Response, Error = CodecError, Compact = B::Compact> + Codec<Input, Error = CodecError, Compact = B::Compact> + 'static + Codec<Vec<Input>, Error = CodecError, Compact = B::Compact> + Codec<I, Error = CodecError, Compact = B::Compact> + Codec<Vec<Output>, Error = CodecError, Compact = B::Compact>, CodecError: Error + Send + Sync + 'static, B::IdType: GenerateId + Send + 'static + Clone, S::Response: Send + 'static, B::Compact: Send + 'static, B::Context: Send + MetadataExt<WorkflowContext> + MetadataExt<FilterState> + MetadataExt<FilterContext<B::IdType>> + 'static + MetadataExt<WorkflowContext, Error = MetaErr> + MetadataExt<FilterContext<B::IdType>, Error = MetaErr> + Sync, SinkError: Error + Send + Sync + 'static, F::Response: Send + 'static, MetaErr: Error + Send + Sync + 'static, Output: Send + 'static,

type Response = Vec<<F as Service<Task<Input, <B as Backend>::Context, IdType>>>::Response>

type Error = <F as Service<Task<Input, <B as Backend>::Context, IdType>>>::Error

impl<Input, B, S, Err> Step<Input, B> for DelayForStep<S>

where B::IdType: GenerateId + Send + 'static, B::Compact: Send + 'static, B: Sink<Task<B::Compact, B::Context, B::IdType>, Error = Err> + Unpin + Send + Sync + Clone + 'static + BackendExt, Err: Error + Send + Sync + 'static, S: Clone + Send + 'static + Step<Input, B>, S::Response: Send + 'static, B::Codec: Codec<Duration, Compact = B::Compact> + Codec<Input, Compact = B::Compact> + 'static, <B::Codec as Codec<Duration>>::Error: Into<BoxDynError>, B::Context: Send + 'static + MetadataExt<WorkflowContext>, Input: Send + 'static, <B::Codec as Codec<Input>>::Error: Into<BoxDynError>,

type Response = Input

type Error = Box<dyn Error + Sync + Send>

impl<Input, Current, B: BackendExt> Step<Input, B> for RootStep<Current>

type Response = Current

type Error = Box<dyn Error + Sync + Send>

impl<Input, F, B, S, Err> Step<Input, B> for DelayWithStep<S, F, B, Input>

where F: FnMut(Task<Input, B::Context, B::IdType>) -> Duration + Send + 'static + Clone, B::IdType: GenerateId + Send + 'static, B::Compact: Send + 'static, B: Sink<Task<B::Compact, B::Context, B::IdType>, Error = Err> + Unpin + Send + Sync + Clone + 'static + BackendExt, Err: Error + Send + Sync + 'static, S: Clone + Send + 'static + Step<Input, B>, S::Response: Send + 'static, B::Codec: Codec<Duration, Compact = B::Compact> + Codec<Input, Compact = B::Compact> + 'static, <B::Codec as Codec<Duration>>::Error: Into<BoxDynError>, B::Context: Send + 'static + MetadataExt<WorkflowContext>, Input: Send + 'static, <B::Codec as Codec<Input>>::Error: Into<BoxDynError>,

type Response = Input

type Error = Box<dyn Error + Sync + Send>

impl<S, F, Input, I, Init, B, MetaErr, Err, CodecError> Step<I, B> for FoldStep<S, F, Init>

where F: Service<Task<(Init, Input), B::Context, B::IdType>, Response = Init> + Send + 'static + Clone, S: Step<Init, B>, B: BackendExt<Error = Err> + Send + Sync + Clone + Sink<Task<B::Compact, B::Context, B::IdType>, Error = Err> + Unpin + 'static, I: IntoIterator<Item = Input> + Send + 'static, B::Context: MetadataExt<FoldState, Error = MetaErr> + MetadataExt<WorkflowContext, Error = MetaErr> + Send + 'static, B::Codec: Codec<(Init, Vec<Input>), Error = CodecError, Compact = B::Compact> + Codec<Init, Error = CodecError, Compact = B::Compact> + Codec<I, Error = CodecError, Compact = B::Compact> + Codec<(Init, Input), Error = CodecError, Compact = B::Compact> + 'static, B::IdType: GenerateId + Send + 'static + Clone, Init: Default + Send + 'static, Err: Error + Send + Sync + 'static, CodecError: Error + Send + Sync + 'static, F::Error: Into<BoxDynError> + Send + 'static, MetaErr: Error + Send + Sync + 'static, F::Future: Send + 'static, B::Compact: Send + 'static, Input: Send + 'static,

type Response = Init

type Error = <F as Service<Task<(Init, Input), <B as Backend>::Context, <B as Backend>::IdType>>>::Error