Modularised dispatch (#95)

* Completely rework dispatch mechanism into something modular.

Not yet complete but 75% there.

* Council vote tests.

* Fix tests.

* whitespace.

* Fix demo runtime tests.

* Fix up tests.

* Remove dead code.

* Use match for Id

* Make PrivPass better protected.

* Address other grumbles.

* Give PrivPass a private member.

* Testing PrivPass.

* Add docs.

substrate/substrate/codec/src/endiansensitive.rs

@@ -1,81 +0,0 @@
-// Copyright 2017 Parity Technologies (UK) Ltd.
-// This file is part of Substrate.
-
-// Substrate is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Substrate is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
-
-//! Endian manager.
-
-/// Trait to allow conversion to a know endian representation when sensitive.
-/// Types implementing this trait must have a size > 0.
-// note: the copy bound and static lifetimes are necessary for safety of `Slicable` blanket
-// implementation.
-pub trait EndianSensitive: Copy + 'static {
-	fn to_le(self) -> Self { self }
-	fn to_be(self) -> Self { self }
-	fn from_le(self) -> Self { self }
-	fn from_be(self) -> Self { self }
-	fn as_be_then<T, F: FnOnce(&Self) -> T>(&self, f: F) -> T { f(&self) }
-	fn as_le_then<T, F: FnOnce(&Self) -> T>(&self, f: F) -> T { f(&self) }
-}
-
-macro_rules! impl_endians {
-	( $( $t:ty ),* ) => { $(
-		impl EndianSensitive for $t {
-			fn to_le(self) -> Self { <$t>::to_le(self) }
-			fn to_be(self) -> Self { <$t>::to_be(self) }
-			fn from_le(self) -> Self { <$t>::from_le(self) }
-			fn from_be(self) -> Self { <$t>::from_be(self) }
-			fn as_be_then<T, F: FnOnce(&Self) -> T>(&self, f: F) -> T { let d = self.to_be(); f(&d) }
-			fn as_le_then<T, F: FnOnce(&Self) -> T>(&self, f: F) -> T { let d = self.to_le(); f(&d) }
-		}
-	)* }
-}
-macro_rules! impl_non_endians {
-	( $( $t:ty ),* ) => { $(
-		impl EndianSensitive for $t {}
-	)* }
-}
-
-// NOTE: See test to ensure correctness.
-impl EndianSensitive for bool {}
-
-impl_endians!(u16, u32, u64, usize, i16, i32, i64, isize);
-impl_non_endians!(u8, i8, [u8; 1], [u8; 2], [u8; 3], [u8; 4], [u8; 5], [u8; 6], [u8; 7], [u8; 8],
-	[u8; 10], [u8; 12], [u8; 14], [u8; 16], [u8; 20], [u8; 24], [u8; 28], [u8; 32], [u8; 40],
-	[u8; 48], [u8; 56], [u8; 64], [u8; 80], [u8; 96], [u8; 112], [u8; 128]);
-
-#[cfg(test)]
-mod tests {
-	use super::EndianSensitive;
-
-	#[test]
-	fn endian_sensitive_is_copy() {
-		fn _takes_copy<T: Copy>() { }
-		fn _takes_endian_sensitive<T: EndianSensitive>() { _takes_copy::<T>() }
-	}
-
-	#[test]
-	fn endian_sensitive_outlives_static() {
-		fn _takes_static<T: 'static>() { }
-		fn _takes_endian_sensitive<T: EndianSensitive>() { _takes_static::<T>() }
-	}
-
-	#[test]
-	fn bool_is_not_endian_sensitive() {
-		let b = true;
-		assert_eq!(b.to_be(), b.to_le());
-		let b = false;
-		assert_eq!(b.to_be(), b.to_le());
-	}
-}

substrate/substrate/codec/src/lib.rs

@@ -23,12 +23,10 @@
 #[cfg_attr(not(feature = "std"), macro_use)]
 extern crate substrate_runtime_std as rstd;
 
-mod endiansensitive;
 mod slicable;
 mod joiner;
 mod keyedvec;
 
-pub use self::endiansensitive::EndianSensitive;
 pub use self::slicable::{Input, Slicable, NonTrivialSlicable};
 pub use self::joiner::Joiner;
 pub use self::keyedvec::KeyedVec;

substrate/substrate/codec/src/slicable.rs

@@ -16,10 +16,9 @@
 
 //! Serialisation.
 
+use rstd::prelude::*;
 use rstd::{mem, slice};
-use rstd::vec::Vec;
 use super::joiner::Joiner;
