Trait InternalMerge 

pub trait InternalMerge:
    Accountable
    + SizableContainer
    + Default {
    type TimeOwned;

    // Required methods
    fn len(&self) -> usize;
    fn clear(&mut self);
    fn merge_from(&mut self, others: &mut [Self], positions: &mut [usize]);
    fn extract(
        &mut self,
        position: &mut usize,
        upper: AntichainRef<'_, Self::TimeOwned>,
        frontier: &mut Antichain<Self::TimeOwned>,
        keep: &mut Self,
        ship: &mut Self,
    );

    // Provided method
    fn account(&self) -> (usize, usize, usize, usize) { ... }
}

A container that supports the operations needed by the merge batcher: merging sorted chains and extracting updates by time.

Required Associated Types

type TimeOwned

The owned time type, for maintaining antichains.

Required Methods

fn len(&self) -> usize

The number of items in this container.

fn clear(&mut self)

Clear the container for reuse.

fn merge_from(&mut self, others: &mut [Self], positions: &mut [usize])

Merge items from sorted inputs into self, advancing positions. Merges until self is at capacity or all inputs are exhausted.

Dispatches based on the number of inputs:

• 0: no-op
• 1: bulk copy (may swap the input into self)
• 2: merge two sorted streams

fn extract( &mut self, position: &mut usize, upper: AntichainRef<'_, Self::TimeOwned>, frontier: &mut Antichain<Self::TimeOwned>, keep: &mut Self, ship: &mut Self, )

Extract updates from self into ship (times not beyond upper) and keep (times beyond upper), updating frontier with kept times.

Iteration starts at *position and advances *position as updates are consumed. The implementation must yield (return early) when either keep.at_capacity() or ship.at_capacity() becomes true, so the caller can swap out a full output buffer and resume by calling extract again. The caller invokes extract repeatedly until *position >= self.len().

This shape exists because at_capacity() for Vec is len() == capacity(), which silently becomes false again the moment a push past capacity grows the backing allocation. Without per-element yielding, a single extract call can quietly produce oversized output chunks.

Provided Methods

fn account(&self) -> (usize, usize, usize, usize)

Account the allocations behind the chunk.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<D: Ord + Clone + 'static, T: Ord + Clone + PartialOrder + 'static, R: Semigroup + Clone + 'static> InternalMerge for Vec<(D, T, R)>

type TimeOwned = T

fn len(&self) -> usize

fn clear(&mut self)

fn merge_from(&mut self, others: &mut [Self], positions: &mut [usize])

fn extract( &mut self, position: &mut usize, upper: AntichainRef<'_, T>, frontier: &mut Antichain<T>, keep: &mut Self, ship: &mut Self, )

Implementors