rlpstream separated to its own submodule

src/rlp/faces.rs

@@ -219,7 +219,97 @@ pub trait Encodable {
 }
 
 pub trait Stream: Sized {
+
+	/// Initializes instance of empty `Stream`.
 	fn new() -> Self;
+
+	/// Initializes the `Stream` as a list.
 	fn new_list(len: usize) -> Self;
-	fn append<'a, E>(&'a mut self, object: &E) -> &'a mut Self;
+
+	/// Apends value to the end of stream, chainable.
+	///
+	/// ```rust
+	/// extern crate ethcore_util as util;
+	/// use util::rlp::*;
+	/// 
+	/// fn main () {
+	/// 	let mut stream = RlpStream::new_list(2);
+	/// 	stream.append(&"cat").append(&"dog");
+	/// 	let out = stream.out();
+	/// 	assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);
+	/// }
+	/// ```
+	fn append<'a, E>(&'a mut self, object: &E) -> &'a mut Self where E: Encodable;
+
+	/// Declare appending the list of given size, chainable.
+	///
+	/// ```rust
+	/// extern crate ethcore_util as util;
+	/// use util::rlp::*;
+	/// 
+	/// fn main () {
+	/// 	let mut stream = RlpStream::new_list(2);
+	/// 	stream.append_list(2).append(&"cat").append(&"dog");
+	/// 	stream.append(&"");	
+	/// 	let out = stream.out();
+	/// 	assert_eq!(out, vec![0xca, 0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g', 0x80]);
+	/// }
+	/// ```
+	fn append_list<'a>(&'a mut self, len: usize) -> &'a mut Self;
+
+	/// Apends null to the end of stream, chainable.
+	///
+	/// ```rust
+	/// extern crate ethcore_util as util;
+	/// use util::rlp::*;
+	/// 
+	/// fn main () {
+	/// 	let mut stream = RlpStream::new_list(2);
+	/// 	stream.append_empty_data().append_empty_data();
+	/// 	let out = stream.out();
+	/// 	assert_eq!(out, vec![0xc2, 0x80, 0x80]);
+	/// }
+	/// ```
+	fn append_empty_data<'a>(&'a mut self) -> &'a mut Self;
+
+	/// Appends raw (pre-serialised) RLP data. Use with caution. Chainable.
+	fn append_raw<'a>(&'a mut self, bytes: &[u8], item_count: usize) -> &'a mut Self;
+
+	/// Clear the output stream so far.
+	/// 
+	/// ```rust
+	/// extern crate ethcore_util as util;
+	/// use util::rlp::*;
+	/// 
+	/// fn main () {
+	/// 	let mut stream = RlpStream::new_list(3);
+	/// 	stream.append(&"cat");
+	/// 	stream.clear();
+	/// 	stream.append(&"dog");
+	/// 	let out = stream.out();
+	/// 	assert_eq!(out, vec![0x83, b'd', b'o', b'g']);
+	/// }
+	fn clear(&mut self);
+
+	/// Returns true if stream doesnt expect any more items.
+	///
+	/// ```rust
+	/// extern crate ethcore_util as util;
+	/// use util::rlp::*;
+	/// 
+	/// fn main () {
+	/// 	let mut stream = RlpStream::new_list(2);
+	/// 	stream.append(&"cat");
+	/// 	assert_eq!(stream.is_finished(), false);
+	/// 	stream.append(&"dog");
+	/// 	assert_eq!(stream.is_finished(), true);
+	/// 	let out = stream.out();
+	/// 	assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);
+	/// }
+	fn is_finished(&self) -> bool;
+
+	/// Streams out encoded bytes.
+	/// 
+	/// panic! if stream is not finished.
+	fn out(self) -> Vec<u8>;
 }

src/rlp/mod.rs

@@ -37,13 +37,45 @@ pub mod rlp;
 pub mod untrusted_rlp;
 pub mod rlpstream;
 
-pub use self::faces::{DecoderError, Decoder, Decodable, View};
+pub use self::faces::{DecoderError, Decoder, Decodable, View, Stream, Encodable, Encoder};
 pub use self::rlp::{Rlp, RlpIterator};
 pub use self::untrusted_rlp::{UntrustedRlp, UntrustedRlpIterator, Prototype, PayloadInfo};
+pub use self::rlpstream::{RlpStream};
 
-pub use self::old::{encode, RlpStream, Encodable};
+//pub use self::old::{encode, RlpStream, Encodable};
 
