Struct RangeExpr 

pub struct RangeExpr { /* private fields */ }

A range expression: a sorted set of non-overlapping integer ranges.

Implementations

impl RangeExpr

pub fn with_contiguous(self, contiguous: bool) -> Self

Set contiguous display mode. When true, Display uses “{start}-{end}” format even for single values (e.g., “5-5”). Only meaningful for contiguous chunks.

pub fn from_values(values: Vec<i64>) -> Self

Create a RangeExpr from a list of individual values.

pub fn from_ranges(ranges: Vec<IntRange>) -> Result<Self, ExpressionError>

Create from pre-built IntRanges. Sorts, merges adjacent ranges, and validates no overlaps.

Returns an error if the number of input ranges exceeds MAX_RANGE_EXPR_CHUNKS.

pub fn len(&self) -> usize

Total number of integers across all sub-ranges.

pub fn is_empty(&self) -> bool

Returns true if the range expression contains no elements.

pub fn contains(&self, value: i64) -> bool

Test membership via binary search on sub-range endpoints. O(log m).

pub fn get(&self, index: i64) -> Option<i64>

Get element by index (supports negative indexing like Python).

pub fn ranges(&self) -> &[IntRange]

The underlying sub-ranges (sorted, non-overlapping).

pub fn cumulative_lengths(&self) -> &[usize]

Cumulative element counts per sub-range (for index mapping).

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

Iterate over all values in ascending order across all sub-ranges.

pub fn to_vec(&self) -> Vec<i64>

pub fn slice( &self, start: i64, stop: i64, step: i64, ) -> Result<RangeExpr, ExpressionError>

Slice this range expression with a positive step.

start, stop, step are already-normalized indices into the flattened element sequence. step must be positive. Returns a new RangeExpr without materializing any elements.

Runs in O(m) where m is the number of sub-ranges, regardless of how many elements are selected. Each sub-range’s intersection with the slice index sequence is computed as pure arithmetic.

For negative step (reverse slices), callers should use get() to collect elements into a list, since RangeExpr cannot represent descending sequences.

pub fn heap_size(&self) -> usize

Heap allocation size (for memory tracking).

Trait Implementations

impl Clone for RangeExpr

fn clone(&self) -> RangeExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RangeExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RangeExpr

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for RangeExpr

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

Formats the value using the given formatter.

impl From<RangeExpr> for ExprValue

fn from(v: RangeExpr) -> Self

Converts to this type from the input type.

impl FromStr for RangeExpr

type Err = ExpressionError

The associated error which can be returned from parsing.

fn from_str(expr: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for RangeExpr

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RangeExpr

fn eq(&self, other: &Self) -> 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 Serialize for RangeExpr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RangeExpr