Struct timely::dataflow::operators::input::Handle

pub struct Handle<T: Timestamp, D: Data> { /* fields omitted */ }

A handle to an input Stream, used to introduce data to a timely dataflow computation.

Methods

impl<T: Timestamp, D: Data> Handle<T, D>

pub fn new() -> Self

Allocates a new input handle, from which one can create timely streams.

Examples

use timely::*;
use timely::dataflow::operators::{Input, Inspect};
use timely::dataflow::operators::input::Handle;

// construct and execute a timely dataflow
timely::execute(Configuration::Thread, |worker| {

    // add an input and base computation off of it
    let mut input = Handle::new();
    worker.dataflow(|scope| {
        scope.input_from(&mut input)
             .inspect(|x| println!("hello {:?}", x));
    });

    // introduce input, advance computation
    for round in 0..10 {
        input.send(round);
        input.advance_to(round + 1);
        worker.step();
    }
});

pub fn to_stream<G: Scope>(&mut self, scope: &mut G) -> Stream<G, D> where
    T: TotalOrder,
    G: ScopeParent<Timestamp = T>, 

Creates an input stream from the handle in the supplied scope.

Examples

use timely::*;
use timely::dataflow::operators::{Input, Inspect};
use timely::dataflow::operators::input::Handle;

// construct and execute a timely dataflow
timely::execute(Configuration::Thread, |worker| {

    // add an input and base computation off of it
    let mut input = Handle::new();
    worker.dataflow(|scope| {
        input.to_stream(scope)
             .inspect(|x| println!("hello {:?}", x));
    });

    // introduce input, advance computation
    for round in 0..10 {
        input.send(round);
        input.advance_to(round + 1);
        worker.step();
    }
});

pub fn send(&mut self, data: D)

Sends one record into the corresponding timely dataflow Stream, at the current epoch.

pub fn send_batch(&mut self, buffer: &mut Vec<D>)

Sends a batch of records into the corresponding timely dataflow Stream, at the current epoch.

This method flushes single elements previously sent with send, to keep the insertion order.

pub fn advance_to(&mut self, next: T)

Advances the current epoch to next.

This method allows timely dataflow to issue progress notifications as it can now determine that this input can no longer produce data at earlier timestamps.

pub fn close(self)

Closes the input.

This method allows timely dataflow to issue all progress notifications blocked by this input and to begin to shut down operators, as this input can no longer produce data.

pub fn epoch(&self) -> &T

Reports the current epoch.

pub fn time(&self) -> &T

Reports the current timestamp.

Trait Implementations

impl<T: Timestamp, D: Data> Drop for Handle<T, D>

fn drop(&mut self)

Executes the destructor for this type.