aldrin_core/impls/
map.rs

1#[cfg(feature = "introspection")]
2use crate::introspection::{ir, Introspectable, LexicalId, References};
3use crate::tags::{KeyTag, Map, PrimaryKeyTag, PrimaryTag, Tag};
4use crate::{
5    Deserialize, DeserializeError, DeserializeKey, Deserializer, Serialize, SerializeError,
6    SerializeKey, Serializer,
7};
8use std::collections::{BTreeMap, HashMap};
9use std::hash::{BuildHasher, Hash};
10
11impl<K: PrimaryKeyTag, T: PrimaryTag, S> PrimaryTag for HashMap<K, T, S> {
12    type Tag = Map<K::KeyTag, T::Tag>;
13}
14
15impl<K, L, T, U, S> Serialize<Map<K, T>> for HashMap<L, U, S>
16where
17    K: KeyTag,
18    L: SerializeKey<K>,
19    T: Tag,
20    U: Serialize<T>,
21{
22    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
23        serializer.serialize_map2_iter(self)
24    }
25}
26
27impl<'a, K, L, T, U, S> Serialize<Map<K, T>> for &'a HashMap<L, U, S>
28where
29    K: KeyTag,
30    &'a L: SerializeKey<K>,
31    T: Tag,
32    &'a U: Serialize<T>,
33{
34    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
35        serializer.serialize_map2_iter(self)
36    }
37}
38
39impl<K, L, T, U, S> Deserialize<Map<K, T>> for HashMap<L, U, S>
40where
41    K: KeyTag,
42    L: DeserializeKey<K> + Eq + Hash,
43    T: Tag,
44    U: Deserialize<T>,
45    S: Default + BuildHasher,
46{
47    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
48        deserializer.deserialize_map_extend_new()
49    }
50}
51
52#[cfg(feature = "introspection")]
53impl<K, V, S> Introspectable for HashMap<K, V, S>
54where
55    K: Introspectable,
56    V: Introspectable,
57{
58    fn layout() -> ir::LayoutIr {
59        ir::BuiltInTypeIr::Map(ir::MapTypeIr::new(K::lexical_id(), V::lexical_id())).into()
60    }
61
62    fn lexical_id() -> LexicalId {
63        LexicalId::map(K::lexical_id(), V::lexical_id())
64    }
65
66    fn add_references(references: &mut References) {
67        references.add::<K>();
68        references.add::<V>();
69    }
70}
71
72impl<K: PrimaryKeyTag, T: PrimaryTag> PrimaryTag for BTreeMap<K, T> {
73    type Tag = Map<K::KeyTag, T::Tag>;
74}
75
76impl<K, L, T, U> Serialize<Map<K, T>> for BTreeMap<L, U>
77where
78    K: KeyTag,
79    L: SerializeKey<K>,
80    T: Tag,
81    U: Serialize<T>,
82{
83    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
84        serializer.serialize_map2_iter(self)
85    }
86}
87
88impl<'a, K, L, T, U> Serialize<Map<K, T>> for &'a BTreeMap<L, U>
89where
90    K: KeyTag,
91    &'a L: SerializeKey<K>,
92    T: Tag,
93    &'a U: Serialize<T>,
94{
95    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
96        serializer.serialize_map2_iter(self)
97    }
98}
99
100impl<K, L, T, U> Deserialize<Map<K, T>> for BTreeMap<L, U>
101where
102    K: KeyTag,
103    L: DeserializeKey<K> + Ord,
104    T: Tag,
105    U: Deserialize<T>,
106{
107    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
108        deserializer.deserialize_map_extend_new()
109    }
110}
111
112#[cfg(feature = "introspection")]
113impl<K: Introspectable, V: Introspectable> Introspectable for BTreeMap<K, V> {
114    fn layout() -> ir::LayoutIr {
115        ir::BuiltInTypeIr::Map(ir::MapTypeIr::new(K::lexical_id(), V::lexical_id())).into()
116    }
117
118    fn lexical_id() -> LexicalId {
119        LexicalId::map(K::lexical_id(), V::lexical_id())
120    }
121
122    fn add_references(references: &mut References) {
123        references.add::<K>();
124        references.add::<V>();
125    }
126}
127
128impl<K: KeyTag, T: Tag> Serialize<Map<K, T>> for () {
129    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
130        serializer.serialize_map2::<K>()?.finish()
131    }
132}
133
134impl<K: KeyTag, T: Tag> Serialize<Map<K, T>> for &() {
135    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
136        serializer.serialize_map2::<K>()?.finish()
137    }
138}
139
140impl<K: KeyTag, T: Tag> Deserialize<Map<K, T>> for () {
141    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
142        deserializer.deserialize_map::<K>()?.finish(())
143    }
144}