Struct range_map::RangeMap

pub struct RangeMap<T, V> { /* private fields */ }

A set of characters. Optionally, each character in the set may be associated with some data.

Implementations

impl<T: Debug + PrimInt, V: Clone + Debug + Eq> RangeMap<T, V>

pub fn new() -> RangeMap<T, V>

Creates a new empty RangeMap.

pub fn try_from_iter<I: IntoIterator<Item = (Range<T>, V)>>(
    iter: I
) -> Result<RangeMap<T, V>, OverlapError<T, V>>

Builds a RangeMap from an iterator over pairs. If any ranges overlap, they should map to the same value. If not, returns an OverlapError.

pub fn num_ranges(&self) -> usize

Returns the number of mapped ranges.

Note that this is not usually the same as the number of mapped values.

pub fn is_empty(&self) -> bool

Tests whether this map is empty.

pub fn is_full(&self) -> bool

Tests whether this CharMap maps every value.

pub fn ranges_values<'a>(&'a self) -> Iter<'a, (Range<T>, V)>

Iterates over all the mapped ranges and values.

pub fn keys_values<'a>(&'a self) -> PairIter<'a, T, V>

Iterates over all mappings.

pub fn get(&self, x: T) -> Option<&V>

Finds the value that x maps to, if it exists.

Runs in O(log n) time, where n is the number of mapped ranges.

pub fn intersection(&self, other: &RangeSet<T>) -> RangeMap<T, V>

Returns those mappings whose keys belong to the given set.

pub fn num_keys(&self) -> usize

Counts the number of mapped keys.

This saturates at usize::MAX.

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

Returns the set of mapped chars, forgetting what they are mapped to.

pub fn map_values<F>(&mut self, f: F)where
    F: FnMut(&V) -> V,

Modifies the values in place.

pub fn retain_values<F>(&mut self, f: F)where
    F: FnMut(&V) -> bool,

Modifies this map to contain only those mappings with values v satisfying f(v).

pub fn as_mut_slice(&mut self) -> &mut [(Range<T>, V)]

Returns a mutable view into this map.

The ranges should not be modified, since that might violate our invariants.

This method will eventually be removed, probably once anonymous return values allow is to write a values_mut() iterator more easily.

Trait Implementations

impl<T: Clone, V: Clone> Clone for RangeMap<T, V>

fn clone(&self) -> RangeMap<T, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, V: Debug> Debug for RangeMap<T, V>

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

Formats the value using the given formatter.

impl<T: Debug + PrimInt, V: Clone + Debug + Eq> FromIterator<(Range<T>, V)> for RangeMap<T, V>

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

Builds a RangeMap from an iterator over pairs. If any ranges overlap, they must map to the same value.

Panics

Panics if there are ranges that overlap and do not map to the same value. If you are not sure whether this could happen, use RangeMap::try_from_iter instead.

impl<T: Hash, V: Hash> Hash for RangeMap<T, V>

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: PartialEq, V: PartialEq> PartialEq<RangeMap<T, V>> for RangeMap<T, V>

fn eq(&self, other: &RangeMap<T, V>) -> 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<T: Eq, V: Eq> Eq for RangeMap<T, V>

impl<T, V> StructuralEq for RangeMap<T, V>

impl<T, V> StructuralPartialEq for RangeMap<T, V>