Struct KeyedSingleton 

pub struct KeyedSingleton<K, V, Loc, Bound: KeyedSingletonBound> { /* private fields */ }

Implementations

impl<'a, K, V, L: Location<'a>, B: KeyedSingletonBound<ValueBound = Bounded>> KeyedSingleton<K, V, L, B>

pub fn entries( self, ) -> Stream<(K, V), L, B::UnderlyingBound, NoOrder, ExactlyOnce>

pub fn values(self) -> Stream<V, L, B::UnderlyingBound, NoOrder, ExactlyOnce>

pub fn keys(self) -> Stream<K, L, B::UnderlyingBound, NoOrder, ExactlyOnce>

pub fn filter_key_not_in<O2, R2>( self, other: Stream<K, L, Bounded, O2, R2>, ) -> Self

where K: Hash + Eq,

pub fn inspect<F>( self, f: impl IntoQuotedMut<'a, F, L> + Copy, ) -> KeyedSingleton<K, V, L, B>

where F: Fn(&V) + 'a,

pub fn inspect_with_key<F>( self, f: impl IntoQuotedMut<'a, F, L>, ) -> KeyedSingleton<K, V, L, B>

where F: Fn(&(K, V)) + 'a,

pub fn into_keyed_stream( self, ) -> KeyedStream<K, V, L, B::UnderlyingBound, TotalOrder, ExactlyOnce>

impl<'a, K, V, L: Location<'a>, B: KeyedSingletonBound> KeyedSingleton<K, V, L, B>

pub fn map<U, F>( self, f: impl IntoQuotedMut<'a, F, L> + Copy, ) -> KeyedSingleton<K, U, L, B>

where F: Fn(V) -> U + 'a,

pub fn map_with_key<U, F>( self, f: impl IntoQuotedMut<'a, F, L> + Copy, ) -> KeyedSingleton<K, U, L, B>

where F: Fn((K, V)) -> U + 'a, K: Clone,

pub fn filter<F>( self, f: impl IntoQuotedMut<'a, F, L> + Copy, ) -> KeyedSingleton<K, V, L, B>

where F: Fn(&V) -> bool + 'a,

pub fn filter_map<F, U>( self, f: impl IntoQuotedMut<'a, F, L> + Copy, ) -> KeyedSingleton<K, U, L, B>

where F: Fn(V) -> Option<U> + 'a,

pub fn key_count(self) -> Singleton<usize, L, B::UnderlyingBound>

pub fn ir_node_named(self, name: &str) -> KeyedSingleton<K, V, L, B>

An operator which allows you to “name” a HydroNode. This is only used for testing, to correlate certain HydroNodes with IDs.

impl<'a, K, V, L: Location<'a>> KeyedSingleton<K, V, Tick<L>, Bounded>

pub fn latest(self) -> KeyedSingleton<K, V, L, Unbounded>

impl<'a, K: Hash + Eq, V, L: Location<'a>> KeyedSingleton<K, V, Tick<L>, Bounded>

pub fn get( self, key: Singleton<K, Tick<L>, Bounded>, ) -> Optional<V, Tick<L>, Bounded>

Gets the value associated with a specific key from the keyed singleton.

Example

let tick = process.tick();
let keyed_data = process
    .source_iter(q!(vec![(1, 2), (2, 3)]))
    .into_keyed()
    .batch(&tick, nondet!(/** test */))
    .fold(q!(|| 0), q!(|acc, x| *acc = x));
let key = tick.singleton(q!(1));
keyed_data.get(key).all_ticks()
// 2

pub fn get_many_if_present<O2, R2, V2>( self, requests: KeyedStream<K, V2, Tick<L>, Bounded, O2, R2>, ) -> KeyedStream<K, (V, V2), Tick<L>, Bounded, NoOrder, R2>

Given a keyed stream of lookup requests, where the key is the lookup and the value is some additional metadata, emits a keyed stream of lookup results where the key is the same as before, but the value is a tuple of the lookup result and the metadata of the request. If the key is not found, no output will be produced.

Example

let tick = process.tick();
let keyed_data = process
    .source_iter(q!(vec![(1, 10), (2, 20)]))
    .into_keyed()
    .batch(&tick, nondet!(/** test */))
    .fold(q!(|| 0), q!(|acc, x| *acc = x));
let other_data = process
    .source_iter(q!(vec![(1, 100), (2, 200), (1, 101)]))
    .into_keyed()
    .batch(&tick, nondet!(/** test */));
keyed_data.get_many_if_present(other_data).entries().all_ticks()
// { 1: [(10, 100), (10, 101)], 2: [(20, 200)] } in any order

pub fn get_from<V2: Clone>( self, from: KeyedSingleton<V, V2, Tick<L>, Bounded>, ) -> KeyedSingleton<K, (V, Option<V2>), Tick<L>, Bounded>

where K: Clone, V: Hash + Eq + Clone,

impl<'a, K, V, L, B: KeyedSingletonBound> KeyedSingleton<K, V, L, B>

where L: Location<'a> + NoTick + NoAtomic,

pub fn atomic(self, tick: &Tick<L>) -> KeyedSingleton<K, V, Atomic<L>, B>

pub fn snapshot( self, tick: &Tick<L>, nondet: NonDet, ) -> KeyedSingleton<K, V, Tick<L>, Bounded>

Given a tick, returns a keyed singleton with a entries consisting of keys with snapshots of the value singleton.

Non-Determinism

Because this picks a snapshot of each singleton whose value is continuously changing, the output singleton has a non-deterministic value since each snapshot can be at an arbitrary point in time.

impl<'a, K, V, L, B: KeyedSingletonBound<ValueBound = Bounded>> KeyedSingleton<K, V, L, B>

where L: Location<'a> + NoTick + NoAtomic,

pub fn batch( self, tick: &Tick<L>, nondet: NonDet, ) -> KeyedSingleton<K, V, Tick<L>, Bounded>

Returns a keyed singleton with entries consisting of new key-value pairs that have arrived since the previous batch was released.

Non-Determinism

Because this picks a batch of asynchronously added entries, each output keyed singleton has a non-deterministic set of key-value pairs.

impl<'a, K, V, L, B: KeyedSingletonBound> KeyedSingleton<K, V, Atomic<L>, B>

where L: Location<'a> + NoTick + NoAtomic,

pub fn snapshot(self, _nondet: NonDet) -> KeyedSingleton<K, V, Tick<L>, Bounded>

Returns a keyed singleton with a entries consisting of keys with snapshots of the value singleton being atomically processed.

Non-Determinism

Because this picks a snapshot of each singleton whose value is continuously changing, each output singleton has a non-deterministic value since each snapshot can be at an arbitrary point in time.

pub fn end_atomic(self) -> KeyedSingleton<K, V, L, B>

impl<'a, K, V, L, B: KeyedSingletonBound<ValueBound = Bounded>> KeyedSingleton<K, V, Atomic<L>, B>

where L: Location<'a> + NoTick + NoAtomic,

pub fn batch(self, nondet: NonDet) -> KeyedSingleton<K, V, Tick<L>, Bounded>

Returns a keyed singleton with entries consisting of new key-value pairs that have arrived since the previous batch was released.

Non-Determinism

Because this picks a batch of asynchronously added entries, each output keyed singleton has a non-deterministic set of key-value pairs.

Trait Implementations

impl<'a, K: Clone, V: Clone, Loc: Location<'a>, Bound: KeyedSingletonBound> Clone for KeyedSingleton<K, V, Loc, Bound>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, K, V, L, B: KeyedSingletonBound> CycleCollection<'a, ForwardRefMarker> for KeyedSingleton<K, V, L, B>

where L: Location<'a> + NoTick,

type Location = L

fn create_source(ident: Ident, location: L) -> Self

impl<'a, K, V, L, B: KeyedSingletonBound> CycleComplete<'a, ForwardRefMarker> for KeyedSingleton<K, V, L, B>

where L: Location<'a> + NoTick,

fn complete(self, ident: Ident, expected_location: LocationId)