Trait Node

pub trait Node<C: Context = ()>: Send + Sync {
    type Input: Send + Sync;
    type Output: Send + Sync;

    // Required method
    fn process<'life0, 'life1, 'async_trait>(
        &'life0 self,
        ctx: &'life1 C,
        input: Self::Input,
    ) -> Pin<Box<dyn Future<Output = Result<Transition<Self::Output>, FloxideError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
}

A node takes an input and a context, and returns a transition.

Required Associated Types

type Input: Send + Sync

Input type for the node

type Output: Send + Sync

Output type produced by the node

Required Methods

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

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

Process an input value within the given context, producing a transition

Implementors

impl<C, I, O, F> Node<C> for SplitNode<I, O, F>

where C: Context, I: Send + Sync + 'static, O: Send + Sync + 'static, F: Fn(I) -> Vec<O> + Send + Sync,

type Input = I

type Output = O

impl<C, N> Node<C> for BatchNode<C, N>

where C: Context + 'static, N: Node<C> + Clone + Send + Sync + 'static, <N as Node<C>>::Input: Clone + Send + 'static, <N as Node<C>>::Output: Send + 'static,

type Input = Vec<<N as Node<C>>::Input>

type Output = Vec<<N as Node<C>>::Output>

impl<C, N> Node<C> for RetryNode<N>

where C: Context + RetryDelay, N: Node<C> + Clone + Send + Sync + 'static, N::Input: Clone + Send + 'static, N::Output: Send + 'static,

type Input = <N as Node<C>>::Input

type Output = <N as Node<C>>::Output

impl<C, W> Node<C> for CompositeNode<C, W>

where C: Serialize + DeserializeOwned + Debug + Clone + Send + Sync + Context, W: Workflow<C> + Clone + Send + Sync, W::Input: Send + Sync, W::Output: Send + Sync,

type Input = <W as Workflow<C>>::Input

type Output = <W as Workflow<C>>::Output