rkyv/impls/indexmap/
index_set.rs

1use crate::{
2    collections::index_set::{ArchivedIndexSet, IndexSetResolver},
3    ser::{ScratchSpace, Serializer},
4    Archive, Deserialize, Fallible, Serialize,
5};
6use core::hash::{BuildHasher, Hash};
7use indexmap::IndexSet;
8
9impl<K: Archive, S> Archive for IndexSet<K, S> {
10    type Archived = ArchivedIndexSet<K::Archived>;
11    type Resolver = IndexSetResolver;
12
13    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
14        ArchivedIndexSet::resolve_from_len(self.len(), pos, resolver, out);
15    }
16}
17
18impl<K, S, RandomState> Serialize<S> for IndexSet<K, RandomState>
19where
20    K: Hash + Eq + Serialize<S>,
21    S: ScratchSpace + Serializer + ?Sized,
22    RandomState: BuildHasher,
23{
24    fn serialize(&self, serializer: &mut S) -> Result<IndexSetResolver, S::Error> {
25        unsafe {
26            ArchivedIndexSet::serialize_from_iter_index(
27                self.iter(),
28                |k| self.get_index_of(k).unwrap(),
29                serializer,
30            )
31        }
32    }
33}
34
35impl<K, D, S> Deserialize<IndexSet<K, S>, D> for ArchivedIndexSet<K::Archived>
36where
37    K: Archive + Hash + Eq,
38    K::Archived: Deserialize<K, D>,
39    D: Fallible + ?Sized,
40    S: Default + BuildHasher,
41{
42    fn deserialize(&self, deserializer: &mut D) -> Result<IndexSet<K, S>, D::Error> {
43        let mut result = IndexSet::with_capacity_and_hasher(self.len(), S::default());
44        for k in self.iter() {
45            result.insert(k.deserialize(deserializer)?);
46        }
47        Ok(result)
48    }
49}
50
51impl<UK, K: PartialEq<UK>, S: BuildHasher> PartialEq<IndexSet<UK, S>> for ArchivedIndexSet<K> {
52    fn eq(&self, other: &IndexSet<UK, S>) -> bool {
53        self.iter().eq(other.iter())
54    }
55}
56
57#[cfg(test)]
58mod tests {
59    use crate::{
60        archived_root,
61        ser::{serializers::AllocSerializer, Serializer},
62        Deserialize, Infallible,
63    };
64    use indexmap::{indexset, IndexSet};
65
66    #[test]
67    fn index_set() {
68        let value = indexset! {
69            String::from("foo"),
70            String::from("bar"),
71            String::from("baz"),
72            String::from("bat"),
73        };
74
75        let mut serializer = AllocSerializer::<4096>::default();
76        serializer.serialize_value(&value).unwrap();
77        let result = serializer.into_serializer().into_inner();
78        let archived = unsafe { archived_root::<IndexSet<String>>(result.as_ref()) };
79
80        assert_eq!(value.len(), archived.len());
81        for k in value.iter() {
82            let ak = archived.get(k.as_str()).unwrap();
83            assert_eq!(k, ak);
84        }
85
86        let deserialized: IndexSet<String> = archived.deserialize(&mut Infallible).unwrap();
87        assert_eq!(value, deserialized);
88    }
89
90    #[cfg(feature = "validation")]
91    #[test]
92    fn validate_index_set() {
93        use crate::check_archived_root;
94
95        let value = indexset! {
96            String::from("foo"),
97            String::from("bar"),
98            String::from("baz"),
99            String::from("bat"),
100        };
101
102        let mut serializer = AllocSerializer::<4096>::default();
103        serializer.serialize_value(&value).unwrap();
104        let result = serializer.into_serializer().into_inner();
105        check_archived_root::<IndexSet<String>>(result.as_ref())
106            .expect("failed to validate archived index set");
107    }
108}
rkyv/impls/indexmap/index_set.rs

rkyv/impls/indexmap/
index_set.rs
