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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use core::marker::PhantomData;
use typenum::Unsigned;

/// Indicate the size type of the current ssz value.
pub trait Size {
	/// Whether the value is fixed sized.
	fn is_fixed() -> bool { Self::size().is_some() }
	/// Whether the value is variable sized.
	fn is_variable() -> bool { Self::size().is_none() }
	/// The actual size of the value.
	fn size() -> Option<usize>;
}

impl<U: Unsigned> Size for U {
	fn size() -> Option<usize> { Some(Self::to_usize()) }
}

/// A plain variable sized value.
pub struct VariableSize;

impl Size for VariableSize {
	fn size() -> Option<usize> { None }
}

// The Rust's type system is not powerful enough at this moment to carry out
// calculations, so we temporarily just calculate stuff like this. Note that
// unless we have const generics, this is probably the most efficient we can
// get.

/// Add `A` and `B`, where `A` and `B` are both `Size`.
pub struct Add<A: Size, B: Size>(PhantomData<(A, B)>);

impl<A: Size, B: Size> Size for Add<A, B> {
	fn size() -> Option<usize> {
		match (A::size(), B::size()) {
			(Some(a), Some(b)) => Some(a + b),
			_ => None,
		}
	}
}

/// Multiply `A` and `B`, where `A` and `B` are both `Size`.
pub struct Mul<A: Size, B: Size>(PhantomData<(A, B)>);

impl<A: Size, B: Size> Size for Mul<A, B> {
	fn size() -> Option<usize> {
		match (A::size(), B::size()) {
			(Some(a), Some(b)) => Some(a * b),
			_ => None,
		}
	}
}

/// Divide `A` by `B`, where `A` and `B` are both `Size`.
pub struct Div<A: Size, B: Size>(PhantomData<(A, B)>);

impl<A: Size, B: Size> Size for Div<A, B> {
	fn size() -> Option<usize> {
		match (A::size(), B::size()) {
			(Some(a), Some(b)) => Some(a / b),
			_ => None,
		}
	}
}

#[macro_export]
/// Shortcut for adding more than two sizes together.
macro_rules! sum {
	( $one:ty ) => ( $one );
	( $first:ty, $( $rest:ty ),* ) => (
		$crate::Add<$first, $crate::sum!($( $rest ),*)>
	);
}