Struct ParallelFlow 

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

ParallelFlow executes nodes (branches) in parallel.

Nodes (branches) are executed concurrently. The flow completes when all node succeed or any node “hard” fails.

• If a node returns NodeOutput::Ok or NodeOutput::SoftFail, the flow continues waiting for other nodes (branches).
• If a node returns an error, then that error is returned.

The output of all nodes is then passed into a Joiner, which decides what should happen and what should this flow return.

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.

See also Joiner.

Examples

use node_flow::node::{Node, NodeOutput};
use node_flow::flows::ParallelFlow;
use node_flow::context::{Fork, Join};

// Example nodes
#[derive(Clone)]
struct A;
#[derive(Clone)]
struct B;

struct ExampleCtx;
impl Fork for ExampleCtx // ...
impl Join for ExampleCtx // ...

impl<Ctx: Send> Node<(), NodeOutput<i32>, (), Ctx> for A {
    async fn run(&mut self, _: (), _: &mut Ctx) -> Result<NodeOutput<i32>, ()> {
        Ok(NodeOutput::SoftFail)
    }
}

impl<Ctx: Send> Node<(), NodeOutput<i32>, (), Ctx> for B {
    async fn run(&mut self, _: (), _: &mut Ctx) -> Result<NodeOutput<i32>, ()> {
        Ok(NodeOutput::Ok(5))
    }
}

async fn main() {
    let mut flow = ParallelFlow::<(), i32, (), _>::builder()
        .add_node(A)
        .add_node(B)
        .build(async |_input, context: &mut ExampleCtx| {
            Ok(NodeOutput::Ok(120))
        });

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

Implementations

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

where Input: Send + Clone, Error: Send, Context: Fork + Join + Send,

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

Creates a new Builder for constructing ParallelFlow.

See also ParallelFlow.

Examples

use node_flow::flows::ParallelFlow;

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

Trait Implementations

impl<Input, Output, Error, Context, ChainRunOutput, J, NodeTypes, NodeIOETypes> Clone for ParallelFlow<Input, Output, Error, Context, ChainRunOutput, J, NodeTypes, NodeIOETypes>

where J: 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, ChainRunOutput, J, NodeTypes, NodeIOETypes> Debug for ParallelFlow<Input, Output, Error, Context, ChainRunOutput, J, NodeTypes, NodeIOETypes>

where NodeTypes: ChainDebug,

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

Formats the value using the given formatter.

impl<Input, Output, Error, Context, ChainRunOutput, J, NodeTypes, NodeIOETypes> Node<Input, NodeOutput<Output>, Error, Context> for ParallelFlow<Input, Output, Error, Context, ChainRunOutput, J, NodeTypes, NodeIOETypes>

where Input: Send, Context: Send, for<'a> J: Joiner<'a, ChainRunOutput, Output, Error, Context>, NodeTypes: ChainRun<Input, Result<ChainRunOutput, Error>, Context, NodeIOETypes> + ChainDescribe<Context, NodeIOETypes> + Send + Sync,

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.