compact binary serialization format with built-in compression
kokirigla.de
1use hateno::Tag;
2use serde::{Deserializer as _, de};
3
4use crate::{Error, Result};
5
6pub struct ListAccess {
7 elements: Vec<Tag>,
8 index: usize,
9}
10
11impl ListAccess {
12 pub fn new(elements: Vec<Tag>) -> Self {
13 Self { elements, index: 0 }
14 }
15}
16
17impl<'de> de::SeqAccess<'de> for ListAccess {
18 type Error = Error;
19
20 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
21 where
22 T: de::DeserializeSeed<'de>,
23 {
24 if self.index >= self.elements.len() {
25 return Ok(None);
26 }
27
28 let tag = self.elements[self.index].clone();
29 self.index += 1;
30 let mut deserializer = super::TagDeserializer::new(tag);
31 seed.deserialize(&mut deserializer).map(Some)
32 }
33
34 fn size_hint(&self) -> Option<usize> {
35 Some(self.elements.len() - self.index)
36 }
37}
38
39pub struct MapAccess {
40 entries: Vec<(Tag, Tag)>,
41 index: usize,
42 value: Option<Tag>,
43}
44
45impl MapAccess {
46 pub fn new(entries: Vec<(Tag, Tag)>) -> Self {
47 Self {
48 entries,
49 index: 0,
50 value: None,
51 }
52 }
53}
54
55impl<'de> de::MapAccess<'de> for MapAccess {
56 type Error = Error;
57
58 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
59 where
60 K: de::DeserializeSeed<'de>,
61 {
62 if self.index >= self.entries.len() {
63 return Ok(None);
64 }
65
66 let (key, value) = &self.entries[self.index];
67 self.value = Some(value.clone());
68 let mut deserializer = super::TagDeserializer::new(key.clone());
69 seed.deserialize(&mut deserializer).map(Some)
70 }
71
72 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
73 where
74 V: de::DeserializeSeed<'de>,
75 {
76 let value = self.value.take().ok_or_else(|| {
77 Error::Custom(
78 "next_value_seed called before next_key_seed".to_string(),
79 )
80 })?;
81 self.index += 1;
82 let mut deserializer = super::TagDeserializer::new(value);
83 seed.deserialize(&mut deserializer)
84 }
85
86 fn size_hint(&self) -> Option<usize> {
87 Some(self.entries.len() - self.index)
88 }
89}
90
91pub struct UnitVariantAccess {
92 variant: String,
93}
94
95impl UnitVariantAccess {
96 pub fn new(variant: String) -> Self {
97 Self { variant }
98 }
99}
100
101impl<'de> de::EnumAccess<'de> for UnitVariantAccess {
102 type Error = Error;
103 type Variant = UnitOnlyVariantAccess;
104
105 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
106 where
107 V: de::DeserializeSeed<'de>,
108 {
109 let mut deserializer =
110 super::TagDeserializer::new(Tag::new_string(&self.variant));
111 let variant = seed.deserialize(&mut deserializer)?;
112 Ok((variant, UnitOnlyVariantAccess))
113 }
114}
115
116pub struct UnitOnlyVariantAccess;
117
118impl<'de> de::VariantAccess<'de> for UnitOnlyVariantAccess {
119 type Error = Error;
120
121 fn unit_variant(self) -> Result<()> {
122 Ok(())
123 }
124
125 fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value>
126 where
127 T: de::DeserializeSeed<'de>,
128 {
129 Err(Error::Custom("expected unit variant".to_string()))
130 }
131
132 fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
133 where
134 V: de::Visitor<'de>,
135 {
136 Err(Error::Custom("expected unit variant".to_string()))
137 }
138
139 fn struct_variant<V>(
140 self,
141 _fields: &'static [&'static str],
142 _visitor: V,
143 ) -> Result<V::Value>
144 where
145 V: de::Visitor<'de>,
146 {
147 Err(Error::Custom("expected unit variant".to_string()))
148 }
149}
150
151pub struct VariantAccess {
152 variant: String,
153 value: Tag,
154}
155
156impl VariantAccess {
157 pub fn new(variant: String, value: Tag) -> Self {
158 Self { variant, value }
159 }
160}
161
162impl<'de> de::EnumAccess<'de> for VariantAccess {
163 type Error = Error;
164 type Variant = ValueVariantAccess;
165
166 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
167 where
168 V: de::DeserializeSeed<'de>,
169 {
170 let mut deserializer =
171 super::TagDeserializer::new(Tag::new_string(&self.variant));
172 let variant = seed.deserialize(&mut deserializer)?;
173 Ok((variant, ValueVariantAccess::new(self.value)))
174 }
175}
176
177pub struct ValueVariantAccess {
178 value: Tag,
179}
180
181impl ValueVariantAccess {
182 fn new(value: Tag) -> Self {
183 Self { value }
184 }
185}
186
187impl<'de> de::VariantAccess<'de> for ValueVariantAccess {
188 type Error = Error;
189
190 fn unit_variant(self) -> Result<()> {
191 match &self.value {
192 Tag::List(elements) if elements.is_empty() => Ok(()),
193 _ => Err(Error::Custom("expected unit variant".to_string())),
194 }
195 }
196
197 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
198 where
199 T: de::DeserializeSeed<'de>,
200 {
201 let mut deserializer = super::TagDeserializer::new(self.value);
202 seed.deserialize(&mut deserializer)
203 }
204
205 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
206 where
207 V: de::Visitor<'de>,
208 {
209 let mut deserializer = super::TagDeserializer::new(self.value);
210 deserializer.deserialize_seq(visitor)
211 }
212
213 fn struct_variant<V>(
214 self,
215 _fields: &'static [&'static str],
216 visitor: V,
217 ) -> Result<V::Value>
218 where
219 V: de::Visitor<'de>,
220 {
221 let mut deserializer = super::TagDeserializer::new(self.value);
222 deserializer.deserialize_map(visitor)
223 }
224}