add default impl for vec and slice, remove blanket impl

Author: RCasatta

src/impls.rs

@@ -34,56 +34,81 @@ impl ::std::error::Error for ::hex::Error {
 impl literacy::Write for sha1::HashEngine {
     type Error = ();
 
-    fn flush(&mut self) -> ::core::result::Result<(), ()> { Ok(()) }
-
     fn write(&mut self, buf: &[u8]) -> ::core::result::Result<usize, ()>  {
         self.input(buf);
         Ok(buf.len())
     }
+
+    fn write_all(&mut self, buf: &[u8]) -> ::core::result::Result<(), ()> {
+        self.write(buf)?;
+        Ok(())
+    }
+
+    fn flush(&mut self) -> ::core::result::Result<(), ()> { Ok(()) }
 }
 
 impl literacy::Write for sha256::HashEngine {
     type Error = ();
 
-    fn flush(&mut self) -> ::core::result::Result<(), ()>  { Ok(()) }
-
     fn write(&mut self, buf: &[u8]) -> ::core::result::Result<usize, ()>  {
         self.input(buf);
         Ok(buf.len())
     }
+
+    fn write_all(&mut self, buf: &[u8]) -> ::core::result::Result<(), ()> {
+        self.write(buf)?;
+        Ok(())
+    }
+
+    fn flush(&mut self) -> ::core::result::Result<(), ()>  { Ok(()) }
 }
 
 impl literacy::Write for sha512::HashEngine {
     type Error = ();
 
-    fn flush(&mut self) -> ::core::result::Result<(), ()>  { Ok(()) }
-
     fn write(&mut self, buf: &[u8]) -> ::core::result::Result<usize, ()>  {
         self.input(buf);
         Ok(buf.len())
     }
+
+    fn write_all(&mut self, buf: &[u8]) -> ::core::result::Result<(), ()> {
+        self.write(buf)?;
+        Ok(())
+    }
+
+    fn flush(&mut self) -> ::core::result::Result<(), ()>  { Ok(()) }
 }
 
 impl literacy::Write for ripemd160::HashEngine {
     type Error = ();
 
-    fn flush(&mut self) -> ::core::result::Result<(), ()>  { Ok(()) }
-
     fn write(&mut self, buf: &[u8]) -> ::core::result::Result<usize, ()>  {
         self.input(buf);
         Ok(buf.len())
     }
+
+    fn write_all(&mut self, buf: &[u8]) -> ::core::result::Result<(), ()> {
+        self.write(buf)?;
+        Ok(())
+    }
+
+    fn flush(&mut self) -> ::core::result::Result<(), ()>  { Ok(()) }
 }
 
 impl literacy::Write for siphash24::HashEngine {
     type Error = ();
 
-    fn flush(&mut self) -> ::core::result::Result<(), ()>  { Ok(()) }
-
     fn write(&mut self, buf: &[u8]) -> ::core::result::Result<usize, ()> {
         self.input(buf);
         Ok(buf.len())
     }
+
+    fn write_all(&mut self, buf: &[u8]) -> ::core::result::Result<(), ()> {
+        self.write(buf)?;
+        Ok(())
+    }
+
+    fn flush(&mut self) -> ::core::result::Result<(), ()>  { Ok(()) }
 }
 
 #[cfg(test)]

src/lib.rs

@@ -51,6 +51,9 @@ pub mod _export {
 
 #[cfg(feature = "schemars")] extern crate schemars;
 
+#[cfg(all(not(feature = "use-core2"), not(feature = "std")))]
+extern crate alloc;
+
 #[macro_use] mod util;
 #[macro_use] pub mod serde_macros;
 mod impls;

src/literacy.rs

@@ -1,29 +1,18 @@
 #[cfg(all(feature = "std", feature = "use-core2"))]
 compile_error!("feature \"std\" and \"use-core2\" cannot be enabled together.");
 
-
-pub trait Read{
+pub trait Read {
     type Error;
     fn read(&mut self, buf: &mut [u8]) -> ::core::result::Result<usize, Self::Error>;
+    fn read_exact(&mut self, buf: &mut [u8]) -> ::core::result::Result<(), Self::Error>;
 }
 
 pub trait Write {
     type Error;
     fn write(&mut self, buf: &[u8]) -> ::core::result::Result<usize, Self::Error>;
+    fn write_all(&mut self, buf: &[u8]) -> ::core::result::Result<(), Self::Error>;
     fn flush(&mut self) -> ::core::result::Result<(), Self::Error>;
-    fn write_all(&mut self, mut buf: &[u8]) -> ::core::result::Result<(), Self::Error> {
-        while !buf.is_empty() {
-            match self.write(buf) {
-                /*Ok(0) => {
-                    return Err(Error::new(ErrorKind::WriteZero, "failed to write whole buffer"));
-                }*/
-                Ok(n) => buf = &buf[n..],
-                //Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
-                Err(e) => return Err(e),
-            }
-        }
-        Ok(())
-    }
+
 }
 
 #[cfg(feature = "std")]
@@ -36,6 +25,10 @@ mod std_impl {
         fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
             Ok(<Self as ::std::io::Read>::read(self, buf)?)
         }
+
+        fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Self::Error> {
+            Ok(<Self as ::std::io::Read>::read_exact(self, buf)?)
+        }
     }
 
     impl<W: ::std::io::Write> Write for W {
@@ -45,6 +38,10 @@ mod std_impl {
             <Self as ::std::io::Write>::write(self, buf)
         }
 
+        fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+            <Self as ::std::io::Write>::write_all(self, buf)
+        }
+
         fn flush(&mut self) -> Result<(), Self::Error> {
             <Self as ::std::io::Write>::flush(self)
         }
@@ -61,6 +58,10 @@ mod core2_impl {
         fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
             Ok(<Self as core2::io::Read>::read(self, buf)?)
         }
+
+        fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Self::Error> {
+            Ok(<Self as core2::io::Read>::read_exact(self, buf)?)
+        }
     }
 
     impl<W: core2::io::Write> Write for W {
@@ -70,12 +71,84 @@ mod core2_impl {
             Ok(<Self as core2::io::Write>::write(self, buf)?)
         }
 
+        fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+            <Self as core2::io::Write>::write_all(self, buf)
+        }
+
         fn flush(&mut self) -> Result<(), Self::Error> {
             Ok(<Self as core2::io::Write>::flush(self)?)
         }
     }
 }
 
