diff --git a/buffered.rs b/buffered.rs index 0615cd5..a46bf20 100644 --- a/buffered.rs +++ b/buffered.rs @@ -1,12 +1,12 @@ //! Buffering wrappers for I/O traits +use core::prelude::v1::*; use io::prelude::*; -use cmp; -use error; -use fmt; +use core::cmp; +use core::fmt; use io::{self, Initializer, DEFAULT_BUF_SIZE, Error, ErrorKind, SeekFrom}; -use memchr; +use io::memchr; /// The `BufReader` struct adds buffering to any reader. /// @@ -42,7 +42,6 @@ use memchr; /// Ok(()) /// } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub struct BufReader { inner: R, buf: Box<[u8]>, @@ -66,7 +65,6 @@ impl BufReader { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn new(inner: R) -> BufReader { BufReader::with_capacity(DEFAULT_BUF_SIZE, inner) } @@ -87,7 +85,6 @@ impl BufReader { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn with_capacity(cap: usize, inner: R) -> BufReader { unsafe { let mut buffer = Vec::with_capacity(cap); @@ -120,7 +117,6 @@ impl BufReader { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn get_ref(&self) -> &R { &self.inner } /// Gets a mutable reference to the underlying reader. @@ -141,7 +137,6 @@ impl BufReader { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn get_mut(&mut self) -> &mut R { &mut self.inner } /// Returns a reference to the internally buffered data. @@ -166,7 +161,6 @@ impl BufReader { /// Ok(()) /// } /// ``` - #[unstable(feature = "bufreader_buffer", issue = "45323")] pub fn buffer(&self) -> &[u8] { &self.buf[self.pos..self.cap] } @@ -189,7 +183,6 @@ impl BufReader { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn into_inner(self) -> R { self.inner } } @@ -198,7 +191,6 @@ impl BufReader { /// the buffer will not be flushed, allowing for more efficient seeks. /// This method does not return the location of the underlying reader, so the caller /// must track this information themselves if it is required. - #[unstable(feature = "bufreader_seek_relative", issue = "31100")] pub fn seek_relative(&mut self, offset: i64) -> io::Result<()> { let pos = self.pos as u64; if offset < 0 { @@ -218,7 +210,6 @@ impl BufReader { } } -#[stable(feature = "rust1", since = "1.0.0")] impl Read for BufReader { fn read(&mut self, buf: &mut [u8]) -> io::Result { // If we don't have any buffered data and we're doing a massive read @@ -241,7 +232,6 @@ impl Read for BufReader { } } -#[stable(feature = "rust1", since = "1.0.0")] impl BufRead for BufReader { fn fill_buf(&mut self) -> io::Result<&[u8]> { // If we've reached the end of our internal buffer then we need to fetch @@ -261,7 +251,6 @@ impl BufRead for BufReader { } } -#[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for BufReader where R: fmt::Debug { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("BufReader") @@ -271,7 +260,6 @@ impl fmt::Debug for BufReader where R: fmt::Debug { } } -#[stable(feature = "rust1", since = "1.0.0")] impl Seek for BufReader { /// Seek to an offset, in bytes, in the underlying reader. /// @@ -380,7 +368,6 @@ impl Seek for BufReader { /// [`Tcpstream::write`]: ../../std/net/struct.TcpStream.html#method.write /// [`TcpStream`]: ../../std/net/struct.TcpStream.html /// [`flush`]: #method.flush -#[stable(feature = "rust1", since = "1.0.0")] pub struct BufWriter { inner: Option, buf: Vec, @@ -415,7 +402,6 @@ pub struct BufWriter { /// }; /// ``` #[derive(Debug)] -#[stable(feature = "rust1", since = "1.0.0")] pub struct IntoInnerError(W, Error); impl BufWriter { @@ -430,7 +416,6 @@ impl BufWriter { /// /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap()); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn new(inner: W) -> BufWriter { BufWriter::with_capacity(DEFAULT_BUF_SIZE, inner) } @@ -448,7 +433,6 @@ impl BufWriter { /// let stream = TcpStream::connect("127.0.0.1:34254").unwrap(); /// let mut buffer = BufWriter::with_capacity(100, stream); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn with_capacity(cap: usize, inner: W) -> BufWriter { BufWriter { inner: Some(inner), @@ -497,7 +481,6 @@ impl BufWriter { /// // we can use reference just like buffer /// let reference = buffer.get_ref(); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn get_ref(&self) -> &W { self.inner.as_ref().unwrap() } /// Gets a mutable reference to the underlying writer. @@ -515,7 +498,6 @@ impl BufWriter { /// // we can use reference just like buffer /// let reference = buffer.get_mut(); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn get_mut(&mut self) -> &mut W { self.inner.as_mut().unwrap() } /// Returns a reference to the internally buffered data. @@ -532,7 +514,6 @@ impl BufWriter { /// // See how many bytes are currently buffered /// let bytes_buffered = buf_writer.buffer().len(); /// ``` - #[unstable(feature = "bufreader_buffer", issue = "45323")] pub fn buffer(&self) -> &[u8] { &self.buf } @@ -556,7 +537,6 @@ impl BufWriter { /// // unwrap the TcpStream and flush the buffer /// let stream = buffer.into_inner().unwrap(); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn into_inner(mut self) -> Result>> { match self.flush_buf() { Err(e) => Err(IntoInnerError(self, e)), @@ -565,7 +545,6 @@ impl BufWriter { } } -#[stable(feature = "rust1", since = "1.0.0")] impl Write for BufWriter { fn write(&mut self, buf: &[u8]) -> io::Result { if self.buf.len() + buf.len() > self.buf.capacity() { @@ -585,7 +564,6 @@ impl Write for BufWriter { } } -#[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for BufWriter where W: fmt::Debug { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("BufWriter") @@ -595,7 +573,6 @@ impl fmt::Debug for BufWriter where W: fmt::Debug { } } -#[stable(feature = "rust1", since = "1.0.0")] impl Seek for BufWriter { /// Seek to the offset, in bytes, in the underlying writer. /// @@ -605,7 +582,6 @@ impl Seek for BufWriter { } } -#[stable(feature = "rust1", since = "1.0.0")] impl Drop for BufWriter { fn drop(&mut self) { if self.inner.is_some() && !self.panicked { @@ -644,7 +620,6 @@ impl IntoInnerError { /// } /// }; /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn error(&self) -> &Error { &self.1 } /// Returns the buffered writer instance which generated the error. @@ -677,23 +652,13 @@ impl IntoInnerError { /// } /// }; /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn into_inner(self) -> W { self.0 } } -#[stable(feature = "rust1", since = "1.0.0")] impl From> for Error { fn from(iie: IntoInnerError) -> Error { iie.1 } } -#[stable(feature = "rust1", since = "1.0.0")] -impl error::Error for IntoInnerError { - fn description(&self) -> &str { - error::Error::description(self.error()) - } -} - -#[stable(feature = "rust1", since = "1.0.0")] impl fmt::Display for IntoInnerError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.error().fmt(f) @@ -764,7 +729,6 @@ impl fmt::Display for IntoInnerError { /// Ok(()) /// } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub struct LineWriter { inner: BufWriter, need_flush: bool, @@ -785,7 +749,6 @@ impl LineWriter { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn new(inner: W) -> LineWriter { // Lines typically aren't that long, don't use a giant buffer LineWriter::with_capacity(1024, inner) @@ -806,7 +769,6 @@ impl LineWriter { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn with_capacity(cap: usize, inner: W) -> LineWriter { LineWriter { inner: BufWriter::with_capacity(cap, inner), @@ -830,7 +792,6 @@ impl LineWriter { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn get_ref(&self) -> &W { self.inner.get_ref() } /// Gets a mutable reference to the underlying writer. @@ -853,7 +814,6 @@ impl LineWriter { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn get_mut(&mut self) -> &mut W { self.inner.get_mut() } /// Unwraps this `LineWriter`, returning the underlying writer. @@ -879,7 +839,6 @@ impl LineWriter { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn into_inner(self) -> Result>> { self.inner.into_inner().map_err(|IntoInnerError(buf, e)| { IntoInnerError(LineWriter { @@ -890,7 +849,6 @@ impl LineWriter { } } -#[stable(feature = "rust1", since = "1.0.0")] impl Write for LineWriter { fn write(&mut self, buf: &[u8]) -> io::Result { if self.need_flush { @@ -935,7 +893,6 @@ impl Write for LineWriter { } } -#[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for LineWriter where W: fmt::Debug { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("LineWriter") diff --git a/cursor.rs b/cursor.rs index b205f78..3d7e33f 100644 --- a/cursor.rs +++ b/cursor.rs @@ -1,7 +1,7 @@ use io::prelude::*; -use core::convert::TryInto; -use cmp; +#[cfg(feature="collections")] use core::convert::TryInto; +use core::cmp; use io::{self, Initializer, SeekFrom, Error, ErrorKind}; /// A `Cursor` wraps an in-memory buffer and provides it with a @@ -70,7 +70,6 @@ use io::{self, Initializer, SeekFrom, Error, ErrorKind}; /// assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); /// } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] #[derive(Clone, Debug)] pub struct Cursor { inner: T, @@ -93,7 +92,6 @@ impl Cursor { /// # fn force_inference(_: &Cursor>) {} /// # force_inference(&buff); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn new(inner: T) -> Cursor { Cursor { pos: 0, inner: inner } } @@ -111,7 +109,6 @@ impl Cursor { /// /// let vec = buff.into_inner(); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn into_inner(self) -> T { self.inner } /// Gets a reference to the underlying value in this cursor. @@ -127,7 +124,6 @@ impl Cursor { /// /// let reference = buff.get_ref(); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn get_ref(&self) -> &T { &self.inner } /// Gets a mutable reference to the underlying value in this cursor. @@ -146,7 +142,6 @@ impl Cursor { /// /// let reference = buff.get_mut(); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn get_mut(&mut self) -> &mut T { &mut self.inner } /// Returns the current position of this cursor. @@ -168,7 +163,6 @@ impl Cursor { /// buff.seek(SeekFrom::Current(-1)).unwrap(); /// assert_eq!(buff.position(), 1); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn position(&self) -> u64 { self.pos } /// Sets the position of this cursor. @@ -188,11 +182,9 @@ impl Cursor { /// buff.set_position(4); /// assert_eq!(buff.position(), 4); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn set_position(&mut self, pos: u64) { self.pos = pos; } } -#[stable(feature = "rust1", since = "1.0.0")] impl io::Seek for Cursor where T: AsRef<[u8]> { fn seek(&mut self, style: SeekFrom) -> io::Result { let (base_pos, offset) = match style { @@ -213,17 +205,16 @@ impl io::Seek for Cursor where T: AsRef<[u8]> { } } -#[stable(feature = "rust1", since = "1.0.0")] impl Read for Cursor where T: AsRef<[u8]> { fn read(&mut self, buf: &mut [u8]) -> io::Result { - let n = Read::read(&mut self.fill_buf()?, buf)?; + let n = Read::read(&mut self.get_buf()?, buf)?; self.pos += n as u64; Ok(n) } fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { let n = buf.len(); - Read::read_exact(&mut self.fill_buf()?, buf)?; + Read::read_exact(&mut self.get_buf()?, buf)?; self.pos += n as u64; Ok(()) } @@ -234,12 +225,16 @@ impl Read for Cursor where T: AsRef<[u8]> { } } -#[stable(feature = "rust1", since = "1.0.0")] -impl BufRead for Cursor where T: AsRef<[u8]> { - fn fill_buf(&mut self) -> io::Result<&[u8]> { +impl Cursor where T: AsRef<[u8]> { + fn get_buf(&mut self) -> io::Result<&[u8]> { let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64); Ok(&self.inner.as_ref()[(amt as usize)..]) } +} + +#[cfg(feature="collections")] +impl BufRead for Cursor where T: AsRef<[u8]> { + fn fill_buf(&mut self) -> io::Result<&[u8]> { self.get_buf() } fn consume(&mut self, amt: usize) { self.pos += amt as u64; } } @@ -252,6 +247,7 @@ fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result, buf: &[u8]) -> io::Result { let pos: usize = (*pos_mut).try_into().map_err(|_| { Error::new(ErrorKind::InvalidInput, @@ -278,7 +274,6 @@ fn vec_write(pos_mut: &mut u64, vec: &mut Vec, buf: &[u8]) -> io::Result Write for Cursor<&'a mut [u8]> { #[inline] fn write(&mut self, buf: &[u8]) -> io::Result { @@ -287,7 +282,7 @@ impl<'a> Write for Cursor<&'a mut [u8]> { fn flush(&mut self) -> io::Result<()> { Ok(()) } } -#[stable(feature = "cursor_mut_vec", since = "1.25.0")] +#[cfg(feature="collections")] impl<'a> Write for Cursor<&'a mut Vec> { fn write(&mut self, buf: &[u8]) -> io::Result { vec_write(&mut self.pos, self.inner, buf) @@ -295,7 +290,7 @@ impl<'a> Write for Cursor<&'a mut Vec> { fn flush(&mut self) -> io::Result<()> { Ok(()) } } -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature = "collections")] impl Write for Cursor> { fn write(&mut self, buf: &[u8]) -> io::Result { vec_write(&mut self.pos, &mut self.inner, buf) @@ -303,8 +298,8 @@ impl Write for Cursor> { fn flush(&mut self) -> io::Result<()> { Ok(()) } } -#[stable(feature = "cursor_box_slice", since = "1.5.0")] -impl Write for Cursor> { +#[cfg(feature = "alloc")] +impl Write for Cursor<::alloc::boxed::Box<[u8]>> { #[inline] fn write(&mut self, buf: &[u8]) -> io::Result { slice_write(&mut self.pos, &mut self.inner, buf) diff --git a/error.rs b/error.rs index e9b4f60..31c0ff1 100644 --- a/error.rs +++ b/error.rs @@ -1,8 +1,13 @@ -use error; -use fmt; -use result; -use sys; -use convert::From; +#[cfg(feature="alloc")] use alloc::boxed::Box; +#[cfg(not(feature="alloc"))] use ::FakeBox as Box; +use core::convert::Into; +use core::fmt; +use core::marker::{Send, Sync}; +use core::option::Option::{self, Some, None}; +use core::result; +#[cfg(feature="collections")] use collections::string::String; +#[cfg(not(feature="collections"))] use ::ErrorString as String; +use core::convert::From; /// A specialized [`Result`](../result/enum.Result.html) type for I/O /// operations. @@ -38,7 +43,6 @@ use convert::From; /// Ok(buffer) /// } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub type Result = result::Result; /// The error type for I/O operations of the [`Read`], [`Write`], [`Seek`], and @@ -52,12 +56,10 @@ pub type Result = result::Result; /// [`Write`]: ../io/trait.Write.html /// [`Seek`]: ../io/trait.Seek.html /// [`ErrorKind`]: enum.ErrorKind.html -#[stable(feature = "rust1", since = "1.0.0")] pub struct Error { repr: Repr, } -#[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Debug::fmt(&self.repr, f) @@ -67,13 +69,16 @@ impl fmt::Debug for Error { enum Repr { Os(i32), Simple(ErrorKind), + #[cfg(feature="alloc")] Custom(Box), + #[cfg(not(feature="alloc"))] + Custom(Custom), } #[derive(Debug)] struct Custom { kind: ErrorKind, - error: Box, + error: String, } /// A list specifying general categories of I/O error. @@ -85,48 +90,35 @@ struct Custom { /// /// [`io::Error`]: struct.Error.html #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] -#[stable(feature = "rust1", since = "1.0.0")] #[allow(deprecated)] #[non_exhaustive] pub enum ErrorKind { /// An entity was not found, often a file. - #[stable(feature = "rust1", since = "1.0.0")] NotFound, /// The operation lacked the necessary privileges to complete. - #[stable(feature = "rust1", since = "1.0.0")] PermissionDenied, /// The connection was refused by the remote server. - #[stable(feature = "rust1", since = "1.0.0")] ConnectionRefused, /// The connection was reset by the remote server. - #[stable(feature = "rust1", since = "1.0.0")] ConnectionReset, /// The connection was aborted (terminated) by the remote server. - #[stable(feature = "rust1", since = "1.0.0")] ConnectionAborted, /// The network operation failed because it was not connected yet. - #[stable(feature = "rust1", since = "1.0.0")] NotConnected, /// A socket address could not be bound because the address is already in /// use elsewhere. - #[stable(feature = "rust1", since = "1.0.0")] AddrInUse, /// A nonexistent interface was requested or the requested address was not /// local. - #[stable(feature = "rust1", since = "1.0.0")] AddrNotAvailable, /// The operation failed because a pipe was closed. - #[stable(feature = "rust1", since = "1.0.0")] BrokenPipe, /// An entity already exists, often a file. - #[stable(feature = "rust1", since = "1.0.0")] AlreadyExists, /// The operation needs to block to complete, but the blocking operation was /// requested to not occur. - #[stable(feature = "rust1", since = "1.0.0")] WouldBlock, /// A parameter was incorrect. - #[stable(feature = "rust1", since = "1.0.0")] InvalidInput, /// Data not valid for the operation were encountered. /// @@ -138,10 +130,8 @@ pub enum ErrorKind { /// `InvalidData` if the file's contents are not valid UTF-8. /// /// [`InvalidInput`]: #variant.InvalidInput - #[stable(feature = "io_invalid_data", since = "1.2.0")] InvalidData, /// The I/O operation's timeout expired, causing it to be canceled. - #[stable(feature = "rust1", since = "1.0.0")] TimedOut, /// An error returned when an operation could not be completed because a /// call to [`write`] returned [`Ok(0)`]. @@ -152,15 +142,12 @@ pub enum ErrorKind { /// /// [`write`]: ../../std/io/trait.Write.html#tymethod.write /// [`Ok(0)`]: ../../std/io/type.Result.html - #[stable(feature = "rust1", since = "1.0.0")] WriteZero, /// This operation was interrupted. /// /// Interrupted operations can typically be retried. - #[stable(feature = "rust1", since = "1.0.0")] Interrupted, /// Any I/O error not part of this list. - #[stable(feature = "rust1", since = "1.0.0")] Other, /// An error returned when an operation could not be completed because an @@ -169,7 +156,6 @@ pub enum ErrorKind { /// This typically means that an operation could only succeed if it read a /// particular number of bytes but only a smaller number of bytes could be /// read. - #[stable(feature = "read_exact", since = "1.6.0")] UnexpectedEof, } @@ -200,7 +186,6 @@ impl ErrorKind { /// Intended for use for errors not exposed to the user, where allocating onto /// the heap (for normal construction via Error::new) is too costly. -#[stable(feature = "io_error_from_errorkind", since = "1.14.0")] impl From for Error { /// Converts an [`ErrorKind`] into an [`Error`]. /// @@ -245,14 +230,13 @@ impl Error { /// // errors can also be created from other errors /// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn new(kind: ErrorKind, error: E) -> Error - where E: Into> + where E: Into { Self::_new(kind, error.into()) } - fn _new(kind: ErrorKind, error: Box) -> Error { + fn _new(kind: ErrorKind, error: String) -> Error { Error { repr: Repr::Custom(Box::new(Custom { kind, @@ -261,24 +245,6 @@ impl Error { } } - /// Returns an error representing the last OS error which occurred. - /// - /// This function reads the value of `errno` for the target platform (e.g. - /// `GetLastError` on Windows) and will return a corresponding instance of - /// `Error` for the error code. - /// - /// # Examples - /// - /// ``` - /// use std::io::Error; - /// - /// println!("last OS error: {:?}", Error::last_os_error()); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn last_os_error() -> Error { - Error::from_raw_os_error(sys::os::errno() as i32) - } - /// Creates a new instance of an `Error` from a particular OS error code. /// /// # Examples @@ -304,7 +270,6 @@ impl Error { /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput); /// # } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn from_raw_os_error(code: i32) -> Error { Error { repr: Repr::Os(code) } } @@ -335,7 +300,6 @@ impl Error { /// print_os_error(&Error::new(ErrorKind::Other, "oh no!")); /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn raw_os_error(&self) -> Option { match self.repr { Repr::Os(i) => Some(i), @@ -369,12 +333,11 @@ impl Error { /// print_error(&Error::new(ErrorKind::Other, "oh no!")); /// } /// ``` - #[stable(feature = "io_error_inner", since = "1.3.0")] - pub fn get_ref(&self) -> Option<&(dyn error::Error+Send+Sync+'static)> { + pub fn get_ref(&self) -> Option<&String> { match self.repr { Repr::Os(..) => None, Repr::Simple(..) => None, - Repr::Custom(ref c) => Some(&*c.error), + Repr::Custom(ref c) => Some(&c.error), } } @@ -440,12 +403,11 @@ impl Error { /// print_error(&change_error(Error::new(ErrorKind::Other, MyError::new()))); /// } /// ``` - #[stable(feature = "io_error_inner", since = "1.3.0")] - pub fn get_mut(&mut self) -> Option<&mut (dyn error::Error+Send+Sync+'static)> { + pub fn get_mut(&mut self) -> Option<&mut String> { match self.repr { Repr::Os(..) => None, Repr::Simple(..) => None, - Repr::Custom(ref mut c) => Some(&mut *c.error), + Repr::Custom(ref mut c) => Some(&mut c.error), } } @@ -474,8 +436,7 @@ impl Error { /// print_error(Error::new(ErrorKind::Other, "oh no!")); /// } /// ``` - #[stable(feature = "io_error_inner", since = "1.3.0")] - pub fn into_inner(self) -> Option> { + pub fn into_inner(self) -> Option { match self.repr { Repr::Os(..) => None, Repr::Simple(..) => None, @@ -501,10 +462,9 @@ impl Error { /// print_error(Error::new(ErrorKind::AddrInUse, "oh no!")); /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn kind(&self) -> ErrorKind { match self.repr { - Repr::Os(code) => sys::decode_error_kind(code), + Repr::Os(_code) => ErrorKind::Other, Repr::Custom(ref c) => c.kind, Repr::Simple(kind) => kind, } @@ -516,22 +476,18 @@ impl fmt::Debug for Repr { match *self { Repr::Os(code) => fmt.debug_struct("Os") - .field("code", &code) - .field("kind", &sys::decode_error_kind(code)) - .field("message", &sys::os::error_string(code)).finish(), + .field("code", &code).finish(), Repr::Custom(ref c) => fmt::Debug::fmt(&c, fmt), Repr::Simple(kind) => fmt.debug_tuple("Kind").field(&kind).finish(), } } } -#[stable(feature = "rust1", since = "1.0.0")] impl fmt::Display for Error { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { match self.repr { Repr::Os(code) => { - let detail = sys::os::error_string(code); - write!(fmt, "{} (os error {})", detail, code) + write!(fmt, "os error {}", code) } Repr::Custom(ref c) => c.error.fmt(fmt), Repr::Simple(kind) => write!(fmt, "{}", kind.as_str()), @@ -539,25 +495,6 @@ impl fmt::Display for Error { } } -#[stable(feature = "rust1", since = "1.0.0")] -impl error::Error for Error { - fn description(&self) -> &str { - match self.repr { - Repr::Os(..) | Repr::Simple(..) => self.kind().as_str(), - Repr::Custom(ref c) => c.error.description(), - } - } - - #[allow(deprecated)] - fn cause(&self) -> Option<&dyn error::Error> { - match self.repr { - Repr::Os(..) => None, - Repr::Simple(..) => None, - Repr::Custom(ref c) => c.error.cause(), - } - } -} - fn _assert_error_is_sync_send() { fn _is_sync_send() {} _is_sync_send::(); diff --git a/impls.rs b/impls.rs index ec75a87..e9d6bf2 100644 --- a/impls.rs +++ b/impls.rs @@ -1,12 +1,15 @@ -use cmp; -use io::{self, SeekFrom, Read, Initializer, Write, Seek, BufRead, Error, ErrorKind}; -use fmt; -use mem; +#[cfg(feature="alloc")] use alloc::boxed::Box; +use core::cmp; +use io::{self, SeekFrom, Read, Initializer, Write, Seek, Error, ErrorKind}; +#[cfg(feature="collections")] use io::BufRead; +use core::fmt; +use core::mem; +#[cfg(feature="collections")] use collections::string::String; +#[cfg(feature="collections")] use collections::vec::Vec; // ============================================================================= // Forwarding implementations -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, R: Read + ?Sized> Read for &'a mut R { #[inline] fn read(&mut self, buf: &mut [u8]) -> io::Result { @@ -18,11 +21,13 @@ impl<'a, R: Read + ?Sized> Read for &'a mut R { (**self).initializer() } + #[cfg(feature="collections")] #[inline] fn read_to_end(&mut self, buf: &mut Vec) -> io::Result { (**self).read_to_end(buf) } + #[cfg(feature="collections")] #[inline] fn read_to_string(&mut self, buf: &mut String) -> io::Result { (**self).read_to_string(buf) @@ -33,7 +38,6 @@ impl<'a, R: Read + ?Sized> Read for &'a mut R { (**self).read_exact(buf) } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, W: Write + ?Sized> Write for &'a mut W { #[inline] fn write(&mut self, buf: &[u8]) -> io::Result { (**self).write(buf) } @@ -51,12 +55,11 @@ impl<'a, W: Write + ?Sized> Write for &'a mut W { (**self).write_fmt(fmt) } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, S: Seek + ?Sized> Seek for &'a mut S { #[inline] fn seek(&mut self, pos: SeekFrom) -> io::Result { (**self).seek(pos) } } -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="collections")] impl<'a, B: BufRead + ?Sized> BufRead for &'a mut B { #[inline] fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() } @@ -75,7 +78,7 @@ impl<'a, B: BufRead + ?Sized> BufRead for &'a mut B { } } -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="alloc")] impl Read for Box { #[inline] fn read(&mut self, buf: &mut [u8]) -> io::Result { @@ -87,11 +90,13 @@ impl Read for Box { (**self).initializer() } + #[cfg(feature="collections")] #[inline] fn read_to_end(&mut self, buf: &mut Vec) -> io::Result { (**self).read_to_end(buf) } + #[cfg(feature="collections")] #[inline] fn read_to_string(&mut self, buf: &mut String) -> io::Result { (**self).read_to_string(buf) @@ -102,7 +107,7 @@ impl Read for Box { (**self).read_exact(buf) } } -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="alloc")] impl Write for Box { #[inline] fn write(&mut self, buf: &[u8]) -> io::Result { (**self).write(buf) } @@ -120,12 +125,12 @@ impl Write for Box { (**self).write_fmt(fmt) } } -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="alloc")] impl Seek for Box { #[inline] fn seek(&mut self, pos: SeekFrom) -> io::Result { (**self).seek(pos) } } -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="collections")] impl BufRead for Box { #[inline] fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() } @@ -151,7 +156,6 @@ impl BufRead for Box { /// /// Note that reading updates the slice to point to the yet unread part. /// The slice will be empty when EOF is reached. -#[stable(feature = "rust1", since = "1.0.0")] impl<'a> Read for &'a [u8] { #[inline] fn read(&mut self, buf: &mut [u8]) -> io::Result { @@ -197,6 +201,7 @@ impl<'a> Read for &'a [u8] { Ok(()) } + #[cfg(feature="collections")] #[inline] fn read_to_end(&mut self, buf: &mut Vec) -> io::Result { buf.extend_from_slice(*self); @@ -206,7 +211,7 @@ impl<'a> Read for &'a [u8] { } } -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="collections")] impl<'a> BufRead for &'a [u8] { #[inline] fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(*self) } @@ -220,7 +225,6 @@ impl<'a> BufRead for &'a [u8] { /// /// Note that writing updates the slice to point to the yet unwritten part. /// The slice will be empty when it has been completely overwritten. -#[stable(feature = "rust1", since = "1.0.0")] impl<'a> Write for &'a mut [u8] { #[inline] fn write(&mut self, data: &[u8]) -> io::Result { @@ -246,7 +250,7 @@ impl<'a> Write for &'a mut [u8] { /// Write is implemented for `Vec` by appending to the vector. /// The vector will grow as needed. -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="collections")] impl Write for Vec { #[inline] fn write(&mut self, buf: &[u8]) -> io::Result { diff --git a/mod.rs b/mod.rs index c0570ae..f10d775 100644 --- a/mod.rs +++ b/mod.rs @@ -257,48 +257,37 @@ //! [`Result`]: ../result/enum.Result.html //! [`.unwrap()`]: ../result/enum.Result.html#method.unwrap -#![stable(feature = "rust1", since = "1.0.0")] - -use cmp; -use fmt; -use slice; -use str; -use memchr; -use ptr; - -#[stable(feature = "rust1", since = "1.0.0")] -pub use self::buffered::{BufReader, BufWriter, LineWriter}; -#[stable(feature = "rust1", since = "1.0.0")] -pub use self::buffered::IntoInnerError; -#[stable(feature = "rust1", since = "1.0.0")] +use core::cmp; +use core::fmt; +#[cfg(feature="collections")] use collections::string::String; +use core::str; +#[cfg(feature="collections")] use collections::vec::Vec; +#[cfg(not(core_memchr))] +mod memchr; +#[cfg(all(feature="collections",core_memchr))] +use core::slice::memchr; +use core::slice; +use core::ptr; + +#[cfg(feature="collections")] pub use self::buffered::{BufReader, BufWriter, LineWriter}; +#[cfg(feature="collections")] pub use self::buffered::IntoInnerError; pub use self::cursor::Cursor; -#[stable(feature = "rust1", since = "1.0.0")] pub use self::error::{Result, Error, ErrorKind}; -#[stable(feature = "rust1", since = "1.0.0")] pub use self::util::{copy, sink, Sink, empty, Empty, repeat, Repeat}; -#[stable(feature = "rust1", since = "1.0.0")] -pub use self::stdio::{stdin, stdout, stderr, Stdin, Stdout, Stderr}; -#[stable(feature = "rust1", since = "1.0.0")] -pub use self::stdio::{StdoutLock, StderrLock, StdinLock}; -#[unstable(feature = "print_internals", issue = "0")] -pub use self::stdio::{_print, _eprint}; -#[unstable(feature = "libstd_io_internals", issue = "42788")] -#[doc(no_inline, hidden)] -pub use self::stdio::{set_panic, set_print}; pub mod prelude; -mod buffered; +#[cfg(feature="collections")] mod buffered; mod cursor; mod error; mod impls; -mod lazy; mod util; -mod stdio; -const DEFAULT_BUF_SIZE: usize = ::sys_common::io::DEFAULT_BUF_SIZE; +const DEFAULT_BUF_SIZE: usize = 8 * 1024; +#[cfg(feature="collections")] struct Guard<'a> { buf: &'a mut Vec, len: usize } +#[cfg(feature="collections")] impl<'a> Drop for Guard<'a> { fn drop(&mut self) { unsafe { self.buf.set_len(self.len); } @@ -323,6 +312,7 @@ impl<'a> Drop for Guard<'a> { // 2. We're passing a raw buffer to the function `f`, and it is expected that // the function only *appends* bytes to the buffer. We'll get undefined // behavior if existing bytes are overwritten to have non-UTF-8 data. +#[cfg(feature="collections")] fn append_to_string(buf: &mut String, f: F) -> Result where F: FnOnce(&mut Vec) -> Result { @@ -350,10 +340,12 @@ fn append_to_string(buf: &mut String, f: F) -> Result // // Because we're extending the buffer with uninitialized data for trusted // readers, we need to make sure to truncate that if any of this panics. +#[cfg(feature="collections")] fn read_to_end(r: &mut R, buf: &mut Vec) -> Result { read_to_end_with_reservation(r, buf, 32) } +#[cfg(feature="collections")] fn read_to_end_with_reservation(r: &mut R, buf: &mut Vec, reservation_size: usize) -> Result @@ -460,7 +452,6 @@ fn read_to_end_with_reservation(r: &mut R, /// [`BufReader`]: struct.BufReader.html /// [`&str`]: ../../std/primitive.str.html /// [slice]: ../../std/primitive.slice.html -#[stable(feature = "rust1", since = "1.0.0")] #[doc(spotlight)] pub trait Read { /// Pull some bytes from this source into the specified buffer, returning @@ -517,7 +508,6 @@ pub trait Read { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn read(&mut self, buf: &mut [u8]) -> Result; /// Determines if this `Read`er can work with buffers of uninitialized @@ -542,7 +532,6 @@ pub trait Read { /// /// [`Initializer::nop()`]: ../../std/io/struct.Initializer.html#method.nop /// [`Initializer`]: ../../std/io/struct.Initializer.html - #[unstable(feature = "read_initializer", issue = "42788")] #[inline] unsafe fn initializer(&self) -> Initializer { Initializer::zeroing() @@ -595,7 +584,7 @@ pub trait Read { /// file.) /// /// [`std::fs::read`]: ../fs/fn.read.html - #[stable(feature = "rust1", since = "1.0.0")] + #[cfg(feature="collections")] fn read_to_end(&mut self, buf: &mut Vec) -> Result { read_to_end(self, buf) } @@ -638,7 +627,7 @@ pub trait Read { /// reading from a file.) /// /// [`std::fs::read_to_string`]: ../fs/fn.read_to_string.html - #[stable(feature = "rust1", since = "1.0.0")] + #[cfg(feature="collections")] fn read_to_string(&mut self, buf: &mut String) -> Result { // Note that we do *not* call `.read_to_end()` here. We are passing // `&mut Vec` (the raw contents of `buf`) into the `read_to_end` @@ -701,7 +690,6 @@ pub trait Read { /// Ok(()) /// } /// ``` - #[stable(feature = "read_exact", since = "1.6.0")] fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<()> { while !buf.is_empty() { match self.read(buf) { @@ -753,7 +741,6 @@ pub trait Read { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn by_ref(&mut self) -> &mut Self where Self: Sized { self } /// Transforms this `Read` instance to an [`Iterator`] over its bytes. @@ -790,7 +777,6 @@ pub trait Read { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn bytes(self) -> Bytes where Self: Sized { Bytes { inner: self } } @@ -825,7 +811,6 @@ pub trait Read { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn chain(self, next: R) -> Chain where Self: Sized { Chain { first: self, second: next, done_first: false } } @@ -861,20 +846,17 @@ pub trait Read { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn take(self, limit: u64) -> Take where Self: Sized { Take { inner: self, limit: limit } } } /// A type used to conditionally initialize buffers passed to `Read` methods. -#[unstable(feature = "read_initializer", issue = "42788")] #[derive(Debug)] pub struct Initializer(bool); impl Initializer { /// Returns a new `Initializer` which will zero out buffers. - #[unstable(feature = "read_initializer", issue = "42788")] #[inline] pub fn zeroing() -> Initializer { Initializer(true) @@ -888,21 +870,18 @@ impl Initializer { /// read from buffers passed to `Read` methods, and that the return value of /// the method accurately reflects the number of bytes that have been /// written to the head of the buffer. - #[unstable(feature = "read_initializer", issue = "42788")] #[inline] pub unsafe fn nop() -> Initializer { Initializer(false) } /// Indicates if a buffer should be initialized. - #[unstable(feature = "read_initializer", issue = "42788")] #[inline] pub fn should_initialize(&self) -> bool { self.0 } /// Initializes a buffer if necessary. - #[unstable(feature = "read_initializer", issue = "42788")] #[inline] pub fn initialize(&self, buf: &mut [u8]) { if self.should_initialize() { @@ -945,7 +924,6 @@ impl Initializer { /// Ok(()) /// } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] #[doc(spotlight)] pub trait Write { /// Write a buffer into this writer, returning how many bytes were written. @@ -994,7 +972,6 @@ pub trait Write { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn write(&mut self, buf: &[u8]) -> Result; /// Flush this output stream, ensuring that all intermediately buffered @@ -1020,7 +997,6 @@ pub trait Write { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn flush(&mut self) -> Result<()>; /// Attempts to write an entire buffer into this writer. @@ -1053,7 +1029,6 @@ pub trait Write { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn write_all(&mut self, mut buf: &[u8]) -> Result<()> { while !buf.is_empty() { match self.write(buf) { @@ -1105,7 +1080,6 @@ pub trait Write { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()> { // Create a shim which translates a Write to a fmt::Write and saves // off I/O errors. instead of discarding them @@ -1161,7 +1135,6 @@ pub trait Write { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn by_ref(&mut self) -> &mut Self where Self: Sized { self } } @@ -1191,7 +1164,6 @@ pub trait Write { /// Ok(()) /// } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub trait Seek { /// Seek to an offset, in bytes, in a stream. /// @@ -1207,7 +1179,6 @@ pub trait Seek { /// Seeking to a negative offset is considered an error. /// /// [`SeekFrom::Start`]: enum.SeekFrom.html#variant.Start - #[stable(feature = "rust1", since = "1.0.0")] fn seek(&mut self, pos: SeekFrom) -> Result; } @@ -1217,29 +1188,26 @@ pub trait Seek { /// /// [`Seek`]: trait.Seek.html #[derive(Copy, PartialEq, Eq, Clone, Debug)] -#[stable(feature = "rust1", since = "1.0.0")] pub enum SeekFrom { /// Sets the offset to the provided number of bytes. - #[stable(feature = "rust1", since = "1.0.0")] - Start(#[stable(feature = "rust1", since = "1.0.0")] u64), + Start(u64), /// Sets the offset to the size of this object plus the specified number of /// bytes. /// /// It is possible to seek beyond the end of an object, but it's an error to /// seek before byte 0. - #[stable(feature = "rust1", since = "1.0.0")] - End(#[stable(feature = "rust1", since = "1.0.0")] i64), + End(i64), /// Sets the offset to the current position plus the specified number of /// bytes. /// /// It is possible to seek beyond the end of an object, but it's an error to /// seek before byte 0. - #[stable(feature = "rust1", since = "1.0.0")] - Current(#[stable(feature = "rust1", since = "1.0.0")] i64), + Current(i64), } +#[cfg(feature="collections")] fn read_until(r: &mut R, delim: u8, buf: &mut Vec) -> Result { let mut read = 0; @@ -1319,7 +1287,7 @@ fn read_until(r: &mut R, delim: u8, buf: &mut Vec) /// } /// ``` /// -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="collections")] pub trait BufRead: Read { /// Returns the contents of the internal buffer, filling it with more data /// from the inner reader if it is empty. @@ -1365,7 +1333,6 @@ pub trait BufRead: Read { /// // ensure the bytes we worked with aren't returned again later /// stdin.consume(length); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn fill_buf(&mut self) -> Result<&[u8]>; /// Tells this buffer that `amt` bytes have been consumed from the buffer, @@ -1387,7 +1354,6 @@ pub trait BufRead: Read { /// that method's example includes an example of `consume()`. /// /// [`fill_buf`]: #tymethod.fill_buf - #[stable(feature = "rust1", since = "1.0.0")] fn consume(&mut self, amt: usize); /// Read all bytes into `buf` until the delimiter `byte` or EOF is reached. @@ -1443,7 +1409,6 @@ pub trait BufRead: Read { /// assert_eq!(num_bytes, 0); /// assert_eq!(buf, b""); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn read_until(&mut self, byte: u8, buf: &mut Vec) -> Result { read_until(self, byte, buf) } @@ -1502,7 +1467,6 @@ pub trait BufRead: Read { /// assert_eq!(num_bytes, 0); /// assert_eq!(buf, ""); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn read_line(&mut self, buf: &mut String) -> Result { // Note that we are not calling the `.read_until` method here, but // rather our hardcoded implementation. For more details as to why, see @@ -1543,7 +1507,6 @@ pub trait BufRead: Read { /// assert_eq!(split_iter.next(), Some(b"dolor".to_vec())); /// assert_eq!(split_iter.next(), None); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn split(self, byte: u8) -> Split where Self: Sized { Split { buf: self, delim: byte } } @@ -1582,7 +1545,6 @@ pub trait BufRead: Read { /// Each line of the iterator has the same error semantics as [`BufRead::read_line`]. /// /// [`BufRead::read_line`]: trait.BufRead.html#method.read_line - #[stable(feature = "rust1", since = "1.0.0")] fn lines(self) -> Lines where Self: Sized { Lines { buf: self } } @@ -1594,7 +1556,6 @@ pub trait BufRead: Read { /// Please see the documentation of [`chain`] for more details. /// /// [`chain`]: trait.Read.html#method.chain -#[stable(feature = "rust1", since = "1.0.0")] pub struct Chain { first: T, second: U, @@ -1620,7 +1581,6 @@ impl Chain { /// Ok(()) /// } /// ``` - #[stable(feature = "more_io_inner_methods", since = "1.20.0")] pub fn into_inner(self) -> (T, U) { (self.first, self.second) } @@ -1643,7 +1603,6 @@ impl Chain { /// Ok(()) /// } /// ``` - #[stable(feature = "more_io_inner_methods", since = "1.20.0")] pub fn get_ref(&self) -> (&T, &U) { (&self.first, &self.second) } @@ -1670,13 +1629,11 @@ impl Chain { /// Ok(()) /// } /// ``` - #[stable(feature = "more_io_inner_methods", since = "1.20.0")] pub fn get_mut(&mut self) -> (&mut T, &mut U) { (&mut self.first, &mut self.second) } } -#[stable(feature = "std_debug", since = "1.16.0")] impl fmt::Debug for Chain { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_struct("Chain") @@ -1686,7 +1643,6 @@ impl fmt::Debug for Chain { } } -#[stable(feature = "rust1", since = "1.0.0")] impl Read for Chain { fn read(&mut self, buf: &mut [u8]) -> Result { if !self.done_first { @@ -1708,7 +1664,7 @@ impl Read for Chain { } } -#[stable(feature = "chain_bufread", since = "1.9.0")] +#[cfg(feature="collections")] impl BufRead for Chain { fn fill_buf(&mut self) -> Result<&[u8]> { if !self.done_first { @@ -1735,7 +1691,6 @@ impl BufRead for Chain { /// Please see the documentation of [`take`] for more details. /// /// [`take`]: trait.Read.html#method.take -#[stable(feature = "rust1", since = "1.0.0")] #[derive(Debug)] pub struct Take { inner: T, @@ -1770,7 +1725,6 @@ impl Take { /// Ok(()) /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn limit(&self) -> u64 { self.limit } /// Sets the number of bytes that can be read before this instance will @@ -1796,7 +1750,6 @@ impl Take { /// Ok(()) /// } /// ``` - #[stable(feature = "take_set_limit", since = "1.27.0")] pub fn set_limit(&mut self, limit: u64) { self.limit = limit; } @@ -1821,7 +1774,6 @@ impl Take { /// Ok(()) /// } /// ``` - #[stable(feature = "io_take_into_inner", since = "1.15.0")] pub fn into_inner(self) -> T { self.inner } @@ -1846,7 +1798,6 @@ impl Take { /// Ok(()) /// } /// ``` - #[stable(feature = "more_io_inner_methods", since = "1.20.0")] pub fn get_ref(&self) -> &T { &self.inner } @@ -1875,13 +1826,11 @@ impl Take { /// Ok(()) /// } /// ``` - #[stable(feature = "more_io_inner_methods", since = "1.20.0")] pub fn get_mut(&mut self) -> &mut T { &mut self.inner } } -#[stable(feature = "rust1", since = "1.0.0")] impl Read for Take { fn read(&mut self, buf: &mut [u8]) -> Result { // Don't call into inner reader at all at EOF because it may still block @@ -1899,6 +1848,7 @@ impl Read for Take { self.inner.initializer() } + #[cfg(feature="collections")] fn read_to_end(&mut self, buf: &mut Vec) -> Result { let reservation_size = cmp::min(self.limit, 32) as usize; @@ -1906,7 +1856,7 @@ impl Read for Take { } } -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="collections")] impl BufRead for Take { fn fill_buf(&mut self) -> Result<&[u8]> { // Don't call into inner reader at all at EOF because it may still block @@ -1933,13 +1883,11 @@ impl BufRead for Take { /// Please see the documentation of [`bytes`] for more details. /// /// [`bytes`]: trait.Read.html#method.bytes -#[stable(feature = "rust1", since = "1.0.0")] #[derive(Debug)] pub struct Bytes { inner: R, } -#[stable(feature = "rust1", since = "1.0.0")] impl Iterator for Bytes { type Item = Result; @@ -1963,14 +1911,14 @@ impl Iterator for Bytes { /// `BufRead`. Please see the documentation of `split()` for more details. /// /// [split]: trait.BufRead.html#method.split -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="collections")] #[derive(Debug)] pub struct Split { buf: B, delim: u8, } -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="collections")] impl Iterator for Split { type Item = Result>; @@ -1995,13 +1943,13 @@ impl Iterator for Split { /// `BufRead`. Please see the documentation of `lines()` for more details. /// /// [lines]: trait.BufRead.html#method.lines -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="collections")] #[derive(Debug)] pub struct Lines { buf: B, } -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="collections")] impl Iterator for Lines { type Item = Result; diff --git a/prelude.rs b/prelude.rs index 2e19edf..66294a3 100644 --- a/prelude.rs +++ b/prelude.rs @@ -8,7 +8,8 @@ //! use std::io::prelude::*; //! ``` -#![stable(feature = "rust1", since = "1.0.0")] +pub use super::{Read, Write, Seek}; +#[cfg(feature="collections")] pub use super::BufRead; -#[stable(feature = "rust1", since = "1.0.0")] -pub use super::{Read, Write, BufRead, Seek}; +#[cfg(feature="collections")] pub use alloc::boxed::Box; +#[cfg(feature="collections")] pub use collections::vec::Vec; diff --git a/util.rs b/util.rs index 8df961a..2b08122 100644 --- a/util.rs +++ b/util.rs @@ -1,8 +1,9 @@ #![allow(missing_copy_implementations)] -use fmt; -use io::{self, Read, Initializer, Write, ErrorKind, BufRead}; -use mem; +use core::fmt; +use io::{self, Read, Initializer, Write, ErrorKind}; +#[cfg(feature="collections")] use io::BufRead; +use core::mem; /// Copies the entire contents of a reader into a writer. /// @@ -39,7 +40,6 @@ use mem; /// Ok(()) /// } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub fn copy(reader: &mut R, writer: &mut W) -> io::Result where R: Read, W: Write { @@ -68,7 +68,6 @@ pub fn copy(reader: &mut R, writer: &mut W) -> io::Result< /// the documentation of [`empty()`][`empty`] for more details. /// /// [`empty`]: fn.empty.html -#[stable(feature = "rust1", since = "1.0.0")] pub struct Empty { _priv: () } /// Constructs a new handle to an empty reader. @@ -88,10 +87,8 @@ pub struct Empty { _priv: () } /// io::empty().read_to_string(&mut buffer).unwrap(); /// assert!(buffer.is_empty()); /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub fn empty() -> Empty { Empty { _priv: () } } -#[stable(feature = "rust1", since = "1.0.0")] impl Read for Empty { #[inline] fn read(&mut self, _buf: &mut [u8]) -> io::Result { Ok(0) } @@ -101,7 +98,8 @@ impl Read for Empty { Initializer::nop() } } -#[stable(feature = "rust1", since = "1.0.0")] + +#[cfg(feature="collections")] impl BufRead for Empty { #[inline] fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(&[]) } @@ -109,7 +107,6 @@ impl BufRead for Empty { fn consume(&mut self, _n: usize) {} } -#[stable(feature = "std_debug", since = "1.16.0")] impl fmt::Debug for Empty { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.pad("Empty { .. }") @@ -122,7 +119,6 @@ impl fmt::Debug for Empty { /// see the documentation of `repeat()` for more details. /// /// [repeat]: fn.repeat.html -#[stable(feature = "rust1", since = "1.0.0")] pub struct Repeat { byte: u8 } /// Creates an instance of a reader that infinitely repeats one byte. @@ -139,10 +135,8 @@ pub struct Repeat { byte: u8 } /// io::repeat(0b101).read_exact(&mut buffer).unwrap(); /// assert_eq!(buffer, [0b101, 0b101, 0b101]); /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub fn repeat(byte: u8) -> Repeat { Repeat { byte } } -#[stable(feature = "rust1", since = "1.0.0")] impl Read for Repeat { #[inline] fn read(&mut self, buf: &mut [u8]) -> io::Result { @@ -158,7 +152,6 @@ impl Read for Repeat { } } -#[stable(feature = "std_debug", since = "1.16.0")] impl fmt::Debug for Repeat { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.pad("Repeat { .. }") @@ -171,7 +164,6 @@ impl fmt::Debug for Repeat { /// see the documentation of `sink()` for more details. /// /// [sink]: fn.sink.html -#[stable(feature = "rust1", since = "1.0.0")] pub struct Sink { _priv: () } /// Creates an instance of a writer which will successfully consume all data. @@ -188,10 +180,8 @@ pub struct Sink { _priv: () } /// let num_bytes = io::sink().write(&buffer).unwrap(); /// assert_eq!(num_bytes, 5); /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub fn sink() -> Sink { Sink { _priv: () } } -#[stable(feature = "rust1", since = "1.0.0")] impl Write for Sink { #[inline] fn write(&mut self, buf: &[u8]) -> io::Result { Ok(buf.len()) } @@ -199,7 +189,6 @@ impl Write for Sink { fn flush(&mut self) -> io::Result<()> { Ok(()) } } -#[stable(feature = "std_debug", since = "1.16.0")] impl fmt::Debug for Sink { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.pad("Sink { .. }")