Struct OrdValBatch 

pub struct OrdValBatch<L: Layout> {
    pub storage: OrdValStorage<L>,
    pub description: Description<Time<L>>,
    pub updates: usize,
}

An immutable collection of update tuples, from a contiguous interval of logical times.

The L parameter captures how the updates should be laid out, and C determines which merge batcher to select.

Fields

storage: OrdValStorage<L>

The updates themselves.

description: Description<Time<L>>

Description of the update times this layer represents.

updates: usize

The number of updates reflected in the batch.

We track this separately from storage because due to the singleton optimization, we may have many more updates than storage.updates.len(). It should equal that length, plus the number of singleton optimizations employed.

Trait Implementations

impl<L: Layout> Batch for OrdValBatch<L>

type Merger = OrdValMerger<L>

A type used to progressively merge batches.

fn begin_merge( &self, other: &Self, compaction_frontier: AntichainRef<'_, Time<L>>, ) -> Self::Merger

Initiates the merging of consecutive batches.

fn empty(lower: Antichain<Self::Time>, upper: Antichain<Self::Time>) -> Self

Produce an empty batch over the indicated interval.

impl<L: Layout> BatchReader for OrdValBatch<L>

type Time = <<L as Layout>::TimeContainer as BatchContainer>::Owned

The timestamp type of the batch’s updates.

fn len(&self) -> usize

The number of updates in the batch.

fn description(&self) -> &Description<Time<L>>

Describes the times of the updates in the batch.

fn is_empty(&self) -> bool

True if the batch is empty.

fn lower(&self) -> &Antichain<Self::Time>

All times in the batch are greater or equal to an element of lower.

fn upper(&self) -> &Antichain<Self::Time>

All times in the batch are not greater or equal to any element of upper.

impl<'de, L: Layout> Deserialize<'de> for OrdValBatch<L>

where L::KeyContainer: Serialize + for<'a> Deserialize<'a>, L::ValContainer: Serialize + for<'a> Deserialize<'a>, L::OffsetContainer: Serialize + for<'a> Deserialize<'a>, L::TimeContainer: Serialize + for<'a> Deserialize<'a>, L::DiffContainer: Serialize + for<'a> Deserialize<'a>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<L: Layout> Merger<OrdValBatch<L>> for OrdValMerger<L>

where OrdValBatch<L>: Batch<Time = Time<L>>,

fn new( batch1: &OrdValBatch<L>, batch2: &OrdValBatch<L>, compaction_frontier: AntichainRef<'_, Time<L>>, ) -> Self

Creates a new merger to merge the supplied batches, optionally compacting up to the supplied frontier.

fn done(self) -> OrdValBatch<L>

Extracts merged results.

fn work( &mut self, source1: &OrdValBatch<L>, source2: &OrdValBatch<L>, fuel: &mut isize, )

Perform some amount of work, decrementing fuel.

impl<L: Layout> Navigable for OrdValBatch<L>

type Cursor = OrdValCursor<L>

The cursor type.

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

Acquire a cursor suitable for the instance.

impl<L: Layout> Serialize for OrdValBatch<L>

where L::KeyContainer: Serialize + for<'a> Deserialize<'a>, L::ValContainer: Serialize + for<'a> Deserialize<'a>, L::OffsetContainer: Serialize + for<'a> Deserialize<'a>, L::TimeContainer: Serialize + for<'a> Deserialize<'a>, L::DiffContainer: Serialize + for<'a> Deserialize<'a>,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<L: Layout> WithLayout for OrdValBatch<L>

type Layout = L

The layout.