From d2b4bf9446683dda88287b8d7e8ae9266eb6e6e7 Mon Sep 17 00:00:00 2001 From: ripytide Date: Sat, 17 Jun 2023 13:07:27 +0100 Subject: [PATCH] removed lots of unneccessary trait bounds from a bunch of functions and the serialize triat --- Cargo.lock | 2 +- src/discrete_range_map.rs | 305 +++++++++++++++++++------------------- src/discrete_range_set.rs | 58 ++++---- 3 files changed, 184 insertions(+), 181 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 3d851d1..cb83bf0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -36,7 +36,7 @@ checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8" [[package]] name = "discrete_range_map" -version = "0.4.1" +version = "0.4.2" dependencies = [ "btree_monstrousity", "either", diff --git a/src/discrete_range_map.rs b/src/discrete_range_map.rs index 044ad19..68f0ca2 100644 --- a/src/discrete_range_map.rs +++ b/src/discrete_range_map.rs @@ -28,8 +28,8 @@ use btree_monstrousity::btree_map::{ use btree_monstrousity::BTreeMap; use either::Either; use itertools::Itertools; -use serde::de::{MapAccess, Visitor}; -use serde::ser::SerializeMap; +use serde::de::{SeqAccess, Visitor}; +use serde::ser::SerializeSeq; use serde::{Deserialize, Deserializer, Serialize, Serializer}; use crate::discrete_finite::DiscreteFinite; @@ -92,57 +92,6 @@ where I: Ord + Copy + DiscreteFinite, K: FiniteRange + Copy + From>, { - /// Makes a new, empty `DiscreteRangeMap`. - /// - /// # Examples - /// ``` - /// use discrete_range_map::{DiscreteRangeMap, Interval}; - /// - /// let map: DiscreteRangeMap, bool> = - /// DiscreteRangeMap::new(); - /// ``` - pub fn new() -> Self { - DiscreteRangeMap { - inner: BTreeMap::new(), - phantom: PhantomData, - } - } - - /// Returns the number of ranges in the map. - /// - /// # Examples - /// ``` - /// use discrete_range_map::test_ranges::ie; - /// use discrete_range_map::DiscreteRangeMap; - /// - /// let mut map = DiscreteRangeMap::new(); - /// - /// assert_eq!(map.len(), 0); - /// map.insert_strict(ie(0, 1), false).unwrap(); - /// assert_eq!(map.len(), 1); - /// ``` - pub fn len(&self) -> usize { - self.inner.len() - } - - /// Returns `true` if the map contains no ranges, and - /// `false` if it does. - /// - /// # Examples - /// ``` - /// use discrete_range_map::test_ranges::ie; - /// use discrete_range_map::DiscreteRangeMap; - /// - /// let mut map = DiscreteRangeMap::new(); - /// - /// assert_eq!(map.is_empty(), true); - /// map.insert_strict(ie(0, 1), false).unwrap(); - /// assert_eq!(map.is_empty(), false); - /// ``` - pub fn is_empty(&self) -> bool { - self.inner.is_empty() - } - /// Returns `true` if the given range overlaps any of the /// other ranges in the map, and `false` if not. /// @@ -384,61 +333,6 @@ where } } - /// Returns an iterator over every entry in the map in ascending - /// order. - /// - /// # Examples - /// ``` - /// use discrete_range_map::test_ranges::ie; - /// use discrete_range_map::DiscreteRangeMap; - /// - /// let map = DiscreteRangeMap::from_slice_strict([ - /// (ie(1, 4), false), - /// (ie(4, 8), true), - /// (ie(8, 100), false), - /// ]) - /// .unwrap(); - /// - /// let mut iter = map.iter(); - /// - /// assert_eq!(iter.next(), Some((&ie(1, 4), &false))); - /// assert_eq!(iter.next(), Some((&ie(4, 8), &true))); - /// assert_eq!(iter.next(), Some((&ie(8, 100), &false))); - /// assert_eq!(iter.next(), None); - /// ``` - pub fn iter(&self) -> impl DoubleEndedIterator { - self.inner.iter() - } - - /// Returns an mutable iterator over every entry in the map in - /// ascending order. - /// - /// # Examples - /// ``` - /// use discrete_range_map::test_ranges::ie; - /// use discrete_range_map::DiscreteRangeMap; - /// - /// let mut map = DiscreteRangeMap::from_slice_strict([ - /// (ie(1, 4), false), - /// (ie(4, 8), true), - /// (ie(8, 100), false), - /// ]) - /// .unwrap(); - /// - /// for (range, value) in map.iter_mut() { - /// if *range == ie(4, 8) { - /// *value = false - /// } else { - /// *value = true - /// } - /// } - /// ``` - pub fn iter_mut( - &mut self, - ) -> impl DoubleEndedIterator { - self.inner.iter_mut() - } - /// Removes every entry in the map which overlaps the given range /// and returns them in an iterator. /// @@ -1275,6 +1169,149 @@ where self.insert_unchecked(range, value); } + /// Allocates a `DiscreteRangeMap` and moves the given entries from + /// the given slice into the map using + /// [`DiscreteRangeMap::insert_strict()`]. + /// + /// May return an `Err` while inserting. See + /// [`DiscreteRangeMap::insert_strict()`] for details. + /// + /// # Panics + /// + /// Panics if the given range is an invalid range. See [`Invalid + /// Ranges`](https://docs.rs/discrete_range_map/latest/discrete_range_map/index.html#invalid-ranges) + /// for more details. + /// + /// # Examples + /// ``` + /// use discrete_range_map::test_ranges::ie; + /// use discrete_range_map::DiscreteRangeMap; + /// + /// let map = DiscreteRangeMap::from_slice_strict([ + /// (ie(1, 4), false), + /// (ie(4, 8), true), + /// (ie(8, 100), false), + /// ]) + /// .unwrap(); + /// ``` + pub fn from_slice_strict( + slice: [(K, V); N], + ) -> Result, OverlapError> { + let mut map = DiscreteRangeMap::new(); + for (range, value) in slice { + map.insert_strict(range, value)?; + } + return Ok(map); + } +} + +impl DiscreteRangeMap { + /// Makes a new, empty `DiscreteRangeMap`. + /// + /// # Examples + /// ``` + /// use discrete_range_map::{DiscreteRangeMap, Interval}; + /// + /// let map: DiscreteRangeMap, bool> = + /// DiscreteRangeMap::new(); + /// ``` + pub fn new() -> Self { + DiscreteRangeMap { + inner: BTreeMap::new(), + phantom: PhantomData, + } + } + + /// Returns the number of ranges in the map. + /// + /// # Examples + /// ``` + /// use discrete_range_map::test_ranges::ie; + /// use discrete_range_map::DiscreteRangeMap; + /// + /// let mut map = DiscreteRangeMap::new(); + /// + /// assert_eq!(map.len(), 0); + /// map.insert_strict(ie(0, 1), false).unwrap(); + /// assert_eq!(map.len(), 1); + /// ``` + pub fn len(&self) -> usize { + self.inner.len() + } + + /// Returns `true` if the map contains no ranges, and + /// `false` if it does. + /// + /// # Examples + /// ``` + /// use discrete_range_map::test_ranges::ie; + /// use discrete_range_map::DiscreteRangeMap; + /// + /// let mut map = DiscreteRangeMap::new(); + /// + /// assert_eq!(map.is_empty(), true); + /// map.insert_strict(ie(0, 1), false).unwrap(); + /// assert_eq!(map.is_empty(), false); + /// ``` + pub fn is_empty(&self) -> bool { + self.inner.is_empty() + } + + /// Returns an iterator over every entry in the map in ascending + /// order. + /// + /// # Examples + /// ``` + /// use discrete_range_map::test_ranges::ie; + /// use discrete_range_map::DiscreteRangeMap; + /// + /// let map = DiscreteRangeMap::from_slice_strict([ + /// (ie(1, 4), false), + /// (ie(4, 8), true), + /// (ie(8, 100), false), + /// ]) + /// .unwrap(); + /// + /// let mut iter = map.iter(); + /// + /// assert_eq!(iter.next(), Some((&ie(1, 4), &false))); + /// assert_eq!(iter.next(), Some((&ie(4, 8), &true))); + /// assert_eq!(iter.next(), Some((&ie(8, 100), &false))); + /// assert_eq!(iter.next(), None); + /// ``` + pub fn iter(&self) -> impl DoubleEndedIterator { + self.inner.iter() + } + + /// Returns an mutable iterator over every entry in the map in + /// ascending order. + /// + /// # Examples + /// ``` + /// use discrete_range_map::test_ranges::ie; + /// use discrete_range_map::DiscreteRangeMap; + /// + /// let mut map = DiscreteRangeMap::from_slice_strict([ + /// (ie(1, 4), false), + /// (ie(4, 8), true), + /// (ie(8, 100), false), + /// ]) + /// .unwrap(); + /// + /// for (range, value) in map.iter_mut() { + /// if *range == ie(4, 8) { + /// *value = false + /// } else { + /// *value = true + /// } + /// } + /// ``` + pub fn iter_mut( + &mut self, + ) -> impl DoubleEndedIterator { + self.inner.iter_mut() + } + /// Returns the first entry in the map, if any. /// /// # Examples @@ -1316,41 +1353,6 @@ where pub fn last_entry(&self) -> Option<(&K, &V)> { self.inner.last_key_value() } - - /// Allocates a `DiscreteRangeMap` and moves the given entries from - /// the given slice into the map using - /// [`DiscreteRangeMap::insert_strict()`]. - /// - /// May return an `Err` while inserting. See - /// [`DiscreteRangeMap::insert_strict()`] for details. - /// - /// # Panics - /// - /// Panics if the given range is an invalid range. See [`Invalid - /// Ranges`](https://docs.rs/discrete_range_map/latest/discrete_range_map/index.html#invalid-ranges) - /// for more details. - /// - /// # Examples - /// ``` - /// use discrete_range_map::test_ranges::ie; - /// use discrete_range_map::DiscreteRangeMap; - /// - /// let map = DiscreteRangeMap::from_slice_strict([ - /// (ie(1, 4), false), - /// (ie(4, 8), true), - /// (ie(8, 100), false), - /// ]) - /// .unwrap(); - /// ``` - pub fn from_slice_strict( - slice: [(K, V); N], - ) -> Result, OverlapError> { - let mut map = DiscreteRangeMap::new(); - for (range, value) in slice { - map.insert_strict(range, value)?; - } - return Ok(map); - } } // Helper Functions ========================== @@ -1450,19 +1452,18 @@ impl Default for DiscreteRangeMap { impl Serialize for DiscreteRangeMap where - I: Ord + Copy + DiscreteFinite, - K: FiniteRange + Copy + From> + Serialize, + K: Serialize, V: Serialize, { fn serialize(&self, serializer: S) -> Result where S: Serializer, { - let mut map = serializer.serialize_map(Some(self.len()))?; + let mut seq = serializer.serialize_seq(Some(self.len()))?; for (range_bounds, value) in self.iter() { - map.serialize_entry(range_bounds, value)?; + seq.serialize_element(&(range_bounds, value))?; } - map.end() + seq.end() } } @@ -1476,7 +1477,7 @@ where where D: Deserializer<'de>, { - deserializer.deserialize_map(DiscreteRangeMapVisitor { + deserializer.deserialize_seq(DiscreteRangeMapVisitor { i: PhantomData, k: PhantomData, v: PhantomData, @@ -1502,12 +1503,12 @@ where formatter.write_str("a DiscreteRangeMap") } - fn visit_map(self, mut access: A) -> Result + fn visit_seq(self, mut access: A) -> Result where - A: MapAccess<'de>, + A: SeqAccess<'de>, { let mut map = DiscreteRangeMap::new(); - while let Some((range_bounds, value)) = access.next_entry()? { + while let Some((range_bounds, value)) = access.next_element()? { map.insert_strict(range_bounds, value) .map_err(|_| serde::de::Error::custom("ranges overlap"))?; } diff --git a/src/discrete_range_set.rs b/src/discrete_range_set.rs index 797411d..a8f0b50 100644 --- a/src/discrete_range_set.rs +++ b/src/discrete_range_set.rs @@ -33,20 +33,6 @@ where I: Ord + Copy + DiscreteFinite, K: FiniteRange + Copy + From>, { - /// See [`DiscreteRangeMap::new()`] for more details. - pub fn new() -> Self { - DiscreteRangeSet { - inner: DiscreteRangeMap::new(), - } - } - /// See [`DiscreteRangeMap::len()`] for more details. - pub fn len(&self) -> usize { - self.inner.len() - } - /// See [`DiscreteRangeMap::is_empty()`] for more details. - pub fn is_empty(&self) -> bool { - self.inner.is_empty() - } /// See [`DiscreteRangeMap::overlaps()`] for more details. pub fn overlaps(&self, range: Q) -> bool where @@ -72,10 +58,6 @@ where pub fn contains_point(&self, point: I) -> bool { self.inner.contains_point(point) } - /// See [`DiscreteRangeMap::iter()`] for more details. - pub fn iter(&self) -> impl DoubleEndedIterator { - self.inner.iter().map(first) - } /// See [`DiscreteRangeMap::remove_overlapping()`] for more details. pub fn remove_overlapping<'a, Q>( &'a mut self, @@ -130,14 +112,6 @@ where pub fn insert_overwrite(&mut self, range: K) { self.inner.insert_overwrite(range, ()) } - /// See [`DiscreteRangeMap::first_entry()`] for more details. - pub fn first(&self) -> Option<&K> { - self.inner.first_entry().map(first) - } - /// See [`DiscreteRangeMap::last_entry()`] for more details. - pub fn last(&self) -> Option<&K> { - self.inner.last_entry().map(first) - } /// See [`DiscreteRangeMap::from_slice_strict()`] for more details. pub fn from_slice_strict( slice: [K; N], @@ -150,6 +124,35 @@ where } } +impl DiscreteRangeSet { + /// See [`DiscreteRangeMap::new()`] for more details. + pub fn new() -> Self { + DiscreteRangeSet { + inner: DiscreteRangeMap::new(), + } + } + /// See [`DiscreteRangeMap::len()`] for more details. + pub fn len(&self) -> usize { + self.inner.len() + } + /// See [`DiscreteRangeMap::is_empty()`] for more details. + pub fn is_empty(&self) -> bool { + self.inner.is_empty() + } + /// See [`DiscreteRangeMap::iter()`] for more details. + pub fn iter(&self) -> impl DoubleEndedIterator { + self.inner.iter().map(first) + } + /// See [`DiscreteRangeMap::first_entry()`] for more details. + pub fn first(&self) -> Option<&K> { + self.inner.first_entry().map(first) + } + /// See [`DiscreteRangeMap::last_entry()`] for more details. + pub fn last(&self) -> Option<&K> { + self.inner.last_entry().map(first) + } +} + // Helper Functions ========================== fn first((a, _): (A, B)) -> A { @@ -198,8 +201,7 @@ where impl Serialize for DiscreteRangeSet where - I: Ord + Copy + DiscreteFinite, - K: FiniteRange + Copy + From> + Serialize, + K: Serialize, { fn serialize(&self, serializer: S) -> Result where