-use super::endiansensitive::EndianSensitive;
 
 /// Trait that allows reading of data into a slice.
 pub trait Input {
@@ -56,39 +55,6 @@ pub trait Slicable: Sized {
 // TODO: under specialization, remove this and simply specialize in place serializable types.
 pub trait NonTrivialSlicable: Slicable {}
 
-impl<T: EndianSensitive> Slicable for T {
-	fn decode<I: Input>(input: &mut I) -> Option<Self> {
-		let size = mem::size_of::<T>();
-		assert!(size > 0, "EndianSensitive can never be implemented for a zero-sized type.");
-		let mut val: T = unsafe { mem::zeroed() };
-
-		unsafe {
-			let raw: &mut [u8] = slice::from_raw_parts_mut(
-				&mut val as *mut T as *mut u8,
-				size
-			);
-			if input.read(raw) != size { return None }
-		}
-		Some(val.from_le())
-	}
-
-	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		self.as_le_then(|le| {
-			let size = mem::size_of::<T>();
-			let value_slice = unsafe {
-				let ptr = le as *const _ as *const u8;
-				if size != 0 {
-					slice::from_raw_parts(ptr, size)
-				} else {
-					&[]
-				}
-			};
-
-			f(value_slice)
-		})
-	}
-}
-
 impl Slicable for Option<bool> {
 	fn decode<I: Input>(input: &mut I) -> Option<Self> {
 		u8::decode(input).and_then(|v| match v {
@@ -109,6 +75,16 @@ impl Slicable for Option<bool> {
 }
 impl NonTrivialSlicable for Option<bool> {}
 
+impl<T: Slicable> Slicable for Box<T> {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		Some(Box::new(T::decode(input)?))
+	}
+
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.as_ref().using_encoded(f)
+	}
+}
+
 impl Slicable for Vec<u8> {
 	fn decode<I: Input>(input: &mut I) -> Option<Self> {
 		u32::decode(input).and_then(move |len| {
@@ -173,7 +149,7 @@ macro_rules! impl_vec_simple_array {
 	($($size:expr),*) => {
 		$(
 			impl<T> Slicable for Vec<[T; $size]>
-				where [T; $size]: EndianSensitive
+				where [T; $size]: Slicable
 			{
 				fn decode<I: Input>(input: &mut I) -> Option<Self> {
 					u32::decode(input).and_then(move |len| {
@@ -325,6 +301,108 @@ mod inner_tuple_impl {
 	tuple_impl!(A, B, C, D, E, F, G, H, I, J, K,);
 }
 
+/// Trait to allow conversion to a know endian representation when sensitive.
+/// Types implementing this trait must have a size > 0.
+// note: the copy bound and static lifetimes are necessary for safety of `Slicable` blanket
+// implementation.
+trait EndianSensitive: Copy + 'static {
+	fn to_le(self) -> Self { self }
+	fn to_be(self) -> Self { self }
+	fn from_le(self) -> Self { self }
+	fn from_be(self) -> Self { self }
+	fn as_be_then<T, F: FnOnce(&Self) -> T>(&self, f: F) -> T { f(&self) }
+	fn as_le_then<T, F: FnOnce(&Self) -> T>(&self, f: F) -> T { f(&self) }
+}
+
+macro_rules! impl_endians {
+	( $( $t:ty ),* ) => { $(
+		impl EndianSensitive for $t {
+			fn to_le(self) -> Self { <$t>::to_le(self) }
+			fn to_be(self) -> Self { <$t>::to_be(self) }
+			fn from_le(self) -> Self { <$t>::from_le(self) }
+			fn from_be(self) -> Self { <$t>::from_be(self) }
+			fn as_be_then<T, F: FnOnce(&Self) -> T>(&self, f: F) -> T { let d = self.to_be(); f(&d) }
+			fn as_le_then<T, F: FnOnce(&Self) -> T>(&self, f: F) -> T { let d = self.to_le(); f(&d) }
+		}
+
+		impl Slicable for $t {
+			fn decode<I: Input>(input: &mut I) -> Option<Self> {
+				let size = mem::size_of::<$t>();
+				assert!(size > 0, "EndianSensitive can never be implemented for a zero-sized type.");
+				let mut val: $t = unsafe { mem::zeroed() };
+
+				unsafe {
+					let raw: &mut [u8] = slice::from_raw_parts_mut(
+						&mut val as *mut $t as *mut u8,
+						size
+					);
+					if input.read(raw) != size { return None }
+				}
+				Some(val.from_le())
+			}
+
+			fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+				self.as_le_then(|le| {
+					let size = mem::size_of::<$t>();
+					let value_slice = unsafe {
+						let ptr = le as *const _ as *const u8;
+						if size != 0 {
+							slice::from_raw_parts(ptr, size)
+						} else {
+							&[]
+						}
+					};
+
+					f(value_slice)
+				})
+			}
+		}
+	)* }
+}
+macro_rules! impl_non_endians {
+	( $( $t:ty ),* ) => { $(
+		impl EndianSensitive for $t {}
+
+		impl Slicable for $t {
+			fn decode<I: Input>(input: &mut I) -> Option<Self> {
+				let size = mem::size_of::<$t>();
+				assert!(size > 0, "EndianSensitive can never be implemented for a zero-sized type.");
+				let mut val: $t = unsafe { mem::zeroed() };
+
+				unsafe {
+					let raw: &mut [u8] = slice::from_raw_parts_mut(
+						&mut val as *mut $t as *mut u8,
+						size
+					);
+					if input.read(raw) != size { return None }
+				}
+				Some(val.from_le())
+			}
+
+			fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+				self.as_le_then(|le| {
+					let size = mem::size_of::<$t>();
+					let value_slice = unsafe {
+						let ptr = le as *const _ as *const u8;
+						if size != 0 {
+							slice::from_raw_parts(ptr, size)
+						} else {
+							&[]
+						}
+					};
+
+					f(value_slice)
+				})
+			}
+		}
+	)* }
+}
+
+impl_endians!(u16, u32, u64, usize, i16, i32, i64, isize);
+impl_non_endians!(u8, i8, [u8; 1], [u8; 2], [u8; 3], [u8; 4], [u8; 5], [u8; 6], [u8; 7], [u8; 8],
+	[u8; 10], [u8; 12], [u8; 14], [u8; 16], [u8; 20], [u8; 24], [u8; 28], [u8; 32], [u8; 40],
+	[u8; 48], [u8; 56], [u8; 64], [u8; 80], [u8; 96], [u8; 112], [u8; 128], bool);
+
 
 #[cfg(test)]
 mod tests {