no_std support (with default-enabled "std" cargo feature)

tarcieri · tarcieri · commit 621104f489ce · 2019-04-14T08:06:06.000-07:00
Feature gates anything dependent on `std` on the eponymous cargo
feature, and changes references to libcore features from `std` to `core`
diff --git a/.travis.yml b/.travis.yml
@@ -33,6 +33,10 @@ matrix:
     - env: RUST_TEST_THREADS=1 TARGET=powerpc-unknown-linux-gnu
     - env: RUST_TEST_THREADS=1 TARGET=powerpc64-unknown-linux-gnu
 
+    # Ensure crate compiles without default features (i.e. for no_std)
+    - env: EXTRA_ARGS="--no-default-features"
+      script: cargo build $EXTRA_ARGS
+
     # Serde implementation
     - env: EXTRA_ARGS="--features serde"
 
diff --git a/Cargo.toml b/Cargo.toml
@@ -22,19 +22,22 @@ exclude       = [
     "bench/**/*",
     "test/**/*"
 ]
-categories = ["network-programming", "data-structures"]
+categories = ["network-programming", "data-structures", "no-std"]
 
 [package.metadata.docs.rs]
 features = ["i128"]
 
 [dependencies]
 byteorder = "1.1.0"
-iovec = "0.1"
+iovec = { version = "0.1", optional = true }
 serde = { version = "1.0", optional = true }
 either = { version = "1.5", default-features = false, optional = true }
 
 [dev-dependencies]
 serde_test = "1.0"
 
 [features]
+default = ["std"]
+alloc = []
 i128 = ["byteorder/i128"]
+std = ["alloc", "iovec"]
diff --git a/src/buf/buf.rs b/src/buf/buf.rs
@@ -1,8 +1,13 @@
 use super::{IntoBuf, Take, Reader, Iter, FromBuf, Chain};
 use byteorder::{BigEndian, ByteOrder, LittleEndian};
+#[cfg(feature = "iovec")]
 use iovec::IoVec;
+#[cfg(feature = "std")]
+use prelude::*;
 
