s2json-core 1.15.0

This library supports the S2JSON 1.0 Specification
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use alloc::collections::BTreeMap;
use core::ops::{Deref, DerefMut};
use serde::{Deserialize, Deserializer, Serialize, Serializer};

/// A BTreeMap wrapper
#[derive(Clone, Debug, PartialEq, Default, PartialOrd, Eq)]
pub struct Map<K: Ord, V> {
    map: BTreeMap<K, V>,
}
impl<K: Ord, V> Map<K, V> {
    /// Creates an empty `Map<K, V>`
    pub fn new() -> Map<K, V> {
        Map { map: BTreeMap::new() }
    }
}
// Automatically expose BTreeMap's methods
impl<K: Ord, V> Deref for Map<K, V> {
    type Target = BTreeMap<K, V>;

    fn deref(&self) -> &Self::Target {
        &self.map
    }
}
impl<K: Ord, V> DerefMut for Map<K, V> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.map
    }
}

impl<K: Ord, V> From<BTreeMap<K, V>> for Map<K, V> {
    fn from(map: BTreeMap<K, V>) -> Self {
        Self { map }
    }
}
// Enable `Map<K, V>::from([(_, _), ...])` (same as BTreeMap::from)
impl<K: Ord, V, const N: usize> From<[(K, V); N]> for Map<K, V> {
    fn from(arr: [(K, V); N]) -> Self {
        Self { map: BTreeMap::from(arr) }
    }
}
// Custom serialization
impl<K: Ord + Serialize, V: Serialize> Serialize for Map<K, V> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        self.map.serialize(serializer) // Serialize only the inner BTreeMap
    }
}
// Custom deserialization
impl<'de, K: Ord + Deserialize<'de>, V: Deserialize<'de>> Deserialize<'de> for Map<K, V> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let map = BTreeMap::deserialize(deserializer)?;
        Ok(Self { map }) // Deserialize directly into the inner BTreeMap
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_map() {
        let mut map = Map::new();
        map.insert("a", 1);
        map.insert("b", 2);
        map.insert("c", 3);
        assert_eq!(map.len(), 3);
        assert_eq!(map.get(&"a").unwrap(), &1);
        assert_eq!(map.get(&"b").unwrap(), &2);
        assert_eq!(map.get(&"c").unwrap(), &3);
        assert_eq!(map.get(&"d"), None);
    }

    #[test]
    fn test_from() {
        let map = Map::from([("a", 1), ("b", 2), ("c", 3)]);
        assert_eq!(map.len(), 3);
        assert_eq!(map.get(&"a").unwrap(), &1);
        assert_eq!(map.get(&"b").unwrap(), &2);
        assert_eq!(map.get(&"c").unwrap(), &3);
        assert_eq!(map.get(&"d"), None);
    }

    #[test]
    fn from_btree_map() {
        let btree_map = BTreeMap::from([("a", 1), ("b", 2), ("c", 3)]);
        let map = Map::from(btree_map);
        assert_eq!(map.len(), 3);
        assert_eq!(map.get(&"a").unwrap(), &1);
        assert_eq!(map.get(&"b").unwrap(), &2);
        assert_eq!(map.get(&"c").unwrap(), &3);
        assert_eq!(map.get(&"d"), None);
    }
}