Struct RangeSet 

pub struct RangeSet<T>(pub Vec<T>)
where
    T: NumericInteger;

The set type this crate operates on, and the range type its constructors take, are irange’s. They are re-exported here so that a dependent needs neither its own dependency on irange nor a version kept in step with this crate’s. A structure holding a collection of u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128 or isize.

Tuple Fields

0: Vec<T>

In this collection all the elements with even index represent the lower bounds (inclusive) and all the odd index represent the upper bounds (inclusive).

Implementations

impl<T> RangeSet<T>

where T: NumericInteger,

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

Return an iterator to iterate in order over all the values contained.

Example:

use irange::RangeSet;

let range = RangeSet::new_from_range(2..=5);

for value in range.iter() {
    print!("{value} "); // 2 3 4 5
}

pub fn new_from_range<R>(range: R) -> RangeSet<T>

where R: RangeBounds<T>,

Create a new instance from the given range.

Example:

use irange::RangeSet;

// Contains 2, 3
RangeSet::new_from_range(2..4);

// Contains 0, 1
RangeSet::<u8>::new_from_range(..2);

// Contains 0, 1, 2
RangeSet::<u32>::new_from_range(..=2);

pub fn new_from_ranges(ranges: &[AnyRange<T>]) -> RangeSet<T>

Create a new instance from the given ranges.

Example:

use irange::RangeSet;
use irange::range::AnyRange;

// Contains 3, 4, 7, 8
RangeSet::<i64>::new_from_ranges(&[AnyRange::from(3..=4), AnyRange::from(7..9)]);

pub fn new_from_bounds(bounds: Vec<T>) -> Option<RangeSet<T>>

Create a new instance from the raw collection of bounds used internally: the elements with an even index are the lower bounds (inclusive) and the elements with an odd index are the upper bounds (inclusive).

Return None if the collection is not a valid representation, i.e. if it does not hold an even number of bounds, if a range is inverted, or if two consecutive ranges are not sorted, overlap, or merely touch each other (they should be merged into a single range).

Example:

use irange::RangeSet;

// Contains 2, 3, 4, 7, 8
assert!(RangeSet::<u8>::new_from_bounds(vec![2, 4, 7, 8]).is_some());

// 4..=6 and 7..=8 are adjacent, they must be given as a single 4..=8 range
assert!(RangeSet::<u8>::new_from_bounds(vec![4, 6, 7, 8]).is_none());

pub fn empty() -> RangeSet<T>

Create a new instance that does not contain any value.

Example:

use irange::RangeSet;

// Contains nothing
RangeSet::<i32>::empty();

pub fn total() -> RangeSet<T>

Create a new instance that contains all possible values.

Example:

use irange::RangeSet;

// Contains all values that can be stored into a u8
// -> 0..=255
RangeSet::<u8>::total();

// Contains all values that can be stored into a i16
// -> -32768..=32767
RangeSet::<i16>::total();

pub fn is_total(&self) -> bool

Return true if it contains all the possible values.

Example:

use irange::RangeSet;

let total = RangeSet::<u128>::total();
assert!(total.is_total());

let range = RangeSet::<u32>::new_from_range(..=2);
assert!(!range.is_total());

pub fn is_empty(&self) -> bool

Return true if it does not contain any value.

Example:

use irange::RangeSet;

let empty = RangeSet::<u128>::empty();
assert!(empty.is_empty());

let range = RangeSet::<i64>::new_from_range(2..4);
assert!(!range.is_empty());

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

Return true if it contains the given value.

Example:

use irange::RangeSet;

let range = RangeSet::<i64>::new_from_range(2..4);
assert!(range.contains(2));
assert!(range.contains(3));
assert!(!range.contains(4));

pub fn contains_all(&self, that: &RangeSet<T>) -> bool

Return true if it contains the given RangeSet.

Example:

use irange::RangeSet;

let range1 = RangeSet::<i64>::new_from_range(11..90);
let range2 = RangeSet::<i64>::new_from_range(19..23);

assert!(range1.contains_all(&range2));
assert!(!range2.contains_all(&range1));

pub fn union(&self, that: &RangeSet<T>) -> RangeSet<T>

Return the union with the given RangeSet.

Example:

use irange::RangeSet;

