simple_config 0.134.0

A config language for humans that is not self-describing.
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

pub(crate) struct EnumDeserializer<'a, T: std::io::BufRead + std::io::Seek> {
	pub root: &'a mut crate::Deserializer<T>,
}

impl<'d, 'a, T: std::io::BufRead + std::io::Seek> serde::de::EnumAccess<'d> for EnumDeserializer<'a, T> {
	type Error = crate::DeserializeError;
	type Variant = Self;

	fn variant_seed<K: serde::de::DeserializeSeed<'d>>(self, seed: K) -> Result<(K::Value, Self), crate::DeserializeError> {
		self.root.buf.clear();
		let read = self.root.input.read_until(b':', &mut self.root.buf)?;
		let colon = self.root.buf.pop();
		debug_assert_eq!(colon.map(|c| c as char), Some(':'));

		// Ignore any comments or empty lines
		let line_start = self.root.buf.iter().rev().position(|c| c == &b'\n');
		self.root.seek_backwards(read - line_start.unwrap_or(0))?;

		let key = seed.deserialize(crate::KeyDeserializer {
			root: self.root,
		})?;

		Ok((key, self))
	}
}

impl<'d, 'a, T: std::io::BufRead + std::io::Seek> serde::de::VariantAccess<'d> for EnumDeserializer<'a, T> {
	type Error = crate::DeserializeError;

	fn unit_variant(self) -> Result<(), crate::DeserializeError> {
		unreachable!("unit_variant")
	}

	fn newtype_variant_seed<S: serde::de::DeserializeSeed<'d>>(self, seed: S)
	-> Result<S::Value, crate::DeserializeError>
	{
		seed.deserialize(self.root)
	}

	fn tuple_variant<V: serde::de::Visitor<'d>>(self, _len: usize, visitor: V)
	-> Result<V::Value, crate::DeserializeError>
	{
		serde::Deserializer::deserialize_seq(self.root, visitor)
	}

	fn struct_variant<V: serde::de::Visitor<'d>>(
		self,
		_fields: &'static [&'static str],
		visitor: V,
	) -> Result<V::Value, crate::DeserializeError>
	{
		serde::Deserializer::deserialize_map(self.root, visitor)
	}
}