Struct OpenBatch 

pub(crate) struct OpenBatch {
    max_bytes: usize,
    entries: Vec<Entry>,
    estimated_bytes: usize,
    first_admitted_at: Option<Instant>,
    positions: HashMap<RegionId, u64>,
}

Entries admitted since the last seal, together with the position of the last entry admitted per region.

Every entry is assigned its id at admission from the sequence the batch takes when it is sealed, so a batch that is rolled back and admitted again under the same sequence hands out the same ids.

Fields

max_bytes: usize

entries: Vec<Entry>

estimated_bytes: usize

first_admitted_at: Option<Instant>

When the first entry of the batch was admitted.

positions: HashMap<RegionId, u64>

Implementations

impl OpenBatch

pub(crate) fn new(max_bytes: usize) -> Self

pub(crate) fn would_exhaust_positions(&self, entries: &[Entry]) -> bool

Returns true when admitting entries would take a region past the position range, so that entries need a batch of their own.

pub(crate) fn admit( &mut self, object_seq: u64, entries: Vec<Entry>, ) -> Result<HashMap<RegionId, EntryId>>

Admits entries into the batch that becomes the object object_seq, assigning each the next position of its region, and returns the last id assigned to every region in entries. Nothing is admitted when a region would run past the position range.

fn check_positions(&self, entries: &[Entry]) -> Result<()>

Checks that every region in entries stays inside the position range once they are admitted.

pub(crate) fn is_empty(&self) -> bool

pub(crate) fn holds_region(&self, region_id: RegionId) -> bool

pub(crate) fn estimated_bytes(&self) -> usize

Returns the estimated size of the admitted entries.

pub(crate) fn first_admitted_at(&self) -> Option<Instant>

Returns when the first admitted entry was admitted, if any.

pub(crate) fn should_seal(&self) -> bool

Returns true once the admitted entries reach the size limit.

pub(crate) fn seal(&mut self) -> (Vec<Entry>, Instant)

Takes the admitted entries out of the batch together with the time the first of them was admitted. The next admission starts at position one again, under the next sequence.

pub(crate) fn reset(&mut self)

Drops the admitted entries, so the next admission under the same sequence hands out the same ids again.

Trait Implementations

impl Debug for OpenBatch

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.