Struct SequentialFlow 

pub struct SequentialFlow<Input, Output, Error, Context, NodeTypes = (), NodeIOETypes = ()> { /* private fields */ }

SequentialFlow executes nodes sequentially, like a pipeline.

Nodes are executed sequentially like a pipeline where the output of one node is used as in input of the next node. Nodes are executed in order of insertion until all succeed or any node “hard” fails.

• If a node returns NodeOutput::Ok, that value is then fed into the next node.
• If a node returns NodeOutput::SoftFail, the flow soft-fails.
• If a node returns an error, then that error is returned.

Type Parameters

• Input: The type of data accepted by this flow.
• Output: The type of data produced by this flow.
• Error: The type of error emitted by this flow.
• Context: The type of context used during execution.

Examples

use node_flow::node::{Node, NodeOutput};
use node_flow::flows::SequentialFlow;

// Example node
#[derive(Clone)]
struct AddOne;

struct ExampleCtx;

impl<Ctx: Send> Node<u8, NodeOutput<u8>, (), Ctx> for AddOne {
    async fn run(&mut self, input: u8, _: &mut Ctx) -> Result<NodeOutput<u8>, ()> {
        Ok(NodeOutput::Ok(input + 1))
    }
}

async fn main() {
    let mut flow = SequentialFlow::<u8, u8, (), _>::builder()
        .add_node(AddOne)
        .add_node(AddOne)
        .add_node(AddOne)
        .build();

    let mut ctx = ExampleCtx;
    let result = flow.run(5u8, &mut ctx).await;
    assert_eq!(result, Ok(NodeOutput::Ok(8)));
}

Implementations

impl<Input, Output, Error, Context> SequentialFlow<Input, Output, Error, Context>

where Input: Send, Error: Send, Context: Send,

pub fn builder() -> Builder<Input, Output, Error, Context>

Creates a new Builder for constructing SequentialFlow.

See also SequentialFlow.

Examples

use node_flow::flows::SequentialFlow;

let builder = SequentialFlow::<u8, u16, (), Ctx>::builder();

Trait Implementations

impl<Input, Output, Error, Context, NodeTypes, NodeIOETypes> Clone for SequentialFlow<Input, Output, Error, Context, NodeTypes, NodeIOETypes>

where NodeTypes: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Input, Output, Error, Context, NodeTypes, NodeIOETypes> Debug for SequentialFlow<Input, Output, Error, Context, NodeTypes, NodeIOETypes>

where NodeTypes: ChainDebug,

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

Formats the value using the given formatter.

impl<Input, Output, Error, Context, NodeTypes, NodeIOETypes> Node<Input, NodeOutput<Output>, Error, Context> for SequentialFlow<Input, Output, Error, Context, NodeTypes, NodeIOETypes>

where NodeTypes: ChainRun<Input, Result<NodeOutput<Output>, Error>, Context, NodeIOETypes> + ChainDescribe<Context, NodeIOETypes>,

fn run( &mut self, input: Input, context: &mut Context, ) -> impl Future<Output = Result<NodeOutput<Output>, Error>> + Send

Runs the node.

fn describe(&self) -> Description

Describes this node, its type signature and other specifics.