Trait 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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so 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