Simple governance subsytem.

substrate/wasm-runtime/polkadot/src/codec/endiansensitive.rs

@@ -44,6 +44,11 @@ macro_rules! impl_non_endians {
 	)* }
 }
 
+// TODO: this is fine as long as bool is one byte. it'll break if llvm tries to use more. happily,
+// this isn't an issue for the forseeable future. if it ever happens, then it should be implemented
+// as endian sensitive.
+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],

substrate/wasm-runtime/polkadot/src/codec/slicable.rs

@@ -23,8 +23,10 @@ use endiansensitive::EndianSensitive;
 /// Trait that allows zero-copy read/write of value-references to/from slices in LE format.
 pub trait Slicable: Sized {
 	fn from_slice(value: &[u8]) -> Option<Self> {
-		Self::set_as_slice(|out| if value.len() == out.len() {
-			out.copy_from_slice(&value);
+		Self::set_as_slice(&|out, offset| if value.len() >= out.len() + offset {
+			let value = &value[offset..];
+			let len = out.len();
+			out.copy_from_slice(&value[0..len]);
 			true
 		} else {
 			false
@@ -33,7 +35,7 @@ pub trait Slicable: Sized {
 	fn to_vec(&self) -> Vec<u8> {
 		self.as_slice_then(|s| s.to_vec())
 	}
-	fn set_as_slice<F: FnOnce(&mut[u8]) -> bool>(set_slice: F) -> Option<Self>;
+	fn set_as_slice<F: Fn(&mut[u8], usize) -> bool>(set_slice: &F) -> Option<Self>;
 	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
 		f(&self.to_vec())
 	}
@@ -44,13 +46,13 @@ pub trait Slicable: Sized {
 pub trait NonTrivialSlicable: Slicable {}
 
 impl<T: EndianSensitive> Slicable for T {
-	fn set_as_slice<F: FnOnce(&mut[u8]) -> bool>(fill_slice: F) -> Option<Self> {
+	fn set_as_slice<F: Fn(&mut[u8], usize) -> bool>(fill_slice: &F) -> Option<Self> {
 		let size = size_of::<T>();
 		let mut result: T = unsafe { uninitialized() };
 		let result_slice = unsafe {
 			slice::from_raw_parts_mut(transmute::<*mut T, *mut u8>(&mut result), size)
 		};
-		if fill_slice(result_slice) {
+		if fill_slice(result_slice, 0) {
 			Some(result.from_le())
 		} else {
 			None
@@ -74,8 +76,16 @@ impl Slicable for Vec<u8> {
 	fn from_slice(value: &[u8]) -> Option<Self> {
 		Some(value[4..].to_vec())
 	}
-	fn set_as_slice<F: FnOnce(&mut[u8]) -> bool>(_fill_slice: F) -> Option<Self> {
-		unimplemented!();
+	fn set_as_slice<F: Fn(&mut[u8], usize) -> bool>(fill_slice: &F) -> Option<Self> {
+		u32::set_as_slice(fill_slice).and_then(|len| {
+			let mut v = Vec::with_capacity(len as usize);
+			unsafe { v.set_len(len as usize); }
+			if fill_slice(&mut v, 4) {
+				Some(v)
+			} else {
+				None
+			}
+		})
 	}
 	fn to_vec(&self) -> Vec<u8> {
 		let mut r: Vec<u8> = Vec::new().join(&(self.len() as u32));