Trait dataflow::pipeline::Node

pub trait Node {
    type Input;
    type Output;
    fn process(&mut self, input: Vec<Self::Input>) -> Vec<Self::Output>;

    fn reset(&mut self) { ... }
    fn data_remaining(&self) -> usize { ... }
    fn add_node<N: Node<Input = Self::Output>>(
        self, 
        node: N
    ) -> Connector<Self, N>
    where
        Self: Sized,
    { ... }
    fn add_batch_fn<O, F: Fn(Vec<Self::Output>) -> Vec<O>>(
        self, 
        function: F
    ) -> Connector<Self, BatchStateless<Self::Output, O, F>>
    where
        Self: Sized,
    { ... }
    fn add_fn<O, F: Fn(Self::Output) -> O + Send + Sync>(
        self, 
        function: F
    ) -> Connector<Self, SingleStateless<Self::Output, O, F>>
    where
        Self: Sized,
    { ... }
    fn split<N3: Node<Input = Self::Output>, N4: Node<Input = Self::Output>>(
        self, 
        node1: N3, 
        node2: N4
    ) -> Connector<Connector<Self, Duplicator<Self::Output>>, Pair<N3, N4>>
    where
        Self: Sized,
        Self::Output: Clone,
    { ... }
    fn pair<O1, O2, N3: Node<Input = O1>, N4: Node<Input = O2>>(
        self, 
        node1: N3, 
        node2: N4
    ) -> Connector<Self, Pair<N3, N4>>
    where
        Self: Sized,
        Self: Node<Output = (O1, O2)>,
    { ... }
}

Associated Types

type Input

type Output

Required methods

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

Process a batch of data

Provided methods

fn reset(&mut self)

Reset signal propogates through pipeline

fn data_remaining(&self) -> usize

Get number of examples left

fn add_node<N: Node<Input = Self::Output>>(self, node: N) -> Connector<Self, N> where
    Self: Sized, 

fn add_batch_fn<O, F: Fn(Vec<Self::Output>) -> Vec<O>>(
    self,
    function: F
) -> Connector<Self, BatchStateless<Self::Output, O, F>> where
    Self: Sized, 

Add function to pipeline

fn add_fn<O, F: Fn(Self::Output) -> O + Send + Sync>(
    self,
    function: F
) -> Connector<Self, SingleStateless<Self::Output, O, F>> where
    Self: Sized, 

Add function that takes a single datapoint and outputs a single datapoint

fn split<N3: Node<Input = Self::Output>, N4: Node<Input = Self::Output>>(
    self,
    node1: N3,
    node2: N4
) -> Connector<Connector<Self, Duplicator<Self::Output>>, Pair<N3, N4>> where
    Self: Sized,
    Self::Output: Clone, 

fn pair<O1, O2, N3: Node<Input = O1>, N4: Node<Input = O2>>(
    self,
    node1: N3,
    node2: N4
) -> Connector<Self, Pair<N3, N4>> where
    Self: Sized,
    Self: Node<Output = (O1, O2)>, 

Implementations on Foreign Types

impl<I, O> Node for fn(_: Vec<I>) -> Vec<O>

type Input = I

type Output = O

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

Implementors

impl Node for FileLoader

type Input = ()

type Output = Vec<u8>

impl Node for KeyedLoader

type Input = usize

type Output = String

impl Node for RandomLoader

type Input = ()

type Output = String

impl<I, O, F: Fn(Vec<I>) -> Vec<O>> Node for BatchStateless<I, O, F>

type Input = I

type Output = O

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

type Input = I

type Output = O

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

type Input = I

type Output = O

impl<N1: Node, N2: Node> Node for Pair<N1, N2>

type Input = (N1::Input, N2::Input)

type Output = (N1::Output, N2::Output)

impl<N1: Node, N2: Node<Input = N1::Output>> Node for Connector<N1, N2>

type Input = N1::Input

type Output = N2::Output

impl<T> Node for Batch<T>

type Input = T

type Output = Vec<T>

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

type Input = T

type Output = T

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

type Input = T

type Output = (T, T)