Trait differential_dataflow::operators::arrange::arrangement::Arrange

pub trait Arrange<G: Scope, K, V, R: Semigroup> where
    G::Timestamp: Lattice,
    K: Data,
    V: Data, {
    fn arrange_core<P, Tr>(
        &self, 
        pact: P, 
        name: &str
    ) -> Arranged<G, TraceAgent<Tr>>
    where
        P: ParallelizationContract<G::Timestamp, ((K, V), G::Timestamp, R)>,
        Tr: Trace + TraceReader<Key = K, Val = V, Time = G::Timestamp, R = R> + 'static,
        Tr::Batch: Batch<K, V, G::Timestamp, R>,
        Tr::Cursor: Cursor<K, V, G::Timestamp, R>;

    fn arrange<Tr>(&self) -> Arranged<G, TraceAgent<Tr>>
    where
        K: ExchangeData + Hashable,
        V: ExchangeData,
        R: ExchangeData,
        Tr: Trace + TraceReader<Key = K, Val = V, Time = G::Timestamp, R = R> + 'static,
        Tr::Batch: Batch<K, V, G::Timestamp, R>,
        Tr::Cursor: Cursor<K, V, G::Timestamp, R>,
    { ... }
    fn arrange_named<Tr>(&self, name: &str) -> Arranged<G, TraceAgent<Tr>>
    where
        K: ExchangeData + Hashable,
        V: ExchangeData,
        R: ExchangeData,
        Tr: Trace + TraceReader<Key = K, Val = V, Time = G::Timestamp, R = R> + 'static,
        Tr::Batch: Batch<K, V, G::Timestamp, R>,
        Tr::Cursor: Cursor<K, V, G::Timestamp, R>,
    { ... }
}

A type that can be arranged into a trace of type T.

This trait is implemented for appropriately typed collections and all traces that might accommodate them, as well as by arranged data for their corresponding trace type.

Required methods

fn arrange_core<P, Tr>(
    &self,
    pact: P,
    name: &str
) -> Arranged<G, TraceAgent<Tr>> where
    P: ParallelizationContract<G::Timestamp, ((K, V), G::Timestamp, R)>,
    Tr: Trace + TraceReader<Key = K, Val = V, Time = G::Timestamp, R = R> + 'static,
    Tr::Batch: Batch<K, V, G::Timestamp, R>,
    Tr::Cursor: Cursor<K, V, G::Timestamp, R>, 

Arranges a stream of (Key, Val) updates by Key. Accepts an empty instance of the trace type.

This operator arranges a stream of values into a shared trace, whose contents it maintains. This trace is current for all times marked completed in the output stream, and probing this stream is the correct way to determine that times in the shared trace are committed.

Loading content...

Provided methods

fn arrange<Tr>(&self) -> Arranged<G, TraceAgent<Tr>> where
    K: ExchangeData + Hashable,
    V: ExchangeData,
    R: ExchangeData,
    Tr: Trace + TraceReader<Key = K, Val = V, Time = G::Timestamp, R = R> + 'static,
    Tr::Batch: Batch<K, V, G::Timestamp, R>,
    Tr::Cursor: Cursor<K, V, G::Timestamp, R>, 

Arranges a stream of (Key, Val) updates by Key. Accepts an empty instance of the trace type.

This operator arranges a stream of values into a shared trace, whose contents it maintains. This trace is current for all times marked completed in the output stream, and probing this stream is the correct way to determine that times in the shared trace are committed.

fn arrange_named<Tr>(&self, name: &str) -> Arranged<G, TraceAgent<Tr>> where
    K: ExchangeData + Hashable,
    V: ExchangeData,
    R: ExchangeData,
    Tr: Trace + TraceReader<Key = K, Val = V, Time = G::Timestamp, R = R> + 'static,
    Tr::Batch: Batch<K, V, G::Timestamp, R>,
    Tr::Cursor: Cursor<K, V, G::Timestamp, R>, 

Arranges a stream of (Key, Val) updates by Key. Accepts an empty instance of the trace type.

This operator arranges a stream of values into a shared trace, whose contents it maintains. This trace is current for all times marked completed in the output stream, and probing this stream is the correct way to determine that times in the shared trace are committed.

Loading content...

Implementors

impl<G, K, V, R> Arrange<G, K, V, R> for Collection<G, (K, V), R> where
    G: Scope,
    G::Timestamp: Lattice + Ord,
    K: ExchangeData + Hashable,
    V: ExchangeData,
    R: Semigroup + ExchangeData, 

fn arrange_core<P, Tr>(
    &self,
    pact: P,
    name: &str
) -> Arranged<G, TraceAgent<Tr>> where
    P: ParallelizationContract<G::Timestamp, ((K, V), G::Timestamp, R)>,
    Tr: Trace + TraceReader<Key = K, Val = V, Time = G::Timestamp, R = R> + 'static,
    Tr::Batch: Batch<K, V, G::Timestamp, R>,
    Tr::Cursor: Cursor<K, V, G::Timestamp, R>, 

impl<G: Scope, K: ExchangeData + Hashable, R: ExchangeData + Semigroup> Arrange<G, K, (), R> for Collection<G, K, R> where
    G::Timestamp: Lattice + Ord, 

fn arrange_core<P, Tr>(
    &self,
    pact: P,
    name: &str
) -> Arranged<G, TraceAgent<Tr>> where
    P: ParallelizationContract<G::Timestamp, ((K, ()), G::Timestamp, R)>,
    Tr: Trace + TraceReader<Key = K, Val = (), Time = G::Timestamp, R = R> + 'static,
    Tr::Batch: Batch<K, (), G::Timestamp, R>,
    Tr::Cursor: Cursor<K, (), G::Timestamp, R>, 

Loading content...