Struct BatchNode

pub struct BatchNode<C: Context, N: Node<C>> {
    pub node: N,
    pub batch_size: usize,
    /* private fields */
}

A node adapter that runs an inner node on a batch of inputs, collecting outputs in parallel

Fields

node: N

batch_size: usize

Implementations

impl<C: Context, N: Node<C>> BatchNode<C, N>

pub fn new(node: N, batch_size: usize) -> Self

Wraps an existing node into a batch adapter with a batch size

impl<C: Context, N: Node<C>> BatchNode<C, N>

pub async fn process_batch( &self, ctx: C, inputs: <Self as Node<C>>::Input, ) -> Result<<Self as Node<C>>::Output, FloxideError>

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,

Process a batch of inputs, where the associated Input/Output types are Vecs

Trait Implementations

impl<C: Clone + Context, N: Clone + Node<C>> Clone for BatchNode<C, N>

fn clone(&self) -> BatchNode<C, N>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug + Context, N: Debug + Node<C>> Debug for BatchNode<C, N>

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

Formats the value using the given formatter.

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>

Input type for the node

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

Output type produced by the node

fn process<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 C, inputs: 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