Move Input and Output traits to a separate crate codec-io

Cargo.toml

@@ -12,6 +12,7 @@ edition = "2018"
 arrayvec = { version = "0.4", default-features = false, features = ["array-sizes-33-128", "array-sizes-129-255"] }
 serde = { version = "1.0", optional = true }
 parity-scale-codec-derive = { path = "derive", version = "1.0", default-features = false, optional = true }
+codec-io = { version = "0.1", path = "io", default-features = false }
 bitvec = { version = "0.11", default-features = false, features = ["alloc"], optional = true }
 byte-slice-cast = { version = "0.3.1", optional = true }
 
@@ -31,7 +32,7 @@ bench = false
 [features]
 default = ["std"]
 derive = ["parity-scale-codec-derive"]
-std = ["serde", "bitvec/std"]
+std = ["serde", "bitvec/std", "codec-io/std"]
 bit-vec = ["bitvec", "byte-slice-cast"]
 
 # WARNING: DO _NOT_ USE THIS FEATURE IF YOU ARE WORKING ON CONSENSUS CODE!*
@@ -44,4 +45,5 @@ full = []
 [workspace]
 members = [
 	"derive",
+	"io",
 ]

derive/src/encode.rs

@@ -100,28 +100,28 @@ fn encode_fields<F>(
 			let field_type = &f.ty;
 			quote_spanned! {
 				f.span() => {
-					#dest.push(
+					_parity_scale_codec::Encode::encode_to(
 						&<<#field_type as _parity_scale_codec::HasCompact>::Type as
-							_parity_scale_codec::EncodeAsRef<'_, #field_type>>::RefType::from(#field)
+							_parity_scale_codec::EncodeAsRef<'_, #field_type>>::RefType::from(#field),
+						#dest,
 					);
 				}
 			}
 		} else if let Some(encoded_as) = encoded_as {
 			let field_type = &f.ty;
 			quote_spanned! {
 				f.span() => {
-					#dest.push(
+					_parity_scale_codec::Encode::encode_to(
 						&<#encoded_as as
-							_parity_scale_codec::EncodeAsRef<'_, #field_type>>::RefType::from(#field)
+							_parity_scale_codec::EncodeAsRef<'_, #field_type>>::RefType::from(#field),
+						#dest,
 					);
 				}
 			}
 		} else if skip {
 			quote! {}
 		} else {
-			quote_spanned! { f.span() =>
-					#dest.push(#field);
-			}
+			quote_spanned! { f.span() => _parity_scale_codec::Encode::encode_to(#field, #dest); }
 		}
 	});
 

derive/src/lib.rs

@@ -138,7 +138,9 @@ pub fn decode_derive(input: TokenStream) -> TokenStream {
 		impl #impl_generics _parity_scale_codec::Decode for #name #ty_generics #where_clause {
 			fn decode<DecIn: _parity_scale_codec::Input>(
 				#input_: &mut DecIn
-			) -> Result<Self, _parity_scale_codec::Error> {
+			) -> Result<Self, _parity_scale_codec::Error> where
+				_parity_scale_codec::Error: From<DecIn::Error>
+			{
 				#decoding
 			}
 		}

io/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "codec-io"
+description = "Common Input/Output trait definition shared by encoding libraries."
+version = "0.1.0"
+authors = ["Parity Technologies <[email protected]>"]
+license = "Apache-2.0"
+repository = "https://github.com/paritytech/parity-scale-codec"
+categories = ["encoding"]
+edition = "2018"
+
+[features]
+default = ["std"]
+std = []

io/src/lib.rs

@@ -0,0 +1,97 @@
+// Copyright 2019 Parity Technologies
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! # Input/Output Trait Definition for Encoding Libraries
+//!
+//! This library defines `Input` and `Output` traits that can be used for
+//! encoding libraries to define their own `Encode` and `Decode` traits.
+
+#![warn(missing_docs)]
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+/// I/O error type for basic `no_std` environment.
+#[cfg(not(feature = "std"))]
+pub enum Error {
+	/// Not enough data to fill the buffer.
+	NotEnoughData,
+}
+
+/// I/O error type for `std`. Alias of std::io::Error.
+#[cfg(feature = "std")]
+pub type Error = std::io::Error;
+
+/// Trait that allows reading of data into a slice.
+pub trait Input {
+	/// Read the exact number of bytes required to fill the given buffer.
+	///
+	/// Note that this function is similar to `std::io::Read::read_exact` and not
+	/// `std::io::Read::read`.
+	fn read(&mut self, into: &mut [u8]) -> Result<(), Error>;
+
+	/// Read a single byte from the input.
+	fn read_byte(&mut self) -> Result<u8, Error> {
+		let mut buf = [0u8];
+		self.read(&mut buf[..])?;
+		Ok(buf[0])
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<'a> Input for &'a [u8] {
+	fn read(&mut self, into: &mut [u8]) -> Result<(), Error> {
+		if into.len() > self.len() {
+			return Err(Error::NotEnoughData);
+		}
+		let len = into.len();
+		into.copy_from_slice(&self[..len]);
+		*self = &self[len..];
+		Ok(())
+	}
+}
+
+#[cfg(feature = "std")]
+impl<R: std::io::Read> Input for R {
+	fn read(&mut self, into: &mut [u8]) -> Result<(), std::io::Error> {
+		(self as &mut dyn std::io::Read).read_exact(into)?;
+		Ok(())
+	}
+}
+
+/// Trait that allows writing of data.
+pub trait Output: Sized {
+	/// Write to the output.
+	fn write(&mut self, bytes: &[u8]);
+
+	/// Write a single byte to the output.
+	fn push_byte(&mut self, byte: u8) {
+		self.write(&[byte]);
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl Output for alloc::vec::Vec<u8> {
+	fn write(&mut self, bytes: &[u8]) {
+		self.extend_from_slice(bytes)
+	}
+}
+
+#[cfg(feature = "std")]
+impl<W: std::io::Write> Output for W {
+	fn write(&mut self, bytes: &[u8]) {
+		(self as &mut dyn std::io::Write).write_all(bytes).expect("Codec outputs are infallible");
+	}
+}