Trait MzArrangeCore 

pub trait MzArrangeCore<'scope> {
    type Timestamp: Timestamp + Lattice;
    type Container: Container + Clone + 'static;

    // Required method
    fn mz_arrange_core<P, Ba, Tr>(
        self,
        pact: P,
        name: &str,
    ) -> Arranged<'scope, TraceAgent<Tr>>
       where P: ParallelizationContract<Self::Timestamp, Self::Container>,
             Ba: Batcher<Self::Container, Time = Self::Timestamp> + BatcherNew + 'static,
             Ba::Output: Into<Tr::Batch>,
             Tr: Trace<Time = Self::Timestamp> + 'static,
             Arranged<'scope, TraceAgent<Tr>>: ArrangementSize;
}

Extension trait to arrange data.

Required Associated Types

type Timestamp: Timestamp + Lattice

The current scope.

type Container: Container + Clone + 'static

The container of updates to arrange.

Required Methods

fn mz_arrange_core<P, Ba, Tr>( self, pact: P, name: &str, ) -> Arranged<'scope, TraceAgent<Tr>>

where P: ParallelizationContract<Self::Timestamp, Self::Container>, Ba: Batcher<Self::Container, Time = Self::Timestamp> + BatcherNew + 'static, Ba::Output: Into<Tr::Batch>, Tr: Trace<Time = Self::Timestamp> + 'static, Arranged<'scope, TraceAgent<Tr>>: ArrangementSize,

Arranges a stream of (Key, Val) updates by Key into a trace of type Tr. Partitions the data according to pact.

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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'scope, T, C> MzArrangeCore<'scope> for Collection<'scope, T, C>

where T: Timestamp + Lattice, C: Container + Clone + 'static,

type Timestamp = T

type Container = C

fn mz_arrange_core<P, Ba, Tr>( self, pact: P, name: &str, ) -> Arranged<'scope, TraceAgent<Tr>>

where P: ParallelizationContract<T, C>, Ba: Batcher<C, Time = T> + BatcherNew + 'static, Ba::Output: Into<Tr::Batch>, Tr: Trace<Time = T> + 'static, Arranged<'scope, TraceAgent<Tr>>: ArrangementSize,

impl<'scope, T, C> MzArrangeCore<'scope> for Stream<'scope, T, C>

where T: Timestamp + Lattice, C: Container + Clone + 'static,

type Timestamp = T

type Container = C

fn mz_arrange_core<P, Ba, Tr>( self, pact: P, name: &str, ) -> Arranged<'scope, TraceAgent<Tr>>

where P: ParallelizationContract<T, C>, Ba: Batcher<C, Time = T> + BatcherNew + 'static, Ba::Output: Into<Tr::Batch>, Tr: Trace<Time = T> + 'static, Arranged<'scope, TraceAgent<Tr>>: ArrangementSize,

Implementors

impl<'scope, T, K, R> MzArrangeCore<'scope> for KeyCollection<'scope, T, K, R>

where T: Timestamp + Lattice, K: Clone + 'static, R: Clone + 'static,

type Timestamp = T

type Container = Vec<((K, ()), T, R)>