ssz 0.2.0

Simple serialization implementation
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

use crate::{Encode, Decode, Error, Codec};

macro_rules! impl_builtin_uint {
	( $t:ty, $len:ty ) => {
		impl Codec for $t {
			type Size = $len;
		}

		impl Encode for $t {
			fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
				let bytes = self.to_le_bytes();
				f(&bytes)
			}
		}

		impl Decode for $t {
			fn decode(value: &[u8]) -> Result<Self, Error> {
				let mut bytes = <$t>::default().to_le_bytes();
				if value.len() != bytes.len() {
					return Err(Error::IncorrectSize)
				}
				bytes.copy_from_slice(value);
				Ok(<$t>::from_le_bytes(bytes))
			}
		}
	}
}

impl_builtin_uint!(u8, typenum::U1);
impl_builtin_uint!(u16, typenum::U2);
impl_builtin_uint!(u32, typenum::U4);
impl_builtin_uint!(u64, typenum::U8);
impl_builtin_uint!(u128, typenum::U16);

impl Codec for bool {
	type Size = typenum::U1;
}

impl Encode for bool {
	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
		let value = match self {
			true => 0x01u8,
			false => 0x00u8,
		};
		value.using_encoded(f)
	}
}

impl Decode for bool {
	fn decode(value: &[u8]) -> Result<Self, Error> {
		let value = u8::decode(value)?;
		match value {
			0x01 => Ok(true),
			0x00 => Ok(false),
			_ => Err(Error::InvalidType),
		}
	}
}