diff --git a/buffered.rs b/buffered.rs index ccebf36..17e6955 100644 --- a/buffered.rs +++ b/buffered.rs @@ -10,15 +10,13 @@ //! Buffering wrappers for I/O traits -use prelude::v1::*; +use core::prelude::v1::*; use io::prelude::*; -use marker::Reflect; -use cmp; -use error; -use fmt; +use core::cmp; +use core::fmt; use io::{self, DEFAULT_BUF_SIZE, Error, ErrorKind, SeekFrom}; -use memchr; +use io::memchr; /// The `BufReader` struct adds buffering to any reader. /// @@ -44,7 +42,6 @@ use memchr; /// # Ok(()) /// # } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub struct BufReader { inner: R, buf: Box<[u8]>, @@ -67,7 +64,6 @@ impl BufReader { /// # Ok(()) /// # } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn new(inner: R) -> BufReader { BufReader::with_capacity(DEFAULT_BUF_SIZE, inner) } @@ -88,7 +84,6 @@ impl BufReader { /// # Ok(()) /// # } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn with_capacity(cap: usize, inner: R) -> BufReader { BufReader { inner: inner, @@ -116,7 +111,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. @@ -137,7 +131,6 @@ impl BufReader { /// # Ok(()) /// # } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn get_mut(&mut self) -> &mut R { &mut self.inner } /// Unwraps this `BufReader`, returning the underlying reader. @@ -158,11 +151,9 @@ impl BufReader { /// # Ok(()) /// # } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] pub fn into_inner(self) -> R { self.inner } } -#[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 @@ -180,7 +171,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 @@ -197,7 +187,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") @@ -207,7 +196,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. /// @@ -296,7 +284,6 @@ impl Seek for BufReader { /// By wrapping the stream with a `BufWriter`, these ten writes are all grouped /// together by the buffer, and will all be written out in one system call when /// the `stream` is dropped. -#[stable(feature = "rust1", since = "1.0.0")] pub struct BufWriter { inner: Option, buf: Vec, @@ -331,7 +318,6 @@ pub struct BufWriter { /// }; /// ``` #[derive(Debug)] -#[stable(feature = "rust1", since = "1.0.0")] pub struct IntoInnerError(W, Error); impl BufWriter { @@ -345,7 +331,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) } @@ -363,7 +348,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), @@ -412,7 +396,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. @@ -430,7 +413,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() } /// Unwraps this `BufWriter`, returning the underlying writer. @@ -448,7 +430,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)), @@ -457,7 +438,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() { @@ -478,7 +458,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") @@ -488,7 +467,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. /// @@ -498,7 +476,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 { @@ -537,7 +514,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. @@ -570,23 +546,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) @@ -641,7 +607,6 @@ impl fmt::Display for IntoInnerError { /// # Ok(()) /// # } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub struct LineWriter { inner: BufWriter, } @@ -661,7 +626,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) @@ -682,7 +646,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) } } @@ -703,7 +666,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. @@ -726,7 +688,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. @@ -748,7 +709,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 { inner: buf }, e) @@ -756,7 +716,6 @@ impl LineWriter { } } -#[stable(feature = "rust1", since = "1.0.0")] impl Write for LineWriter { fn write(&mut self, buf: &[u8]) -> io::Result { match memchr::memrchr(b'\n', buf) { @@ -773,7 +732,6 @@ impl Write for LineWriter { fn flush(&mut self) -> io::Result<()> { self.inner.flush() } } -#[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 420fede..d4242f7 100644 --- a/cursor.rs +++ b/cursor.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use prelude::v1::*; +use core::prelude::v1::*; use io::prelude::*; -use cmp; +use core::cmp; use io::{self, SeekFrom, Error, ErrorKind}; /// A `Cursor` wraps another type and provides it with a @@ -73,7 +73,6 @@ use io::{self, 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, @@ -92,7 +91,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 } } @@ -110,7 +108,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. @@ -126,7 +123,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. @@ -145,7 +141,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. @@ -167,7 +162,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. @@ -187,11 +181,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 pos = match style { @@ -210,25 +202,27 @@ 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 = try!(Read::read(&mut try!(self.fill_buf()), buf)); + let n = try!(Read::read(&mut try!(self.get_buf()), buf)); self.pos += n as u64; Ok(n) } } -#[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; } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a> Write for Cursor<&'a mut [u8]> { fn write(&mut self, data: &[u8]) -> io::Result { let pos = cmp::min(self.pos, self.inner.len() as u64); @@ -239,7 +233,7 @@ impl<'a> Write for Cursor<&'a mut [u8]> { 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 { // Make sure the internal buffer is as least as big as where we @@ -267,8 +261,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]>> { fn write(&mut self, buf: &[u8]) -> io::Result { let pos = cmp::min(self.pos, self.inner.len() as u64); let amt = try!((&mut self.inner[(pos as usize)..]).write(buf)); diff --git a/error.rs b/error.rs index e3f17c8..50e3658 100644 --- a/error.rs +++ b/error.rs @@ -8,14 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use boxed::Box; -use convert::Into; -use error; -use fmt; -use marker::{Send, Sync}; -use option::Option::{self, Some, None}; -use result; -use sys; +#[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; /// A specialized [`Result`](../result/enum.Result.html) type for I/O /// operations. @@ -47,7 +48,6 @@ use sys; /// 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 @@ -57,20 +57,22 @@ pub type Result = result::Result; /// `Error` can be created with crafted error messages and a particular value of /// `ErrorKind`. #[derive(Debug)] -#[stable(feature = "rust1", since = "1.0.0")] pub struct Error { repr: Repr, } enum Repr { Os(i32), + #[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. @@ -78,47 +80,34 @@ struct Custom { /// This list is intended to grow over time and it is not recommended to /// exhaustively match against it. #[derive(Copy, PartialEq, Eq, Clone, Debug)] -#[stable(feature = "rust1", since = "1.0.0")] #[allow(deprecated)] 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. /// @@ -128,10 +117,8 @@ pub enum ErrorKind { /// /// For example, a function that reads a file into a string will error with /// `InvalidData` if the file's contents are not valid UTF-8. - #[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)`. @@ -139,21 +126,15 @@ pub enum ErrorKind { /// This typically means that an operation could only succeed if it wrote a /// particular number of bytes but only a smaller number of bytes could be /// written. - #[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, #[allow(missing_docs)] - #[unstable(feature = "read_exact_old", reason = "recently added", - issue = "0")] - #[rustc_deprecated(since = "1.6.0", reason = "renamed to UnexpectedEof")] UnexpectedEOF, /// An error returned when an operation could not be completed because an @@ -162,14 +143,9 @@ 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, /// Any I/O error not part of this list. - #[unstable(feature = "io_error_internals", - reason = "better expressed through extensible enums that this \ - enum cannot be exhaustively matched against", - issue = "0")] #[doc(hidden)] __Nonexhaustive, } @@ -193,14 +169,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: kind, @@ -209,18 +184,7 @@ 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. - #[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. - #[stable(feature = "rust1", since = "1.0.0")] pub fn from_raw_os_error(code: i32) -> Error { Error { repr: Repr::Os(code) } } @@ -230,7 +194,6 @@ impl Error { /// If this `Error` was constructed via `last_os_error` or /// `from_raw_os_error`, then this function will return `Some`, otherwise /// it will return `None`. - #[stable(feature = "rust1", since = "1.0.0")] pub fn raw_os_error(&self) -> Option { match self.repr { Repr::Os(i) => Some(i), @@ -242,11 +205,10 @@ impl Error { /// /// If this `Error` was constructed via `new` then this function will /// return `Some`, otherwise it will return `None`. - #[stable(feature = "io_error_inner", since = "1.3.0")] - pub fn get_ref(&self) -> Option<&(error::Error+Send+Sync+'static)> { + pub fn get_ref(&self) -> Option<&String> { match self.repr { Repr::Os(..) => None, - Repr::Custom(ref c) => Some(&*c.error), + Repr::Custom(ref c) => Some(&c.error), } } @@ -255,11 +217,10 @@ impl Error { /// /// If this `Error` was constructed via `new` then this function will /// return `Some`, otherwise it will return `None`. - #[stable(feature = "io_error_inner", since = "1.3.0")] - pub fn get_mut(&mut self) -> Option<&mut (error::Error+Send+Sync+'static)> { + pub fn get_mut(&mut self) -> Option<&mut String> { match self.repr { Repr::Os(..) => None, - Repr::Custom(ref mut c) => Some(&mut *c.error), + Repr::Custom(ref mut c) => Some(&mut c.error), } } @@ -267,8 +228,7 @@ impl Error { /// /// If this `Error` was constructed via `new` then this function will /// return `Some`, otherwise it will return `None`. - #[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::Custom(c) => Some(c.error) @@ -276,10 +236,9 @@ impl Error { } /// Returns the corresponding `ErrorKind` for this error. - #[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, } } @@ -289,65 +248,23 @@ impl fmt::Debug for Repr { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { match *self { Repr::Os(ref code) => - fmt.debug_struct("Os").field("code", code) - .field("message", &sys::os::error_string(*code)).finish(), + fmt.debug_struct("Os").field("code", code).finish(), Repr::Custom(ref c) => fmt.debug_tuple("Custom").field(c).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), } } } -#[stable(feature = "rust1", since = "1.0.0")] -impl error::Error for Error { - #[allow(deprecated)] // remove with UnexpectedEOF - fn description(&self) -> &str { - match self.repr { - Repr::Os(..) => match self.kind() { - ErrorKind::NotFound => "entity not found", - ErrorKind::PermissionDenied => "permission denied", - ErrorKind::ConnectionRefused => "connection refused", - ErrorKind::ConnectionReset => "connection reset", - ErrorKind::ConnectionAborted => "connection aborted", - ErrorKind::NotConnected => "not connected", - ErrorKind::AddrInUse => "address in use", - ErrorKind::AddrNotAvailable => "address not available", - ErrorKind::BrokenPipe => "broken pipe", - ErrorKind::AlreadyExists => "entity already exists", - ErrorKind::WouldBlock => "operation would block", - ErrorKind::InvalidInput => "invalid input parameter", - ErrorKind::InvalidData => "invalid data", - ErrorKind::TimedOut => "timed out", - ErrorKind::WriteZero => "write zero", - ErrorKind::Interrupted => "operation interrupted", - ErrorKind::Other => "other os error", - ErrorKind::UnexpectedEOF => "unexpected end of file", - ErrorKind::UnexpectedEof => "unexpected end of file", - ErrorKind::__Nonexhaustive => unreachable!() - }, - Repr::Custom(ref c) => c.error.description(), - } - } - - fn cause(&self) -> Option<&error::Error> { - match self.repr { - Repr::Os(..) => 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 ec63f14..ac172bf 100644 --- a/impls.rs +++ b/impls.rs @@ -8,29 +8,31 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use boxed::Box; -use cmp; -use io::{self, SeekFrom, Read, Write, Seek, BufRead, Error, ErrorKind}; -use fmt; -use mem; -use string::String; -use vec::Vec; +#[cfg(feature="alloc")] use alloc::boxed::Box; +use core::cmp; +use io::{self, SeekFrom, Read, 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 { (**self).read(buf) } + #[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) @@ -41,7 +43,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) } @@ -59,12 +60,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() } @@ -83,18 +83,20 @@ 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 { (**self).read(buf) } + #[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) @@ -105,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) } @@ -123,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() } @@ -150,7 +152,6 @@ impl BufRead for Box { // ============================================================================= // In-memory buffer implementations -#[stable(feature = "rust1", since = "1.0.0")] impl<'a> Read for &'a [u8] { #[inline] fn read(&mut self, buf: &mut [u8]) -> io::Result { @@ -174,7 +175,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) } @@ -183,7 +184,6 @@ impl<'a> BufRead for &'a [u8] { fn consume(&mut self, amt: usize) { *self = &self[amt..]; } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a> Write for &'a mut [u8] { #[inline] fn write(&mut self, data: &[u8]) -> io::Result { @@ -207,7 +207,7 @@ impl<'a> Write for &'a mut [u8] { fn flush(&mut self) -> io::Result<()> { Ok(()) } } -#[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/memchr.rs b/memchr.rs index 1d97611..110cfac 100644 --- a/memchr.rs +++ b/memchr.rs @@ -11,103 +11,12 @@ // Original implementation taken from rust-memchr // Copyright 2015 Andrew Gallant, bluss and Nicolas Koch - - -/// A safe interface to `memchr`. -/// -/// Returns the index corresponding to the first occurrence of `needle` in -/// `haystack`, or `None` if one is not found. -/// -/// memchr reduces to super-optimized machine code at around an order of -/// magnitude faster than `haystack.iter().position(|&b| b == needle)`. -/// (See benchmarks.) -/// -/// # Example -/// -/// This shows how to find the first position of a byte in a byte string. -/// -/// ```rust,ignore -/// use memchr::memchr; -/// -/// let haystack = b"the quick brown fox"; -/// assert_eq!(memchr(b'k', haystack), Some(8)); -/// ``` -pub fn memchr(needle: u8, haystack: &[u8]) -> Option { - // libc memchr - #[cfg(not(target_os = "windows"))] - fn memchr_specific(needle: u8, haystack: &[u8]) -> Option { - use libc; - - let p = unsafe { - libc::memchr( - haystack.as_ptr() as *const libc::c_void, - needle as libc::c_int, - haystack.len() as libc::size_t) - }; - if p.is_null() { - None - } else { - Some(p as usize - (haystack.as_ptr() as usize)) - } - } - - // use fallback on windows, since it's faster - #[cfg(target_os = "windows")] - fn memchr_specific(needle: u8, haystack: &[u8]) -> Option { - fallback::memchr(needle, haystack) - } - - memchr_specific(needle, haystack) -} - -/// A safe interface to `memrchr`. -/// -/// Returns the index corresponding to the last occurrence of `needle` in -/// `haystack`, or `None` if one is not found. -/// -/// # Example -/// -/// This shows how to find the last position of a byte in a byte string. -/// -/// ```rust,ignore -/// use memchr::memrchr; -/// -/// let haystack = b"the quick brown fox"; -/// assert_eq!(memrchr(b'o', haystack), Some(17)); -/// ``` -pub fn memrchr(needle: u8, haystack: &[u8]) -> Option { - - #[cfg(target_os = "linux")] - fn memrchr_specific(needle: u8, haystack: &[u8]) -> Option { - use libc; - - // GNU's memrchr() will - unlike memchr() - error if haystack is empty. - if haystack.is_empty() {return None} - let p = unsafe { - libc::memrchr( - haystack.as_ptr() as *const libc::c_void, - needle as libc::c_int, - haystack.len() as libc::size_t) - }; - if p.is_null() { - None - } else { - Some(p as usize - (haystack.as_ptr() as usize)) - } - } - - #[cfg(not(target_os = "linux"))] - fn memrchr_specific(needle: u8, haystack: &[u8]) -> Option { - fallback::memrchr(needle, haystack) - } - - memrchr_specific(needle, haystack) -} +pub use self::fallback::{memchr,memrchr}; #[allow(dead_code)] mod fallback { - use cmp; - use mem; + use core::cmp; + use core::mem; const LO_U64: u64 = 0x0101010101010101; const HI_U64: u64 = 0x8080808080808080; diff --git a/mod.rs b/mod.rs index 61334f3..26b9102 100644 --- a/mod.rs +++ b/mod.rs @@ -248,49 +248,32 @@ //! contract. The implementation of many of these functions are subject to change over //! time and may call fewer or more syscalls/library functions. -#![stable(feature = "rust1", since = "1.0.0")] - -use cmp; +use core::cmp; use rustc_unicode::str as core_str; -use error as std_error; -use fmt; -use iter::{Iterator}; -use marker::Sized; -use ops::{Drop, FnOnce}; -use option::Option::{self, Some, None}; -use result::Result::{Ok, Err}; -use result; -use string::String; -use str; -use vec::Vec; -use memchr; - -#[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::fmt; +use core::iter::{Iterator}; +use core::marker::Sized; +#[cfg(feature="collections")] use core::ops::{Drop, FnOnce}; +use core::option::Option::{self, Some, None}; +use core::result::Result::{Ok, Err}; +use core::result; +#[cfg(feature="collections")] use collections::string::String; +use core::str; +#[cfg(feature="collections")] use collections::vec::Vec; +mod memchr; + +#[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, _print, Stdin, Stdout, Stderr}; -#[stable(feature = "rust1", since = "1.0.0")] -pub use self::stdio::{StdoutLock, StderrLock, StdinLock}; -#[unstable(feature = "libstd_io_internals", issue = "0")] -#[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 = 64 * 1024; @@ -312,6 +295,7 @@ const DEFAULT_BUF_SIZE: usize = 64 * 1024; // 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 { @@ -343,6 +327,7 @@ fn append_to_string(buf: &mut String, f: F) -> Result // of data to return. Simply tacking on an extra DEFAULT_BUF_SIZE space every // time is 4,500 times (!) slower than this if the reader has a very small // amount of data to return. +#[cfg(feature="collections")] fn read_to_end(r: &mut R, buf: &mut Vec) -> Result { let start_len = buf.len(); let mut len = start_len; @@ -425,7 +410,6 @@ fn read_to_end(r: &mut R, buf: &mut Vec) -> Result /// # Ok(()) /// # } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub trait Read { /// Pull some bytes from this source into the specified buffer, returning /// how many bytes were read. @@ -475,7 +459,6 @@ pub trait Read { /// # Ok(()) /// # } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn read(&mut self, buf: &mut [u8]) -> Result; /// Read all bytes until EOF in this source, placing them into `buf`. @@ -517,7 +500,7 @@ pub trait Read { /// # Ok(()) /// # } /// ``` - #[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) } @@ -555,7 +538,7 @@ pub trait Read { /// # Ok(()) /// # } /// ``` - #[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` @@ -616,7 +599,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) { @@ -668,7 +650,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. @@ -698,7 +679,6 @@ pub trait Read { /// # Ok(()) /// # } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn bytes(self) -> Bytes where Self: Sized { Bytes { inner: self } } @@ -735,10 +715,6 @@ pub trait Read { /// # Ok(()) /// # } /// ``` - #[unstable(feature = "io", reason = "the semantics of a partial read/write \ - of where errors happen is currently \ - unclear and may change", - issue = "27802")] fn chars(self) -> Chars where Self: Sized { Chars { inner: self } } @@ -773,7 +749,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 } } @@ -807,7 +782,6 @@ 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 } } @@ -843,13 +817,6 @@ pub trait Read { /// # Ok(()) /// # } /// ``` - #[unstable(feature = "io", reason = "the semantics of a partial read/write \ - of where errors happen is currently \ - unclear and may change", - issue = "27802")] - #[rustc_deprecated(reason = "error handling semantics unclear and \ - don't seem to have an ergonomic resolution", - since = "1.6.0")] #[allow(deprecated)] fn tee(self, out: W) -> Tee where Self: Sized { Tee { reader: self, writer: out } @@ -886,7 +853,6 @@ pub trait Read { /// # Ok(()) /// # } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub trait Write { /// Write a buffer into this object, returning how many bytes were written. /// @@ -926,7 +892,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 @@ -952,7 +917,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 write. @@ -979,7 +943,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) { @@ -1031,7 +994,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 @@ -1087,7 +1049,6 @@ pub trait Write { /// # Ok(()) /// # } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn by_ref(&mut self) -> &mut Self where Self: Sized { self } /// Creates a new writer which will write all data to both this writer and @@ -1117,13 +1078,6 @@ pub trait Write { /// # Ok(()) /// # } /// ``` - #[unstable(feature = "io", reason = "the semantics of a partial read/write \ - of where errors happen is currently \ - unclear and may change", - issue = "27802")] - #[rustc_deprecated(reason = "error handling semantics unclear and \ - don't seem to have an ergonomic resolution", - since = "1.6.0")] #[allow(deprecated)] fn broadcast(self, other: W) -> Broadcast where Self: Sized @@ -1158,7 +1112,6 @@ pub trait Write { /// # Ok(()) /// # } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub trait Seek { /// Seek to an offset, in bytes, in a stream. /// @@ -1172,35 +1125,31 @@ pub trait Seek { /// # Errors /// /// Seeking to a negative offset is considered an error. - #[stable(feature = "rust1", since = "1.0.0")] fn seek(&mut self, pos: SeekFrom) -> Result; } /// Enumeration of possible methods to seek within an I/O object. #[derive(Copy, PartialEq, Eq, Clone, Debug)] -#[stable(feature = "rust1", since = "1.0.0")] pub enum SeekFrom { /// Set 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), /// Set 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), /// Set 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; @@ -1280,7 +1229,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 { /// Fills the internal buffer of this object, returning the buffer contents. /// @@ -1325,7 +1274,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, @@ -1347,7 +1295,6 @@ pub trait BufRead: Read { /// /// Since `consume()` is meant to be used with [`fill_buf()`][fillbuf], /// that method's example includes an example of `consume()`. - #[stable(feature = "rust1", since = "1.0.0")] fn consume(&mut self, amt: usize); /// Read all bytes into `buf` until the delimiter `byte` is reached. @@ -1388,7 +1335,6 @@ pub trait BufRead: Read { /// # Ok(()) /// # } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn read_until(&mut self, byte: u8, buf: &mut Vec) -> Result { read_until(self, byte, buf) } @@ -1436,7 +1382,6 @@ pub trait BufRead: Read { /// buffer.clear(); /// } /// ``` - #[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 @@ -1469,7 +1414,6 @@ pub trait BufRead: Read { /// println!("{:?}", content.unwrap()); /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn split(self, byte: u8) -> Split where Self: Sized { Split { buf: self, delim: byte } } @@ -1494,7 +1438,6 @@ pub trait BufRead: Read { /// println!("{}", line.unwrap()); /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] fn lines(self) -> Lines where Self: Sized { Lines { buf: self } } @@ -1506,21 +1449,11 @@ pub trait BufRead: Read { /// writer. Please see the documentation of `broadcast()` for more details. /// /// [broadcast]: trait.Write.html#method.broadcast -#[unstable(feature = "io", reason = "awaiting stability of Write::broadcast", - issue = "27802")] -#[rustc_deprecated(reason = "error handling semantics unclear and \ - don't seem to have an ergonomic resolution", - since = "1.6.0")] pub struct Broadcast { first: T, second: U, } -#[unstable(feature = "io", reason = "awaiting stability of Write::broadcast", - issue = "27802")] -#[rustc_deprecated(reason = "error handling semantics unclear and \ - don't seem to have an ergonomic resolution", - since = "1.6.0")] #[allow(deprecated)] impl Write for Broadcast { fn write(&mut self, data: &[u8]) -> Result { @@ -1541,14 +1474,12 @@ impl Write for Broadcast { /// 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, done_first: bool, } -#[stable(feature = "rust1", since = "1.0.0")] impl Read for Chain { fn read(&mut self, buf: &mut [u8]) -> Result { if !self.done_first { @@ -1567,7 +1498,6 @@ impl Read for Chain { /// Please see the documentation of `take()` for more details. /// /// [take]: trait.Read.html#method.take -#[stable(feature = "rust1", since = "1.0.0")] pub struct Take { inner: T, limit: u64, @@ -1581,11 +1511,9 @@ impl Take { /// /// This instance may reach EOF after reading fewer bytes than indicated by /// this method if the underlying `Read` instance reaches EOF. - #[stable(feature = "rust1", since = "1.0.0")] pub fn limit(&self) -> u64 { self.limit } } -#[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 @@ -1600,7 +1528,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]> { let buf = try!(self.inner.fill_buf()); @@ -1622,21 +1550,11 @@ impl BufRead for Take { /// Please see the documentation of `tee()` for more details. /// /// [tee]: trait.Read.html#method.tee -#[unstable(feature = "io", reason = "awaiting stability of Read::tee", - issue = "27802")] -#[rustc_deprecated(reason = "error handling semantics unclear and \ - don't seem to have an ergonomic resolution", - since = "1.6.0")] pub struct Tee { reader: R, writer: W, } -#[unstable(feature = "io", reason = "awaiting stability of Read::tee", - issue = "27802")] -#[rustc_deprecated(reason = "error handling semantics unclear and \ - don't seem to have an ergonomic resolution", - since = "1.6.0")] #[allow(deprecated)] impl Read for Tee { fn read(&mut self, buf: &mut [u8]) -> Result { @@ -1653,12 +1571,10 @@ impl Read for Tee { /// Please see the documentation of `bytes()` for more details. /// /// [bytes]: trait.Read.html#method.bytes -#[stable(feature = "rust1", since = "1.0.0")] pub struct Bytes { inner: R, } -#[stable(feature = "rust1", since = "1.0.0")] impl Iterator for Bytes { type Item = Result; @@ -1678,8 +1594,6 @@ impl Iterator for Bytes { /// Please see the documentation of `chars()` for more details. /// /// [chars]: trait.Read.html#method.chars -#[unstable(feature = "io", reason = "awaiting stability of Read::chars", - issue = "27802")] pub struct Chars { inner: R, } @@ -1687,8 +1601,6 @@ pub struct Chars { /// An enumeration of possible errors that can be generated from the `Chars` /// adapter. #[derive(Debug)] -#[unstable(feature = "io", reason = "awaiting stability of Read::chars", - issue = "27802")] pub enum CharsError { /// Variant representing that the underlying stream was read successfully /// but it did not contain valid utf8 data. @@ -1698,8 +1610,6 @@ pub enum CharsError { Other(Error), } -#[unstable(feature = "io", reason = "awaiting stability of Read::chars", - issue = "27802")] impl Iterator for Chars { type Item = result::Result; @@ -1731,25 +1641,6 @@ impl Iterator for Chars { } } -#[unstable(feature = "io", reason = "awaiting stability of Read::chars", - issue = "27802")] -impl std_error::Error for CharsError { - fn description(&self) -> &str { - match *self { - CharsError::NotUtf8 => "invalid utf8 encoding", - CharsError::Other(ref e) => std_error::Error::description(e), - } - } - fn cause(&self) -> Option<&std_error::Error> { - match *self { - CharsError::NotUtf8 => None, - CharsError::Other(ref e) => e.cause(), - } - } -} - -#[unstable(feature = "io", reason = "awaiting stability of Read::chars", - issue = "27802")] impl fmt::Display for CharsError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { @@ -1768,13 +1659,13 @@ impl fmt::Display for CharsError { /// `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")] pub struct Split { buf: B, delim: u8, } -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="collections")] impl Iterator for Split { type Item = Result>; @@ -1799,12 +1690,12 @@ 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")] 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 8772d0f..49d66c9 100644 --- a/prelude.rs +++ b/prelude.rs @@ -18,7 +18,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 e05a0d5..2f03121 100644 --- a/util.rs +++ b/util.rs @@ -10,7 +10,8 @@ #![allow(missing_copy_implementations)] -use io::{self, Read, Write, ErrorKind, BufRead}; +use io::{self, Read, Write, ErrorKind}; +#[cfg(feature="collections")] use io::BufRead; /// Copies the entire contents of a reader into a writer. /// @@ -42,7 +43,6 @@ use io::{self, Read, Write, ErrorKind, BufRead}; /// # Ok(()) /// # } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub fn copy(reader: &mut R, writer: &mut W) -> io::Result where R: Read, W: Write { @@ -66,7 +66,6 @@ pub fn copy(reader: &mut R, writer: &mut W) -> io::Result< /// the documentation of `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. @@ -87,14 +86,12 @@ pub struct Empty { _priv: () } /// # Ok(buffer) /// # } /// ``` -#[stable(feature = "rust1", since = "1.0.0")] pub fn empty() -> Empty { Empty { _priv: () } } -#[stable(feature = "rust1", since = "1.0.0")] impl Read for Empty { fn read(&mut self, _buf: &mut [u8]) -> io::Result { Ok(0) } } -#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(feature="collections")] impl BufRead for Empty { fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(&[]) } fn consume(&mut self, _n: usize) {} @@ -106,17 +103,14 @@ impl BufRead 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. /// /// All reads from this reader will succeed by filling the specified buffer with /// the given byte. -#[stable(feature = "rust1", since = "1.0.0")] pub fn repeat(byte: u8) -> Repeat { Repeat { byte: byte } } -#[stable(feature = "rust1", since = "1.0.0")] impl Read for Repeat { fn read(&mut self, buf: &mut [u8]) -> io::Result { for slot in &mut *buf { @@ -132,17 +126,14 @@ impl Read 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. /// /// All calls to `write` on the returned instance will return `Ok(buf.len())` /// and the contents of the buffer will not be inspected. -#[stable(feature = "rust1", since = "1.0.0")] pub fn sink() -> Sink { Sink { _priv: () } } -#[stable(feature = "rust1", since = "1.0.0")] impl Write for Sink { fn write(&mut self, buf: &[u8]) -> io::Result { Ok(buf.len()) } fn flush(&mut self) -> io::Result<()> { Ok(()) }