let range1 = RangeSet::<i64>::new_from_range(2..4);
let range2 = RangeSet::<i64>::new_from_range(3..=5);

// Contains 2..=5
let union = range1.union(&range2);

pub fn has_intersection(&self, that: &RangeSet<T>) -> bool

Return true if there is common value with the given RangeSet.

Example:

use irange::RangeSet;

let range1 = RangeSet::<i64>::new_from_range(2..4);
let range2 = RangeSet::<i64>::new_from_range(3..=5);
let range3 = RangeSet::<i64>::new_from_range(5..13);

assert!(range1.has_intersection(&range2));
assert!(!range1.has_intersection(&range3));
assert!(range2.has_intersection(&range3));

pub fn intersection(&self, that: &RangeSet<T>) -> RangeSet<T>

Return the intersection with the given RangeSet.

Example:

use irange::RangeSet;

let range1 = RangeSet::<i64>::new_from_range(2..4);
let range2 = RangeSet::<i64>::new_from_range(3..=5);

// Contains 2..=3
let intersection = range1.intersection(&range2);

pub fn complement(&self) -> RangeSet<T>

Return the complement.

Example:

use irange::RangeSet;

let range = RangeSet::<u8>::new_from_range(2..4);

// Contains 0..=1 + 4..=255
range.complement();

pub fn difference(&self, that: &RangeSet<T>) -> RangeSet<T>

Return the difference with the given RangeSet.

Example:

use irange::RangeSet;

let range1 = RangeSet::<i64>::new_from_range(2..4);
let range2 = RangeSet::<i64>::new_from_range(3..=5);

// Contains 2
let difference = range1.difference(&range2);

Trait Implementations

impl<T> BitAnd<&RangeSet<T>> for &RangeSet<T>

where T: NumericInteger,

fn bitand(self, that: &RangeSet<T>) -> RangeSet<T>

Compute the intersection, like RangeSet::intersection.

Example:

use irange::RangeSet;

let a = RangeSet::new_from_range(3..=8);
let b = RangeSet::new_from_range(7..=9);
assert_eq!("[ 7..=8 ]", (&a & &b).to_string());

type Output = RangeSet<T>

The resulting type after applying the & operator.

impl<T> BitOr<&RangeSet<T>> for &RangeSet<T>

where T: NumericInteger,

fn bitor(self, that: &RangeSet<T>) -> RangeSet<T>

Compute the union, like RangeSet::union.

Example:

use irange::RangeSet;

let a = RangeSet::new_from_range(3..=4);
let b = RangeSet::new_from_range(7..=8);
assert_eq!("[ 3..=4 7..=8 ]", (&a | &b).to_string());

type Output = RangeSet<T>

The resulting type after applying the | operator.

impl CharacterClass for RangeSet<Char>

fn new_from_range_u32<R: RangeBounds<u32>>(range: R) -> Option<Self>

Create a new instance from the given range of codepoints, or return None if a bound is not a char, i.e. if it is a surrogate or above char::MAX.

A range holding no codepoint gives the empty set.

Example

use regex_charclass::{CharacterClass, RangeSet};

let range = RangeSet::new_from_range_u32(97..=122).unwrap();
assert_eq!("[a-z]", range.to_regex());

// An empty range, and a bound that is not a `char`.
assert!(RangeSet::new_from_range_u32(97..97).unwrap().is_empty());
assert_eq!(None, RangeSet::new_from_range_u32(0xD800..=0xD800));

fn new_from_range_char<R: RangeBounds<char>>(range: R) -> Self

Create a new instance from the given range of char.

A range holding no char gives the empty set.

Example

use regex_charclass::{CharacterClass, RangeSet};

let range = RangeSet::new_from_range_char('a'..='z');
assert_eq!("[a-z]", range.to_regex());

assert_eq!("[a-y]", RangeSet::new_from_range_char('a'..'z').to_regex());
assert!(RangeSet::new_from_range_char('a'..'a').is_empty());

fn get_cardinality(&self) -> u32

Return the number of char values contained, at most 1,112,064.

The surrogate block holds no char, so a range spanning it does not count it.

Example

use regex_charclass::{CharacterClass, RangeSet};

let range = RangeSet::new_from_range_char('a'..='z');
assert_eq!(26, range.get_cardinality());