-use std::{cmp, io, ptr};
+use core::{cmp, ptr};
+#[cfg(feature = "std")]
+use std::io;
 
 macro_rules! buf_get_impl {
     ($this:ident, $size:expr, $conv:path) => ({
@@ -146,6 +151,7 @@ pub trait Buf {
     /// with `dst` being a zero length slice.
     ///
     /// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html
+    #[cfg(feature = "iovec")]
     fn bytes_vec<'a>(&'a self, dst: &mut [&'a IoVec]) -> usize {
         if dst.is_empty() {
             return 0;
@@ -1061,6 +1067,7 @@ impl<'a, T: Buf + ?Sized> Buf for &'a mut T {
         (**self).bytes()
     }
 
+    #[cfg(feature = "iovec")]
     fn bytes_vec<'b>(&'b self, dst: &mut [&'b IoVec]) -> usize {
         (**self).bytes_vec(dst)
     }
@@ -1070,6 +1077,7 @@ impl<'a, T: Buf + ?Sized> Buf for &'a mut T {
     }
 }
 
+#[cfg(feature = "std")]
 impl<T: Buf + ?Sized> Buf for Box<T> {
     fn remaining(&self) -> usize {
         (**self).remaining()
@@ -1079,6 +1087,7 @@ impl<T: Buf + ?Sized> Buf for Box<T> {
         (**self).bytes()
     }
 
+    #[cfg(feature = "iovec")]
     fn bytes_vec<'b>(&'b self, dst: &mut [&'b IoVec]) -> usize {
         (**self).bytes_vec(dst)
     }
@@ -1088,6 +1097,7 @@ impl<T: Buf + ?Sized> Buf for Box<T> {
     }
 }
 
+#[cfg(feature = "std")]
 impl<T: AsRef<[u8]>> Buf for io::Cursor<T> {
     fn remaining(&self) -> usize {
         let len = self.get_ref().as_ref().len();
diff --git a/src/buf/buf_mut.rs b/src/buf/buf_mut.rs
@@ -1,8 +1,13 @@
 use super::{IntoBuf, Writer};
 use byteorder::{LittleEndian, ByteOrder, BigEndian};
+#[cfg(feature = "iovec")]
 use iovec::IoVec;
+#[cfg(feature = "std")]
+use prelude::*;
 
-use std::{cmp, io, ptr, usize};
+use core::{cmp, ptr, usize};
+#[cfg(feature = "std")]
+use std::io;
 
 /// A trait for values that provide sequential write access to bytes.
 ///
@@ -189,6 +194,7 @@ pub trait BufMut {
     /// with `dst` being a zero length slice.
     ///
     /// [`readv`]: http://man7.org/linux/man-pages/man2/readv.2.html
+    #[cfg(feature = "iovec")]
     unsafe fn bytes_vec_mut<'a>(&'a mut self, dst: &mut [&'a mut IoVec]) -> usize {
         if dst.is_empty() {
             return 0;
@@ -1072,6 +1078,7 @@ impl<'a, T: BufMut + ?Sized> BufMut for &'a mut T {
         (**self).bytes_mut()
     }
 
+    #[cfg(feature = "iovec")]
     unsafe fn bytes_vec_mut<'b>(&'b mut self, dst: &mut [&'b mut IoVec]) -> usize {
         (**self).bytes_vec_mut(dst)
     }
@@ -1081,6 +1088,7 @@ impl<'a, T: BufMut + ?Sized> BufMut for &'a mut T {
     }
 }
 
+#[cfg(feature = "std")]
 impl<T: BufMut + ?Sized> BufMut for Box<T> {
     fn remaining_mut(&self) -> usize {
         (**self).remaining_mut()
@@ -1099,6 +1107,7 @@ impl<T: BufMut + ?Sized> BufMut for Box<T> {
     }
 }
 
+#[cfg(feature = "std")]
 impl<T: AsMut<[u8]> + AsRef<[u8]>> BufMut for io::Cursor<T> {
     fn remaining_mut(&self) -> usize {
         use Buf;
@@ -1127,6 +1136,7 @@ impl<T: AsMut<[u8]> + AsRef<[u8]>> BufMut for io::Cursor<T> {
     }
 }
 
+#[cfg(feature = "std")]
 impl BufMut for Vec<u8> {
     #[inline]
     fn remaining_mut(&self) -> usize {
@@ -1148,7 +1158,7 @@ impl BufMut for Vec<u8> {
 
     #[inline]
     unsafe fn bytes_mut(&mut self) -> &mut [u8] {
-        use std::slice;
+        use core::slice;
 
         if self.capacity() == self.len() {
             self.reserve(64); // Grow the vec
diff --git a/src/buf/chain.rs b/src/buf/chain.rs
@@ -1,4 +1,5 @@
 use {Buf, BufMut};
+#[cfg(feature = "iovec")]
 use iovec::IoVec;
 
 /// A `Chain` sequences two buffers.
@@ -177,6 +178,7 @@ impl<T, U> Buf for Chain<T, U>
         self.b.advance(cnt);
     }
 
+    #[cfg(feature = "iovec")]
     fn bytes_vec<'a>(&'a self, dst: &mut [&'a IoVec]) -> usize {
         let mut n = self.a.bytes_vec(dst);
         n += self.b.bytes_vec(&mut dst[n..]);
@@ -218,6 +220,7 @@ impl<T, U> BufMut for Chain<T, U>
         self.b.advance_mut(cnt);
     }
 
+    #[cfg(feature = "iovec")]
     unsafe fn bytes_vec_mut<'a>(&'a mut self, dst: &mut [&'a mut IoVec]) -> usize {
         let mut n = self.a.bytes_vec_mut(dst);
         n += self.b.bytes_vec_mut(&mut dst[n..]);
diff --git a/src/buf/from_buf.rs b/src/buf/from_buf.rs
@@ -1,4 +1,8 @@
-use {Buf, BufMut, IntoBuf, Bytes, BytesMut};
+use {IntoBuf};
+#[cfg(feature = "std")]
+use prelude::*;
+#[cfg(feature = "std")]
+use {Buf, BufMut, Bytes, BytesMut};
 
 /// Conversion from a [`Buf`]
 ///
@@ -86,6 +90,7 @@ pub trait FromBuf {
     fn from_buf<T>(buf: T) -> Self where T: IntoBuf;
 }
 
+#[cfg(feature = "std")]
 impl FromBuf for Vec<u8> {
     fn from_buf<T>(buf: T) -> Self
         where T: IntoBuf
@@ -97,6 +102,7 @@ impl FromBuf for Vec<u8> {
     }
 }
 
+#[cfg(feature = "std")]
 impl FromBuf for Bytes {
     fn from_buf<T>(buf: T) -> Self
         where T: IntoBuf
@@ -105,6 +111,7 @@ impl FromBuf for Bytes {
     }
 }
 
+#[cfg(feature = "std")]
 impl FromBuf for BytesMut {
     fn from_buf<T>(buf: T) -> Self
         where T: IntoBuf
diff --git a/src/buf/into_buf.rs b/src/buf/into_buf.rs
@@ -1,5 +1,8 @@
 use super::{Buf};
+#[cfg(feature = "std")]
+use prelude::*;
 
+#[cfg(feature = "std")]
 use std::io;
 
 /// Conversion into a `Buf`
@@ -55,6 +58,7 @@ impl<T: Buf> IntoBuf for T {
     }
 }
 
+#[cfg(feature = "std")]
 impl<'a> IntoBuf for &'a [u8] {
     type Buf = io::Cursor<&'a [u8]>;
 
@@ -63,6 +67,7 @@ impl<'a> IntoBuf for &'a [u8] {
     }
 }
 
+#[cfg(feature = "std")]
 impl<'a> IntoBuf for &'a mut [u8] {
     type Buf = io::Cursor<&'a mut [u8]>;
 
@@ -71,6 +76,7 @@ impl<'a> IntoBuf for &'a mut [u8] {
     }
 }
 
+#[cfg(feature = "std")]
 impl<'a> IntoBuf for &'a str {
     type Buf = io::Cursor<&'a [u8]>;
 
@@ -79,6 +85,7 @@ impl<'a> IntoBuf for &'a str {
     }
 }
 
+#[cfg(feature = "std")]
 impl IntoBuf for Vec<u8> {
     type Buf = io::Cursor<Vec<u8>>;
 
@@ -87,6 +94,7 @@ impl IntoBuf for Vec<u8> {
     }
 }
 
+#[cfg(feature = "std")]
 impl<'a> IntoBuf for &'a Vec<u8> {
     type Buf = io::Cursor<&'a [u8]>;
 
@@ -97,6 +105,7 @@ impl<'a> IntoBuf for &'a Vec<u8> {
 
 // Kind of annoying... but this impl is required to allow passing `&'static
 // [u8]` where for<'a> &'a T: IntoBuf is required.
+#[cfg(feature = "std")]
 impl<'a> IntoBuf for &'a &'static [u8] {
     type Buf = io::Cursor<&'static [u8]>;
 
@@ -105,6 +114,7 @@ impl<'a> IntoBuf for &'a &'static [u8] {
     }
 }
 
+#[cfg(feature = "std")]
 impl<'a> IntoBuf for &'a &'static str {
     type Buf = io::Cursor<&'static [u8]>;
 
@@ -113,6 +123,7 @@ impl<'a> IntoBuf for &'a &'static str {
     }
 }
 
+#[cfg(feature = "std")]
 impl IntoBuf for String {
     type Buf = io::Cursor<Vec<u8>>;
 
@@ -121,6 +132,7 @@ impl IntoBuf for String {
     }
 }
 
+#[cfg(feature = "std")]
 impl<'a> IntoBuf for &'a String {
     type Buf = io::Cursor<&'a [u8]>;
 
diff --git a/src/buf/mod.rs b/src/buf/mod.rs
@@ -24,6 +24,7 @@ mod into_buf;
 mod iter;
 mod reader;
 mod take;
+#[cfg(feature = "std")]
 mod vec_deque;
 mod writer;
 
diff --git a/src/buf/reader.rs b/src/buf/reader.rs
@@ -1,5 +1,6 @@
 use {Buf};
 
+#[cfg(feature = "std")]
 use std::{cmp, io};
 
 /// A `Buf` adapter which implements `io::Read` for the inner value.
@@ -78,6 +79,7 @@ impl<B: Buf> Reader<B> {
     }
 }
 
+#[cfg(feature = "std")]
 impl<B: Buf + Sized> io::Read for Reader<B> {
     fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
         let len = cmp::min(self.buf.remaining(), dst.len());
@@ -87,6 +89,7 @@ impl<B: Buf + Sized> io::Read for Reader<B> {
     }
 }
 
+#[cfg(feature = "std")]
 impl<B: Buf + Sized> io::BufRead for Reader<B> {
     fn fill_buf(&mut self) -> io::Result<&[u8]> {
         Ok(self.buf.bytes())
diff --git a/src/buf/take.rs b/src/buf/take.rs
@@ -1,6 +1,6 @@
 use {Buf};
 
-use std::cmp;
+use core::cmp;
 
 /// A `Buf` adapter which limits the bytes read from an underlying buffer.
 ///
diff --git a/src/buf/vec_deque.rs b/src/buf/vec_deque.rs
@@ -24,6 +24,7 @@ impl Buf for VecDeque<u8> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use prelude::*;
 
     #[test]
     fn hello_world() {
diff --git a/src/buf/writer.rs b/src/buf/writer.rs
@@ -1,5 +1,6 @@
 use BufMut;
 
+#[cfg(feature = "std")]
 use std::{cmp, io};
 
 /// A `BufMut` adapter which implements `io::Write` for the inner value.
@@ -74,6 +75,7 @@ impl<B: BufMut> Writer<B> {
     }
 }
 
+#[cfg(feature = "std")]
 impl<B: BufMut + Sized> io::Write for Writer<B> {
     fn write(&mut self, src: &[u8]) -> io::Result<usize> {
         let n = cmp::min(self.buf.remaining_mut(), src.len());
diff --git a/src/bytes.rs b/src/bytes.rs
@@ -1,6 +1,7 @@
 use {IntoBuf, Buf, BufMut};
 use buf::Iter;
 use debug;
+use prelude::*;
 
 use std::{cmp, fmt, mem, hash, ops, slice, ptr, usize};
 use std::borrow::{Borrow, BorrowMut};
@@ -1499,7 +1500,7 @@ impl BytesMut {
         }
 
         unsafe {
-            ptr = self.inner.ptr.offset(self.inner.len as isize); 
+            ptr = self.inner.ptr.offset(self.inner.len as isize);
         }
         if ptr == other.inner.ptr &&
            self.inner.kind() == KIND_ARC &&
diff --git a/src/lib.rs b/src/lib.rs
@@ -70,9 +70,13 @@
 
 #![deny(warnings, missing_docs, missing_debug_implementations)]
 #![doc(html_root_url = "https://docs.rs/bytes/0.4.12")]
+#![no_std]
 
 extern crate byteorder;
+#[cfg(feature = "iovec")]
 extern crate iovec;
+#[cfg(feature = "std")]
+extern crate std;
 
 pub mod buf;
 pub use buf::{
@@ -88,9 +92,13 @@ pub use buf::{
     Take,
 };
 
+#[cfg(feature = "std")]
 mod bytes;
+#[cfg(feature = "std")]
 mod debug;
+#[cfg(feature = "std")]
 pub use bytes::{Bytes, BytesMut};
+mod prelude;
 
 #[deprecated]
 pub use byteorder::{ByteOrder, BigEndian, LittleEndian};
diff --git a/src/prelude.rs b/src/prelude.rs

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,13 @@`
`1`	`1`	`use super::{IntoBuf, Take, Reader, Iter, FromBuf, Chain};`
`2`	`2`	`use byteorder::{BigEndian, ByteOrder, LittleEndian};`
	`3`	`+#[cfg(feature = "iovec")]`
`3`	`4`	`use iovec::IoVec;`
	`5`	`+#[cfg(feature = "std")]`
	`6`	`+use prelude::*;`
`4`	`7`
`5`		`-use std::{cmp, io, ptr};`
	`8`	`+use core::{cmp, ptr};`
	`9`	`+#[cfg(feature = "std")]`
	`10`	`+use std::io;`
`6`	`11`
`7`	`12`	`macro_rules! buf_get_impl {`
`8`	`13`	`($this:ident, $size:expr, $conv:path) => ({`
`@@ -146,6 +151,7 @@ pub trait Buf {`
`146`	`151`	/// with `dst` being a zero length slice.
`147`	`152`	`///`
`148`	`153`	/// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html
	`154`	`+ #[cfg(feature = "iovec")]`
`149`	`155`	`fn bytes_vec<'a>(&'a self, dst: &mut [&'a IoVec]) -> usize {`
`150`	`156`	`if dst.is_empty() {`
`151`	`157`	`return 0;`
`@@ -1061,6 +1067,7 @@ impl<'a, T: Buf + ?Sized> Buf for &'a mut T {`
`1061`	`1067`	`(**self).bytes()`
`1062`	`1068`	`}`
`1063`	`1069`
	`1070`	`+ #[cfg(feature = "iovec")]`
`1064`	`1071`	`fn bytes_vec<'b>(&'b self, dst: &mut [&'b IoVec]) -> usize {`
`1065`	`1072`	`(**self).bytes_vec(dst)`
`1066`	`1073`	`}`
`@@ -1070,6 +1077,7 @@ impl<'a, T: Buf + ?Sized> Buf for &'a mut T {`
`1070`	`1077`	`}`
`1071`	`1078`	`}`
`1072`	`1079`
	`1080`	`+#[cfg(feature = "std")]`
`1073`	`1081`	`impl<T: Buf + ?Sized> Buf for Box<T> {`
`1074`	`1082`	`fn remaining(&self) -> usize {`
`1075`	`1083`	`(**self).remaining()`
`@@ -1079,6 +1087,7 @@ impl<T: Buf + ?Sized> Buf for Box<T> {`
`1079`	`1087`	`(**self).bytes()`
`1080`	`1088`	`}`
`1081`	`1089`
	`1090`	`+ #[cfg(feature = "iovec")]`
`1082`	`1091`	`fn bytes_vec<'b>(&'b self, dst: &mut [&'b IoVec]) -> usize {`
`1083`	`1092`	`(**self).bytes_vec(dst)`
`1084`	`1093`	`}`
`@@ -1088,6 +1097,7 @@ impl<T: Buf + ?Sized> Buf for Box<T> {`
`1088`	`1097`	`}`
`1089`	`1098`	`}`
`1090`	`1099`
	`1100`	`+#[cfg(feature = "std")]`
`1091`	`1101`	`impl<T: AsRef<[u8]>> Buf for io::Cursor<T> {`
`1092`	`1102`	`fn remaining(&self) -> usize {`
`1093`	`1103`	`let len = self.get_ref().as_ref().len();`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,8 @@`
`1`		`-use {Buf, BufMut, IntoBuf, Bytes, BytesMut};`
	`1`	`+use {IntoBuf};`
	`2`	`+#[cfg(feature = "std")]`
	`3`	`+use prelude::*;`
	`4`	`+#[cfg(feature = "std")]`
	`5`	`+use {Buf, BufMut, Bytes, BytesMut};`
`2`	`6`
`3`	`7`	/// Conversion from a [`Buf`]
`4`	`8`	`///`
`@@ -86,6 +90,7 @@ pub trait FromBuf {`
`86`	`90`	`fn from_buf<T>(buf: T) -> Self where T: IntoBuf;`
`87`	`91`	`}`
`88`	`92`
	`93`	`+#[cfg(feature = "std")]`
`89`	`94`	`impl FromBuf for Vec<u8> {`
`90`	`95`	`fn from_buf<T>(buf: T) -> Self`
`91`	`96`	`where T: IntoBuf`
`@@ -97,6 +102,7 @@ impl FromBuf for Vec<u8> {`
`97`	`102`	`}`
`98`	`103`	`}`
`99`	`104`
	`105`	`+#[cfg(feature = "std")]`
`100`	`106`	`impl FromBuf for Bytes {`
`101`	`107`	`fn from_buf<T>(buf: T) -> Self`
`102`	`108`	`where T: IntoBuf`
`@@ -105,6 +111,7 @@ impl FromBuf for Bytes {`
`105`	`111`	`}`
`106`	`112`	`}`
`107`	`113`
	`114`	`+#[cfg(feature = "std")]`
`108`	`115`	`impl FromBuf for BytesMut {`
`109`	`116`	`fn from_buf<T>(buf: T) -> Self`
`110`	`117`	`where T: IntoBuf`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,8 @@`
`1`	`1`	`use super::{Buf};`
	`2`	`+#[cfg(feature = "std")]`
	`3`	`+use prelude::*;`
`2`	`4`
	`5`	`+#[cfg(feature = "std")]`
`3`	`6`	`use std::io;`
`4`	`7`
`5`	`8`	/// Conversion into a `Buf`
`@@ -55,6 +58,7 @@ impl<T: Buf> IntoBuf for T {`
`55`	`58`	`}`
`56`	`59`	`}`
`57`	`60`
	`61`	`+#[cfg(feature = "std")]`
`58`	`62`	`impl<'a> IntoBuf for &'a [u8] {`
`59`	`63`	`type Buf = io::Cursor<&'a [u8]>;`
`60`	`64`
`@@ -63,6 +67,7 @@ impl<'a> IntoBuf for &'a [u8] {`
`63`	`67`	`}`
`64`	`68`	`}`
`65`	`69`
	`70`	`+#[cfg(feature = "std")]`
`66`	`71`	`impl<'a> IntoBuf for &'a mut [u8] {`
`67`	`72`	`type Buf = io::Cursor<&'a mut [u8]>;`
`68`	`73`
`@@ -71,6 +76,7 @@ impl<'a> IntoBuf for &'a mut [u8] {`
`71`	`76`	`}`
`72`	`77`	`}`
`73`	`78`
	`79`	`+#[cfg(feature = "std")]`
`74`	`80`	`impl<'a> IntoBuf for &'a str {`
`75`	`81`	`type Buf = io::Cursor<&'a [u8]>;`
`76`	`82`
`@@ -79,6 +85,7 @@ impl<'a> IntoBuf for &'a str {`
`79`	`85`	`}`
`80`	`86`	`}`
`81`	`87`
	`88`	`+#[cfg(feature = "std")]`
`82`	`89`	`impl IntoBuf for Vec<u8> {`
`83`	`90`	`type Buf = io::Cursor<Vec<u8>>;`
`84`	`91`
`@@ -87,6 +94,7 @@ impl IntoBuf for Vec<u8> {`
`87`	`94`	`}`
`88`	`95`	`}`
`89`	`96`
	`97`	`+#[cfg(feature = "std")]`
`90`	`98`	`impl<'a> IntoBuf for &'a Vec<u8> {`
`91`	`99`	`type Buf = io::Cursor<&'a [u8]>;`
`92`	`100`
`@@ -97,6 +105,7 @@ impl<'a> IntoBuf for &'a Vec<u8> {`
`97`	`105`
`98`	`106`	// Kind of annoying... but this impl is required to allow passing `&'static
`99`	`107`	// [u8]` where for<'a> &'a T: IntoBuf is required.
	`108`	`+#[cfg(feature = "std")]`
`100`	`109`	`impl<'a> IntoBuf for &'a &'static [u8] {`
`101`	`110`	`type Buf = io::Cursor<&'static [u8]>;`
`102`	`111`
`@@ -105,6 +114,7 @@ impl<'a> IntoBuf for &'a &'static [u8] {`
`105`	`114`	`}`
`106`	`115`	`}`
`107`	`116`
	`117`	`+#[cfg(feature = "std")]`
`108`	`118`	`impl<'a> IntoBuf for &'a &'static str {`
`109`	`119`	`type Buf = io::Cursor<&'static [u8]>;`
`110`	`120`
`@@ -113,6 +123,7 @@ impl<'a> IntoBuf for &'a &'static str {`
`113`	`123`	`}`
`114`	`124`	`}`
`115`	`125`
	`126`	`+#[cfg(feature = "std")]`
`116`	`127`	`impl IntoBuf for String {`
`117`	`128`	`type Buf = io::Cursor<Vec<u8>>;`
`118`	`129`
`@@ -121,6 +132,7 @@ impl IntoBuf for String {`
`121`	`132`	`}`
`122`	`133`	`}`
`123`	`134`
	`135`	`+#[cfg(feature = "std")]`
`124`	`136`	`impl<'a> IntoBuf for &'a String {`
`125`	`137`	`type Buf = io::Cursor<&'a [u8]>;`
`126`	`138`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`use {Buf};`
`2`	`2`
	`3`	`+#[cfg(feature = "std")]`
`3`	`4`	`use std::{cmp, io};`
`4`	`5`
`5`	`6`	/// A `Buf` adapter which implements `io::Read` for the inner value.
`@@ -78,6 +79,7 @@ impl<B: Buf> Reader<B> {`
`78`	`79`	`}`
`79`	`80`	`}`
`80`	`81`
	`82`	`+#[cfg(feature = "std")]`
`81`	`83`	`impl<B: Buf + Sized> io::Read for Reader<B> {`
`82`	`84`	`fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {`
`83`	`85`	`let len = cmp::min(self.buf.remaining(), dst.len());`
`@@ -87,6 +89,7 @@ impl<B: Buf + Sized> io::Read for Reader<B> {`
`87`	`89`	`}`
`88`	`90`	`}`
`89`	`91`
	`92`	`+#[cfg(feature = "std")]`
`90`	`93`	`impl<B: Buf + Sized> io::BufRead for Reader<B> {`
`91`	`94`	`fn fill_buf(&mut self) -> io::Result<&[u8]> {`
`92`	`95`	`Ok(self.buf.bytes())`