extract out runtime-codec to a separate crate

substrate/runtime-codec/src/endiansensitive.rs

@@ -0,0 +1,81 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  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/runtime-codec/src/joiner.rs

@@ -0,0 +1,33 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Trait
+
+use std::iter::Extend;
+use super::slicable::Slicable;
+
+/// Trait to allow itself to be serialised into a value which can be extended
+/// by bytes.
+pub trait Joiner {
+	fn join<V: Slicable + Sized>(self, value: &V) -> Self;
+}
+
+impl<T> Joiner for T where T: for<'a> Extend<&'a u8> {
+	fn join<V: Slicable + Sized>(mut self, value: &V) -> Self {
+		value.as_slice_then(|s| self.extend(s));
+		self
+	}
+}

substrate/runtime-codec/src/keyedvec.rs

@@ -0,0 +1,57 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Serialiser and prepender.
+
+use slicable::Slicable;
+use std::iter::Extend;
+use std::vec::Vec;
+
+/// Trait to allow itselg to be serialised and prepended by a given slice.
+pub trait KeyedVec {
+	fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8>;
+}
+
+macro_rules! impl_non_endians {
+	( $( $t:ty ),* ) => { $(
+		impl KeyedVec for $t {
+			fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8> {
+				let mut r = prepend_key.to_vec();
+				r.extend(&self[..]);
+				r
+			}
+		}
+	)* }
+}
+
+macro_rules! impl_endians {
+	( $( $t:ty ),* ) => { $(
+		impl KeyedVec for $t {
+			fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8> {
+				self.as_slice_then(|slice| {
+					let mut r = prepend_key.to_vec();
+					r.extend(slice);
+					r
+				})
+			}
+		}
+	)* }
+}
+
+impl_endians!(u8, i8, u16, u32, u64, usize, i16, i32, i64, isize);
+impl_non_endians!([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]);

substrate/runtime-codec/src/lib.rs

@@ -0,0 +1,41 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Implements the serialization and deserialization codec for polkadot runtime
+//! values.
+
+#![cfg_attr(feature = "no-std", no_std)]
+#![cfg_attr(feature = "no-std", feature(alloc))]
+
+mod endiansensitive;
+mod slicable;
+mod streamreader;
+mod joiner;
+mod keyedvec;
+
+pub use self::endiansensitive::EndianSensitive;
+pub use self::slicable::{Slicable, NonTrivialSlicable};
+pub use self::streamreader::StreamReader;
+pub use self::joiner::Joiner;
+pub use self::keyedvec::KeyedVec;
+
+#[cfg(feature = "no-std")]
+mod std {
+	extern crate alloc;
+
+	pub use core::*;
+	pub use self::alloc::vec;
+}

substrate/runtime-codec/src/slicable.rs

