Trait differential_dataflow::trace::implementations::merge_batcher_flat::MergerChunk

pub trait MergerChunk: Region {
    type Key<'a>: Ord
       where Self: 'a;
    type Val<'a>: Ord
       where Self: 'a;
    type Time<'a>: Ord
       where Self: 'a;
    type TimeOwned;
    type Diff<'a>
       where Self: 'a;
    type DiffOwned;

    // Required method
    fn into_parts<'a>(
        item: Self::ReadItem<'a>,
    ) -> (Self::Key<'a>, Self::Val<'a>, Self::Time<'a>, Self::Diff<'a>);
}

Behavior to dissect items of chunks in the merge batcher

Required Associated Types

type Key<'a>: Ord where Self: 'a

The key of the update

type Val<'a>: Ord where Self: 'a

The value of the update

type Time<'a>: Ord where Self: 'a

The time of the update

type TimeOwned

The owned time type.

type Diff<'a> where Self: 'a

The diff of the update

type DiffOwned

The owned diff type.

Required Methods

fn into_parts<'a>( item: Self::ReadItem<'a>, ) -> (Self::Key<'a>, Self::Val<'a>, Self::Time<'a>, Self::Diff<'a>)

Split a read item into its constituents. Must be cheap.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<K, V, T, R> MergerChunk for TupleABCRegion<TupleABRegion<K, V>, T, R>

where K: Region, for<'a> K::ReadItem<'a>: Ord, V: Region, for<'a> V::ReadItem<'a>: Ord, T: Region, for<'a> T::ReadItem<'a>: Ord, R: Region,

type Key<'a> = <K as Region>::ReadItem<'a> where Self: 'a

type Val<'a> = <V as Region>::ReadItem<'a> where Self: 'a

type Time<'a> = <T as Region>::ReadItem<'a> where Self: 'a

type TimeOwned = <T as Region>::Owned

type Diff<'a> = <R as Region>::ReadItem<'a> where Self: 'a

type DiffOwned = <R as Region>::Owned

fn into_parts<'a>( ((key, val), time, diff): Self::ReadItem<'a>, ) -> (Self::Key<'a>, Self::Val<'a>, Self::Time<'a>, Self::Diff<'a>)

Implementors