Struct OrdKeyBatch 

pub struct OrdKeyBatch<L: Layout> {
    pub storage: OrdKeyStorage<L>,
    pub updates: usize,
    pub value: L::ValContainer,
}

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: OrdKeyStorage<L>

The updates themselves.

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.

value: L::ValContainer

Single value to return if asked.

Implementations

impl<L: Layout<ValContainer: BatchContainer<Owned: Default>>> OrdKeyBatch<L>

pub fn create_value() -> L::ValContainer

Creates a container with one value, to slot in to self.value.

Trait Implementations

impl<'de, L: Layout> Deserialize<'de> for OrdKeyBatch<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<ValContainer: BatchContainer<Owned: Default>>> Merger<OrdKeyBatch<L>> for OrdKeyMerger<L>

fn new( batch1: &OrdKeyBatch<L>, batch2: &OrdKeyBatch<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) -> Option<OrdKeyBatch<L>>

Extracts merged results, absent if the merge cancelled to nothing.

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

Perform some amount of work, decrementing fuel.

impl<L: Layout<ValContainer: BatchContainer<Owned: Default>>> Navigable for OrdKeyBatch<L>

type Cursor = OrdKeyCursor<L>

The cursor type.

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

Acquire a cursor suitable for the instance.

impl<L: Layout> Serialize for OrdKeyBatch<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<ValContainer: BatchContainer<Owned: Default>>> SpineBatch for OrdKeyBatch<L>

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

The timestamp type of the batch’s updates.

type Merger = OrdKeyMerger<L>

A type used to progressively merge batches.

fn len(&self) -> usize

The number of updates in the batch.