@@ -0,0 +1,149 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Serialisation.
+
+use std::{mem, slice};
+use std::vec::Vec;
+use super::joiner::Joiner;
+use super::endiansensitive::EndianSensitive;
+
+/// Trait that allows zero-copy read/write of value-references to/from slices in LE format.
+pub trait Slicable: Sized {
+	/// Attempt to deserialise the value from a slice.
+	fn from_slice(value: &[u8]) -> Option<Self> {
+		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
+		})
+	}
+	fn to_vec(&self) -> Vec<u8> {
+		self.as_slice_then(|s| s.to_vec())
+	}
+	fn set_as_slice<F: Fn(&mut [u8], usize) -> bool>(fill_slice: F) -> Option<Self>;
+	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		f(&self.to_vec())
+	}
+	fn size_of(_value: &[u8]) -> Option<usize>;
+}
+
+/// Trait to mark that a type is not trivially (essentially "in place") serialisable.
+pub trait NonTrivialSlicable: Slicable {}
+
+impl<T: EndianSensitive> Slicable for T {
+	fn set_as_slice<F: Fn(&mut [u8], usize) -> bool>(fill_slice: F) -> Option<Self> {
+		let size = mem::size_of::<T>();
+		assert!(size > 0, "EndianSensitive can never be implemented for a zero-sized type.");
+		let mut result: T = unsafe { mem::zeroed() };
+		let result_slice = unsafe {
+			let ptr = &mut result as *mut _ as *mut u8;
+			slice::from_raw_parts_mut(ptr, size)
+		};
+		if fill_slice(result_slice, 0) {
+			Some(result.from_le())
+		} else {
+			None
+		}
+	}
+	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		let size = mem::size_of::<Self>();
+		assert!(size > 0, "EndianSensitive can never be implemented for a zero-sized type.");
+		self.as_le_then(|le| {
+			let value_slice = unsafe {
+				let ptr = le as *const _ as *const u8;
+				slice::from_raw_parts(ptr, size)
+			};
+			f(value_slice)
+		})
+	}
+	fn size_of(_value: &[u8]) -> Option<usize> {
+		Some(mem::size_of::<Self>())
+	}
+}
+
+impl Slicable for Vec<u8> {
+	fn from_slice(value: &[u8]) -> Option<Self> {
+		Some(value[4..].to_vec())
+	}
+	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));
+		r.extend_from_slice(&self);
+		r
+	}
+	fn size_of(data: &[u8]) -> Option<usize> {
+		u32::from_slice(&data[0..4]).map(|i| (i + 4) as usize)
+	}
+}
+
+impl<T: Slicable> NonTrivialSlicable for Vec<T> where Vec<T>: Slicable {}
+
+impl<T: NonTrivialSlicable> Slicable for Vec<T> {
+	fn from_slice(value: &[u8]) -> Option<Self> {
+		let len = Self::size_of(&value[0..4])?;
+		let mut off = 4;
+		let mut r = Vec::new();
+		while off < len {
+			let element_len = T::size_of(&value[off..])?;
+			r.push(T::from_slice(&value[off..off + element_len])?);
+			off += element_len;
+		}
+		Some(r)
+	}
+
+	fn set_as_slice<F: Fn(&mut [u8], usize) -> bool>(_fill_slice: F) -> Option<Self> {
+		unimplemented!();
+	}
+
+	fn to_vec(&self) -> Vec<u8> {
+		let vecs = self.iter().map(Slicable::to_vec).collect::<Vec<_>>();
+		let len = vecs.iter().fold(0, |mut a, v| {a += v.len(); a});
+		let mut r = Vec::new().join(&(len as u32));
+		vecs.iter().for_each(|v| r.extend_from_slice(v));
+		r
+	}
+
+	fn size_of(data: &[u8]) -> Option<usize> {
+		u32::from_slice(&data[0..4]).map(|i| (i + 4) as usize)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn vec_is_slicable() {
+		let v = b"Hello world".to_vec();
+		v.as_slice_then(|ref slice|
+			assert_eq!(slice, &b"\x0b\0\0\0Hello world")
+		);
+	}
+}

substrate/runtime-codec/src/streamreader.rs

@@ -0,0 +1,74 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Deserialiser.
+
+use slicable::Slicable;
+
+/// Simple deserialiser.
+pub struct StreamReader<'a> {
+	data: &'a [u8],
+	offset: usize,
+}
+
+impl<'a> StreamReader<'a> {
+	/// Create a new deserialiser based on the `data`.
+	pub fn new(data: &'a [u8]) -> Self {
+		StreamReader {
+			data: data,
+			offset: 0,
+		}
+	}
+
+	/// Deserialise a single item from the data stream.
+	pub fn read<T: Slicable>(&mut self) -> Option<T> {
+		let size = T::size_of(&self.data[self.offset..])?;
+		let new_offset = self.offset + size;
+		let slice = &self.data[self.offset..new_offset];
+		self.offset = new_offset;
+		Slicable::from_slice(slice)
+	}
+}
+/*
+// Not in use yet
+// TODO: introduce fn size_will_be(&self) -> usize; to Slicable trait and implement
+struct StreamWriter<'a> {
+	data: &'a mut[u8],
+	offset: usize,
+}
+
+impl<'a> StreamWriter<'a> {
+	pub fn new(data: &'a mut[u8]) -> Self {
+		StreamWriter {
+			data: data,
+			offset: 0,
+		}
+	}
+	pub fn write<T: Slicable>(&mut self, value: &T) -> bool {
+		value.as_slice_then(|s| {
+			let new_offset = self.offset + s.len();
+			if self.data.len() <= new_offset {
+				let slice = &mut self.data[self.offset..new_offset];
+				self.offset = new_offset;
+				slice.copy_from_slice(s);
+				true
+			} else {
+				false
+			}
+		})
+	}
+}
+*/