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

pub trait Arrange<G, K, V, R>
where
    G: Scope,
    G::Timestamp: Lattice,
{
    // Required method
    fn arrange_core<P, Tr>(
        &self,
        pact: P,
        name: &str
    ) -> Arranged<G, TraceAgent<Tr>>
       where P: ParallelizationContract<G::Timestamp, ((K, V), G::Timestamp, R)>,
             K: Clone,
             V: Clone,
             R: Clone,
             Tr: Trace<Time = G::Timestamp> + 'static,
             Tr::Batch: Batch,
             Tr::Batcher: Batcher<Item = ((K, V), G::Timestamp, R), Time = G::Timestamp>,
             Tr::Builder: Builder<Item = ((K, V), G::Timestamp, R), Time = G::Timestamp, Output = Tr::Batch>;

    // Provided methods
    fn arrange<Tr>(&self) -> Arranged<G, TraceAgent<Tr>>
       where Tr: Trace<Time = G::Timestamp> + 'static,
             K: ExchangeData + Hashable,
             V: ExchangeData,
             R: ExchangeData,
             Tr::Batch: Batch,
             Tr::Batcher: Batcher<Item = ((K, V), G::Timestamp, R), Time = G::Timestamp>,
             Tr::Builder: Builder<Item = ((K, V), G::Timestamp, R), Time = G::Timestamp, Output = Tr::Batch> { ... }
    fn arrange_named<Tr>(&self, name: &str) -> Arranged<G, TraceAgent<Tr>>
       where Tr: Trace<Time = G::Timestamp> + 'static,
             K: ExchangeData + Hashable,
             V: ExchangeData,
             R: ExchangeData,
             Tr::Batch: Batch,
             Tr::Batcher: Batcher<Item = ((K, V), G::Timestamp, R), Time = G::Timestamp>,
             Tr::Builder: Builder<Item = ((K, V), G::Timestamp, R), Time = G::Timestamp, Output = Tr::Batch> { ... }
}

A type that can be arranged as if a collection of updates shaped as ((K,V),G::Timestamp,R).

This trait is primarily implemented by Collection<G,(K,V),R>.

The resulting arrangements may not present as ((K,V),T,R), as their output types are unconstrained. This allows e.g. for Vec<u8> inputs to present as &[u8] when read, but that relationship is not constrained by this trait.

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)>, K: Clone, V: Clone, R: Clone, Tr: Trace<Time = G::Timestamp> + 'static, Tr::Batch: Batch, Tr::Batcher: Batcher<Item = ((K, V), G::Timestamp, R), Time = G::Timestamp>, Tr::Builder: Builder<Item = ((K, V), G::Timestamp, R), Time = G::Timestamp, Output = Tr::Batch>,

Arranges a stream of (Key, Val) updates by Key, configured with a name and a parallelization contract.

This operator arranges a stream of values into a shared trace, whose contents it maintains. It uses the supplied parallelization contract to distribute the data, which does not need to be consistently by key (though this is the most common).

Provided Methods

fn arrange<Tr>(&self) -> Arranged<G, TraceAgent<Tr>>

where Tr: Trace<Time = G::Timestamp> + 'static, K: ExchangeData + Hashable, V: ExchangeData, R: ExchangeData, Tr::Batch: Batch, Tr::Batcher: Batcher<Item = ((K, V), G::Timestamp, R), Time = G::Timestamp>, Tr::Builder: Builder<Item = ((K, V), G::Timestamp, R), Time = G::Timestamp, Output = Tr::Batch>,

Arranges a stream of (Key, Val) updates by Key.

This operator arranges a stream of values into a shared trace, whose contents it maintains.

fn arrange_named<Tr>(&self, name: &str) -> Arranged<G, TraceAgent<Tr>>

where Tr: Trace<Time = G::Timestamp> + 'static, K: ExchangeData + Hashable, V: ExchangeData, R: ExchangeData, Tr::Batch: Batch, Tr::Batcher: Batcher<Item = ((K, V), G::Timestamp, R), Time = G::Timestamp>, Tr::Builder: Builder<Item = ((K, V), G::Timestamp, R), Time = G::Timestamp, Output = Tr::Batch>,

Arranges a stream of (Key, Val) updates by Key, and presents with a name argument.

This operator arranges a stream of values into a shared trace, whose contents it maintains.

Object Safety

This trait is not object safe.

Implementors

impl<G, K, V, R> Arrange<G, K, V, R> for Collection<G, (K, V), R>

where G: Scope, G::Timestamp: Lattice, K: Clone + 'static, V: Clone + 'static, R: Semigroup,

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

where G::Timestamp: Lattice + Ord,