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

removed lots of unneccessary trait bounds from a bunch of functions and the serialize triat

Browse Source
This commit is contained in:
ripytide
2023-06-17 13:07:27 +01:00
parent 1fcb0d8b63
commit d2b4bf9446
3 changed files with 184 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.lock
Generated
+1 -1
View File
@@ -36,7 +36,7 @@ checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
[[package]]
name = "discrete_range_map"
version = "0.4.1"
version = "0.4.2"
dependencies = [
"btree_monstrousity",
"either",
src/discrete_range_map.rs
+153 -152
View File
@@ -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<I> + Copy + From<Interval<I>>,
{
/// Makes a new, empty `DiscreteRangeMap`.
///
/// # Examples
/// ```
/// use discrete_range_map::{DiscreteRangeMap, Interval};
///
/// let map: DiscreteRangeMap<i8, Interval<i8>, 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<Item = (&K, &V)> {
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<Item = (&K, &mut V)> {
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<const N: usize>(
slice: [(K, V); N],
) -> Result<DiscreteRangeMap<I, K, V>, OverlapError> {
let mut map = DiscreteRangeMap::new();
for (range, value) in slice {
map.insert_strict(range, value)?;
}
return Ok(map);
}
}
impl<I, K, V> DiscreteRangeMap<I, K, V> {
/// Makes a new, empty `DiscreteRangeMap`.
///
/// # Examples
/// ```
/// use discrete_range_map::{DiscreteRangeMap, Interval};
///
/// let map: DiscreteRangeMap<i8, Interval<i8>, 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<Item = (&K, &V)> {
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<Item = (&K, &mut V)> {
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<const N: usize>(
slice: [(K, V); N],
) -> Result<DiscreteRangeMap<I, K, V>, 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<I, K, V> Default for DiscreteRangeMap<I, K, V> {
impl<I, K, V> Serialize for DiscreteRangeMap<I, K, V>
where
I: Ord + Copy + DiscreteFinite,
K: FiniteRange<I> + Copy + From<Interval<I>> + Serialize,
K: Serialize,
V: Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
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<A>(self, mut access: A) -> Result<Self::Value, A::Error>
fn visit_seq<A>(self, mut access: A) -> Result<Self::Value, A::Error>
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"))?;
}
src/discrete_range_set.rs
+30 -28
View File
@@ -33,20 +33,6 @@ where
I: Ord + Copy + DiscreteFinite,
K: FiniteRange<I> + Copy + From<Interval<I>>,
{
/// 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<Q>(&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<Item = &K> {
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<const N: usize>(
slice: [K; N],
@@ -150,6 +124,35 @@ where
}
}
impl<I, K> DiscreteRangeSet<I, K> {
/// 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<Item = &K> {
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, B>((a, _): (A, B)) -> A {
@@ -198,8 +201,7 @@ where
impl<I, K> Serialize for DiscreteRangeSet<I, K>
where
I: Ord + Copy + DiscreteFinite,
K: FiniteRange<I> + Copy + From<Interval<I>> + Serialize,
K: Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where