Struct anchor_chain::chain::Chain

pub struct Chain<I, O, L> { /* private fields */ }

Represents a chain of nodes that can asynchronously process data.

Chain is constructed from a sequence of Node instances, each taking an input and producing an output. The output of one node serves as the input to the next, allowing for a flexible and composable approach to complex asynchronous processing tasks.

Implementations

impl<I, O, L> Chain<I, O, L>

where L: Node<Input = I, Output = O> + Send + Sync + Debug, I: Debug, O: Debug,

pub fn new(link: L) -> Self

Creates a new Chain from the provided initial link.

Link serves as a container for chaining two Node instances together, where the output of the first node is fed as the input to the next. These links can be nested to create a chain of nodes.

pub async fn process(&self, input: I) -> Result<O, AnchorChainError>

Asynchronously processes the provided input through the chain of nodes.

The input is processed by each node in the chain, with the output of one node serving as the input to the next. The final output of the chain is returned. If any node in the chain returns an error, the processing is halted and the error is returned.

Trait Implementations

impl<I: Debug, O: Debug, L: Debug> Debug for Chain<I, O, L>

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

Formats the value using the given formatter.

impl<I, O, L> Node for Chain<I, O, L>

where L: Node<Input = I, Output = O> + Send + Sync + Debug, I: Debug + Send + Sync, O: Debug + Send + Sync,

type Input = I

The input type for the node.

type Output = O

The output type for the node.

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,

Asynchronously processes the given input, returning the output. When chained together the output type of one node must match the input of the next node in the chain.