+#[cfg(all(not(feature = "use-core2"), not(feature = "std")))]
+mod default_impl {
+    use super::{Read, Write};
+
+    pub enum DefaultError {
+        UnexpectedEof,
+    }
+
+    impl Read for &[u8] {
+        type Error = DefaultError;
+
+        fn read(&mut self, buf: &mut [u8]) -> ::core::result::Result<usize, Self::Error> {
+            let amt = ::core::cmp::min(buf.len(), self.len());
+            let (a, b) = self.split_at(amt);
+
+            // First check if the amount of bytes we want to read is small:
+            // `copy_from_slice` will generally expand to a call to `memcpy`, and
+            // for a single byte the overhead is significant.
+            if amt == 1 {
+                buf[0] = a[0];
+            } else {
+                buf[..amt].copy_from_slice(a);
+            }
+
+            *self = b;
+            Ok(amt)
+        }
+
+        fn read_exact(&mut self, buf: &mut [u8]) -> ::core::result::Result<(), Self::Error>  {
+            if buf.len() > self.len() {
+                return Err(Self::Error::UnexpectedEof);
+            }
+            let (a, b) = self.split_at(buf.len());
+
+            // First check if the amount of bytes we want to read is small:
+            // `copy_from_slice` will generally expand to a call to `memcpy`, and
+            // for a single byte the overhead is significant.
+            if buf.len() == 1 {
+                buf[0] = a[0];
+            } else {
+                buf.copy_from_slice(a);
+            }
+
+            *self = b;
+            Ok(())
+        }
+    }
+
+    impl Write for ::alloc::vec::Vec<u8> {
+        type Error = DefaultError;
+
+        fn write(&mut self, buf: &[u8]) -> ::core::result::Result<usize, Self::Error> {
+            self.extend_from_slice(buf);
+            Ok(buf.len())
+        }
+
+        fn write_all(&mut self, buf: &[u8]) -> ::core::result::Result<(), Self::Error> {
+            self.extend_from_slice(buf);
+            Ok(())
+        }
+
+        fn flush(&mut self) -> ::core::result::Result<(), Self::Error> {
+            Ok(())
+        }
+    }
+}
+
+
 #[cfg(test)]
 mod tests {