Add core IO using core2 crate

Author: samuelburnham

Cargo.lock

@@ -50,6 +50,8 @@ sha-2 = { version = "0.9.0", default-features = false, optional = true, package
 sha-3 = { version = "0.9.0", default-features = false, optional = true, package = "sha3" }
 strobe-rs = { version = "0.6.2", default-features = false, optional = true }
 
+core2 = { version = "0.3", default-features = false, features = ["alloc"] }
+
 [dev-dependencies]
 criterion = "0.3.3"
 hex = "0.4.2"

Cargo.toml

@@ -1,5 +1,8 @@
 #[cfg(feature = "std")]
 use std::io::Error as IoError;
+#[cfg(not(feature = "std"))]
+use core2::io::Error as IoError;
+  
 use unsigned_varint::decode::Error as DecodeError;
 #[cfg(feature = "std")]
 use unsigned_varint::io::ReadError;
@@ -8,7 +11,6 @@ use unsigned_varint::io::ReadError;
 #[derive(Debug)]
 pub enum Error {
     /// Io error.
-    #[cfg(feature = "std")]
     Io(IoError),
     /// Unsupported multihash code.
     UnsupportedCode(u64),
@@ -21,7 +23,7 @@ pub enum Error {
 impl core::fmt::Display for Error {
     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match self {
-            #[cfg(feature = "std")]
+            //#[cfg(feature = "std")]
             Self::Io(err) => write!(f, "{}", err),
             Self::UnsupportedCode(code) => write!(f, "Unsupported multihash code {}.", code),
             Self::InvalidSize(size) => write!(f, "Invalid multihash size {}.", size),
@@ -33,6 +35,16 @@ impl core::fmt::Display for Error {
 #[cfg(feature = "std")]
 impl std::error::Error for Error {}
 
+#[cfg(not(feature = "std"))]
+impl core2::error::Error for Error {} 
+
+#[cfg(not(feature = "std"))]
+impl From<core2::io::Error> for Error {
+  fn from(err: core2::io::Error) -> Self {
+    Self::Io(err)
+  }
+} 
+
 #[cfg(feature = "std")]
 impl From<IoError> for Error {
     fn from(err: IoError) -> Self {

src/error.rs

@@ -3,6 +3,12 @@ use core::fmt::Debug;
 use generic_array::typenum::marker_traits::Unsigned;
 use generic_array::{ArrayLength, GenericArray};
 
+#[cfg(feature = "std")]
+use std::io;
+
+#[cfg(not(feature = "std"))]
+use core2::io;
+
 /// Size marker trait.
 pub trait Size:
     ArrayLength<u8> + Debug + Default + Eq + core::hash::Hash + Send + Sync + 'static
@@ -48,12 +54,15 @@ pub trait Digest<S: Size>:
     /// Reads a multihash digest from a byte stream that contains the digest prefixed with the size.
     ///
     /// The byte stream must not contain the code as prefix.
-    #[cfg(feature = "std")]
     fn from_reader<R>(mut r: R) -> Result<Self, Error>
     where
-        R: std::io::Read,
+        R: io::Read,
     {
-        use unsigned_varint::io::read_u64;
+      #[cfg(not(feature = "std"))]
+      use crate::varint_read_u64 as read_u64;
+      
+      #[cfg(feature = "std")]
+      use unsigned_varint::io::read_u64;
 
         let size = read_u64(&mut r)?;
         if size > S::to_u64() || size > u8::max_value() as u64 {

src/hasher.rs

@@ -53,6 +53,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 #[cfg(not(feature = "std"))]
+#[macro_use]
 extern crate alloc;
 
 #[cfg(any(test, feature = "arb"))]
@@ -92,3 +93,26 @@ pub use crate::hasher_impl::sha3::{Sha3Digest, Sha3_224, Sha3_256, Sha3_384, Sha
 #[cfg(feature = "strobe")]
 pub use crate::hasher_impl::strobe::{Strobe256, Strobe512, StrobeDigest, StrobeHasher};
 pub use crate::hasher_impl::unknown::UnknownDigest;
+
+#[cfg(feature = "std")]
+use std::io;
+#[cfg(not(feature = "std"))]
+use core2::io;
+
+use unsigned_varint::{encode, decode};
+  
+/// Reader function from unsigned_varint
+pub fn varint_read_u64<R: io::Read>(mut r: R) -> Result<u64> {
+  let mut b = encode::u64_buffer();
+  for i in 0..b.len() {
+    let n = r.read(&mut (b[i..i + 1]))?;
+    if n == 0 {
+      return Err(error::Error::Varint(decode::Error::Insufficient));
+    }
+    else if decode::is_last(b[i]) {
+      return Ok(decode::u64(&b[..=i]).unwrap().0);
+    }
+  }
+  Err(error::Error::Varint(decode::Error::Overflow))
+}
+

src/lib.rs

@@ -1,11 +1,19 @@
 use crate::hasher::{Digest, Size};
 use crate::Error;
+#[cfg(not(feature = "std"))]
+use alloc::vec::Vec;
 use core::convert::TryFrom;
-#[cfg(feature = "std")]
+
 use core::convert::TryInto;
 use core::fmt::Debug;
 use generic_array::{ArrayLength, GenericArray};
 
+#[cfg(feature = "std")]
+use std::io;
+
+#[cfg(not(feature = "std"))]
+use core2::io;
+
 /// Trait that implements hashing.
 ///
 /// It is usually implemented by a custom code table enum that derives the [`Multihash` derive].
@@ -118,8 +126,7 @@ impl<S: Size> Multihash<S> {
     }
 
     /// Reads a multihash from a byte stream.
-    #[cfg(feature = "std")]
-    pub fn read<R: std::io::Read>(r: R) -> Result<Self, Error>
+    pub fn read<R: io::Read>(r: R) -> Result<Self, Error>
     where
         Self: Sized,
     {
@@ -131,7 +138,6 @@ impl<S: Size> Multihash<S> {
     ///
     /// You need to make sure the passed in bytes have the correct length. The digest length
     /// needs to match the `size` value of the multihash.
-    #[cfg(feature = "std")]
     pub fn from_bytes(mut bytes: &[u8]) -> Result<Self, Error>
     where
         Self: Sized,
@@ -148,15 +154,13 @@ impl<S: Size> Multihash<S> {
     }
 
     /// Writes a multihash to a byte stream.
-    #[cfg(feature = "std")]
-    pub fn write<W: std::io::Write>(&self, w: W) -> Result<(), Error> {
+    pub fn write<W: io::Write>(&self, w: W) -> Result<(), Error> {
         write_multihash(w, self.code(), self.size(), self.digest())
     }
 
     /// Returns the bytes of a multihash.
-    #[cfg(feature = "std")]
     pub fn to_bytes(&self) -> Vec<u8> {
-        let mut bytes = Vec::with_capacity(self.size().into());
+        let mut bytes: Vec<u8> = Vec::with_capacity(self.size().into());
         self.write(&mut bytes)
             .expect("writing to a vec should never fail");
         bytes
@@ -172,7 +176,6 @@ impl<S: Size> core::hash::Hash for Multihash<S> {
     }
 }
 
-#[cfg(feature = "std")]
 impl<S: Size> From<Multihash<S>> for Vec<u8> {
     fn from(multihash: Multihash<S>) -> Self {
         multihash.to_bytes()
@@ -252,10 +255,9 @@ impl parity_scale_codec::Decode for Multihash<crate::U64> {
 }
 
 /// Writes the multihash to a byte stream.
-#[cfg(feature = "std")]
 pub fn write_multihash<W>(mut w: W, code: u64, size: u8, digest: &[u8]) -> Result<(), Error>
 where
-    W: std::io::Write,
+    W: io::Write,
 {
     use unsigned_varint::encode as varint_encode;
 
@@ -277,16 +279,25 @@ where
 /// maximum/allocated size of the digest.
 ///
 /// Currently the maximum size for a digest is 255 bytes.
-#[cfg(feature = "std")]
 pub fn read_multihash<R, S>(mut r: R) -> Result<(u64, u8, GenericArray<u8, S>), Error>
 where
-    R: std::io::Read,
+    R: io::Read,
     S: Size,
 {
-    use unsigned_varint::io::read_u64;
-
-    let code = read_u64(&mut r)?;
-    let size = read_u64(&mut r)?;
+  #[cfg(not(feature = "std"))]
+  use crate::varint_read_u64 as read_u64;
+  
+  #[cfg(feature = "std")]
+  use unsigned_varint::io::read_u64;
+
+  let code = match read_u64(&mut r) {
+    Ok(c) => c,
+    Err(e) => return Err(e.into()),
+  };
+  let size = match read_u64(&mut r) {
+    Ok(s) => s,
+    Err(e) => return Err(e.into()),
+  };
 
     if size > S::to_u64() || size > u8::MAX as u64 {
         return Err(Error::InvalidSize(size));