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;
}

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.

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

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

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

Implementors