From 28a29b09c3f9dd1c599742eebbe95acb88cb5427 Mon Sep 17 00:00:00 2001 From: ripytide Date: Tue, 4 Apr 2023 19:30:03 +0100 Subject: [PATCH] removed bloat from set.rs too --- src/range_bounds_set.rs | 664 ++-------------------------------------- 1 file changed, 32 insertions(+), 632 deletions(-) diff --git a/src/range_bounds_set.rs b/src/range_bounds_set.rs index 0e60e7f..40d8cb1 100644 --- a/src/range_bounds_set.rs +++ b/src/range_bounds_set.rs @@ -174,38 +174,6 @@ where self.map.is_empty() } - /// Adds a new `RangeBounds` to the set without modifying other - /// `RangeBounds` in the set. - /// - /// If the given `RangeBounds` overlaps one or more `RangeBounds` - /// already in the set, then an [`OverlapError`] is returned and - /// the set is not updated. - /// - /// # Panics - /// - /// Panics if the given `range_bounds` is an invalid - /// `RangeBounds`. See [`Invalid - /// RangeBounds`](https://docs.rs/range_bounds_map/latest/range_bounds_map/index.html#Invalid-RangeBounds) - /// for more details. - /// - /// # Examples - /// ``` - /// use range_bounds_map::{OverlapError, RangeBoundsSet}; - /// - /// let mut set = RangeBoundsSet::new(); - /// - /// assert_eq!(set.insert_strict(5..10), Ok(())); - /// assert_eq!(set.insert_strict(5..10), Err(OverlapError)); - /// assert_eq!(set.len(), 1); - /// ``` - #[trivial] - pub fn insert_strict( - &mut self, - range_bounds: K, - ) -> Result<(), OverlapError> { - self.map.insert_strict(range_bounds, ()) - } - /// Returns `true` if the given `RangeBounds` overlaps any of the /// `RangeBounds` in the set, and `false` if not. /// @@ -424,51 +392,6 @@ where self.map.cut(range_bounds).map(|x| x.map(|(key, _)| key)) } - /// Identical to [`RangeBoundsSet::cut()`] except it returns an - /// iterator of `Result` - /// - /// # Panics - /// - /// Panics if the given `range_bounds` is an invalid - /// `RangeBounds`. See [`Invalid - /// RangeBounds`](https://docs.rs/range_bounds_map/latest/range_bounds_map/index.html#Invalid-RangeBounds) - /// for more details. - /// - /// # Examples - /// ``` - /// use range_bounds_map::{RangeBoundsSet, TryFromBoundsError}; - /// - /// let mut base = - /// RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100]) - /// .unwrap(); - /// - /// let after_cut = - /// RangeBoundsSet::from_slice_strict([1..2, 40..100]).unwrap(); - /// - /// assert_eq!( - /// base.cut_same(&(2..40)).unwrap().collect::>(), - /// [Ok(2..4), Ok(4..8), Ok(8..40)] - /// ); - /// assert_eq!(base, after_cut); - /// assert!(base.cut_same(&(60..=80)).is_err()); - /// ``` - #[trivial] - pub fn cut_same( - &mut self, - range_bounds: &Q, - ) -> Result< - impl DoubleEndedIterator>, - TryFromBoundsError, - > - where - Q: RangeBounds, - K: TryFromBounds, - { - self.map - .cut_same(range_bounds) - .map(|x| x.map(|(key, _)| key)) - } - /// Returns an iterator of `(Bound<&I>, Bound<&I>)` over all the /// maximally-sized gaps in the set that are also within the given /// `outer_range_bounds`. @@ -515,44 +438,6 @@ where self.map.gaps(outer_range_bounds) } - /// Identical to [`RangeBoundsSet::gaps()`] except it returns an - /// iterator of `Result`. - /// - /// # Panics - /// - /// Panics if the given `outer_range_bounds` is an invalid - /// `RangeBounds`. See [`Invalid - /// RangeBounds`](https://docs.rs/range_bounds_map/latest/range_bounds_map/index.html#Invalid-RangeBounds) - /// for more details. - /// - /// # Examples - /// ``` - /// use std::ops::Bound; - /// - /// use range_bounds_map::{RangeBoundsSet, TryFromBoundsError}; - /// - /// let set = RangeBoundsSet::from_slice_strict([1..3, 5..7, 9..100]) - /// .unwrap(); - /// - /// let mut gaps_same = set.gaps_same(&(2..)); - /// - /// assert_eq!( - /// gaps_same.collect::>(), - /// [Ok(3..5), Ok(7..9), Err(TryFromBoundsError),] - /// ); - /// ``` - #[trivial] - pub fn gaps_same<'a, Q>( - &'a self, - outer_range_bounds: &'a Q, - ) -> impl Iterator> + 'a - where - Q: RangeBounds, - K: TryFromBounds, - { - self.map.gaps_same(outer_range_bounds) - } - /// Returns `true` if the set covers every point in the given /// `RangeBounds`, and `false` if it doesn't. /// @@ -582,6 +467,38 @@ where self.map.contains_range_bounds(range_bounds) } + /// Adds a new `RangeBounds` to the set without modifying other + /// `RangeBounds` in the set. + /// + /// If the given `RangeBounds` overlaps one or more `RangeBounds` + /// already in the set, then an [`OverlapError`] is returned and + /// the set is not updated. + /// + /// # Panics + /// + /// Panics if the given `range_bounds` is an invalid + /// `RangeBounds`. See [`Invalid + /// RangeBounds`](https://docs.rs/range_bounds_map/latest/range_bounds_map/index.html#Invalid-RangeBounds) + /// for more details. + /// + /// # Examples + /// ``` + /// use range_bounds_map::{OverlapError, RangeBoundsSet}; + /// + /// let mut set = RangeBoundsSet::new(); + /// + /// assert_eq!(set.insert_strict(5..10), Ok(())); + /// assert_eq!(set.insert_strict(5..10), Err(OverlapError)); + /// assert_eq!(set.len(), 1); + /// ``` + #[trivial] + pub fn insert_strict( + &mut self, + range_bounds: K, + ) -> Result<(), OverlapError> { + self.map.insert_strict(range_bounds, ()) + } + /// Adds a new `RangeBounds` to the set and merges into other /// `RangeBounds` in the set which touch it. /// @@ -812,253 +729,6 @@ where self.map.last_entry().map(|(key, _)| key) } - /// Moves all elements from `other` into `self` using - /// [`RangeBoundsSet::insert_strict()`] in ascending order, - /// leaving `other` empty. - /// - /// If the underlying [`RangeBoundsMap::insert_strict()`] returns - /// an `Err` at any point, then the element it failed on and all - /// those following are dropped, but not inserted into `self`. - /// - /// # Examples - /// ``` - /// use range_bounds_map::RangeBoundsSet; - /// - /// let mut base = - /// RangeBoundsSet::from_slice_strict([1..4, 4..8]).unwrap(); - /// - /// let mut add = - /// RangeBoundsSet::from_slice_strict([10..38, 40..42]).unwrap(); - /// - /// let expected = RangeBoundsSet::from_slice_strict([ - /// 1..4, - /// 4..8, - /// 10..38, - /// 40..42, - /// ]) - /// .unwrap(); - /// - /// assert_eq!(base.append_strict(&mut add), Ok(())); - /// assert_eq!(base, expected); - /// assert!(add.is_empty()); - /// ``` - #[trivial] - pub fn append_strict( - &mut self, - other: &mut RangeBoundsSet, - ) -> Result<(), OverlapError> { - for range_bounds in - other.remove_overlapping(&(Bound::Unbounded::, Bound::Unbounded)) - { - self.insert_strict(range_bounds)?; - } - - return Ok(()); - } - /// Moves all elements from `other` into `self` using - /// [`RangeBoundsSet::insert_merge_touching()`] in ascending order, - /// leaving `other` empty. - /// - /// If the underlying [`RangeBoundsMap::insert_merge_touching()`] returns - /// an `Err` at any point, then the element it failed on and all - /// those following are dropped, but not inserted into `self`. - /// - /// # Examples - /// ``` - /// use range_bounds_map::RangeBoundsSet; - /// - /// let mut base = - /// RangeBoundsSet::from_slice_merge_touching([1..4, 4..8]) - /// .unwrap(); - /// - /// let mut add = - /// RangeBoundsSet::from_slice_merge_touching([10..38, 40..42]) - /// .unwrap(); - /// - /// let expected = RangeBoundsSet::from_slice_merge_touching([ - /// 1..4, - /// 4..8, - /// 10..38, - /// 40..42, - /// ]) - /// .unwrap(); - /// - /// assert_eq!(base.append_merge_touching(&mut add), Ok(())); - /// assert_eq!(base, expected); - /// assert!(add.is_empty()); - /// ``` - #[trivial] - pub fn append_merge_touching( - &mut self, - other: &mut RangeBoundsSet, - ) -> Result<(), OverlapOrTryFromBoundsError> - where - K: TryFromBounds, - { - for range_bounds in - other.remove_overlapping(&(Bound::Unbounded::, Bound::Unbounded)) - { - self.insert_merge_touching(range_bounds)?; - } - - return Ok(()); - } - /// Moves all elements from `other` into `self` using - /// [`RangeBoundsSet::insert_merge_overlapping()`] in ascending order, - /// leaving `other` empty. - /// - /// If the underlying [`RangeBoundsMap::insert_merge_overlapping()`] returns - /// an `Err` at any point, then the element it failed on and all - /// those following are dropped, but not inserted into `self`. - /// - /// # Examples - /// ``` - /// use range_bounds_map::RangeBoundsSet; - /// - /// let mut base = - /// RangeBoundsSet::from_slice_merge_overlapping([1..4, 4..8]) - /// .unwrap(); - /// - /// let mut add = RangeBoundsSet::from_slice_merge_overlapping([ - /// 10..38, - /// 40..42, - /// ]) - /// .unwrap(); - /// - /// let expected = RangeBoundsSet::from_slice_merge_overlapping([ - /// 1..4, - /// 4..8, - /// 10..38, - /// 40..42, - /// ]) - /// .unwrap(); - /// - /// assert_eq!(base.append_merge_overlapping(&mut add), Ok(())); - /// assert_eq!(base, expected); - /// assert!(add.is_empty()); - /// ``` - #[trivial] - pub fn append_merge_overlapping( - &mut self, - other: &mut RangeBoundsSet, - ) -> Result<(), TryFromBoundsError> - where - K: TryFromBounds, - { - for range_bounds in - other.remove_overlapping(&(Bound::Unbounded::, Bound::Unbounded)) - { - self.insert_merge_overlapping(range_bounds)?; - } - - return Ok(()); - } - /// Moves all elements from `other` into `self` using - /// [`RangeBoundsSet::insert_merge_touching_or_overlapping()`] in ascending order, - /// leaving `other` empty. - /// - /// If the underlying [`RangeBoundsMap::insert_merge_touching_or_overlapping()`] returns - /// an `Err` at any point, then the element it failed on and all - /// those following are dropped, but not inserted into `self`. - /// - /// # Examples - /// ``` - /// use range_bounds_map::RangeBoundsSet; - /// - /// let mut base = - /// RangeBoundsSet::from_slice_merge_touching_or_overlapping([ - /// 1..4, - /// 4..8, - /// ]) - /// .unwrap(); - /// - /// let mut add = - /// RangeBoundsSet::from_slice_merge_touching_or_overlapping([ - /// 10..38, - /// 40..42, - /// ]) - /// .unwrap(); - /// - /// let expected = - /// RangeBoundsSet::from_slice_merge_touching_or_overlapping([ - /// 1..4, - /// 4..8, - /// 10..38, - /// 40..42, - /// ]) - /// .unwrap(); - /// - /// assert_eq!( - /// base.append_merge_touching_or_overlapping(&mut add), - /// Ok(()) - /// ); - /// assert_eq!(base, expected); - /// assert!(add.is_empty()); - /// ``` - #[trivial] - pub fn append_merge_touching_or_overlapping( - &mut self, - other: &mut RangeBoundsSet, - ) -> Result<(), TryFromBoundsError> - where - K: TryFromBounds, - { - for range_bounds in - other.remove_overlapping(&(Bound::Unbounded::, Bound::Unbounded)) - { - self.insert_merge_touching_or_overlapping(range_bounds)?; - } - - return Ok(()); - } - /// Moves all elements from `other` into `self` using - /// [`RangeBoundsSet::insert_overwrite()`] in ascending order, - /// leaving `other` empty. - /// - /// If the underlying [`RangeBoundsMap::insert_overwrite()`] returns - /// an `Err` at any point, then the element it failed on and all - /// those following are dropped, but not inserted into `self`. - /// - /// # Examples - /// ``` - /// use range_bounds_map::RangeBoundsSet; - /// - /// let mut base = - /// RangeBoundsSet::from_slice_overwrite([1..4, 4..8]).unwrap(); - /// - /// let mut add = - /// RangeBoundsSet::from_slice_overwrite([10..38, 40..42]) - /// .unwrap(); - /// - /// let expected = RangeBoundsSet::from_slice_overwrite([ - /// 1..4, - /// 4..8, - /// 10..38, - /// 40..42, - /// ]) - /// .unwrap(); - /// - /// assert_eq!(base.append_overwrite(&mut add), Ok(())); - /// assert_eq!(base, expected); - /// assert!(add.is_empty()); - /// ``` - #[trivial] - pub fn append_overwrite( - &mut self, - other: &mut RangeBoundsSet, - ) -> Result<(), TryFromBoundsError> - where - K: TryFromBounds, - { - for range_bounds in - other.remove_overlapping(&(Bound::Unbounded::, Bound::Unbounded)) - { - self.insert_overwrite(range_bounds)?; - } - - return Ok(()); - } - /// Splits the set in two at the given `start_bound()`. Returns /// the full or partial `RangeBounds` after the split. /// @@ -1104,276 +774,6 @@ where Ok(set) } - - /// Similar to [`RangeBoundsSet::overlapping()`] except the - /// `(Bound, Bound)`s returned in the iterator have been - /// trimmed/cut by the given `RangeBounds`. - /// - /// This is sort of the analogue to the AND function between a - /// `RangeBounds` AND a [`RangeBoundsSet`]. - /// - /// # Panics - /// - /// Panics if the given `range_bounds` is an invalid - /// `RangeBounds`. See [`Invalid - /// RangeBounds`](https://docs.rs/range_bounds_map/latest/range_bounds_map/index.html#Invalid-RangeBounds) - /// for more details. - /// - /// # Examples - /// ``` - /// use std::ops::Bound; - /// - /// use range_bounds_map::RangeBoundsSet; - /// - /// let set = RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100]) - /// .unwrap(); - /// - /// let mut overlapping_trimmed = set.overlapping_trimmed(&(2..20)); - /// - /// assert_eq!( - /// overlapping_trimmed.collect::>(), - /// [ - /// (Bound::Included(&2), Bound::Excluded(&4)), - /// (Bound::Included(&4), Bound::Excluded(&8)), - /// (Bound::Included(&8), Bound::Excluded(&20)), - /// ] - /// ); - /// ``` - #[trivial] - pub fn overlapping_trimmed<'a, Q>( - &'a self, - range_bounds: &'a Q, - ) -> impl DoubleEndedIterator, Bound<&I>)> - where - Q: RangeBounds, - { - self.map.overlapping_trimmed(range_bounds).map(first) - } - - /// Identical to [`RangeBoundsSet::overlapping_trimmed()`] except - /// it returns an iterator of `Result`. - /// - /// # Panics - /// - /// Panics if the given `range_bounds` is an invalid - /// `RangeBounds`. See [`Invalid - /// RangeBounds`](https://docs.rs/range_bounds_map/latest/range_bounds_map/index.html#Invalid-RangeBounds) - /// for more details. - /// - /// # Examples - /// ``` - /// use range_bounds_map::{RangeBoundsSet, TryFromBoundsError}; - /// - /// let set = RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100]) - /// .unwrap(); - /// - /// let mut overlapping_trimmed_same = - /// set.overlapping_trimmed_same(&(2..=20)); - /// - /// assert_eq!( - /// overlapping_trimmed_same.collect::>(), - /// [ - /// Ok(2..4), - /// Ok(4..8), - /// // Due to using a RangeInclusive in `overlapping_trimmed_same()` - /// Err(TryFromBoundsError), - /// ] - /// ); - /// ``` - #[trivial] - pub fn overlapping_trimmed_same<'a, Q>( - &'a self, - range_bounds: &'a Q, - ) -> impl DoubleEndedIterator> + 'a - where - Q: RangeBounds, - K: TryFromBounds, - { - self.map.overlapping_trimmed_same(range_bounds).map(first) - } - - /// Allocate a `RangeBoundsSet` and move the given `RangeBounds` - /// from the slice into the set using - /// [`RangeBoundsSet::insert_strict()`]. - /// - /// May return an `Err` while inserting. See - /// [`RangeBoundsSet::insert_strict()`] for details. - /// - /// # Panics - /// - /// Panics if any of the given `RangeBounds` is an invalid - /// `RangeBounds`. See [`Invalid - /// RangeBounds`](https://docs.rs/range_bounds_map/latest/range_bounds_map/index.html#Invalid-RangeBounds) - /// for more details. - /// - /// # Examples - /// ``` - /// use range_bounds_map::{RangeBoundsSet, TryFromBoundsError}; - /// - /// let set = RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100]) - /// .unwrap(); - /// ``` - #[trivial] - pub fn from_slice_strict( - slice: [K; N], - ) -> Result, OverlapError> { - let mut set = RangeBoundsSet::new(); - for range_bounds in slice { - set.insert_strict(range_bounds)?; - } - return Ok(set); - } - /// Allocate a `RangeBoundsSet` and move the given `RangeBounds` - /// from the slice into the set using - /// [`RangeBoundsSet::insert_merge_touching()`]. - /// - /// May return an `Err` while inserting. See - /// [`RangeBoundsSet::insert_merge_touching()`] for details. - /// - /// # Panics - /// - /// Panics if any of the given `RangeBounds` is an invalid - /// `RangeBounds`. See [`Invalid - /// RangeBounds`](https://docs.rs/range_bounds_map/latest/range_bounds_map/index.html#Invalid-RangeBounds) - /// for more details. - /// - /// # Examples - /// ``` - /// use range_bounds_map::{RangeBoundsSet, TryFromBoundsError}; - /// - /// let set = RangeBoundsSet::from_slice_merge_touching([ - /// 1..4, - /// 4..8, - /// 8..100, - /// ]) - /// .unwrap(); - /// ``` - #[trivial] - pub fn from_slice_merge_touching( - slice: [K; N], - ) -> Result, OverlapOrTryFromBoundsError> - where - K: TryFromBounds, - { - let mut set = RangeBoundsSet::new(); - for range_bounds in slice { - set.insert_merge_touching(range_bounds)?; - } - return Ok(set); - } - /// Allocate a `RangeBoundsSet` and move the given `RangeBounds` - /// from the slice into the set using - /// [`RangeBoundsSet::insert_merge_overlapping()`]. - /// - /// May return an `Err` while inserting. See - /// [`RangeBoundsSet::insert_merge_overlapping()`] for details. - /// - /// # Panics - /// - /// Panics if any of the given `RangeBounds` is an invalid - /// `RangeBounds`. See [`Invalid - /// RangeBounds`](https://docs.rs/range_bounds_map/latest/range_bounds_map/index.html#Invalid-RangeBounds) - /// for more details. - /// - /// # Examples - /// ``` - /// use range_bounds_map::{RangeBoundsSet, TryFromBoundsError}; - /// - /// let set = RangeBoundsSet::from_slice_merge_overlapping([ - /// 1..4, - /// 4..8, - /// 8..100, - /// ]) - /// .unwrap(); - /// ``` - #[trivial] - pub fn from_slice_merge_overlapping( - slice: [K; N], - ) -> Result, TryFromBoundsError> - where - K: TryFromBounds, - { - let mut set = RangeBoundsSet::new(); - for range_bounds in slice { - set.insert_merge_overlapping(range_bounds)?; - } - return Ok(set); - } - /// Allocate a `RangeBoundsSet` and move the given `RangeBounds` - /// from the slice into the set using - /// [`RangeBoundsSet::insert_merge_touching_or_overlapping()`]. - /// - /// May return an `Err` while inserting. See - /// [`RangeBoundsSet::insert_merge_touching_or_overlapping()`] for details. - /// - /// # Panics - /// - /// Panics if any of the given `RangeBounds` is an invalid - /// `RangeBounds`. See [`Invalid - /// RangeBounds`](https://docs.rs/range_bounds_map/latest/range_bounds_map/index.html#Invalid-RangeBounds) - /// for more details. - /// - /// # Examples - /// ``` - /// use range_bounds_map::{RangeBoundsSet, TryFromBoundsError}; - /// - /// let set = - /// RangeBoundsSet::from_slice_merge_touching_or_overlapping([ - /// 1..4, - /// 4..8, - /// 8..100, - /// ]) - /// .unwrap(); - /// ``` - #[trivial] - pub fn from_slice_merge_touching_or_overlapping( - slice: [K; N], - ) -> Result, TryFromBoundsError> - where - K: TryFromBounds, - { - let mut set = RangeBoundsSet::new(); - for range_bounds in slice { - set.insert_merge_touching_or_overlapping(range_bounds)?; - } - return Ok(set); - } - /// Allocate a `RangeBoundsSet` and move the given `RangeBounds` - /// from the slice into the set using - /// [`RangeBoundsSet::insert_overwrite()`]. - /// - /// May return an `Err` while inserting. See - /// [`RangeBoundsSet::insert_overwrite()`] for details. - /// - /// # Panics - /// - /// Panics if any of the given `RangeBounds` is an invalid - /// `RangeBounds`. See [`Invalid - /// RangeBounds`](https://docs.rs/range_bounds_map/latest/range_bounds_map/index.html#Invalid-RangeBounds) - /// for more details. - /// - /// # Examples - /// ``` - /// use range_bounds_map::{RangeBoundsSet, TryFromBoundsError}; - /// - /// let set = - /// RangeBoundsSet::from_slice_overwrite([1..4, 4..8, 8..100]) - /// .unwrap(); - /// ``` - #[trivial] - pub fn from_slice_overwrite( - slice: [K; N], - ) -> Result, TryFromBoundsError> - where - K: TryFromBounds, - { - let mut set = RangeBoundsSet::new(); - for range_bounds in slice { - set.insert_overwrite(range_bounds)?; - } - return Ok(set); - } } impl IntoIterator for RangeBoundsSet