Struct ParallelNode 

pub struct ParallelNode<I, O, C>
where
    I: Clone + Send + Sync,
    O: Send + Sync,
    C: Send + Sync,
{
    pub nodes: Vec<Box<dyn Node<Input = I, Output = O> + Send + Sync>>,
    pub function: Box<dyn Fn(Vec<O>) -> BoxFuture<'static, Result<C, AnchorChainError>> + Send + Sync>,
}

A node that processes input through multiple nodes in parallel.

The ParallelNode struct represents a node that processes input through multiple nodes in parallel. The output of each node is then combined using a provided function to produce the final output.

Fields

nodes: Vec<Box<dyn Node<Input = I, Output = O> + Send + Sync>>

The nodes that will process the input in parallel.

function: Box<dyn Fn(Vec<O>) -> BoxFuture<'static, Result<C, AnchorChainError>> + Send + Sync>

The function to process the output of the nodes.

Implementations

impl<I, O, C> ParallelNode<I, O, C>

where I: Clone + Send + Sync, O: Send + Sync, C: Send + Sync,

pub fn new( nodes: Vec<Box<dyn Node<Input = I, Output = O> + Send + Sync>>, function: Box<dyn Fn(Vec<O>) -> BoxFuture<'static, Result<C, AnchorChainError>> + Send + Sync>, ) -> Self

Creates a new ParallelNode with the provided nodes and combination function.

The combination function can be defined using the helper function to_boxed_future.

Example

// Using PassThroughNode as an example node

use anchor_chain::{
    node::NoOpNode,
    parallel_node::ParallelNode,
    parallel_node::to_boxed_future
};

#[tokio::main]
async fn main() {
    let node1 = Box::new(NoOpNode::new());
    let node2 = Box::new(NoOpNode::new());
    let concat_fn = to_boxed_future(|outputs: Vec<String>| {
        Ok(outputs
           .iter()
           .enumerate()
           .map(|(i, output)| format!("Output {}:\n```\n{}\n```\n", i + 1, output))
           .collect::<Vec<String>>()
           .concat())
    });
    let parallel_node = ParallelNode::new(vec![node1, node2], concat_fn);
}

Trait Implementations

impl<I, O, C> Debug for ParallelNode<I, O, C>

where I: Debug + Clone + Send + Sync, O: Debug + Send + Sync, C: Debug + Send + Sync,

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

Formats the value using the given formatter.

impl<I, O, C> Node for ParallelNode<I, O, C>

where I: Clone + Send + Sync + Debug, O: Send + Sync + Debug, C: Send + Sync + Debug,

fn process<'life0, 'async_trait>( &'life0 self, input: Self::Input, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, AnchorChainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Processes the given input through nodes in parallel.

The input is processed by each node in parallel, and the results are combined using the provided function to produce the final output.

type Input = I

The input type for the node.

type Output = C

The output type for the node.