sbor/codec/
collection.rs

1use crate::rust::collections::*;
2use crate::rust::hash::Hash;
3use crate::rust::ptr::copy;
4use crate::rust::vec::Vec;
5use crate::value_kind::*;
6use crate::*;
7
8categorize_generic!(Vec<T>, <T>, ValueKind::Array);
9categorize_generic!(BTreeSet<T>, <T>, ValueKind::Array);
10categorize_generic!(HashSet<T>, <T>, ValueKind::Array);
11categorize_generic!(IndexSet<T>, <T>, ValueKind::Array);
12
13categorize_generic!(BTreeMap<K, V>, <K, V>, ValueKind::Map);
14categorize_generic!(HashMap<K, V>, <K, V>, ValueKind::Map);
15categorize_generic!(IndexMap<K, V>, <K, V>, ValueKind::Map);
16
17impl<X: CustomValueKind, E: Encoder<X>, T: Encode<X, E> + Categorize<X>> Encode<X, E> for Vec<T> {
18    #[inline]
19    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
20        encoder.write_value_kind(Self::value_kind())
21    }
22
23    #[inline]
24    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
25        self.as_slice().encode_body(encoder)?;
26        Ok(())
27    }
28}
29
30impl<X: CustomValueKind, E: Encoder<X>, T: Encode<X, E> + Categorize<X>> Encode<X, E>
31    for BTreeSet<T>
32{
33    #[inline]
34    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
35        encoder.write_value_kind(Self::value_kind())
36    }
37
38    #[inline]
39    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
40        encoder.write_value_kind(T::value_kind())?;
41        encoder.write_size(self.len())?;
42        for v in self {
43            encoder.encode_deeper_body(v)?;
44        }
45        Ok(())
46    }
47}
48
49impl<X: CustomValueKind, E: Encoder<X>, T: Encode<X, E> + Categorize<X> + Ord + Hash> Encode<X, E>
50    for HashSet<T>
51{
52    #[inline]
53    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
54        encoder.write_value_kind(Self::value_kind())
55    }
56
57    #[inline]
58    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
59        encoder.write_value_kind(T::value_kind())?;
60        encoder.write_size(self.len())?;
61        let set: BTreeSet<&T> = self.iter().collect();
62        for v in set {
63            encoder.encode_deeper_body(v)?;
64        }
65        Ok(())
66    }
67}
68
69impl<X: CustomValueKind, E: Encoder<X>, T: Encode<X, E> + Categorize<X> + Hash> Encode<X, E>
70    for IndexSet<T>
71{
72    #[inline]
73    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
74        encoder.write_value_kind(Self::value_kind())
75    }
76
77    #[inline]
78    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
79        encoder.write_value_kind(T::value_kind())?;
80        encoder.write_size(self.len())?;
81        for v in self {
82            encoder.encode_deeper_body(v)?;
83        }
84        Ok(())
85    }
86}
87
88impl<
89        X: CustomValueKind,
90        E: Encoder<X>,
91        K: Encode<X, E> + Categorize<X>,
92        V: Encode<X, E> + Categorize<X>,
93    > Encode<X, E> for BTreeMap<K, V>
94{
95    #[inline]
96    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
97        encoder.write_value_kind(Self::value_kind())
98    }
99
100    #[inline]
101    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
102        encoder.write_value_kind(K::value_kind())?;
103        encoder.write_value_kind(V::value_kind())?;
104        encoder.write_size(self.len())?;
105        for (k, v) in self {
106            encoder.encode_deeper_body(k)?;
107            encoder.encode_deeper_body(v)?;
108        }
109        Ok(())
110    }
111}
112
113impl<
114        X: CustomValueKind,
115        E: Encoder<X>,
116        K: Encode<X, E> + Categorize<X> + Ord + Hash,
117        V: Encode<X, E> + Categorize<X>,
118    > Encode<X, E> for HashMap<K, V>
119{
120    #[inline]
121    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
122        encoder.write_value_kind(Self::value_kind())
123    }
124
125    #[inline]
126    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
127        encoder.write_value_kind(K::value_kind())?;
128        encoder.write_value_kind(V::value_kind())?;
129        encoder.write_size(self.len())?;
130        let mut keys: Vec<&K> = self.keys().collect();
131        keys.sort();
132        for key in keys {
133            encoder.encode_deeper_body(key)?;
134            encoder.encode_deeper_body(self.get(key).unwrap())?;
135        }
136        Ok(())
137    }
138}
139
140impl<
141        X: CustomValueKind,
142        E: Encoder<X>,
143        K: Encode<X, E> + Categorize<X> + Hash + Eq + PartialEq,
144        V: Encode<X, E> + Categorize<X>,
145    > Encode<X, E> for IndexMap<K, V>
146{
147    #[inline]
148    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
149        encoder.write_value_kind(Self::value_kind())
150    }
151
152    #[inline]
153    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
154        encoder.write_value_kind(K::value_kind())?;
155        encoder.write_value_kind(V::value_kind())?;
156        encoder.write_size(self.len())?;
157        for (key, value) in self.iter() {
158            encoder.encode_deeper_body(key)?;
159            encoder.encode_deeper_body(value)?;
160        }
161        Ok(())
162    }
163}
164
165impl<X: CustomValueKind, D: Decoder<X>, T: Decode<X, D> + Categorize<X>> Decode<X, D> for Vec<T> {
166    #[inline]
167    fn decode_body_with_value_kind(
168        decoder: &mut D,
169        value_kind: ValueKind<X>,
170    ) -> Result<Self, DecodeError> {
171        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
172        let element_value_kind = decoder.read_and_check_value_kind(T::value_kind())?;
173        let len = decoder.read_size()?;
174
175        if T::value_kind() == ValueKind::U8 || T::value_kind() == ValueKind::I8 {
176            let slice = decoder.read_slice(len)?; // length is checked here
177            let mut result = Vec::<T>::with_capacity(len);
178            unsafe {
179                copy(slice.as_ptr(), result.as_mut_ptr() as *mut u8, slice.len());
180                result.set_len(slice.len());
181            }
182            Ok(result)
183        } else {
184            let mut result = Vec::<T>::with_capacity(if len <= 1024 { len } else { 1024 });
185            for _ in 0..len {
186                result.push(decoder.decode_deeper_body_with_value_kind(element_value_kind)?);
187            }
188            Ok(result)
189        }
190    }
191}
192
193impl<X: CustomValueKind, D: Decoder<X>, T: Decode<X, D> + Categorize<X> + Ord> Decode<X, D>
194    for BTreeSet<T>
195{
196    #[inline]
197    fn decode_body_with_value_kind(
198        decoder: &mut D,
199        value_kind: ValueKind<X>,
200    ) -> Result<Self, DecodeError> {
201        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
202        let element_value_kind = decoder.read_and_check_value_kind(T::value_kind())?;
203        let len = decoder.read_size()?;
204        let mut result = BTreeSet::new();
205        for _ in 0..len {
206            if !result.insert(decoder.decode_deeper_body_with_value_kind(element_value_kind)?) {
207                return Err(DecodeError::DuplicateKey);
208            }
209        }
210        Ok(result)
211    }
212}
213
214impl<X: CustomValueKind, D: Decoder<X>, T: Decode<X, D> + Categorize<X> + Hash + Eq> Decode<X, D>
215    for HashSet<T>
216{
217    #[inline]
218    fn decode_body_with_value_kind(
219        decoder: &mut D,
220        value_kind: ValueKind<X>,
221    ) -> Result<Self, DecodeError> {
222        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
223        let element_value_kind = decoder.read_and_check_value_kind(T::value_kind())?;
224        let len = decoder.read_size()?;
225        let mut result = hash_set_with_capacity(if len <= 1024 { len } else { 1024 });
226        for _ in 0..len {
227            if !result.insert(decoder.decode_deeper_body_with_value_kind(element_value_kind)?) {
228                return Err(DecodeError::DuplicateKey);
229            }
230        }
231        Ok(result)
232    }
233}
234
235impl<X: CustomValueKind, D: Decoder<X>, T: Decode<X, D> + Categorize<X> + Hash + Eq> Decode<X, D>
236    for IndexSet<T>
237{
238    #[inline]
239    fn decode_body_with_value_kind(
240        decoder: &mut D,
241        value_kind: ValueKind<X>,
242    ) -> Result<Self, DecodeError> {
243        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
244        let element_value_kind = decoder.read_and_check_value_kind(T::value_kind())?;
245        let len = decoder.read_size()?;
246        let mut result = index_set_with_capacity(if len <= 1024 { len } else { 1024 });
247        for _ in 0..len {
248            if !result.insert(decoder.decode_deeper_body_with_value_kind(element_value_kind)?) {
249                return Err(DecodeError::DuplicateKey);
250            }
251        }
252        Ok(result)
253    }
254}
255
256impl<
257        X: CustomValueKind,
258        D: Decoder<X>,
259        K: Decode<X, D> + Categorize<X> + Ord,
260        V: Decode<X, D> + Categorize<X>,
261    > Decode<X, D> for BTreeMap<K, V>
262{
263    #[inline]
264    fn decode_body_with_value_kind(
265        decoder: &mut D,
266        value_kind: ValueKind<X>,
267    ) -> Result<Self, DecodeError> {
268        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
269        let key_value_kind = decoder.read_and_check_value_kind(K::value_kind())?;
270        let value_value_kind = decoder.read_and_check_value_kind(V::value_kind())?;
271        let len = decoder.read_size()?;
272        let mut result = BTreeMap::new();
273        for _ in 0..len {
274            if result
275                .insert(
276                    decoder.decode_deeper_body_with_value_kind(key_value_kind)?,
277                    decoder.decode_deeper_body_with_value_kind(value_value_kind)?,
278                )
279                .is_some()
280            {
281                return Err(DecodeError::DuplicateKey);
282            }
283        }
284        Ok(result)
285    }
286}
287
288impl<
289        X: CustomValueKind,
290        D: Decoder<X>,
291        K: Decode<X, D> + Categorize<X> + Hash + Eq,
292        V: Decode<X, D> + Categorize<X>,
293    > Decode<X, D> for HashMap<K, V>
294{
295    #[inline]
296    fn decode_body_with_value_kind(
297        decoder: &mut D,
298        value_kind: ValueKind<X>,
299    ) -> Result<Self, DecodeError> {
300        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
301        let key_value_kind = decoder.read_and_check_value_kind(K::value_kind())?;
302        let value_value_kind = decoder.read_and_check_value_kind(V::value_kind())?;
303        let len = decoder.read_size()?;
304        let mut result = hash_map_with_capacity(if len <= 1024 { len } else { 1024 });
305        for _ in 0..len {
306            if result
307                .insert(
308                    decoder.decode_deeper_body_with_value_kind(key_value_kind)?,
309                    decoder.decode_deeper_body_with_value_kind(value_value_kind)?,
310                )
311                .is_some()
312            {
313                return Err(DecodeError::DuplicateKey);
314            }
315        }
316        Ok(result)
317    }
318}
319
320impl<
321        X: CustomValueKind,
322        D: Decoder<X>,
323        K: Decode<X, D> + Categorize<X> + Hash + Eq,
324        V: Decode<X, D> + Categorize<X>,
325    > Decode<X, D> for IndexMap<K, V>
326{
327    #[inline]
328    fn decode_body_with_value_kind(
329        decoder: &mut D,
330        value_kind: ValueKind<X>,
331    ) -> Result<Self, DecodeError> {
332        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
333        let key_value_kind = decoder.read_and_check_value_kind(K::value_kind())?;
334        let value_value_kind = decoder.read_and_check_value_kind(V::value_kind())?;
335        let len = decoder.read_size()?;
336        let mut result = index_map_with_capacity(if len <= 1024 { len } else { 1024 });
337        for _ in 0..len {
338            if result
339                .insert(
340                    decoder.decode_deeper_body_with_value_kind(key_value_kind)?,
341                    decoder.decode_deeper_body_with_value_kind(value_value_kind)?,
342                )
343                .is_some()
344            {
345                return Err(DecodeError::DuplicateKey);
346            }
347        }
348        Ok(result)
349    }
350}
351
352wrapped_generic_describe!(T, Vec<T>, [T]);
353
354impl<C: CustomTypeKind<RustTypeId>, T: Describe<C>> Describe<C> for BTreeSet<T> {
355    const TYPE_ID: RustTypeId = RustTypeId::novel("Set", &[T::TYPE_ID]);
356
357    fn type_data() -> TypeData<C, RustTypeId> {
358        TypeData::new(
359            TypeKind::Array {
360                element_type: T::TYPE_ID,
361            },
362            TypeMetadata::unnamed(),
363        )
364    }
365
366    fn add_all_dependencies(aggregator: &mut TypeAggregator<C>) {
367        aggregator.add_child_type_and_descendents::<T>();
368    }
369}
370
371wrapped_generic_describe!(T, HashSet<T>, BTreeSet<T>);
372wrapped_generic_describe!(T, IndexSet<T>, BTreeSet<T>);
373
374impl<C: CustomTypeKind<RustTypeId>, K: Describe<C>, V: Describe<C>> Describe<C> for BTreeMap<K, V> {
375    const TYPE_ID: RustTypeId = RustTypeId::novel("Map", &[K::TYPE_ID, V::TYPE_ID]);
376
377    fn type_data() -> TypeData<C, RustTypeId> {
378        TypeData::new(
379            TypeKind::Map {
380                key_type: K::TYPE_ID,
381                value_type: V::TYPE_ID,
382            },
383            TypeMetadata::unnamed(),
384        )
385    }
386
387    fn add_all_dependencies(aggregator: &mut TypeAggregator<C>) {
388        aggregator.add_child_type_and_descendents::<K>();
389        aggregator.add_child_type_and_descendents::<V>();
390    }
391}
392
393wrapped_double_generic_describe!(K, V, HashMap<K, V>, BTreeMap<K, V>);
394wrapped_double_generic_describe!(K, V, IndexMap<K, V>, BTreeMap<K, V>);
sbor/codec/collection.rs

sbor/codec/
collection.rs