+/// Shortcut function to decode trusted rlp
+/// 
+/// ```rust
+/// extern crate ethcore_util as util;
+/// use util::rlp::*;
+/// 
+/// fn main () {
+/// 	let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
+/// 	let animals: Vec<String> = decode(&data);
+/// 	assert_eq!(animals, vec!["cat".to_string(), "dog".to_string()]);
+/// }
+/// ```
 pub fn decode<T>(bytes: &[u8]) -> T where T: Decodable {
 	let rlp = Rlp::new(bytes);
 	rlp.as_val()
 }
+
+/// Shortcut function to encode structure into rlp.
+///
+/// ```rust
+/// extern crate ethcore_util as util;
+/// use util::rlp::*;
+/// 
+/// fn main () {
+/// 	let animals = vec!["cat", "dog"];
+/// 	let out = encode(&animals);
+/// 	assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);
+/// }
+/// ```
+pub fn encode<E>(object: &E) -> Vec<u8> where E: Encodable
+{
+	let mut stream = RlpStream::new();
+	stream.append(object);
+	stream.out()
+}

src/rlp/rlpstream.rs

@@ -0,0 +1,247 @@
+use elastic_array::*;
+use bytes::ToBytes;
+use super::faces::{Stream, Encoder, Encodable};
+
+#[derive(Debug, Copy, Clone)]
+struct ListInfo {
+	position: usize,
+	current: usize,
+	max: usize,
+}
+
+impl ListInfo {
+	fn new(position: usize, max: usize) -> ListInfo {
+		ListInfo {
+			position: position,
+			current: 0,
+			max: max,
+		}
+	}
+}
+
+/// Appendable rlp encoder.
+pub struct RlpStream {
+	unfinished_lists: ElasticArray16<ListInfo>,
+	encoder: BasicEncoder,
+}
+
+impl Stream for RlpStream {
+	fn new() -> Self {	
+		RlpStream {
+			unfinished_lists: ElasticArray16::new(),
+			encoder: BasicEncoder::new(),
+		}
+	}
+
+	fn new_list(len: usize) -> Self {
+		let mut stream = RlpStream::new();
+		stream.append_list(len);
+		stream
+	}
+
+	fn append<'a, E>(&'a mut self, object: &E) -> &'a mut RlpStream where E: Encodable {
+		// encode given value and add it at the end of the stream
+		object.encode(&mut self.encoder);
+
+		// if list is finished, prepend the length
+		self.note_appended(1);
+
+		// return chainable self
+		self
+	}
+
+	fn append_list<'a>(&'a mut self, len: usize) -> &'a mut RlpStream {
+		match len {
+			0 => {
+				// we may finish, if the appended list len is equal 0
+				self.encoder.bytes.push(0xc0u8);
+				self.note_appended(1);
+			},
+			_ => { 
+				let position = self.encoder.bytes.len();
+				self.unfinished_lists.push(ListInfo::new(position, len));
+			},
+		}
+
+		// return chainable self
+		self
+	}
+	
+	fn append_empty_data<'a>(&'a mut self) -> &'a mut RlpStream {
+		// self push raw item
+		self.encoder.bytes.push(0x80);
+
+		// try to finish and prepend the length
+		self.note_appended(1);
+
+		// return chainable self
+		self
+	}
+
+	fn append_raw<'a>(&'a mut self, bytes: &[u8], item_count: usize) -> &'a mut RlpStream {
+		// push raw items
+		self.encoder.bytes.append_slice(bytes);	
+
+		// try to finish and prepend the length
+		self.note_appended(item_count);
+
+		// return chainable self
+		self
+	}
+
+	fn clear(&mut self) {
+		// clear bytes
+		self.encoder.bytes.clear();
+
+		// clear lists
+		self.unfinished_lists.clear();
+	}
+
+	fn is_finished(&self) -> bool {
+		self.unfinished_lists.len() == 0
+	}
+
+	fn out(self) -> Vec<u8> {
+		match self.is_finished() {
+			true => self.encoder.out().to_vec(),
+			false => panic!()
+		}
+	}
+}
+
+impl RlpStream {
+
+	/// Try to finish lists
+	fn note_appended(&mut self, inserted_items: usize) -> () {
+		if self.unfinished_lists.len() == 0 {
+			return;
+		}
+
+		let back = self.unfinished_lists.len() - 1;
+		let should_finish = match self.unfinished_lists.get_mut(back) {
+			None => false,
+			Some(ref mut x) => {
+				x.current += inserted_items;
+				if x.current > x.max {
+					panic!("You cannot append more items then you expect!");
+				}
+				x.current == x.max
+			}
+		};
+
+		if should_finish {
+			let x = self.unfinished_lists.pop().unwrap();
+			let len = self.encoder.bytes.len() - x.position;
+			self.encoder.insert_list_len_at_pos(len, x.position);
+			self.note_appended(1);
+		}
+	}
+}
+
+struct BasicEncoder {
+	bytes: ElasticArray1024<u8>,
+}
+
+impl BasicEncoder {
+	fn new() -> BasicEncoder {
+		BasicEncoder { bytes: ElasticArray1024::new() }
+	}
+
+	/// inserts list prefix at given position
+	/// TODO: optimise it further?
+	fn insert_list_len_at_pos(&mut self, len: usize, pos: usize) -> () {
+		let mut res = vec![];
+		match len {
+			0...55 => res.push(0xc0u8 + len as u8),
+			_ => {
+				res.push(0xf7u8 + len.to_bytes_len() as u8);
+				res.extend(len.to_bytes());
+			}
+		};
+
+		self.bytes.insert_slice(pos, &res);
+	}
+
+	/// get encoded value
+	fn out(self) -> ElasticArray1024<u8> {
+		self.bytes
+	}
+}
+
+impl Encoder for BasicEncoder {
+	fn emit_value(&mut self, bytes: &[u8]) -> () {
+		match bytes.len() {
+			// just 0
+			0 => self.bytes.push(0x80u8),
+			// byte is its own encoding
+			1 if bytes[0] < 0x80 => self.bytes.append_slice(bytes),
+			// (prefix + length), followed by the string
+			len @ 1 ... 55 => {
+				self.bytes.push(0x80u8 + len as u8);
+				self.bytes.append_slice(bytes);
+			}
+			// (prefix + length of length), followed by the length, followd by the string
+			len => {
+				self.bytes.push(0xb7 + len.to_bytes_len() as u8);
+				self.bytes.append_slice(&len.to_bytes());
+				self.bytes.append_slice(bytes);
+			}
+		}
+	}
+
+	fn emit_list<F>(&mut self, f: F) -> () where F: FnOnce(&mut Self) -> ()
+	{
+		// get len before inserting a list
+		let before_len = self.bytes.len();
+
+		// insert all list elements
+		f(self);
+
+		// get len after inserting a list
+		let after_len = self.bytes.len();
+
+		// diff is list len
+		let list_len = after_len - before_len;
+		self.insert_list_len_at_pos(list_len, before_len);
+	}
+}
+
+impl<T> Encodable for T where T: ToBytes {
+	fn encode<E>(&self, encoder: &mut E) -> () where E: Encoder {
+		encoder.emit_value(&self.to_bytes())
+	}
+}
+
+impl<'a, T> Encodable for &'a [T] where T: Encodable + 'a {
+	fn encode<E>(&self, encoder: &mut E) -> () where E: Encoder {
+		encoder.emit_list(|e| {
+			// insert all list elements
+			for el in self.iter() {
+				el.encode(e);
+			}
+		})
+	}
+}
+
+impl<T> Encodable for Vec<T> where T: Encodable {
+	fn encode<E>(&self, encoder: &mut E) -> () where E: Encoder {
+		let r: &[T] = self.as_ref();
+		r.encode(encoder)
+	}
+}
+
+/// lets treat bytes differently than other lists
+/// they are a single value
+impl<'a> Encodable for &'a [u8] {
+	fn encode<E>(&self, encoder: &mut E) -> () where E: Encoder {
+		encoder.emit_value(self)
+	}
+}
+
+/// lets treat bytes differently than other lists
+/// they are a single value
+impl Encodable for Vec<u8> {
+	fn encode<E>(&self, encoder: &mut E) -> () where E: Encoder {
+		encoder.emit_value(self)
+	}
+}

src/rlp/untrusted_rlp.rs

@@ -266,7 +266,7 @@ impl<'a> BasicDecoder<'a> {
 				PayloadInfo::new(header_len, value_len)
 			},
 			// we cant reach this place, but rust requires _ to be implemented
-			_ => { panic!(); }
+			_ => { unreachable!(); }
 		};
 
 		match item.header_len + item.value_len <= bytes.len() {
@@ -297,7 +297,7 @@ impl<'a> Decoder for BasicDecoder<'a> {
 				Ok(try!(f(&bytes[begin_of_value..begin_of_value + len])))
 			}
 			// we are reading value, not a list!
-			_ => { unreachable!(); }
+			_ => Err(DecoderError::RlpExpectedToBeData)
 		}
 	}
 

src/triehash.rs

@@ -7,7 +7,7 @@ use std::cmp;
 use hash::*;
 use sha3::*;
 use rlp;
-use rlp::RlpStream;
+use rlp::{RlpStream, Stream};
 use vector::SharedPrefix;
 
 /// Generates a trie root hash for a vector of values