assert_eq!(1_112_064, RangeSet::total().get_cardinality());

fn to_regex(&self) -> String

Return the set as a regular expression character class.

See the crate documentation for the forms this returns and the flags they assume.

Example

use regex_charclass::{AnyRange, Char, CharacterClass, RangeSet};

let range = RangeSet::new_from_range_char('a'..='z');
assert_eq!("[a-z]", range.to_regex());

let range = RangeSet::<Char>::new_from_ranges(&[
    AnyRange::from(Char::new('0')..=Char::new('9')),
    AnyRange::from(Char::new('A')..=Char::new('F')),
    AnyRange::from(Char::new('a')..=Char::new('f')),
]);
assert_eq!("\\p{ASCII_Hex_Digit}", range.to_regex());

// A single `char` needs no class, but is escaped if it is a metacharacter.
assert_eq!("\\.", RangeSet::new_from_range_char('.'..='.').to_regex());

impl<T> Clone for RangeSet<T>

where T: Clone + NumericInteger,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for RangeSet<T>

where T: Debug + NumericInteger,

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

Formats the value using the given formatter.

impl<T> Default for RangeSet<T>

where T: NumericInteger,

fn default() -> RangeSet<T>

Return the empty set, like RangeSet::empty.

impl<'de, T> Deserialize<'de> for RangeSet<T>

where T: NumericInteger + Deserialize<'de>,

Available on crate feature serde only.

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for RangeSet<T>

where T: NumericInteger,

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

Formats the value using the given formatter.

impl<T> Eq for RangeSet<T>

where T: Eq + NumericInteger,

impl<T> FromIterator<AnyRange<T>> for RangeSet<T>

where T: NumericInteger,

fn from_iter<I>(iter: I) -> RangeSet<T>

where I: IntoIterator<Item = AnyRange<T>>,

Collect the given ranges into a single set, like RangeSet::new_from_ranges.

Example:

use irange::range::AnyRange;
use irange::RangeSet;

let range: RangeSet<i64> = [3..=4, 7..=8].into_iter().map(AnyRange::from).collect();
assert_eq!("[ 3..=4 7..=8 ]", range.to_string());

impl<T> Hash for RangeSet<T>

where T: Hash + NumericInteger,

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

where __H: Hasher,

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<'a, T> IntoIterator for &'a RangeSet<T>

where T: NumericInteger,

fn into_iter(self) -> RangeSetIter<'a, T>

Iterate in order over all the values contained, like RangeSet::iter.

Example:

use irange::RangeSet;

let range = RangeSet::new_from_range(2..=5);

for value in &range {
    print!("{value} "); // 2 3 4 5
}

type Item = T

The type of the elements being iterated over.

type IntoIter = RangeSetIter<'a, T>

Which kind of iterator are we turning this into?

impl<T> Not for &RangeSet<T>

where T: NumericInteger,

fn not(self) -> RangeSet<T>

Compute the complement, like RangeSet::complement.

Example:

use irange::RangeSet;

let a = RangeSet::<u8>::new_from_range(3..=254);
assert_eq!("[ 0..=2 255..=255 ]", (!&a).to_string());

type Output = RangeSet<T>

The resulting type after applying the ! operator.

impl<T> Ord for RangeSet<T>

where T: Ord + NumericInteger,

fn cmp(&self, other: &RangeSet<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl<T> PartialEq for RangeSet<T>

where T: PartialEq + NumericInteger,

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

Equality operator ==.

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

Inequality operator !=.

impl<T> PartialOrd for RangeSet<T>

where T: PartialOrd + NumericInteger,

fn partial_cmp(&self, other: &RangeSet<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Serialize for RangeSet<T>

where T: NumericInteger + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for RangeSet<T>

where T: PartialEq + NumericInteger,

impl<T> Sub<&RangeSet<T>> for &RangeSet<T>

where T: NumericInteger,

fn sub(self, that: &RangeSet<T>) -> RangeSet<T>

Compute the difference, like RangeSet::difference.

Example:

use irange::RangeSet;

let a = RangeSet::new_from_range(3..=8);
let b = RangeSet::new_from_range(7..=9);
assert_eq!("[ 3..=6 ]", (&a - &b).to_string());

type Output = RangeSet<T>

The resulting type after applying the - operator.