Struct OneOfParallelFlow 

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

OneOfParallelFlow executes nodes (branches) in parallel, returning when one succeeds or fails.

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

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

If all nodes (branches) soft-fail, the flow itself returns NodeOutput::SoftFail.

This flow allows defining race-style execution, where multiple branches are ran in parallel and the first one to complete determines the returned value.

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::OneOfParallelFlow;
use node_flow::context::{Fork, Update};

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

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

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

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

async fn main() {
    let mut flow = OneOfParallelFlow::<(), i32, (), _>::builder()
        .add_node(A)
        .add_node(B)
        .build();

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

Implementations

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

where Input: Send + Clone, Output: Send, Error: Send, Context: Fork + Update + Send,

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

Creates a new Builder for constructing OneOfParallelFlow.

See also OneOfParallelFlow.

Examples

use node_flow::flows::OneOfParallelFlow;

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

Trait Implementations

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

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 OneOfParallelFlow<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 OneOfParallelFlow<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.