added custom serde Serialize an Deserialize impls for neater than the serde_derive impls

Cargo.lock

@@ -108,7 +108,7 @@ dependencies = [
 
 [[package]]
 name = "range_bounds_map"
-version = "0.0.5"
+version = "0.0.6"
 dependencies = [
  "either",
  "itertools",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "range_bounds_map"
-version = "0.0.5"
+version = "0.0.6"
 authors = ["James Forster <james.forsterer@gmail.com>"]
 edition = "2021"
 description = """

src/range_bounds_map.rs

@@ -19,14 +19,17 @@ along with range_bounds_map. If not, see <https://www.gnu.org/licenses/>.
 
 use std::collections::btree_map::IntoValues;
 use std::collections::BTreeMap;
-use std::fmt::Debug;
+use std::fmt::{self, Debug};
 use std::iter::once;
+use std::marker::PhantomData;
 use std::ops::{Bound, RangeBounds};
 
 use either::Either;
 use itertools::Itertools;
 use labels::{parent_tested, tested, trivial};
-use serde::{Deserialize, Serialize};
+use serde::de::{MapAccess, Visitor};
+use serde::ser::SerializeMap;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use crate::bound_ord::BoundOrd;
 use crate::TryFromBounds;
@@ -123,7 +126,7 @@ use crate::TryFromBounds;
 ///
 /// [`RangeBounds`]: https://doc.rust-lang.org/std/ops/trait.RangeBounds.html
 /// [`BTreeMap`]: https://doc.rust-lang.org/std/collections/struct.BTreeMap.html
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub struct RangeBoundsMap<I, K, V>
 where
 	I: PartialOrd,
@@ -1408,9 +1411,9 @@ where
 		self.iter().next_back()
 	}
 
-    /// Moves all elements from `other` into `self` by
-    /// [`RangeBoundsMap::insert_platonic()`] in acending order,
-    /// leaving `other` empty.
+	/// Moves all elements from `other` into `self` by
+	/// [`RangeBoundsMap::insert_platonic()`] in acending order,
+	/// leaving `other` empty.
 	///
 	/// If any of the `RangeBounds` in `other` overlap `self` then
 	/// that `RangeBounds` is not inserted and the function returns.
@@ -1622,6 +1625,74 @@ where
 	}
 }
 
+impl<I, K, V> Serialize for RangeBoundsMap<I, K, V>
+where
+	I: Ord + Clone,
+	K: RangeBounds<I> + 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()))?;
+		for (range_bounds, value) in self.iter() {
+			map.serialize_entry(range_bounds, value)?;
+		}
+		map.end()
+	}
+}
+
+impl<'de, I, K, V> Deserialize<'de> for RangeBoundsMap<I, K, V>
+where
+	K: Deserialize<'de> + RangeBounds<I>,
+	I: Ord + Clone,
+	V: Deserialize<'de>,
+{
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		deserializer.deserialize_map(RangeBoundsMapVisitor {
+			i: PhantomData,
+			k: PhantomData,
+			v: PhantomData,
+		})
+	}
+}
+
+struct RangeBoundsMapVisitor<I, K, V> {
+	i: PhantomData<I>,
+	k: PhantomData<K>,
+	v: PhantomData<V>,
+}
+
+impl<'de, I, K, V> Visitor<'de> for RangeBoundsMapVisitor<I, K, V>
+where
+	I: Ord + Clone,
+	K: RangeBounds<I> + Deserialize<'de>,
+	V: Deserialize<'de>,
+{
+	type Value = RangeBoundsMap<I, K, V>;
+
+	fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+		formatter.write_str("a RangeBoundsMap")
+	}
+
+	fn visit_map<A>(self, mut access: A) -> Result<Self::Value, A::Error>
+	where
+		A: MapAccess<'de>,
+	{
+		let mut range_bounds_map = RangeBoundsMap::new();
+		while let Some((range_bounds, value)) = access.next_entry()? {
+			range_bounds_map
+				.insert_platonic(range_bounds, value)
+				.map_err(|_| serde::de::Error::custom("RangeBounds overlap"))?;
+		}
+		Ok(range_bounds_map)
+	}
+}
+
 #[derive(Debug, PartialEq)]
 enum Config {
 	LeftFirstNonOverlapping,

src/range_bounds_set.rs

@@ -17,11 +17,14 @@ You should have received a copy of the GNU Affero General Public License
 along with range_bounds_map. If not, see <https://www.gnu.org/licenses/>.
 */
 
-use std::fmt::Debug;
+use std::fmt::{self, Debug};
+use std::marker::PhantomData;
 use std::ops::{Bound, RangeBounds};
 
 use labels::trivial;
-use serde::{Deserialize, Serialize};
+use serde::de::{SeqAccess, Visitor};
+use serde::ser::SerializeSeq;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use crate::range_bounds_map::IntoIter as MapIntoIter;
 use crate::{
@@ -105,7 +108,7 @@ use crate::{
 /// ```
 ///
 /// [`RangeBounds`]: https://doc.rust-lang.org/std/ops/trait.RangeBounds.html
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub struct RangeBoundsSet<I, K>
 where
 	I: PartialOrd,
@@ -930,6 +933,69 @@ where
 	}
 }
 
+impl<I, K> Serialize for RangeBoundsSet<I, K>
+where
+	I: Ord + Clone,
+	K: RangeBounds<I> + Serialize,
+{
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		let mut seq = serializer.serialize_seq(Some(self.len()))?;
+		for range_bounds in self.iter() {
+			seq.serialize_element(&range_bounds)?;
+		}
+		seq.end()
+	}
+}
+
+impl<'de, I, K> Deserialize<'de> for RangeBoundsSet<I, K>
+where
+	K: Deserialize<'de> + RangeBounds<I>,
+	I: Ord + Clone,
+{
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		deserializer.deserialize_seq(RangeBoundsSetVisitor {
+			i: PhantomData,
+			k: PhantomData,
+		})
+	}
+}
+
+struct RangeBoundsSetVisitor<I, K> {
+	i: PhantomData<I>,
+	k: PhantomData<K>,
+}
+
+impl<'de, I, K> Visitor<'de> for RangeBoundsSetVisitor<I, K>
+where
+	I: Ord + Clone,
+	K: RangeBounds<I> + Deserialize<'de>,
+{
+	type Value = RangeBoundsSet<I, K>;
+
+	fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+		formatter.write_str("a RangeBoundsSet")
+	}
+
+	fn visit_seq<A>(self, mut access: A) -> Result<Self::Value, A::Error>
+	where
+		A: SeqAccess<'de>,
+	{
+		let mut range_bounds_set = RangeBoundsSet::new();
+		while let Some(range_bounds) = access.next_element()? {
+			range_bounds_set
+				.insert_platonic(range_bounds)
+				.map_err(|_| serde::de::Error::custom("RangeBounds overlap"))?;
+		}
+		Ok(range_bounds_set)
+	}
+}
+
 #[trivial]
 fn first<A, B>((a, _): (A, B)) -> A {
 	a