Struct VecChunk 

pub struct VecChunk<K, V, T, R>(/* private fields */);

A sorted, consolidated run of ((key, val), time, diff), shared via Rc.

Trait Implementations

impl<K: 'static, V: 'static, T: 'static, R: 'static> Accountable for VecChunk<K, V, T, R>

fn record_count(&self) -> i64

The number of records

fn is_empty(&self) -> bool

Determine if this contains any updates, corresponding to update_count() == 0. It is a correctness error for this to be anything other than self.record_count() == 0.

impl<K, V, T, R> Chunk for VecChunk<K, V, T, R>

where K: Ord + Clone + 'static, V: Ord + Clone + 'static, T: Lattice + Timestamp, R: Ord + Semigroup + 'static,

fn merge( in1: &mut VecDeque<Self>, in2: &mut VecDeque<Self>, out: &mut VecDeque<Self>, )

A two-pointer binary merge of the two deques’ loaded content, up to their shared horizon — the lesser of the two last (key, val, time)s. Consolidates equal triples and bulk-copies disjoint runs as slices, walking chunk boundaries with local indices. The horizon’s owner drains fully; the other’s partial front is pruned and pushed back once, at the yield.

fn settle(input: &mut VecDeque<Self>, done: bool, out: &mut VecDeque<Self>)

Maximal packing via the harness pack: coalesce by extending the inner Vec in place (make_mut is free while the carry’s Rc is unique, so packing a run of small chunks stays linear), split with split_off, and seal as a no-op (Vec chunks are never paged).

const TARGET: usize = TARGET

The intended maximum chunk size.

type Time = <<Vector<((K, V), T, R)> as Layout>::TimeContainer as BatchContainer>::Owned

The timestamp type of the chunk’s updates.

fn len(&self) -> usize

The number of updates in the chunk.

fn extract( input: &mut VecDeque<Self>, frontier: AntichainRef<'_, T>, residual: &mut Antichain<T>, keep: &mut VecDeque<Self>, ship: &mut VecDeque<Self>, )

Partition input updates into keep (greater or equal frontier) or not (ship).

fn advance( input: &mut VecDeque<Self>, frontier: AntichainRef<'_, T>, done: bool, out: &mut VecDeque<Self>, )

Advance times by frontier producing consolidated chunks.

impl<K, V, T, R> Clone for VecChunk<K, V, T, R>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V, T, R> Consolidate for VecChunk<K, V, T, R>

where K: Ord + Clone + 'static, V: Ord + Clone + 'static, T: Ord + Clone + 'static, R: Semigroup + 'static,

fn len(&self) -> usize

The number of elements in the container.

fn clear(&mut self)

Clear the container.

fn consolidate_into(&mut self, target: &mut Self)

Sort and consolidate self into target.

impl<K, V, T, R> Default for VecChunk<K, V, T, R>

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, T, R> Navigable for VecChunk<K, V, T, R>

where K: Ord + Clone + 'static, V: Ord + Clone + 'static, T: Lattice + Timestamp, R: Ord + Semigroup + 'static,

type Cursor = VecChunkCursor<K, V, T, R>

The cursor type.

fn cursor(&self) -> Self::Cursor

Acquire a cursor suitable for the instance.

impl<K, V, T, R> NavigableChunk for VecChunk<K, V, T, R>

where K: Ord + Clone + 'static, V: Ord + Clone + 'static, T: Lattice + Timestamp, R: Ord + Semigroup + 'static,

fn bounds(&self) -> ((&K, &V, &T), (&K, &V, &T))

The first and last (key, val, time) triples in the chunk.

impl<K, V, T, R> PushInto<((K, V), T, R)> for VecChunk<K, V, T, R>

where K: Clone + 'static, V: Clone + 'static, T: Clone + 'static, R: Clone + 'static,

fn push_into(&mut self, item: ((K, V), T, R))

Push item into self.

impl<K, V, T, R> SizableContainer for VecChunk<K, V, T, R>

where K: Clone + 'static, V: Clone + 'static, T: Clone + 'static, R: Clone + 'static,

fn at_capacity(&self) -> bool

Indicates that the container is “full” and should be shipped.

fn ensure_capacity(&mut self, _stash: &mut Option<Self>)

Restores self to its desired capacity, if it has one.

impl<K, V, T, R> WithLayout for VecChunk<K, V, T, R>

where K: Ord + Clone + 'static, V: Ord + Clone + 'static, T: Lattice + Timestamp, R: Ord + Semigroup + 'static,

type Layout = Vector<((K, V), T, R)>

The layout.