Trait Node 

pub trait Node<Input> {
    type Output;

    // Required method
    fn process(&mut self, input: Input) -> Self::Output;

    // Provided methods
    fn reset(&mut self) { ... }
    fn data_remaining(&self, before: usize) -> usize { ... }
}

Required Associated Types

type Output

Required Methods

fn process(&mut self, input: Input) -> Self::Output

Process a batch of data

Provided Methods

fn reset(&mut self)

Reset signal propogates through pipeline

fn data_remaining(&self, before: usize) -> usize

Get number of examples left

Implementations on Foreign Types

impl<Input, M2: Node<M1::Output>, M1: Node<Input>> Node<Input> for (M1, M2)

type Output = <M2 as Node<<M1 as Node<Input>>::Output>>::Output

fn process(&mut self, x: Input) -> Self::Output

fn reset(&mut self)

fn data_remaining(&self, before: usize) -> usize

impl<Input, M3: Node<M2::Output>, M2: Node<M1::Output>, M1: Node<Input>> Node<Input> for (M1, M2, M3)

type Output = <M3 as Node<<M2 as Node<<M1 as Node<Input>>::Output>>::Output>>::Output

fn process(&mut self, x: Input) -> Self::Output

fn reset(&mut self)

fn data_remaining(&self, before: usize) -> usize

impl<Input, M4: Node<M3::Output>, M3: Node<M2::Output>, M2: Node<M1::Output>, M1: Node<Input>> Node<Input> for (M1, M2, M3, M4)

type Output = <M4 as Node<<M3 as Node<<M2 as Node<<M1 as Node<Input>>::Output>>::Output>>::Output>>::Output

fn process(&mut self, x: Input) -> Self::Output

fn reset(&mut self)

fn data_remaining(&self, before: usize) -> usize

impl<Input, M5: Node<M4::Output>, M4: Node<M3::Output>, M3: Node<M2::Output>, M2: Node<M1::Output>, M1: Node<Input>> Node<Input> for (M1, M2, M3, M4, M5)

type Output = <M5 as Node<<M4 as Node<<M3 as Node<<M2 as Node<<M1 as Node<Input>>::Output>>::Output>>::Output>>::Output>>::Output

fn process(&mut self, x: Input) -> Self::Output

fn reset(&mut self)

fn data_remaining(&self, before: usize) -> usize

impl<Input, M6: Node<M5::Output>, M5: Node<M4::Output>, M4: Node<M3::Output>, M3: Node<M2::Output>, M2: Node<M1::Output>, M1: Node<Input>> Node<Input> for (M1, M2, M3, M4, M5, M6)

type Output = <M6 as Node<<M5 as Node<<M4 as Node<<M3 as Node<<M2 as Node<<M1 as Node<Input>>::Output>>::Output>>::Output>>::Output>>::Output>>::Output

fn process(&mut self, x: Input) -> Self::Output

fn reset(&mut self)

fn data_remaining(&self, before: usize) -> usize

Implementors

impl Node<Vec<()>> for FileLoader

type Output = Vec<(PathBuf, Vec<u8>)>

impl Node<Vec<usize>> for KeyedLoader

type Output = Vec<String>

impl<I1, I2, N1: Node<I1>, N2: Node<I2>> Node<(I1, I2)> for Pair<I1, I2, N1, N2>

type Output = (<N1 as Node<I1>>::Output, <N2 as Node<I2>>::Output)

impl<I> Node<I> for Pipeline

type Output = I

impl<I, F: FnMut(&I) -> bool> Node<Vec<I>> for Filter<I, F>

type Output = Vec<I>

impl<I, K: Ord, V, O, Map: Fn(I) -> Vec<(K, V)>, Reduce: Fn((K, Vec<V>)) -> Vec<O>> Node<Vec<I>> for MapReduce<I, K, V, O, Map, Reduce>

type Output = Vec<O>

impl<I, O> Node<Vec<I>> for BalancedSelector<I, O>

type Output = Vec<O>

impl<I, O, F: FnMut(I) -> O> Node<I> for F

type Output = O

impl<I, O, N: Node<I, Output = Option<O>>> Node<Vec<I>> for FilterMap<I, N>

type Output = Vec<O>

impl<I, O, N: Node<I, Output = O>> Node<Vec<I>> for Map<I, N>

type Output = Vec<O>

impl<I, O, S, F: Fn(I, &mut S) -> O, R: Fn(usize) -> usize> Node<I> for Stateful<I, O, S, F, R>

type Output = O

impl<T> Node<Vec<T>> for Batch<T>

type Output = Vec<Vec<T>>

impl<T> Node<Vec<T>> for Shuffle<T>

type Output = Vec<T>

impl<T, F: Fn(&T, &T) -> Ordering> Node<Vec<T>> for Sort<T, F>

type Output = Vec<T>

impl<T: Clone> Node<T> for Duplicator<T>

type Output = (T, T)

impl<const B: usize, T> Node<Vec<T>> for ArrayBatch<B, T>

type Output = Vec<[T; B]>