aldrin_core/
unknown_fields.rs

1#[cfg(test)]
2mod test;
3
4use crate::{
5    tags, DeserializeError, Serialize, SerializedValue, SerializedValueSlice, Struct, ValueKind,
6};
7use std::collections::hash_map::{HashMap, IntoIter, Iter};
8use std::convert::Infallible;
9use std::iter::{self, Empty, Map};
10use std::ops::{Deref, DerefMut};
11
12pub trait AsUnknownFields {
13    type Field: Serialize<tags::Value>;
14    type FieldsIter: Iterator<Item = (u32, Self::Field)>;
15
16    fn fields(self) -> Self::FieldsIter;
17}
18
19#[derive(Debug, Clone, PartialEq, Eq, Default)]
20pub struct UnknownFields(pub HashMap<u32, SerializedValue>);
21
22impl UnknownFields {
23    pub fn new() -> Self {
24        Self::default()
25    }
26
27    pub fn has_fields_set(&self) -> bool {
28        self.0
29            .values()
30            .filter_map(|val| val.kind().ok())
31            .any(|kind| kind != ValueKind::None)
32    }
33
34    pub fn iter(&self) -> impl ExactSizeIterator<Item = (u32, &SerializedValueSlice)> {
35        self.into_iter()
36    }
37
38    pub fn deserialize_as_value(&self) -> Result<Struct, DeserializeError> {
39        self.iter()
40            .map(|(id, val)| val.deserialize_as_value().map(|val| (id, val)))
41            .collect::<Result<_, _>>()
42            .map(Struct)
43    }
44}
45
46impl Deref for UnknownFields {
47    type Target = HashMap<u32, SerializedValue>;
48
49    fn deref(&self) -> &Self::Target {
50        &self.0
51    }
52}
53
54impl DerefMut for UnknownFields {
55    fn deref_mut(&mut self) -> &mut Self::Target {
56        &mut self.0
57    }
58}
59
60impl IntoIterator for UnknownFields {
61    type Item = (u32, SerializedValue);
62    type IntoIter = IntoIter<u32, SerializedValue>;
63
64    fn into_iter(self) -> Self::IntoIter {
65        self.0.into_iter()
66    }
67}
68
69impl<'a> IntoIterator for &'a UnknownFields {
70    type Item = (u32, &'a SerializedValueSlice);
71
72    type IntoIter = Map<
73        Iter<'a, u32, SerializedValue>,
74        fn((&'a u32, &'a SerializedValue)) -> (u32, &'a SerializedValueSlice),
75    >;
76
77    fn into_iter(self) -> Self::IntoIter {
78        self.0.iter().map(|(id, val)| (*id, val))
79    }
80}
81
82impl AsUnknownFields for UnknownFields {
83    type Field = SerializedValue;
84    type FieldsIter = <Self as IntoIterator>::IntoIter;
85
86    fn fields(self) -> Self::FieldsIter {
87        self.into_iter()
88    }
89}
90
91impl<'a> AsUnknownFields for &'a UnknownFields {
92    type Field = &'a SerializedValueSlice;
93    type FieldsIter = <Self as IntoIterator>::IntoIter;
94
95    fn fields(self) -> Self::FieldsIter {
96        self.into_iter()
97    }
98}
99
100#[derive(Debug, Copy, Clone)]
101pub struct UnknownFieldsRef<Fields>(pub Fields);
102
103impl<Fields, Field> AsUnknownFields for UnknownFieldsRef<Fields>
104where
105    Fields: IntoIterator<Item = (u32, Field)>,
106    Field: Serialize<tags::Value>,
107{
108    type Field = Field;
109    type FieldsIter = Fields::IntoIter;
110
111    fn fields(self) -> Self::FieldsIter {
112        self.0.into_iter()
113    }
114}
115
116impl AsUnknownFields for () {
117    type Field = Infallible;
118    type FieldsIter = Empty<(u32, Infallible)>;
119
120    fn fields(self) -> Self::FieldsIter {
121        iter::empty()
122    }
123}
124
125impl AsUnknownFields for Infallible {
126    type Field = Self;
127    type FieldsIter = Empty<(u32, Self)>;
128
129    fn fields(self) -> Self::FieldsIter {
130        iter::empty()
131    }
132}
aldrin_core/unknown_fields.rs

aldrin_core/
unknown_fields.rs
