Struct rangemap::inclusive_map::RangeInclusiveMap

pub struct RangeInclusiveMap<K, V, StepFnsT = K> { /* private fields */ }

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

Contiguous and overlapping ranges that map to the same value are coalesced into a single range.

Successor and predecessor functions must be provided for the key type K, so that we can detect adjacent but non-overlapping (closed) ranges. (This is not a problem for half-open ranges, because adjacent ranges can be detected using equality of range ends alone.)

You can provide these functions either by implementing the StepLite trait for your key type K, or, if this is impossible because of Rust’s “orphan rules”, you can provide equivalent free functions using the StepFnsT type parameter. StepLite is implemented for all standard integer types, but not for any third party crate types.

Implementations

impl<K, V, StepFnsT> RangeInclusiveMap<K, V, StepFnsT>

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

Gets an iterator over all pairs of key range and value, ordered by key range.

The iterator element type is (&'a RangeInclusive<K>, &'a V).

impl<K, V> RangeInclusiveMap<K, V, K>

where K: Ord + Clone + StepLite, V: Eq + Clone,

pub fn new() -> Self

Makes a new empty RangeInclusiveMap.

impl<K, V, StepFnsT> RangeInclusiveMap<K, V, StepFnsT>

where K: Ord + Clone, V: Eq + Clone, StepFnsT: StepFns<K>,

pub fn new_with_step_fns() -> Self

Makes a new empty RangeInclusiveMap, specifying successor and predecessor functions defined separately from K itself.

This is useful as a workaround for Rust’s “orphan rules”, which prevent you from implementing StepLite for K if K 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, key: &K) -> Option<&V>

Returns a reference to the value corresponding to the given key, if the key is covered by any range in the map.

pub fn get_key_value(&self, key: &K) -> Option<(&RangeInclusive<K>, &V)>

Returns the range-value pair (as a pair of references) corresponding to the given key, if the key is covered by any range in the map.

pub fn contains_key(&self, key: &K) -> bool

Returns true if any range in the map covers the specified key.

pub fn clear(&mut self)

Clears the map, removing all elements.

pub fn len(&self) -> usize

Returns the number of elements in the map.

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

pub fn insert(&mut self, range: RangeInclusive<K>, value: V)

Insert a pair of key range and value into the map.

If the inserted range partially or completely overlaps any existing range in the map, then the existing range (or ranges) will be partially or completely replaced by the inserted range.

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

Panics

Panics if range start > end.

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

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

If the range to be removed partially overlaps any ranges in the map, 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<K> ) -> Gaps<'a, K, V, StepFnsT>

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

The iterator element type is RangeInclusive<K>.

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

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

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

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

pub fn first_range_value(&self) -> Option<(&RangeInclusive<K>, &V)>

Returns the first range-value pair in this map, if one exists. The range in this pair is the minimum range in the map.

pub fn last_range_value(&self) -> Option<(&RangeInclusive<K>, &V)>

Returns the last range-value pair in this map, if one exists. The range in this pair is the maximum range in the map.

Trait Implementations

impl<K: Clone, V: Clone, StepFnsT: Clone> Clone for RangeInclusiveMap<K, V, StepFnsT>

fn clone(&self) -> RangeInclusiveMap<K, V, StepFnsT>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V> Debug for RangeInclusiveMap<K, V>

where K: Ord + Clone + StepLite + Debug, V: Eq + Clone + Debug,

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

Formats the value using the given formatter.

impl<K, V, StepFnsT> Default for RangeInclusiveMap<K, V, StepFnsT>

fn default() -> Self

Returns the “default value” for a type.

impl<K, V> Extend<(RangeInclusive<K>, V)> for RangeInclusiveMap<K, V>

where K: Ord + Clone + StepLite, V: Eq + Clone,

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

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<K: Ord + Clone + StepLite, V: Eq + Clone, const N: usize> From<[(RangeInclusive<K>, V); N]> for RangeInclusiveMap<K, V>

fn from(value: [(RangeInclusive<K>, V); N]) -> Self

Converts to this type from the input type.

impl<K, V> FromIterator<(RangeInclusive<K>, V)> for RangeInclusiveMap<K, V>

where K: Ord + Clone + StepLite, V: Eq + Clone,

fn from_iter<T: IntoIterator<Item = (RangeInclusive<K>, V)>>(iter: T) -> Self

Creates a value from an iterator.

impl<K, V, StepFnsT> Hash for RangeInclusiveMap<K, V, StepFnsT>

where K: Hash, V: Hash,

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<K, V> IntoIterator for RangeInclusiveMap<K, V>

type Item = (RangeInclusive<K>, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V, StepFnsT> Ord for RangeInclusiveMap<K, V, StepFnsT>

where K: Ord, V: Ord,

fn cmp(&self, other: &RangeInclusiveMap<K, V, 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 + PartialOrd,

Restrict a value to a certain interval.

impl<K, V, StepFnsT> PartialEq for RangeInclusiveMap<K, V, StepFnsT>

where K: PartialEq, V: PartialEq,

fn eq(&self, other: &RangeInclusiveMap<K, V, StepFnsT>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K, V, StepFnsT> PartialOrd for RangeInclusiveMap<K, V, StepFnsT>

where K: PartialOrd, V: PartialOrd,

fn partial_cmp( &self, other: &RangeInclusiveMap<K, V, StepFnsT> ) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<K, V, StepFnsT> Eq for RangeInclusiveMap<K, V, StepFnsT>

where K: Eq, V: Eq,