revision/implementations/
result.rs

1use crate::DeserializeRevisioned;
2use crate::SerializeRevisioned;
3
4use super::super::Error;
5use super::super::Revisioned;
6
7impl<E: SerializeRevisioned, T: SerializeRevisioned> SerializeRevisioned for Result<T, E> {
8	#[inline]
9	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
10		match self {
11			Ok(v) => {
12				0u32.serialize_revisioned(writer)?;
13				v.serialize_revisioned(writer)
14			}
15			Err(e) => {
16				1u32.serialize_revisioned(writer)?;
17				e.serialize_revisioned(writer)
18			}
19		}
20	}
21}
22
23impl<E: DeserializeRevisioned, T: DeserializeRevisioned> DeserializeRevisioned for Result<T, E> {
24	#[inline]
25	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
26		let variant = u32::deserialize_revisioned(reader)?;
27		match variant {
28			0 => Ok(Ok(T::deserialize_revisioned(reader)
29				.map_err(|ref err| Error::Deserialize(format!("{:?}", err)))?)),
30			1 => Ok(Err(E::deserialize_revisioned(reader)
31				.map_err(|ref err| Error::Deserialize(format!("{:?}", err)))?)),
32			_ => Err(Error::Deserialize("Unknown variant index".to_string())),
33		}
34	}
35}
36
37impl<E: Revisioned, T: Revisioned> Revisioned for Result<T, E> {
38	#[inline]
39	fn revision() -> u16 {
40		1
41	}
42}
43
44#[cfg(test)]
45mod tests {
46
47	use super::*;
48
49	#[test]
50	fn test_result_ok() {
51		let val: Result<bool, String> = Ok(true);
52		let mut mem: Vec<u8> = vec![];
53		val.serialize_revisioned(&mut mem).unwrap();
54		assert_eq!(mem.len(), 2);
55		let out = <Result<bool, String> as DeserializeRevisioned>::deserialize_revisioned(
56			&mut mem.as_slice(),
57		)
58		.unwrap();
59		assert_eq!(val, out);
60	}
61
62	#[test]
63	fn test_result_err() {
64		let val: Result<bool, String> = Err("some error".into());
65		let mut mem: Vec<u8> = vec![];
66		val.serialize_revisioned(&mut mem).unwrap();
67		assert_eq!(mem.len(), 12);
68		let out = <Result<bool, String> as DeserializeRevisioned>::deserialize_revisioned(
69			&mut mem.as_slice(),
70		)
71		.unwrap();
72		assert_eq!(val, out);
73	}
74}