reifydb_core/util/encoding/keycode/
deserialize.rs

1// SPDX-License-Identifier: AGPL-3.0-or-later
2// Copyright (c) 2025 ReifyDB
3
4use reifydb_type::{
5	error,
6	error::{Error, diagnostic::serde::serde_keycode_error},
7};
8use serde::de::{DeserializeSeed, EnumAccess, IntoDeserializer, SeqAccess, VariantAccess, Visitor};
9
10pub(crate) struct Deserializer<'de> {
11	pub(crate) input: &'de [u8],
12}
13
14impl<'de> Deserializer<'de> {
15	pub fn from_bytes(input: &'de [u8]) -> Self {
16		Deserializer {
17			input,
18		}
19	}
20
21	fn take_bytes(&mut self, len: usize) -> reifydb_type::Result<&[u8]> {
22		if self.input.len() < len {
23			return Err(error!(serde_keycode_error(format!(
24				"insufficient bytes, expected {len} bytes for {:x?}",
25				self.input
26			))));
27		}
28		let bytes = &self.input[..len];
29		self.input = &self.input[len..];
30		Ok(bytes)
31	}
32
33	fn decode_next_bytes(&mut self) -> reifydb_type::Result<Vec<u8>> {
34		let mut decoded = Vec::new();
35		let mut iter = self.input.iter().enumerate();
36		let taken = loop {
37			match iter.next() {
38				Some((_, 0xff)) => match iter.next() {
39					Some((i, 0xff)) => break i + 1,        // terminator
40					Some((_, 0x00)) => decoded.push(0xff), // escaped 0xff
41					_ => {
42						return Err(error!(serde_keycode_error(
43							"invalid escape sequence".to_string()
44						)));
45					}
46				},
47				Some((_, b)) => decoded.push(*b),
48				None => {
49					return Err(error!(serde_keycode_error("unexpected end of input".to_string())));
50				}
51			}
52		};
53		self.input = &self.input[taken..];
54		Ok(decoded)
55	}
56}
57
58impl<'de> serde::de::Deserializer<'de> for &mut Deserializer<'de> {
59	type Error = Error;
60
61	fn deserialize_any<V: Visitor<'de>>(self, _: V) -> reifydb_type::Result<V::Value> {
62		panic!("must provide type, Keycode is not self-describing")
63	}
64
65	fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
66		visitor.visit_bool(match self.take_bytes(1)?[0] {
67			0x01 => false,
68			0x00 => true,
69			b => {
70				return Err(error!(serde_keycode_error(format!("invalid boolean value {b}"))));
71			}
72		})
73	}
74
75	fn deserialize_i8<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
76		let mut byte = self.take_bytes(1)?[0];
77		byte = !byte;
78		byte ^= 1 << 7; // restore original sign
79		visitor.visit_i8(byte as i8)
80	}
81
82	fn deserialize_i16<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
83		let mut bytes = self.take_bytes(2)?.to_vec();
84		for b in &mut bytes {
85			*b = !*b;
86		}
87		bytes[0] ^= 1 << 7;
88		visitor.visit_i16(i16::from_be_bytes(bytes.as_slice().try_into()?))
89	}
90
91	fn deserialize_i32<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
92		let mut bytes = self.take_bytes(4)?.to_vec();
93		for b in &mut bytes {
94			*b = !*b;
95		}
96		bytes[0] ^= 1 << 7;
97		visitor.visit_i32(i32::from_be_bytes(bytes.as_slice().try_into()?))
98	}
99
100	fn deserialize_i64<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
101		let mut bytes = self.take_bytes(8)?.to_vec();
102		for b in &mut bytes {
103			*b = !*b;
104		}
105		bytes[0] ^= 1 << 7;
106		visitor.visit_i64(i64::from_be_bytes(bytes.as_slice().try_into()?))
107	}
108
109	fn deserialize_i128<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
110		let mut bytes = self.take_bytes(16)?.to_vec();
111		for b in &mut bytes {
112			*b = !*b;
113		}
114		bytes[0] ^= 1 << 7;
115		visitor.visit_i128(i128::from_be_bytes(bytes.as_slice().try_into()?))
116	}
117
118	fn deserialize_u8<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
119		let byte = !self.take_bytes(1)?[0];
120		visitor.visit_u8(byte)
121	}
122
123	fn deserialize_u16<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
124		let mut bytes = self.take_bytes(2)?.to_vec();
125		for b in &mut bytes {
126			*b = !*b;
127		}
128		visitor.visit_u16(u16::from_be_bytes(bytes.as_slice().try_into()?))
129	}
130
131	fn deserialize_u32<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
132		let mut bytes = self.take_bytes(4)?.to_vec();
133		for b in &mut bytes {
134			*b = !*b;
135		}
136		visitor.visit_u32(u32::from_be_bytes(bytes.as_slice().try_into()?))
137	}
138
139	fn deserialize_u64<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
140		let mut bytes = self.take_bytes(8)?.to_vec();
141		for b in &mut bytes {
142			*b = !*b;
143		}
144		visitor.visit_u64(u64::from_be_bytes(bytes.as_slice().try_into()?))
145	}
146
147	fn deserialize_u128<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
148		let mut bytes = self.take_bytes(16)?.to_vec();
149		for b in &mut bytes {
150			*b = !*b;
151		}
152		visitor.visit_u128(u128::from_be_bytes(bytes.as_slice().try_into()?))
153	}
154
155	fn deserialize_f32<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
156		let mut bytes = self.take_bytes(4)?.to_vec();
157		for b in &mut bytes {
158			*b = !*b;
159		}
160		match bytes[0] >> 7 {
161			0 => bytes.iter_mut().for_each(|b| *b = !*b), // negative, flip all bits
162			1 => bytes[0] ^= 1 << 7,                      // positive, flip sign bit
163			_ => panic!("bits can only be 0 or 1"),
164		}
165		visitor.visit_f32(f32::from_be_bytes(bytes.as_slice().try_into()?))
166	}
167
168	fn deserialize_f64<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
169		let mut bytes = self.take_bytes(8)?.to_vec();
170		for b in &mut bytes {
171			*b = !*b;
172		}
173		match bytes[0] >> 7 {
174			0 => bytes.iter_mut().for_each(|b| *b = !*b), // negative, flip all bits
175			1 => bytes[0] ^= 1 << 7,                      // positive, flip sign bit
176			_ => panic!("bits can only be 0 or 1"),
177		}
178		visitor.visit_f64(f64::from_be_bytes(bytes.as_slice().try_into()?))
179	}
180
181	fn deserialize_char<V: Visitor<'de>>(self, _: V) -> reifydb_type::Result<V::Value> {
182		unimplemented!()
183	}
184
185	fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
186		let bytes = self.decode_next_bytes()?;
187		visitor.visit_str(&String::from_utf8(bytes)?)
188	}
189
190	fn deserialize_string<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
191		let bytes = self.decode_next_bytes()?;
192		visitor.visit_string(String::from_utf8(bytes)?)
193	}
194
195	fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
196		let bytes = self.decode_next_bytes()?;
197		visitor.visit_bytes(&bytes)
198	}
199
200	fn deserialize_byte_buf<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
201		let bytes = self.decode_next_bytes()?;
202		visitor.visit_byte_buf(bytes)
203	}
204
205	fn deserialize_option<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
206		match self.take_bytes(1)?[0] {
207			0x00 => visitor.visit_none(),
208			0x01 => visitor.visit_some(self),
209			b => Err(error!(serde_keycode_error(format!("invalid option marker byte 0x{:02x}", b)))),
210		}
211	}
212
213	fn deserialize_unit<V: Visitor<'de>>(self, _: V) -> reifydb_type::Result<V::Value> {
214		unimplemented!()
215	}
216
217	fn deserialize_unit_struct<V: Visitor<'de>>(self, _: &'static str, _: V) -> reifydb_type::Result<V::Value> {
218		unimplemented!()
219	}
220
221	fn deserialize_newtype_struct<V: Visitor<'de>>(self, _: &'static str, _: V) -> reifydb_type::Result<V::Value> {
222		unimplemented!()
223	}
224
225	fn deserialize_seq<V: Visitor<'de>>(self, visitor: V) -> reifydb_type::Result<V::Value> {
226		visitor.visit_seq(self)
227	}
228
229	fn deserialize_tuple<V: Visitor<'de>>(self, _: usize, visitor: V) -> reifydb_type::Result<V::Value> {
230		visitor.visit_seq(self)
231	}
232
233	fn deserialize_tuple_struct<V: Visitor<'de>>(
234		self,
235		_: &'static str,
236		_: usize,
237		_: V,
238	) -> reifydb_type::Result<V::Value> {
239		unimplemented!()
240	}
241
242	fn deserialize_map<V: Visitor<'de>>(self, _: V) -> reifydb_type::Result<V::Value> {
243		unimplemented!()
244	}
245
246	fn deserialize_struct<V: Visitor<'de>>(
247		self,
248		_: &'static str,
249		_: &'static [&'static str],
250		_: V,
251	) -> reifydb_type::Result<V::Value> {
252		unimplemented!()
253	}
254
255	fn deserialize_enum<V: Visitor<'de>>(
256		self,
257		_: &'static str,
258		_: &'static [&'static str],
259		visitor: V,
260	) -> reifydb_type::Result<V::Value> {
261		visitor.visit_enum(self)
262	}
263
264	fn deserialize_identifier<V: Visitor<'de>>(self, _: V) -> reifydb_type::Result<V::Value> {
265		unimplemented!()
266	}
267
268	fn deserialize_ignored_any<V: Visitor<'de>>(self, _: V) -> reifydb_type::Result<V::Value> {
269		unimplemented!()
270	}
271}
272
273impl<'de> SeqAccess<'de> for Deserializer<'de> {
274	type Error = Error;
275
276	fn next_element_seed<T: DeserializeSeed<'de>>(&mut self, seed: T) -> reifydb_type::Result<Option<T::Value>> {
277		if self.input.is_empty() {
278			return Ok(None);
279		}
280		seed.deserialize(self).map(Some)
281	}
282}
283
284impl<'de> EnumAccess<'de> for &mut Deserializer<'de> {
285	type Error = Error;
286	type Variant = Self;
287
288	fn variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> reifydb_type::Result<(V::Value, Self::Variant)> {
289		let index = self.take_bytes(1)?[0] as u32;
290		let value: reifydb_type::Result<_> = seed.deserialize(index.into_deserializer());
291		Ok((value?, self))
292	}
293}
294
295impl<'de> VariantAccess<'de> for &mut Deserializer<'de> {
296	type Error = Error;
297
298	fn unit_variant(self) -> reifydb_type::Result<()> {
299		Ok(())
300	}
301
302	fn newtype_variant_seed<T: DeserializeSeed<'de>>(self, seed: T) -> reifydb_type::Result<T::Value> {
303		seed.deserialize(&mut *self)
304	}
305
306	fn tuple_variant<V: Visitor<'de>>(self, _: usize, visitor: V) -> reifydb_type::Result<V::Value> {
307		visitor.visit_seq(self)
308	}
309
310	fn struct_variant<V: Visitor<'de>>(
311		self,
312		fields: &'static [&'static str],
313		visitor: V,
314	) -> reifydb_type::Result<V::Value> {
315		self.tuple_variant(fields.len(), visitor)
316	}
317}
reifydb_core/util/encoding/keycode/deserialize.rs

reifydb_core/util/encoding/keycode/
deserialize.rs
