Struct ResolvedRange 

pub struct ResolvedRange {
    pub range: Range<u64>,
    pub end_checkpoint: u64,
    pub entry_checkpoint: u64,
    pub end_position: u64,
    pub exhaustion: RangeExhaustion,
}

A request’s checkpoint bounds resolved into the transaction-sequence interval to scan, annotated with the checkpoint-space facts watermark rendering needs.

Two coordinate spaces meet here: range lives in transaction-sequence space (the scan’s key space), while wire watermarks speak checkpoints — coverage claims are checkpoint numbers and cursors are full (checkpoint, tx_seq) positions. Mapping a tx back to its checkpoint takes a store lookup, so resolution captures the two endpoint checkpoints up front.

The endpoint checkpoints are deliberately not a Range: they are direction-relative (entry_checkpoint is numerically the high checkpoint of a descending scan), they serve unrelated consumers (coverage clamping vs. terminal-frame rendering), and only the terminal side carries a companion position.

Fields

range: Range<u64>

Half-open tx-sequence interval to scan (numeric order regardless of request ordering; a descending scan walks it from end - 1 down).

end_checkpoint: u64

Checkpoint containing end_position. Together they form the terminal-frame cursor position and the natural-completion coverage claim when the scan exhausts the interval.

entry_checkpoint: u64

Checkpoint containing the interval’s first position in scan direction. Checkpoint-only because its sole consumer — the covered-bound fold — claims coverage at checkpoint granularity: a claim before it proves nothing and is suppressed, keeping the wire checkpoint unset until the scan’s first checkpoint is fully covered.

end_position: u64

The tx-sequence bound the scan reports when the interval is exhausted (the terminal frame’s cursor coordinate, paired with end_checkpoint). Tracks the scan-direction edge of range (range.end ascending, range.start descending) as cursor bounds tighten it, but stays pinned to the reported bound if the backend further clamps range to available history.

exhaustion: RangeExhaustion

Why the interval is exhausted once the scan drains it.

Implementations

impl ResolvedRange

pub fn empty_at( end_checkpoint: u64, end_position: u64, exhaustion: RangeExhaustion, ) -> Self

pub fn is_empty(&self) -> bool

pub fn apply_serving_floor( &mut self, floor_tx: u64, floor_checkpoint: u64, options: &QueryOptions, )

Reconcile the interval and its watermark metadata after the backend clamped the interval’s low end to the serving floor (floor_tx = the effective first scannable transaction, floor_checkpoint = its containing checkpoint).

A floor inside the interval starts the scan there: an ascending scan must not claim coverage below it (entry rises), and a descending scan terminates at it (terminal pinned), so no watermark ever claims unscanned history. A floor at or past the interval’s high end leaves an empty intersection with retained history: the interval canonicalizes to empty and the terminal metadata stays at the requested boundary — the cursor must not move outside the requested interval, and the empty interval already claims nothing.

Trait Implementations

impl Clone for ResolvedRange

fn clone(&self) -> ResolvedRange

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResolvedRange

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

Formats the value using the given formatter.

impl PartialEq for ResolvedRange

fn eq(&self, other: &ResolvedRange) -> 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 Eq for ResolvedRange

impl StructuralPartialEq for ResolvedRange