Struct range_set::RangeSet

pub struct RangeSet<A> where
    A: Array + Eq + Debug,
    A::Item: Clone + Eq + Debug,  { /* private fields */ }

A set of primitive integers represented as a sorted list of disjoint, inclusive ranges.

let mut s = RangeSet::<[RangeInclusive <u32>; 1]>::from (0..=2);
println!("s: {:?}", s);
assert!(!s.spilled());

assert!(s.insert_range (8..=10).is_none());
println!("s: {:?}", s);
assert!(s.spilled());
let v : Vec <u32> = s.iter().collect();
assert_eq!(v, vec![0,1,2,8,9,10]);

assert_eq!(s.insert_range (3..=12), Some (RangeSet::from (8..=10)));
println!("s: {:?}", s);
assert!(s.spilled());  // once spilled, stays spilled
let v : Vec <u32> = s.iter().collect();
assert_eq!(v, vec![0,1,2,3,4,5,6,7,8,9,10,11,12]);
s.shrink_to_fit();  // manually un-spill
assert!(!s.spilled());

Implementations

impl<A, T> RangeSet<A> where
    A: Array<Item = RangeInclusive<T>> + Eq + Debug,
    T: PrimInt + Debug, 

pub fn new() -> Self

New empty range set

pub fn with_capacity(capacity: usize) -> Self

New empty range set with the internal smallvec initialized with the given initial capacity

pub fn from_ranges(ranges: SmallVec<A>) -> Option<Self>

Returns a new range set if the given vector of ranges is valid (valid_range_vec)

pub fn is_empty(&self) -> bool

Check if range set is empty

pub fn clear(&mut self)

Clears the range set

pub fn into_smallvec(self) -> SmallVec<A>

Converts into the internal smallvec

pub fn insert(&mut self, element: T) -> bool

Insert a single element, returning true if it was successfully inserted or else false if it was already present

let mut s = RangeSet::<[RangeInclusive <u32>; 2]>::new();
assert!(s.insert (4));
assert_eq!(s, RangeSet::from (4..=4));
assert!(!s.insert (4));
assert_eq!(s, RangeSet::from (4..=4));
assert!(s.insert (5));
assert_eq!(s, RangeSet::from (4..=5));
assert!(s.insert (3));
assert_eq!(s, RangeSet::from (3..=5));
assert!(s.insert (10));
assert_eq!(s, RangeSet::from_ranges (vec![3..=5, 10..=10].into()).unwrap());

pub fn remove(&mut self, element: T) -> bool

Remove a single element, returning true if it was successfully removed or else false if it was not present

let mut s = RangeSet::<[RangeInclusive <u32>; 2]>::from (0..=5);
assert!(s.remove (1));
assert_eq!(s, RangeSet::from_ranges (vec![0..=0, 2..=5].into()).unwrap());
assert!(!s.remove (1));
assert_eq!(s, RangeSet::from_ranges (vec![0..=0, 2..=5].into()).unwrap());
assert!(s.remove (4));
assert_eq!(s, RangeSet::from_ranges (vec![0..=0, 2..=3, 5..=5].into()).unwrap());
assert!(s.remove (3));
assert_eq!(s, RangeSet::from_ranges (vec![0..=0, 2..=2, 5..=5].into()).unwrap());
assert!(s.remove (2));
assert_eq!(s, RangeSet::from_ranges (vec![0..=0, 5..=5].into()).unwrap());
assert!(s.remove (0));
assert_eq!(s, RangeSet::from (5..=5));
assert!(s.remove (5));
assert!(s.is_empty());

pub fn insert_range(&mut self, range: A::Item) -> Option<Self>

Returns the intersected values if the range is not disjoint with the curret range set.

let mut s = RangeSet::<[RangeInclusive <u32>; 2]>::from (0..=5);
assert_eq!(s.insert_range ( 3..=10), Some (RangeSet::from (3..=5)));
assert_eq!(s.insert_range (20..=30), None);

pub fn remove_range(&mut self, range: A::Item) -> Option<Self>

Removes and returns the intersected elements, if there were any.

let mut s = RangeSet::<[RangeInclusive <u32>; 2]>::from (0..=5);
assert_eq!(s.remove_range (3..=3), Some (RangeSet::from (3..=3)));
assert_eq!(s, RangeSet::from_ranges (vec![0..=2, 4..=5].into()).unwrap());
assert_eq!(s.remove_range (0..=10), Some (
  RangeSet::from_ranges (vec![0..=2, 4..=5].into()).unwrap()));
assert!(s.is_empty());

pub fn iter(&self) -> Iter<'_, A, T>

pub fn valid_range_vec(ranges: &SmallVec<A>) -> bool

Tests a raw smallvec of ranges for validity as a range set: the element ranges must be properly disjoint (not adjacent) and sorted.

let mut v = SmallVec::<[RangeInclusive <u32>; 2]>::new();
assert!(RangeSet::valid_range_vec (&v));
v.push (0..=3);
assert!(RangeSet::valid_range_vec (&v));
v.push (6..=10);
assert!(RangeSet::valid_range_vec (&v));
v.push (0..=1);
assert!(!RangeSet::valid_range_vec (&v));

pub fn spilled(&self) -> bool

Calls spilled on the underlying smallvec

pub fn shrink_to_fit(&mut self)

Calls shrink_to_fit on the underlying smallvec

Trait Implementations

impl<A, T> AsRef<SmallVec<A>> for RangeSet<A> where
    A: Array<Item = RangeInclusive<T>> + Eq + Debug,
    T: PrimInt + Debug, 

fn as_ref(&self) -> &SmallVec<A>

Converts this type into a shared reference of the (usually inferred) input type.

impl<A: Clone> Clone for RangeSet<A> where
    A: Array + Eq + Debug,
    A::Item: Clone + Eq + Debug, 

fn clone(&self) -> RangeSet<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for RangeSet<A> where
    A: Array + Eq + Debug,
    A::Item: Clone + Eq + Debug, 

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

Formats the value using the given formatter.

impl<A, T> From<RangeInclusive<T>> for RangeSet<A> where
    A: Array<Item = RangeInclusive<T>> + Eq + Debug,
    T: PrimInt + Debug, 

fn from(range: RangeInclusive<T>) -> Self

Converts to this type from the input type.

impl<A: PartialEq> PartialEq<RangeSet<A>> for RangeSet<A> where
    A: Array + Eq + Debug,
    A::Item: Clone + Eq + Debug, 

fn eq(&self, other: &RangeSet<A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &RangeSet<A>) -> bool

This method tests for !=.

impl<A: Eq> Eq for RangeSet<A> where
    A: Array + Eq + Debug,
    A::Item: Clone + Eq + Debug, 

impl<A> StructuralEq for RangeSet<A> where
    A: Array + Eq + Debug,
    A::Item: Clone + Eq + Debug, 

impl<A> StructuralPartialEq for RangeSet<A> where
    A: Array + Eq + Debug,
    A::Item: Clone + Eq + Debug,