Trait differential_dataflow::trace::implementations::BuilderInput

pub trait BuilderInput<K: BatchContainer, V: BatchContainer>: Container {
    type Key<'a>: Ord;
    type Val<'a>: Ord;
    type Time;
    type Diff;

    // Required methods
    fn into_parts<'a>(
        item: Self::Item<'a>,
    ) -> (Self::Key<'a>, Self::Val<'a>, Self::Time, Self::Diff);
    fn key_eq(this: &Self::Key<'_>, other: K::ReadItem<'_>) -> bool;
    fn val_eq(this: &Self::Val<'_>, other: V::ReadItem<'_>) -> bool;
    fn key_val_upd_counts(chain: &[Self]) -> (usize, usize, usize);
}

Behavior to split an update into principal components.

Required Associated Types

type Key<'a>: Ord

Key portion

type Val<'a>: Ord

Value portion

type Time

Time

type Diff

Diff

Required Methods

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

Split an item into separate parts.

fn key_eq(this: &Self::Key<'_>, other: K::ReadItem<'_>) -> bool

Test that the key equals a key in the layout’s key container.

fn val_eq(this: &Self::Val<'_>, other: V::ReadItem<'_>) -> bool

Test that the value equals a key in the layout’s value container.

fn key_val_upd_counts(chain: &[Self]) -> (usize, usize, usize)

Count the number of distinct keys, (key, val) pairs, and total updates.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<K, KBC, V, VBC, T, R> BuilderInput<KBC, VBC> for FlatStack<TupleABCRegion<TupleABRegion<K, V>, T, R>>

where K: Region + Clone + 'static, V: Region + Clone + 'static, T: Region + Clone + 'static, R: Region + Clone + 'static, for<'a> K::ReadItem<'a>: Copy + Ord, for<'a> V::ReadItem<'a>: Copy + Ord, for<'a> T::ReadItem<'a>: Copy + Ord, for<'a> R::ReadItem<'a>: Copy + Ord, KBC: BatchContainer, VBC: BatchContainer, for<'a> KBC::ReadItem<'a>: PartialEq<K::ReadItem<'a>>, for<'a> VBC::ReadItem<'a>: PartialEq<V::ReadItem<'a>>,

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

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

type Time = <T as Region>::Owned

type Diff = <R as Region>::Owned

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

fn key_eq(this: &Self::Key<'_>, other: KBC::ReadItem<'_>) -> bool

fn val_eq(this: &Self::Val<'_>, other: VBC::ReadItem<'_>) -> bool

fn key_val_upd_counts(chain: &[Self]) -> (usize, usize, usize)

impl<K, KBC, V, VBC, T, R> BuilderInput<KBC, VBC> for Vec<((K, V), T, R)>

where K: Ord + Clone + 'static, KBC: BatchContainer, for<'a> KBC::ReadItem<'a>: PartialEq<&'a K>, V: Ord + Clone + 'static, VBC: BatchContainer, for<'a> VBC::ReadItem<'a>: PartialEq<&'a V>, T: Timestamp + Lattice + Clone + 'static, R: Ord + Semigroup + 'static,

type Key<'a> = K

type Val<'a> = V

type Time = T

type Diff = R

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

fn key_eq(this: &K, other: KBC::ReadItem<'_>) -> bool

fn val_eq(this: &V, other: VBC::ReadItem<'_>) -> bool

fn key_val_upd_counts(chain: &[Self]) -> (usize, usize, usize)

impl<K, V, T, R> BuilderInput<K, V> for TimelyStack<((K::Owned, V::Owned), T, R)>

where K: BatchContainer, for<'a> K::ReadItem<'a>: PartialEq<&'a K::Owned>, K::Owned: Ord + Columnation + Clone + 'static, V: BatchContainer, for<'a> V::ReadItem<'a>: PartialEq<&'a V::Owned>, V::Owned: Ord + Columnation + Clone + 'static, T: Timestamp + Lattice + Columnation + Clone + 'static, R: Ord + Clone + Semigroup + Columnation + 'static,

type Key<'a> = &'a <K as BatchContainer>::Owned

type Val<'a> = &'a <V as BatchContainer>::Owned

type Time = T

type Diff = R

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

fn key_eq(this: &&K::Owned, other: K::ReadItem<'_>) -> bool

fn val_eq(this: &&V::Owned, other: V::ReadItem<'_>) -> bool

fn key_val_upd_counts(chain: &[Self]) -> (usize, usize, usize)

Implementors