Struct PositionSet 

pub struct PositionSet { /* private fields */ }

A set of usize positions stored as a BitSet. Provides O(1) membership testing and efficient set operations. Caches bounds for cheap overlap pre-checks.

Implementations

impl PositionSet

pub fn from_usize_iter<I: IntoIterator<Item = usize>>(iter: I) -> Self

Create a PositionSet from an iterator of usize positions.

pub fn new() -> Self

Create an empty PositionSet.

pub fn len(&self) -> usize

Number of positions in the set.

pub fn is_empty(&self) -> bool

Is the set empty?

pub fn min_pos(&self) -> usize

Returns the minimum position in the set.

Returns usize::MAX for an empty set.

pub fn max_pos(&self) -> usize

Returns the maximum position in the set.

Returns 0 for an empty set.

pub fn insert(&mut self, pos: usize) -> bool

Insert a position.

pub fn extend_from_span(&mut self, span: &PositionSpan)

Extend this set from a PositionSpan without allocating an intermediate set.

pub fn contains(&self, pos: usize) -> bool

Check if position is in the set.

pub fn remove(&mut self, pos: usize) -> bool

Remove a position from the set.

pub fn remove_span(&mut self, span: &PositionSpan)

Remove all positions in a span from the set.

pub fn may_overlap_range(&self, range_start: usize, range_end: usize) -> bool

Quick check if a range [range_start, range_end) might overlap with this set. Returns true if the bounding boxes overlap, false if they definitely don’t. This is O(1) and used as a pre-filter before the expensive BitSet check.

pub fn restricted_to_range(&self, start: usize, end: usize) -> PositionSet

Build the subset of positions that fall within the half-open range [start, end).

The naive form is self.iter().filter(|p| start <= p < end), which always walks the entire set. When this set is a whole-query matchables set (hundreds of thousands of positions for a multi-MB file) but the range is a single small query run (tens of tokens), that full scan is repeated once per run and the per-file cost degrades to O(num_runs * total_positions) — quadratic in file size. Translation catalogs (.po) are the pathological case: thousands of small runs over a single huge token stream.

Instead, iterate whichever side is smaller. The clamped range can never be longer than the set’s own span, and for a small run it is far shorter, so we probe range.contains against this set’s O(1) membership test. For a range that spans the whole set (the whole-query run) we fall back to walking the set directly, which is the same work as before.

pub fn union(&self, other: &PositionSet) -> PositionSet

Compute the union of this set with another PositionSet.

Returns a new PositionSet containing all positions from both sets.

pub fn difference(&self, other: &PositionSet) -> PositionSet

Return the difference (elements in self but not in other).

pub fn intersection_len(&self, other: &PositionSet) -> usize

Count elements in the intersection of self and other.

pub fn overlaps_span(&self, span: &PositionSpan) -> bool

Check if this set overlaps with a PositionSpan. Uses O(1) bounds check before the O(n) element-wise check.

pub fn contains_range(&self, range: Range<usize>) -> bool

Check if this set contains all positions in a range. Returns true for empty ranges.

pub fn iter(&self) -> impl Iterator<Item = usize> + '_

Iterate over positions.

pub fn to_position_span(&self) -> PositionSpan

Convert this PositionSet to a PositionSpan.

If positions are contiguous, returns a Range; otherwise returns Discrete.

Trait Implementations

impl Clone for PositionSet

fn clone(&self) -> PositionSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PositionSet

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

Formats the value using the given formatter.

impl Default for PositionSet

fn default() -> Self

Returns the “default value” for a type.

impl Eq for PositionSet

impl FromIterator<usize> for PositionSet

fn from_iter<T: IntoIterator<Item = usize>>(iter: T) -> Self

Creates a value from an iterator.

impl PartialEq for PositionSet

fn eq(&self, other: &PositionSet) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PositionSet