From f114f2898bd1dcbfc8b7e1b31354e8b8e2bf45c2 Mon Sep 17 00:00:00 2001 From: ripytide Date: Sun, 11 Jun 2023 12:39:38 +0100 Subject: [PATCH] rename overly complicated name for DiscreteRangeBounds to interval --- README.md | 8 +- src/discrete_range_map.rs | 112 +++++++++--------- src/discrete_range_set.rs | 10 +- ...{discrete_finite_bounds.rs => interval.rs} | 6 +- src/lib.rs | 13 +- src/test_ranges.rs | 34 +++--- src/utils.rs | 38 +++--- 7 files changed, 108 insertions(+), 113 deletions(-) rename src/{discrete_finite_bounds.rs => interval.rs} (89%) diff --git a/README.md b/README.md index 32a8c08..1819157 100644 --- a/README.md +++ b/README.md @@ -40,7 +40,7 @@ assert_eq!(map.contains_point(5), true); ```rust use discrete_range_map::test_ranges::ie; use discrete_range_map::{ - DiscreteFinite, DiscreteFiniteBounds, DiscreteRangeMap, + DiscreteFinite, Interval, DiscreteRangeMap, FiniteRange, }; @@ -70,9 +70,9 @@ impl FiniteRange for Reservation { } } -// Second, we need to implement From> -impl From> for Reservation { - fn from(bounds: DiscreteFiniteBounds) -> Self { +// Second, we need to implement From> +impl From> for Reservation { + fn from(bounds: Interval) -> Self { if bounds.end == i8::MAX { Reservation::Infinite(bounds.start) } else { diff --git a/src/discrete_range_map.rs b/src/discrete_range_map.rs index 71e61ff..cc63726 100644 --- a/src/discrete_range_map.rs +++ b/src/discrete_range_map.rs @@ -33,7 +33,7 @@ use serde::ser::SerializeMap; use serde::{Deserialize, Deserializer, Serialize, Serializer}; use crate::discrete_finite::DiscreteFinite; -use crate::discrete_finite_bounds::DiscreteFiniteBounds; +use crate::interval::Interval; use crate::utils::{cmp_point_with_range, cut_range, is_valid_range, overlaps}; /// An ordered map of non-overlapping ranges based on [`BTreeMap`]. @@ -90,17 +90,15 @@ pub struct OverlapError; impl DiscreteRangeMap where I: Ord + Copy + DiscreteFinite, - K: FiniteRange + Copy + From>, + K: FiniteRange + Copy + From>, { /// Makes a new, empty `DiscreteRangeMap`. /// /// # Examples /// ``` - /// use discrete_range_map::{ - /// DiscreteFiniteBounds, DiscreteRangeMap, - /// }; + /// use discrete_range_map::{DiscreteRangeMap, Interval}; /// - /// let map: DiscreteRangeMap, bool> = + /// let map: DiscreteRangeMap, bool> = /// DiscreteRangeMap::new(); /// ``` pub fn new() -> Self { @@ -368,7 +366,7 @@ where .get_key_value(overlapping_comp(point)) .ok_or_else(|| K::from(self.get_gap_at_raw(point))) } - fn get_gap_at_raw(&self, point: I) -> DiscreteFiniteBounds { + fn get_gap_at_raw(&self, point: I) -> Interval { let lower = self .inner .upper_bound(overlapping_comp(point), SearchBoundCustom::Included); @@ -376,7 +374,7 @@ where .inner .lower_bound(overlapping_comp(point), SearchBoundCustom::Included); - DiscreteFiniteBounds { + Interval { start: lower .key() .map_or(I::MIN, |lower| lower.end().up().unwrap()), @@ -655,7 +653,7 @@ where .into_iter() .chain(self.remove_overlapping(range).map(|(key, value)| { ( - K::from(DiscreteFiniteBounds { + K::from(Interval { start: key.start(), end: key.end(), }), @@ -744,7 +742,7 @@ where let inner_gaps = overlapping .tuple_windows() .map(|(first, second)| { - K::from(DiscreteFiniteBounds { + K::from(Interval { start: first.1.up().unwrap(), end: second.0.down().unwrap(), }) @@ -857,17 +855,15 @@ where let matching_end = get_end(self, &value); let returning = match (matching_start, matching_end) { - (Some(matching_start), Some(matching_end)) => { - K::from(DiscreteFiniteBounds { - start: matching_start.start(), - end: matching_end.end(), - }) - } - (Some(matching_start), None) => K::from(DiscreteFiniteBounds { + (Some(matching_start), Some(matching_end)) => K::from(Interval { + start: matching_start.start(), + end: matching_end.end(), + }), + (Some(matching_start), None) => K::from(Interval { start: matching_start.start(), end: range.end(), }), - (None, Some(matching_end)) => K::from(DiscreteFiniteBounds { + (None, Some(matching_end)) => K::from(Interval { start: range.start(), end: matching_end.end(), }), @@ -1455,7 +1451,7 @@ impl Default for DiscreteRangeMap { impl Serialize for DiscreteRangeMap where I: Ord + Copy + DiscreteFinite, - K: FiniteRange + Copy + From> + Serialize, + K: FiniteRange + Copy + From> + Serialize, V: Serialize, { fn serialize(&self, serializer: S) -> Result @@ -1473,7 +1469,7 @@ where impl<'de, I, K, V> Deserialize<'de> for DiscreteRangeMap where I: Ord + Copy + DiscreteFinite, - K: FiniteRange + Copy + From> + Deserialize<'de>, + K: FiniteRange + Copy + From> + Deserialize<'de>, V: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result @@ -1497,7 +1493,7 @@ struct DiscreteRangeMapVisitor { impl<'de, I, K, V> Visitor<'de> for DiscreteRangeMapVisitor where I: Ord + Copy + DiscreteFinite, - K: FiniteRange + Copy + From> + Deserialize<'de>, + K: FiniteRange + Copy + From> + Deserialize<'de>, V: Deserialize<'de>, { type Value = DiscreteRangeMap; @@ -1534,7 +1530,7 @@ mod tests { pub(crate) const NUMBERS_DOMAIN: &'static [i8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]; - fn basic() -> DiscreteRangeMap, bool> { + fn basic() -> DiscreteRangeMap, bool> { DiscreteRangeMap::from_slice_strict([ (ui(4), false), (ee(5, 7), true), @@ -1543,7 +1539,7 @@ mod tests { ]) .unwrap() } - fn basic_slice() -> [(DiscreteFiniteBounds, bool); 4] { + fn basic_slice() -> [(Interval, bool); 4] { [ (ui(4), false), (ee(5, 7), true), @@ -1586,10 +1582,10 @@ mod tests { ); } fn assert_insert_strict( - mut before: DiscreteRangeMap, bool>, - to_insert: (DiscreteFiniteBounds, bool), + mut before: DiscreteRangeMap, bool>, + to_insert: (Interval, bool), result: Result<(), OverlapError>, - after: [(DiscreteFiniteBounds, bool); N], + after: [(Interval, bool); N], ) { assert_eq!(before.insert_strict(to_insert.0, to_insert.1), result); assert_eq!(before, DiscreteRangeMap::from_slice_strict(after).unwrap()) @@ -1601,7 +1597,7 @@ mod tests { for overlap_range in all_valid_test_bounds() { //you can't overlap nothing assert!( - DiscreteRangeMap::, ()>::new() + DiscreteRangeMap::, ()>::new() .overlapping(overlap_range) .next() .is_none() @@ -1705,10 +1701,10 @@ mod tests { ); } fn assert_remove_overlapping( - mut before: DiscreteRangeMap, bool>, - to_remove: DiscreteFiniteBounds, - result: [(DiscreteFiniteBounds, bool); N], - after: [(DiscreteFiniteBounds, bool); Y], + mut before: DiscreteRangeMap, bool>, + to_remove: Interval, + result: [(Interval, bool); N], + after: [(Interval, bool); Y], ) { assert_eq!( before.remove_overlapping(to_remove).collect::>(), @@ -1755,10 +1751,10 @@ mod tests { ); } fn assert_cut( - mut before: DiscreteRangeMap, bool>, - to_cut: DiscreteFiniteBounds, - result: [(DiscreteFiniteBounds, bool); Y], - after: [(DiscreteFiniteBounds, bool); N], + mut before: DiscreteRangeMap, bool>, + to_cut: Interval, + result: [(Interval, bool); Y], + after: [(Interval, bool); N], ) { assert_eq!(before.cut(to_cut).collect::>(), result); assert_eq!(before, DiscreteRangeMap::from_slice_strict(after).unwrap()); @@ -1794,9 +1790,9 @@ mod tests { ); } fn assert_gaps( - map: DiscreteRangeMap, bool>, - outer_range: DiscreteFiniteBounds, - result: [DiscreteFiniteBounds; N], + map: DiscreteRangeMap, bool>, + outer_range: Interval, + result: [Interval; N], ) { assert_eq!(map.gaps(outer_range).collect::>(), result); } @@ -1844,10 +1840,10 @@ mod tests { ); } fn assert_insert_merge_touching( - mut before: DiscreteRangeMap, bool>, - to_insert: (DiscreteFiniteBounds, bool), - result: Result, OverlapError>, - after: [(DiscreteFiniteBounds, bool); N], + mut before: DiscreteRangeMap, bool>, + to_insert: (Interval, bool), + result: Result, OverlapError>, + after: [(Interval, bool); N], ) { assert_eq!( before.insert_merge_touching(to_insert.0, to_insert.1), @@ -1900,10 +1896,10 @@ mod tests { ); } fn assert_insert_merge_touching_if_values_equal( - mut before: DiscreteRangeMap, bool>, - to_insert: (DiscreteFiniteBounds, bool), - result: Result, OverlapError>, - after: [(DiscreteFiniteBounds, bool); N], + mut before: DiscreteRangeMap, bool>, + to_insert: (Interval, bool), + result: Result, OverlapError>, + after: [(Interval, bool); N], ) { assert_eq!( before.insert_merge_touching_if_values_equal( @@ -1964,10 +1960,10 @@ mod tests { ); } fn assert_insert_merge_overlapping( - mut before: DiscreteRangeMap, bool>, - to_insert: (DiscreteFiniteBounds, bool), - result: DiscreteFiniteBounds, - after: [(DiscreteFiniteBounds, bool); N], + mut before: DiscreteRangeMap, bool>, + to_insert: (Interval, bool), + result: Interval, + after: [(Interval, bool); N], ) { assert_eq!( before.insert_merge_overlapping(to_insert.0, to_insert.1), @@ -2040,10 +2036,10 @@ mod tests { ); } fn assert_insert_merge_touching_or_overlapping( - mut before: DiscreteRangeMap, bool>, - to_insert: (DiscreteFiniteBounds, bool), - result: DiscreteFiniteBounds, - after: [(DiscreteFiniteBounds, bool); N], + mut before: DiscreteRangeMap, bool>, + to_insert: (Interval, bool), + result: Interval, + after: [(Interval, bool); N], ) { assert_eq!( before @@ -2141,7 +2137,7 @@ mod tests { } } } - fn con(x: Option>, point: &i8) -> bool { + fn con(x: Option>, point: &i8) -> bool { match x { Some(y) => contains_point(y, *point), None => false, @@ -2175,7 +2171,7 @@ mod tests { // Test Helper Functions //====================== fn all_non_overlapping_test_bound_entries() - -> Vec<(DiscreteFiniteBounds, DiscreteFiniteBounds)> { + -> Vec<(Interval, Interval)> { let mut output = Vec::new(); for test_bounds1 in all_valid_test_bounds() { for test_bounds2 in all_valid_test_bounds() { @@ -2188,12 +2184,12 @@ mod tests { return output; } - fn all_valid_test_bounds() -> Vec> { + fn all_valid_test_bounds() -> Vec> { let mut output = Vec::new(); for i in NUMBERS { for j in NUMBERS { if i <= j { - output.push(DiscreteFiniteBounds { start: *i, end: *j }); + output.push(Interval { start: *i, end: *j }); } } } diff --git a/src/discrete_range_set.rs b/src/discrete_range_set.rs index 3992b4c..797411d 100644 --- a/src/discrete_range_set.rs +++ b/src/discrete_range_set.rs @@ -6,10 +6,10 @@ use serde::ser::SerializeSeq; use serde::{Deserialize, Deserializer, Serialize, Serializer}; use crate::discrete_finite::DiscreteFinite; -use crate::discrete_finite_bounds::DiscreteFiniteBounds; use crate::discrete_range_map::{ FiniteRange, IntoIter as DiscreteRangeMapIntoIter, }; +use crate::interval::Interval; use crate::{DiscreteRangeMap, OverlapError}; /// An ordered set of non-overlapping ranges based on [`DiscreteRangeMap`]. @@ -31,7 +31,7 @@ pub struct DiscreteRangeSet { impl DiscreteRangeSet where I: Ord + Copy + DiscreteFinite, - K: FiniteRange + Copy + From>, + K: FiniteRange + Copy + From>, { /// See [`DiscreteRangeMap::new()`] for more details. pub fn new() -> Self { @@ -199,7 +199,7 @@ where impl Serialize for DiscreteRangeSet where I: Ord + Copy + DiscreteFinite, - K: FiniteRange + Copy + From> + Serialize, + K: FiniteRange + Copy + From> + Serialize, { fn serialize(&self, serializer: S) -> Result where @@ -216,7 +216,7 @@ where impl<'de, I, K> Deserialize<'de> for DiscreteRangeSet where I: Ord + Copy + DiscreteFinite, - K: FiniteRange + Copy + From> + Deserialize<'de>, + K: FiniteRange + Copy + From> + Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where @@ -237,7 +237,7 @@ struct DiscreteRangeSetVisitor { impl<'de, I, K> Visitor<'de> for DiscreteRangeSetVisitor where I: Ord + Copy + DiscreteFinite, - K: FiniteRange + Copy + From> + Deserialize<'de>, + K: FiniteRange + Copy + From> + Deserialize<'de>, { type Value = DiscreteRangeSet; diff --git a/src/discrete_finite_bounds.rs b/src/interval.rs similarity index 89% rename from src/discrete_finite_bounds.rs rename to src/interval.rs index f9fadf5..f17b197 100644 --- a/src/discrete_finite_bounds.rs +++ b/src/interval.rs @@ -19,14 +19,14 @@ along with discrete_range_map. If not, see . use crate::discrete_range_map::FiniteRange; +///both ends are always included #[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub struct DiscreteFiniteBounds { - //both are always included +pub struct Interval { pub start: I, pub end: I, } -impl FiniteRange for DiscreteFiniteBounds +impl FiniteRange for Interval where I: Copy, { diff --git a/src/lib.rs b/src/lib.rs index c046281..12883b4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -48,8 +48,7 @@ along with discrete_range_map. If not, see . //! ```rust //! use discrete_range_map::test_ranges::ie; //! use discrete_range_map::{ -//! DiscreteFinite, DiscreteFiniteBounds, DiscreteRangeMap, -//! FiniteRange, +//! DiscreteFinite, DiscreteRangeMap, FiniteRange, Interval, //! }; //! //! #[derive(Debug, Copy, Clone)] @@ -78,9 +77,9 @@ along with discrete_range_map. If not, see . //! } //! } //! -//! // Second, we need to implement From> -//! impl From> for Reservation { -//! fn from(bounds: DiscreteFiniteBounds) -> Self { +//! // Second, we need to implement From> +//! impl From> for Reservation { +//! fn from(bounds: Interval) -> Self { //! if bounds.end == i8::MAX { //! Reservation::Infinite(bounds.start) //! } else { @@ -271,14 +270,14 @@ pub mod test_ranges; pub(crate) mod utils; pub mod discrete_finite; -pub mod discrete_finite_bounds; +pub mod interval; pub mod discrete_range_map; pub mod discrete_range_set; pub use crate::discrete_finite::DiscreteFinite; -pub use crate::discrete_finite_bounds::DiscreteFiniteBounds; pub use crate::discrete_range_map::{ DiscreteRangeMap, FiniteRange, OverlapError, }; pub use crate::discrete_range_set::DiscreteRangeSet; +pub use crate::interval::Interval; diff --git a/src/test_ranges.rs b/src/test_ranges.rs index a8fc1cd..3a85ee6 100644 --- a/src/test_ranges.rs +++ b/src/test_ranges.rs @@ -1,26 +1,26 @@ use crate::discrete_finite::DiscreteFinite; -use crate::discrete_finite_bounds::DiscreteFiniteBounds; +use crate::interval::Interval; -pub fn uu() -> DiscreteFiniteBounds { - DiscreteFiniteBounds { +pub fn uu() -> Interval { + Interval { start: i8::MIN, end: i8::MAX, } } -pub fn ui(x: i8) -> DiscreteFiniteBounds { - DiscreteFiniteBounds { +pub fn ui(x: i8) -> Interval { + Interval { start: i8::MIN, end: x, } } -pub fn ue(x: i8) -> DiscreteFiniteBounds { - DiscreteFiniteBounds { +pub fn ue(x: i8) -> Interval { + Interval { start: i8::MIN, end: x.down().unwrap(), } } -pub fn iu(x: i8) -> DiscreteFiniteBounds { - DiscreteFiniteBounds { +pub fn iu(x: i8) -> Interval { + Interval { start: x, end: i8::MAX, } @@ -28,23 +28,23 @@ pub fn iu(x: i8) -> DiscreteFiniteBounds { //fn eu(x: i8) -> TestBounds { //(Bound::Excluded(x), Bound::Unbounded) //} -pub fn ii(x1: i8, x2: i8) -> DiscreteFiniteBounds { - DiscreteFiniteBounds { start: x1, end: x2 } +pub fn ii(x1: i8, x2: i8) -> Interval { + Interval { start: x1, end: x2 } } -pub fn ie(x1: i8, x2: i8) -> DiscreteFiniteBounds { - DiscreteFiniteBounds { +pub fn ie(x1: i8, x2: i8) -> Interval { + Interval { start: x1, end: x2.down().unwrap(), } } -pub fn ei(x1: i8, x2: i8) -> DiscreteFiniteBounds { - DiscreteFiniteBounds { +pub fn ei(x1: i8, x2: i8) -> Interval { + Interval { start: x1.up().unwrap(), end: x2, } } -pub fn ee(x1: i8, x2: i8) -> DiscreteFiniteBounds { - DiscreteFiniteBounds { +pub fn ee(x1: i8, x2: i8) -> Interval { + Interval { start: x1.up().unwrap(), end: x2.down().unwrap(), } diff --git a/src/utils.rs b/src/utils.rs index 62a9e48..f7f5b78 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -20,8 +20,8 @@ along with discrete_range_map. If not, see . use std::cmp::Ordering; use crate::discrete_finite::DiscreteFinite; -use crate::discrete_finite_bounds::DiscreteFiniteBounds; use crate::discrete_range_map::FiniteRange; +use crate::interval::Interval; pub(crate) fn cmp_point_with_range(point: I, range: K) -> Ordering where @@ -71,9 +71,9 @@ where } enum SortedConfig { - NonOverlapping(DiscreteFiniteBounds, DiscreteFiniteBounds), - PartialOverlap(DiscreteFiniteBounds, DiscreteFiniteBounds), - Swallowed(DiscreteFiniteBounds, DiscreteFiniteBounds), + NonOverlapping(Interval, Interval), + PartialOverlap(Interval, Interval), + Swallowed(Interval, Interval), } fn sorted_config(a: A, b: B) -> SortedConfig where @@ -81,11 +81,11 @@ where B: FiniteRange + Copy, I: Ord, { - let ae = DiscreteFiniteBounds { + let ae = Interval { start: a.start(), end: a.end(), }; - let be = DiscreteFiniteBounds { + let be = Interval { start: b.start(), end: b.end(), }; @@ -114,9 +114,9 @@ where #[derive(Debug)] pub(crate) struct CutResult { - pub(crate) before_cut: Option>, - pub(crate) inside_cut: Option>, - pub(crate) after_cut: Option>, + pub(crate) before_cut: Option>, + pub(crate) inside_cut: Option>, + pub(crate) after_cut: Option>, } pub(crate) fn cut_range(base: B, cut: C) -> CutResult where @@ -132,34 +132,34 @@ where match config(base, cut) { Config::LeftFirstNonOverlapping => { - result.before_cut = Some(DiscreteFiniteBounds { + result.before_cut = Some(Interval { start: base.start(), end: base.end(), }); } Config::LeftFirstPartialOverlap => { - result.before_cut = Some(DiscreteFiniteBounds { + result.before_cut = Some(Interval { start: base.start(), end: cut.start().down().unwrap(), }); - result.inside_cut = Some(DiscreteFiniteBounds { + result.inside_cut = Some(Interval { start: cut.start(), end: base.end(), }); } Config::LeftContainsRight => { - result.before_cut = Some(DiscreteFiniteBounds { + result.before_cut = Some(Interval { start: base.start(), end: cut.start().down().unwrap(), }); - result.inside_cut = Some(DiscreteFiniteBounds { + result.inside_cut = Some(Interval { start: cut.start(), end: cut.end(), }); //if cut is already max then we don't need to have an //after_cut if let Some(upped_end) = cut.end().up() { - result.after_cut = Some(DiscreteFiniteBounds { + result.after_cut = Some(Interval { start: upped_end, end: base.end(), }); @@ -167,23 +167,23 @@ where } Config::RightFirstNonOverlapping => { - result.after_cut = Some(DiscreteFiniteBounds { + result.after_cut = Some(Interval { start: base.start(), end: base.end(), }); } Config::RightFirstPartialOverlap => { - result.after_cut = Some(DiscreteFiniteBounds { + result.after_cut = Some(Interval { start: cut.end().up().unwrap(), end: base.end(), }); - result.inside_cut = Some(DiscreteFiniteBounds { + result.inside_cut = Some(Interval { start: base.start(), end: cut.end(), }); } Config::RightContainsLeft => { - result.inside_cut = Some(DiscreteFiniteBounds { + result.inside_cut = Some(Interval { start: base.start(), end: base.end(), });