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

pub trait MergerChunk: Region {
    type Data<'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::Data<'a>, Self::Time<'a>, Self::Diff<'a>);
}

Behavior to dissect items of chunks in the merge batcher

Required Associated Types

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

The data portion 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::Data<'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<D, T, R> MergerChunk for TupleABCRegion<D, T, R>

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

type Data<'a> = <D 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>( (data, time, diff): Self::ReadItem<'a>, ) -> (Self::Data<'a>, Self::Time<'a>, Self::Diff<'a>)

Implementors