redust-resp 0.3.0

A simple RESP parser for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use serde::de;

use super::Deserializer;

use crate::Error;

pub struct WithLen<'a, 'de: 'a> {
	pub de: &'a mut Deserializer<'de>,
	pub cur: usize,
	pub len: usize,
}

impl<'a, 'de> de::SeqAccess<'de> for WithLen<'a, 'de> {
	type Error = Error<'de>;

	fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
	where
		T: de::DeserializeSeed<'de>,
	{
		if self.cur == self.len {
			Ok(None)
		} else {
			self.cur += 1;
			seed.deserialize(&mut *self.de).map(Some)
		}
	}

	fn size_hint(&self) -> Option<usize> {
		Some(self.len - self.cur)
	}
}

impl<'a, 'de> de::MapAccess<'de> for WithLen<'a, 'de> {
	type Error = Error<'de>;

	fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
	where
		K: de::DeserializeSeed<'de>,
	{
		if self.cur == self.len {
			Ok(None)
		} else {
			self.cur += 1;
			seed.deserialize(&mut *self.de).map(Some)
		}
	}

	fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
	where
		V: de::DeserializeSeed<'de>,
	{
		seed.deserialize(&mut *self.de)
	}

	fn size_hint(&self) -> Option<usize> {
		Some(self.len - self.cur)
	}
}

pub struct Enum<'a, 'de: 'a> {
	pub de: &'a mut Deserializer<'de>,
}

impl<'de, 'a> de::EnumAccess<'de> for Enum<'a, 'de> {
	type Error = Error<'de>;
	type Variant = Self;

	fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
	where
		V: de::DeserializeSeed<'de>,
	{
		let val = seed.deserialize(&mut *self.de)?;
		Ok((val, self))
	}
}

impl<'de, 'a> de::VariantAccess<'de> for Enum<'a, 'de> {
	type Error = Error<'de>;

	fn unit_variant(self) -> Result<(), Self::Error> {
		Ok(())
	}

	fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
	where
		T: de::DeserializeSeed<'de>,
	{
		seed.deserialize(self.de)
	}

	fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: de::Visitor<'de>,
	{
		de::Deserializer::deserialize_tuple(self.de, len, visitor)
	}

	fn struct_variant<V>(
		self,
		_fields: &'static [&'static str],
		visitor: V,
	) -> Result<V::Value, Self::Error>
	where
		V: de::Visitor<'de>,
	{
		de::Deserializer::deserialize_map(self.de, visitor)
	}
}