yggdrasil/discrete_range_map
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

finished writing docs for map methods

Browse Source
This commit is contained in:
ripytide
2022-11-30 17:25:21 +00:00
parent 78dff0d99e
commit fd30485ee8
3 changed files with 206 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib.rs
+16 -6
View File
@@ -61,8 +61,12 @@ along with range_bounds_map. If not, see <https://www.gnu.org/licenses/>.
//! impl RangeBounds<u8> for Reservation {
//! fn start_bound(&self) -> Bound<&u8> {
//! match self {
//! Reservation::Finite(start, _) => Bound::Included(start),
//! Reservation::Infinite(start) => Bound::Excluded(start),
//! Reservation::Finite(start, _) => {
//! Bound::Included(start)
//! }
//! Reservation::Infinite(start) => {
//! Bound::Excluded(start)
//! }
//! }
//! }
//! fn end_bound(&self) -> Bound<&u8> {
@@ -80,15 +84,21 @@ along with range_bounds_map. If not, see <https://www.gnu.org/licenses/>.
//! ])
//! .unwrap();
//!
//! for (reservation, name) in reservation_map.overlapping(&(16..17)) {
//! println!("{name} has reserved {reservation:?} inside the range 16..17");
//! for (reservation, name) in reservation_map.overlapping(&(16..17))
//! {
//! println!(
//! "{name} has reserved {reservation:?} inside the range 16..17"
//! );
//! }
//!
//! for (reservation, name) in reservation_map.iter() {
//! println!("{name} has reserved {reservation:?}");
//! }
//!
//! assert_eq!(reservation_map.overlaps(&Reservation::Infinite(0)), true);
//! assert_eq!(
//! reservation_map.overlaps(&Reservation::Infinite(0)),
//! true
//! );
//! ```
//!
//! # How
@@ -161,7 +171,7 @@ along with range_bounds_map. If not, see <https://www.gnu.org/licenses/>.
//! - <https://docs.rs/unbounded-interval-tree>
//! A data structure based off of a 2007 published paper! It supports any
//! RangeBounds as keys too, except it is implemented with a non-balancing
//! Box<Node> based tree, however it also supports overlapping
//! `Box<Node>` based tree, however it also supports overlapping
//! RangeBounds which my library does not.
//! - <https://docs.rs/rangetree>
//! I'm not entirely sure what this library is or isn't, but it looks like
src/range_bounds_map.rs
+181 -10
View File
@@ -103,7 +103,7 @@ use crate::bounds::StartBound;
/// );
///
/// assert_eq!(
/// map.get_key_value_at_point(&NotNan::new(2.0).unwrap()),
/// map.get_range_bounds_value_at_point(&NotNan::new(2.0).unwrap()),
/// Some((&ExEx::new(0.0, 5.0), &8))
/// );
/// ```
@@ -120,18 +120,55 @@ where
K: RangeBounds<I>,
I: Ord + Clone,
{
/// Makes a new, empty `RangeBoundsMap`.
///
/// # Examples
/// ```
/// use std::ops::Range;
///
/// use range_bounds_map::RangeBoundsMap;
///
/// let range_bounds_map: RangeBoundsMap<u8, Range<u8>, bool> =
/// RangeBoundsMap::new();
/// ```
pub fn new() -> Self {
RangeBoundsMap {
starts: BTreeMap::new(),
}
}
/// Returns the number of `RangeBounds` in the map.
///
/// # Examples
/// ```
/// use range_bounds_map::RangeBoundsMap;
///
/// let mut range_bounds_map = RangeBoundsMap::new();
///
/// assert_eq!(range_bounds_map.len(), 0);
/// range_bounds_map.insert(0..1, false).unwrap();
/// assert_eq!(range_bounds_map.len(), 1);
/// ```
pub fn len(&self) -> usize {
self.starts.len()
}
//returns Err(()) if the given range overlaps another range
//does not coalesce ranges if they touch
/// Adds a new (`RangeBounds` `Value`) pair to the map.
///
/// If the new `RangeBounds` overlaps one or more `RangeBounds`
/// already in the set then `Err(())` is returned and the map is
/// not updated.
///
/// # Examples
/// ```
/// use range_bounds_map::RangeBoundsMap;
///
/// let mut range_bounds_map = RangeBoundsMap::new();
///
/// assert_eq!(range_bounds_map.insert(5..10, 9), Ok(()));
/// assert_eq!(range_bounds_map.insert(5..10, 2), Err(()));
/// assert_eq!(range_bounds_map.len(), 1);
/// ```
pub fn insert(&mut self, range_bounds: K, value: V) -> Result<(), ()> {
if self.overlaps(&range_bounds) {
return Err(());
@@ -148,10 +185,23 @@ where
return Ok(());
}
pub fn contains_point(&self, point: &I) -> bool {
self.get_at_point(point).is_some()
}
/// Returns `true` if the given `RangeBounds` overlaps any of the
/// `RangeBounds` in the map.
///
/// # Examples
/// ```
/// use range_bounds_map::RangeBoundsMap;
///
/// let mut range_bounds_map = RangeBoundsMap::new();
///
/// range_bounds_map.insert(5..10, false);
///
/// assert_eq!(range_bounds_map.overlaps(&(1..=3)), false);
/// assert_eq!(range_bounds_map.overlaps(&(4..5)), false);
///
/// assert_eq!(range_bounds_map.overlaps(&(4..=5)), true);
/// assert_eq!(range_bounds_map.overlaps(&(4..6)), true);
/// ```
pub fn overlaps<Q>(&self, search_range_bounds: &Q) -> bool
where
Q: RangeBounds<I>,
@@ -159,6 +209,27 @@ where
self.overlapping(search_range_bounds).next().is_some()
}
/// Returns an iterator over every (`RangeBounds`, `Value`) pair
/// in the map which overlap the given `search_range_bounds` in
/// ascending order.
///
/// # Examples
/// ```
/// use range_bounds_map::RangeBoundsMap;
///
/// let range_bounds_map = RangeBoundsMap::try_from([
/// (1..4, false),
/// (4..8, true),
/// (8..100, false),
/// ])
/// .unwrap();
///
/// let mut overlapping = range_bounds_map.overlapping(&(2..8));
///
/// assert_eq!(overlapping.next(), Some((&(1..4), &false)));
/// assert_eq!(overlapping.next(), Some((&(4..8), &true)));
/// assert_eq!(overlapping.next(), None);
/// ```
pub fn overlapping<Q>(
&self,
search_range_bounds: &Q,
@@ -214,13 +285,71 @@ where
);
}
/// Returns a reference to the `Value` corresponding to the
/// `RangeBounds` in the set that overlaps the given point, if
/// any.
///
/// # Examples
/// ```
/// use range_bounds_map::RangeBoundsMap;
///
/// let range_bounds_map = RangeBoundsMap::try_from([
/// (1..4, false),
/// (4..8, true),
/// (8..100, false),
/// ])
/// .unwrap();
///
/// assert_eq!(range_bounds_map.get_at_point(&3), Some(&false));
/// assert_eq!(range_bounds_map.get_at_point(&4), Some(&true));
/// assert_eq!(range_bounds_map.get_at_point(&101), None);
/// ```
pub fn get_at_point(&self, point: &I) -> Option<&V> {
self.get_key_value_at_point(point).map(|(_, value)| value)
self.get_range_bounds_value_at_point(point)
.map(|(_, value)| value)
}
/// Returns `true` if the map contains a `RangeBounds` that
/// overlaps a given point, and `false` if not.
///
/// # Examples
/// ```
/// use range_bounds_map::RangeBoundsMap;
///
/// let range_bounds_map = RangeBoundsMap::try_from([
/// (1..4, false),
/// (4..8, true),
/// (8..100, false),
/// ])
/// .unwrap();
///
/// assert_eq!(range_bounds_map.contains_point(&3), true);
/// assert_eq!(range_bounds_map.contains_point(&4), true);
/// assert_eq!(range_bounds_map.contains_point(&101), false);
/// ```
pub fn contains_point(&self, point: &I) -> bool {
self.get_at_point(point).is_some()
}
/// Returns a mutable reference to the `Value` corresponding to
/// the `RangeBounds` that overlaps the given point, if any.
///
/// # Examples
/// ```
/// use range_bounds_map::RangeBoundsMap;
///
/// let mut range_bounds_map =
/// RangeBoundsMap::try_from([(1..4, false)]).unwrap();
///
/// if let Some(x) = range_bounds_map.get_at_point_mut(&2) {
/// *x = true;
/// }
///
/// assert_eq!(range_bounds_map.get_at_point(&1), Some(&true));
/// ```
pub fn get_at_point_mut(&mut self, point: &I) -> Option<&mut V> {
if let Some(overlapping_start_bound) = self
.get_key_value_at_point(point)
.get_range_bounds_value_at_point(point)
.map(|(key, _)| key.start_bound())
{
return self
@@ -232,7 +361,28 @@ where
return None;
}
pub fn get_key_value_at_point(&self, point: &I) -> Option<(&K, &V)> {
/// Returns an (`RangeBounds`, `Value`) pair corresponding to the
/// `RangeBounds` that overlaps the given point, if any.
///
/// # Examples
/// ```
/// use range_bounds_map::RangeBoundsMap;
///
/// let range_bounds_map = RangeBoundsMap::try_from([
/// (1..4, false),
/// (4..8, true),
/// (8..100, false),
/// ])
/// .unwrap();
///
/// assert_eq!(range_bounds_map.get_range_bounds_value_at_point(&3), Some((&(1..4), &false)));
/// assert_eq!(range_bounds_map.get_range_bounds_value_at_point(&4), Some((&(4..8), &true)));
/// assert_eq!(range_bounds_map.get_range_bounds_value_at_point(&101), None);
/// ```
pub fn get_range_bounds_value_at_point(
&self,
point: &I,
) -> Option<(&K, &V)> {
//a zero-range included-included range is equivalent to a point
return self
.overlapping(&(
@@ -242,6 +392,27 @@ where
.next();
}
/// Returns an iterator over every (`RangeBounds`, `Value`) pair in the map in
/// ascending order.
///
/// # Examples
/// ```
/// use range_bounds_map::RangeBoundsMap;
///
/// let range_bounds_map = RangeBoundsMap::try_from([
/// (1..4, false),
/// (4..8, true),
/// (8..100, false),
/// ])
/// .unwrap();
///
/// let mut iter = range_bounds_map.iter();
///
/// assert_eq!(iter.next(), Some((&(1..4), &false)));
/// assert_eq!(iter.next(), Some((&(4..8), &true)));
/// assert_eq!(iter.next(), Some((&(8..100), &false)));
/// assert_eq!(iter.next(), None);
/// ```
pub fn iter(&self) -> impl Iterator<Item = (&K, &V)> {
self.starts.iter().map(|(_, (key, value))| (key, value))
}
src/range_bounds_set.rs
+9 -6
View File
@@ -28,7 +28,8 @@ use crate::range_bounds_map::RangeBoundsMap;
/// use range_bounds_map::RangeBoundsSet;
///
/// // Make a set with some ranges
/// let visits = RangeBoundsSet::try_from([4..8, 8..18, 20..100]).unwrap();
/// let visits =
/// RangeBoundsSet::try_from([4..8, 8..18, 20..100]).unwrap();
///
/// // Check if a point is contained in the set
/// if !visits.contains_point(&0) {
@@ -104,7 +105,8 @@ where
///
/// use range_bounds_map::RangeBoundsSet;
///
/// let range_bounds_set: RangeBoundsSet<u8, Range<u8>> = RangeBoundsSet::new();
/// let range_bounds_set: RangeBoundsSet<u8, Range<u8>> =
/// RangeBoundsSet::new();
/// ```
pub fn new() -> Self {
RangeBoundsSet {
@@ -173,7 +175,7 @@ where
}
/// Returns an iterator over every `RangeBounds` in the set which
/// overlaps the given `search_range_bounds` in ascending order.
/// overlap the given `search_range_bounds` in ascending order.
///
/// # Examples
/// ```
@@ -215,7 +217,7 @@ where
/// assert_eq!(range_bounds_set.get_at_point(&101), None);
/// ```
pub fn get_at_point(&self, point: &I) -> Option<&K> {
self.map.get_key_value_at_point(point).map(|(key, _)| key)
self.map.get_range_bounds_value_at_point(point).map(|(key, _)| key)
}
/// Returns `true` if the set contains a `RangeBounds` that
@@ -236,7 +238,7 @@ where
self.map.contains_point(point)
}
/// Returns an iterator over every `RangeBouns` in the set in
/// Returns an iterator over every `RangeBounds` in the set in
/// ascending order.
///
/// # Examples
@@ -246,10 +248,11 @@ where
/// let range_bounds_set =
/// RangeBoundsSet::try_from([1..4, 4..8, 8..100]).unwrap();
///
/// let mut iter = range_bounds_set.overlapping(&(2..8));
/// let mut iter = range_bounds_set.iter();
///
/// assert_eq!(iter.next(), Some(&(1..4)));
/// assert_eq!(iter.next(), Some(&(4..8)));
/// assert_eq!(iter.next(), Some(&(8..100)));
/// assert_eq!(iter.next(), None);
/// ```
pub fn iter(&self) -> impl Iterator<Item = &K> {