Struct ResolvedScan 

pub struct ResolvedScan<P> {
    pub bounds: ScanBounds<P>,
    pub entry_checkpoint: u64,
    pub end_checkpoint: u64,
    pub end_position: P,
    pub exhaustion: RangeExhaustion,
    pub window_terminal_checkpoint: Option<u64>,
}

A request’s checkpoint bounds resolved into the scan-position interval to scan, along with the checkpoint-space facts for watermark rendering.

Fields

bounds: ScanBounds<P>

Scan-position interval to scan, expressed as explicit lo/hi Bounds.

entry_checkpoint: u64

The window’s first checkpoint in scan direction, raised to the serving floor for an ascending scan. No coverage claim passes it. Cursors do not move it: a cursor vouches for every position before it in scan order, so a scan claims each checkpoint whose end it reaches, wherever its cursor started.

end_checkpoint: u64

Checkpoint containing the end_position.

end_position: P

Scan-direction terminal edge of the interval.

exhaustion: RangeExhaustion

Why the interval is exhausted once the scan drains it.

window_terminal_checkpoint: Option<u64>

The window’s terminal checkpoint in scan direction (see ResolvedCheckpointRange::terminal_checkpoint), or None when the window holds no checkpoint. Cursors do not move it, unlike end_checkpoint, which carries the checkpoint field of a cursor that ends the scan: a non-empty window’s natural end claims its edge even when the scan reads nothing, because the request’s starting cursor vouches for every position before it.

Implementations

impl ResolvedScan<u64>

pub fn range(&self) -> Range<u64>

Collapse the symbolic bounds to the half-open store range.

impl<P: ScanPosition> ResolvedScan<P>

where CursorToken: ScanCursor<P>,

pub fn resolve( cp_range: ResolvedCheckpointRange, range: Range<P>, options: &QueryOptions, ) -> Result<Self, RpcError>

Record the request’s checkpoint bounds, then apply cursor bounds to tighten the range scanning interval. Cursors bound the scan by position alone; their checkpoint fields only label the cursors this scan hands back. If the backend data source has a serving floor, apply_serving_floor must be called to reconcile the scanning interval.

pub fn is_empty(&self) -> bool

pub fn natural_end_claim(&self, options: &QueryOptions) -> Option<u64>

The checkpoint this scan’s natural end reports as fully covered in Watermark.checkpoint: the window’s last checkpoint in scan direction, just below its exclusive upper edge ascending, or its inclusive lower edge descending. A scan that drains its window has covered every checkpoint up to that edge, and so has a scan its starting cursor leaves empty, because the cursor vouches for every position before it. None when the window has no checkpoint.

pub fn apply_serving_floor( &mut self, floor: P, floor_checkpoint: u64, options: &QueryOptions, ) -> Result<(), RpcError>

Raises the scan’s low end to the serving floor, for a scan with no lower bound of its own whose low end lies below the floor. An ascending scan starts at the floor and claims coverage from floor_checkpoint on. A descending scan ends at the floor with RangeExhaustion::ServingFloor: everything below it is pruned.

A floor that leaves the scan nothing to cover (its before cursor sits at or below the floor) is OutOfRange.

Trait Implementations

impl<P: Clone> Clone for ResolvedScan<P>

fn clone(&self) -> ResolvedScan<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug> Debug for ResolvedScan<P>

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

Formats the value using the given formatter.

impl<P: Eq> Eq for ResolvedScan<P>

impl<P: PartialEq> PartialEq for ResolvedScan<P>

fn eq(&self, other: &ResolvedScan<P>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P: PartialEq> StructuralPartialEq for ResolvedScan<P>