Add Validate impl for ScMap and Map ScVal variant that can be invalid

src/lib.rs

@@ -20,3 +20,8 @@ pub use scval_conversions::*;
 mod scval_validations;
 #[cfg(feature = "next")]
 pub use scval_validations::*;
+
+#[cfg(all(feature = "alloc", feature = "next"))]
+mod scmap;
+#[cfg(all(feature = "alloc", feature = "next"))]
+pub use scmap::*;

src/scmap.rs

@@ -0,0 +1,68 @@
+#![allow(clippy::result_unit_err)]
+#![allow(clippy::missing_errors_doc)]
+
+use crate::{ScMap, ScMapEntry, ScVal, Validate};
+extern crate alloc;
+use alloc::vec::Vec;
+
+impl ScMap {
+    pub fn sorted_from_entries<I: Iterator<Item = ScMapEntry>>(entries: I) -> Result<ScMap, ()> {
+        let mut v: Vec<ScMapEntry> = entries.collect();
+        v.sort_by(|a, b| a.key.cmp(&b.key));
+        let m = ScMap(v.try_into()?);
+        // `validate` here will further check that there are no duplicates.
+        m.validate()?;
+        Ok(m)
+    }
+
+    pub fn sorted_from_pairs<K, V, I: Iterator<Item = (K, V)>>(pairs: I) -> Result<ScMap, ()>
+    where
+        ScVal: From<K> + From<V>,
+    {
+        Self::sorted_from_entries(pairs.map(|(key, val)| ScMapEntry {
+            key: key.into(),
+            val: val.into(),
+        }))
+    }
+
+    pub fn sorted_from<K, V, II: IntoIterator<Item = (K, V)>>(src: II) -> Result<ScMap, ()>
+    where
+        ScVal: From<K> + From<V>,
+    {
+        Self::sorted_from_pairs(src.into_iter())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use alloc::{collections::BTreeMap, vec};
+
+    #[test]
+    fn scmap_from_map() -> Result<(), ()> {
+        let mut m: BTreeMap<u32, u32> = BTreeMap::new();
+        m.insert(1, 2);
+        m.insert(5, 6);
+        m.insert(3, 4);
+        let scm = ScMap::sorted_from(m)?;
+        assert_eq!(scm.0.first().unwrap().key, 1u32.into());
+        assert_eq!(scm.0.last().unwrap().key, 5u32.into());
+        Ok(())
+    }
+
+    #[test]
+    fn scmap_from_pairs() -> Result<(), ()> {
+        let pairs: Vec<(u32, u32)> = vec![(3, 4), (5, 6), (1, 2)];
+        let scm = ScMap::sorted_from(pairs)?;
+        assert_eq!(scm.0.first().unwrap().key, 1u32.into());
+        assert_eq!(scm.0.last().unwrap().key, 5u32.into());
+        Ok(())
+    }
+
+    #[test]
+    fn scmap_from_bad_pairs() {
+        let pairs: Vec<(u32, u32)> = vec![(3, 4), (3, 5), (5, 6), (1, 2)];
+        let scm = ScMap::sorted_from(pairs);
+        assert!(scm.is_err());
+    }
+}

src/scval_validations.rs

@@ -66,9 +66,13 @@ impl Validate for ScMap {
     type Error = ();
 
     fn validate(&self) -> Result<(), Self::Error> {
-        // TODO: Validate that the map is sorted and has no duplicates, or find
-        // a way to guarantee this to be the case.
-        todo!()
+        // Check the map is sorted by key, and there are no keys that are
+        // duplicates.
+        if self.windows(2).all(|w| w[0].key < w[1].key) {
+            Ok(())
+        } else {
+            Err(())
+        }
     }
 }
 
@@ -98,4 +102,86 @@ mod test {
         assert_eq!(ScVal::Bitset(0x1000_0000_0000_0000).validate(), Err(()));
         assert_eq!(ScVal::Bitset(0x1fff_ffff_ffff_ffff).validate(), Err(()));
     }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn map() {
+        extern crate alloc;
+        use crate::{ScMap, ScMapEntry, ScObject};
+        use alloc::vec;
+        // Maps should be sorted by key and have no duplicates. The sort order
+        // is just the "normal" sort order on ScVal emitted by derive(PartialOrd).
+        assert_eq!(
+            ScVal::Object(Some(ScObject::Map(ScMap(
+                vec![
+                    ScMapEntry {
+                        key: ScVal::U63(0),
+                        val: ScVal::U32(1),
+                    },
+                    ScMapEntry {
+                        key: ScVal::U63(1),
+                        val: ScVal::U63(1),
+                    }
+                ]
+                .try_into()
+                .unwrap()
+            ))))
+            .validate(),
+            Ok(())
+        );
+        assert_eq!(
+            ScVal::Object(Some(ScObject::Map(ScMap(
+                vec![
+                    ScMapEntry {
+                        key: ScVal::U63(0),
+                        val: ScVal::U63(1),
+                    },
+                    ScMapEntry {
+                        key: ScVal::U63(1),
+                        val: ScVal::U63(1),
+                    }
+                ]
+                .try_into()
+                .unwrap()
+            ))))
+            .validate(),
+            Ok(())
+        );
+        assert_eq!(
+            ScVal::Object(Some(ScObject::Map(ScMap(
+                vec![
+                    ScMapEntry {
+                        key: ScVal::U63(2),
+                        val: ScVal::U63(1),
+                    },
+                    ScMapEntry {
+                        key: ScVal::U63(1),
+                        val: ScVal::U63(1),
+                    }
+                ]
+                .try_into()
+                .unwrap()
+            ))))
+            .validate(),
+            Err(())
+        );
+        assert_eq!(
+            ScVal::Object(Some(ScObject::Map(ScMap(
+                vec![
+                    ScMapEntry {
+                        key: ScVal::U32(1),
+                        val: ScVal::U63(1),
+                    },
+                    ScMapEntry {
+                        key: ScVal::U63(2),
+                        val: ScVal::U63(1),
+                    },
+                ]
+                .try_into()
+                .unwrap()
+            ))))
+            .validate(),
+            Err(())
+        );
+    }
 }