Struct RangeInclusiveSet

pub struct RangeInclusiveSet<T, StepFnsT = T> { /* private fields */ }

A set whose items are stored as ranges bounded inclusively below and above (start..=end).

See RangeInclusiveMap’s documentation for more details.

Implementations

impl<T> RangeInclusiveSet<T, T>

where T: Ord + Clone + StepLite,

pub fn new() -> Self

Makes a new empty RangeInclusiveSet.

impl<T, StepFnsT> RangeInclusiveSet<T, StepFnsT>

where T: Ord + Clone, StepFnsT: StepFns<T>,

pub fn new_with_step_fns() -> Self

Makes a new empty RangeInclusiveSet, specifying successor and predecessor functions defined separately from T itself.

This is useful as a workaround for Rust’s “orphan rules”, which prevent you from implementing StepLite for T if T is a foreign type.

NOTE: This will likely be deprecated and then eventually removed once the standard library’s Step trait is stabilised, as most crates will then likely implement Step for their types where appropriate.

See this issue for details about that stabilization process.

pub fn get(&self, value: &T) -> Option<&RangeInclusive<T>>

Returns a reference to the range covering the given key, if any.

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

Returns true if any range in the set covers the specified value.

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

Gets an ordered iterator over all ranges, ordered by range.

pub fn clear(&mut self)

Clears the set, removing all elements.

pub fn len(&self) -> usize

Returns the number of elements in the set.

pub fn is_empty(&self) -> bool

Returns true if the set contains no elements.

pub fn insert(&mut self, range: RangeInclusive<T>)

Insert a range into the set.

If the inserted range either overlaps or is immediately adjacent any existing range, then the ranges will be coalesced into a single contiguous range.

Panics

Panics if range start > end.

pub fn remove(&mut self, range: RangeInclusive<T>)

Removes a range from the set, if all or any of it was present.

If the range to be removed partially overlaps any ranges in the set, then those ranges will be contracted to no longer cover the removed range.

Panics

Panics if range start > end.

pub fn gaps<'a>( &'a self, outer_range: &'a RangeInclusive<T>, ) -> Gaps<'a, T, StepFnsT>

Gets an iterator over all the maximally-sized ranges contained in outer_range that are not covered by any range stored in the set.

The iterator element type is RangeInclusive<T>.

pub fn overlapping<R: Borrow<RangeInclusive<T>>>( &self, range: R, ) -> Overlapping<'_, T, R>

Gets an iterator over all the stored ranges that are either partially or completely overlapped by the given range.

The iterator element type is RangeInclusive<T>.

pub fn overlaps(&self, range: &RangeInclusive<T>) -> bool

Returns true if any range in the set completely or partially overlaps the given range.

pub fn first(&self) -> Option<&RangeInclusive<T>>

Returns the first range in the set, if one exists. The range is the minimum range in this set.

pub fn last(&self) -> Option<&RangeInclusive<T>>

Returns the last range in the set, if one exists. The range is the maximum range in this set.

pub fn union<'a>(&'a self, other: &'a Self) -> Union<'a, T>

Return an iterator over the union of two range sets.

pub fn intersection<'a>(&'a self, other: &'a Self) -> Intersection<'a, T>

Return an iterator over the intersection of two range sets.

Trait Implementations

impl<T: Ord + Clone + StepLite> BitAnd for &RangeInclusiveSet<T>

type Output = RangeInclusiveSet<T>

The resulting type after applying the & operator.

fn bitand(self, other: Self) -> Self::Output

Performs the & operation.

impl<T: Ord + Clone + StepLite> BitOr for &RangeInclusiveSet<T>

type Output = RangeInclusiveSet<T>

The resulting type after applying the | operator.

fn bitor(self, other: Self) -> Self::Output

Performs the | operation.

impl<T: Clone, StepFnsT: Clone> Clone for RangeInclusiveSet<T, StepFnsT>

fn clone(&self) -> RangeInclusiveSet<T, StepFnsT>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for RangeInclusiveSet<T>

where T: Ord + Clone + StepLite + Debug,

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

Formats the value using the given formatter.

impl<T, StepFnsT> Default for RangeInclusiveSet<T, StepFnsT>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Extend<RangeInclusive<T>> for RangeInclusiveSet<T>

where T: Ord + Clone + StepLite,

fn extend<I: IntoIterator<Item = RangeInclusive<T>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<T: Ord + Clone + StepLite, const N: usize> From<[RangeInclusive<T>; N]> for RangeInclusiveSet<T>

fn from(value: [RangeInclusive<T>; N]) -> Self

Converts to this type from the input type.

impl<T> FromIterator<RangeInclusive<T>> for RangeInclusiveSet<T>

where T: Ord + Clone + StepLite,

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

Creates a value from an iterator.

impl<T: Hash, StepFnsT: Hash> Hash for RangeInclusiveSet<T, StepFnsT>

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<T> IntoIterator for RangeInclusiveSet<T>

type Item = RangeInclusive<T>

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Ord, StepFnsT: Ord> Ord for RangeInclusiveSet<T, StepFnsT>

fn cmp(&self, other: &RangeInclusiveSet<T, StepFnsT>) -> 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.

impl<T: PartialEq, StepFnsT: PartialEq> PartialEq for RangeInclusiveSet<T, StepFnsT>

fn eq(&self, other: &RangeInclusiveSet<T, StepFnsT>) -> 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<T: PartialOrd, StepFnsT: PartialOrd> PartialOrd for RangeInclusiveSet<T, StepFnsT>

fn partial_cmp( &self, other: &RangeInclusiveSet<T, StepFnsT>, ) -> 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: Eq, StepFnsT: Eq> Eq for RangeInclusiveSet<T, StepFnsT>

impl<T, StepFnsT> StructuralPartialEq for RangeInclusiveSet<T, StepFnsT>