Deserialize boundedbtreeset (#781)

* deserialize for btreeset

* tests added

* run tests under std for bounded-btree-set

* insert after bound check, new tests for bound check

bounded-collections/src/bounded_btree_set.rs

@@ -21,6 +21,11 @@ use crate::{Get, TryCollect};
 use alloc::collections::BTreeSet;
 use codec::{Compact, Decode, Encode, MaxEncodedLen};
 use core::{borrow::Borrow, marker::PhantomData, ops::Deref};
+#[cfg(feature = "serde")]
+use serde::{
+ de::{Error, SeqAccess, Visitor},
+ Deserialize, Deserializer, Serialize,
+};
 
 /// A bounded set based on a B-Tree.
 ///
@@ -29,9 +34,67 @@ use core::{borrow::Borrow, marker::PhantomData, ops::Deref};
 ///
 /// Unlike a standard `BTreeSet`, there is an enforced upper limit to the number of items in the
 /// set. All internal operations ensure this bound is respected.
+#[cfg_attr(feature = "serde", derive(Serialize), serde(transparent))]
 #[derive(Encode, scale_info::TypeInfo)]
 #[scale_info(skip_type_params(S))]
-pub struct BoundedBTreeSet<T, S>(BTreeSet<T>, PhantomData<S>);
+pub struct BoundedBTreeSet<T, S>(BTreeSet<T>, #[cfg_attr(feature = "serde", serde(skip_serializing))] PhantomData<S>);
+
+#[cfg(feature = "serde")]
+impl<'de, T, S: Get<u32>> Deserialize<'de> for BoundedBTreeSet<T, S>
+where
+ T: Ord + Deserialize<'de>,
+ S: Clone,
+{
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ // Create a visitor to visit each element in the sequence
+ struct BTreeSetVisitor<T, S>(std::marker::PhantomData<(T, S)>);
+
+ impl<'de, T, S> Visitor<'de> for BTreeSetVisitor<T, S>
+ where
+ T: Ord + Deserialize<'de>,
+ S: Get<u32> + Clone,
+ {
+ type Value = BTreeSet<T>;
+
+ fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+ formatter.write_str("a sequence")
+ }
+
+ fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ let size = seq.size_hint().unwrap_or(0);
+ let max = match usize::try_from(S::get()) {
+ Ok(n) => n,
+ Err(_) => return Err(A::Error::custom("can't convert to usize")),
+ };
+ if size > max {
+ Err(A::Error::custom("out of bounds"))
+ } else {
+ let mut values = BTreeSet::new();
+
+ while let Some(value) = seq.next_element()? {
+ if values.len() >= max {
+ return Err(A::Error::custom("out of bounds"))
+ }
+ values.insert(value);
+ }
+
+ Ok(values)
+ }
+ }
+ }
+
+ let visitor: BTreeSetVisitor<T, S> = BTreeSetVisitor(PhantomData);
+ deserializer
+ .deserialize_seq(visitor)
+ .map(|v| BoundedBTreeSet::<T, S>::try_from(v).map_err(|_| Error::custom("out of bounds")))?
+ }
+}
 
 impl<T, S> Decode for BoundedBTreeSet<T, S>
 where
@@ -333,7 +396,7 @@ where
  }
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "std"))]
 mod test {
  use super::*;
  use crate::ConstU32;
@@ -522,4 +585,49 @@ mod test {
  set: BoundedBTreeSet<String, ConstU32<16>>,
  }
  }
+
+ #[test]
+ fn test_serializer() {
+ let mut c = BoundedBTreeSet::<u32, ConstU32<6>>::new();
+ c.try_insert(0).unwrap();
+ c.try_insert(1).unwrap();
+ c.try_insert(2).unwrap();
+
+ assert_eq!(serde_json::json!(&c).to_string(), r#"[0,1,2]"#);
+ }
+
+ #[test]
+ fn test_deserializer() {
+ let c: Result<BoundedBTreeSet<u32, ConstU32<6>>, serde_json::error::Error> = serde_json::from_str(r#"[0,1,2]"#);
+ assert!(c.is_ok());
+ let c = c.unwrap();
+
+ assert_eq!(c.len(), 3);
+ assert!(c.contains(&0));
+ assert!(c.contains(&1));
+ assert!(c.contains(&2));
+ }
+
+ #[test]
+ fn test_deserializer_bound() {
+ let c: Result<BoundedBTreeSet<u32, ConstU32<3>>, serde_json::error::Error> = serde_json::from_str(r#"[0,1,2]"#);
+ assert!(c.is_ok());
+ let c = c.unwrap();
+
+ assert_eq!(c.len(), 3);
+ assert!(c.contains(&0));
+ assert!(c.contains(&1));
+ assert!(c.contains(&2));
+ }
+
+ #[test]
+ fn test_deserializer_failed() {
+ let c: Result<BoundedBTreeSet<u32, ConstU32<4>>, serde_json::error::Error> =
+ serde_json::from_str(r#"[0,1,2,3,4]"#);
+
+ match c {
+ Err(msg) => assert_eq!(msg.to_string(), "out of bounds at line 1 column 11"),
+ _ => unreachable!("deserializer must raise error"),
+ }
+ }
 }

bounded-collections/src/bounded_vec.rs

@@ -87,10 +87,10 @@ where
  let mut values = Vec::with_capacity(size);
 
  while let Some(value) = seq.next_element()? {
- values.push(value);
- if values.len() > max {
+ if values.len() >= max {
  return Err(A::Error::custom("out of bounds"))
  }
+ values.push(value);
  }
 
  Ok(values)
@@ -1187,10 +1187,19 @@ mod test {
  assert_eq!(c[2], 2);
  }
 
+ #[test]
+ fn test_deserializer_bound() {
+ let c: BoundedVec<u32, ConstU32<3>> = serde_json::from_str(r#"[0,1,2]"#).unwrap();
+
+ assert_eq!(c.len(), 3);
+ assert_eq!(c[0], 0);
+ assert_eq!(c[1], 1);
+ assert_eq!(c[2], 2);
+ }
+
  #[test]
  fn test_deserializer_failed() {
- let c: Result<BoundedVec<u32, ConstU32<4>>, serde_json::error::Error> =
- serde_json::from_str(r#"[0,1,2,3,4,5]"#);
+ let c: Result<BoundedVec<u32, ConstU32<4>>, serde_json::error::Error> = serde_json::from_str(r#"[0,1,2,3,4]"#);
 
  match c {
  Err(msg) => assert_eq!(msg.to_string(), "out of bounds at line 1 column 11"),