srenblad/rust-core_io
1
0
Fork 0
forked from abdul124/rust-core_io
Code Pull Requests Activity
81adf070b3
rust-core_io/patches/0b9c686b479ce337581ba9773481ada8dd8f91d6.patch

1796 lines
61 KiB
Diff
Raw Normal View History

Update to 2019-04-27
2019-04-28 06:26:46 +08:00
diff --git a/buffered.rs b/buffered.rs
index ee297d3..452b718 100644
--- a/buffered.rs
+++ b/buffered.rs
@@ -10,13 +10,13 @@
//! 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.
///
@@ -52,7 +52,6 @@ use memchr;
/// Ok(())
/// }
/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
pub struct BufReader<R> {
inner: R,
buf: Box<[u8]>,
@@ -75,7 +74,6 @@ impl<R: Read> BufReader<R> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn new(inner: R) -> BufReader<R> {
BufReader::with_capacity(DEFAULT_BUF_SIZE, inner)
}
@@ -96,7 +94,6 @@ impl<R: Read> BufReader<R> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn with_capacity(cap: usize, inner: R) -> BufReader<R> {
unsafe {
let mut buffer = Vec::with_capacity(cap);
@@ -129,7 +126,6 @@ impl<R: Read> BufReader<R> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn get_ref(&self) -> &R { &self.inner }
/// Gets a mutable reference to the underlying reader.
@@ -150,36 +146,8 @@ impl<R: Read> BufReader<R> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn get_mut(&mut self) -> &mut R { &mut self.inner }
- /// Returns `true` if there are no bytes in the internal buffer.
- ///
- /// # Examples
- //
- /// ```no_run
- /// # #![feature(bufreader_is_empty)]
- /// use std::io::BufReader;
- /// use std::io::BufRead;
- /// use std::fs::File;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let f1 = File::open("log.txt")?;
- /// let mut reader = BufReader::new(f1);
- /// assert!(reader.is_empty());
- ///
- /// if reader.fill_buf()?.len() > 0 {
- /// assert!(!reader.is_empty());
- /// }
- /// Ok(())
- /// }
- /// ```
- #[unstable(feature = "bufreader_is_empty", issue = "45323", reason = "recently added")]
- #[rustc_deprecated(since = "1.26.0", reason = "use .buffer().is_empty() instead")]
- pub fn is_empty(&self) -> bool {
- self.buffer().is_empty()
- }
-
/// Returns a reference to the internally buffered data.
///
/// Unlike `fill_buf`, this will not attempt to fill the buffer if it is empty.
@@ -202,7 +170,6 @@ impl<R: Read> BufReader<R> {
/// Ok(())
/// }
/// ```
- #[unstable(feature = "bufreader_buffer", issue = "45323")]
pub fn buffer(&self) -> &[u8] {
&self.buf[self.pos..self.cap]
}
@@ -225,7 +192,6 @@ impl<R: Read> BufReader<R> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn into_inner(self) -> R { self.inner }
}
@@ -234,7 +200,6 @@ impl<R: Seek> BufReader<R> {
/// 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 {
@@ -254,7 +219,6 @@ impl<R: Seek> BufReader<R> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<R: Read> Read for BufReader<R> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
// If we don't have any buffered data and we're doing a massive read
@@ -277,7 +241,6 @@ impl<R: Read> Read for BufReader<R> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<R: Read> BufRead for BufReader<R> {
fn fill_buf(&mut self) -> io::Result<&[u8]> {
// If we've reached the end of our internal buffer then we need to fetch
@@ -297,7 +260,6 @@ impl<R: Read> BufRead for BufReader<R> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<R> fmt::Debug for BufReader<R> where R: fmt::Debug {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.debug_struct("BufReader")
@@ -307,7 +269,6 @@ impl<R> fmt::Debug for BufReader<R> where R: fmt::Debug {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<R: Seek> Seek for BufReader<R> {
/// Seek to an offset, in bytes, in the underlying reader.
///
@@ -415,7 +376,6 @@ impl<R: Seek> Seek for BufReader<R> {
/// [`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<W: Write> {
inner: Option<W>,
buf: Vec<u8>,
@@ -450,7 +410,6 @@ pub struct BufWriter<W: Write> {
/// };
/// ```
#[derive(Debug)]
-#[stable(feature = "rust1", since = "1.0.0")]
pub struct IntoInnerError<W>(W, Error);
impl<W: Write> BufWriter<W> {
@@ -464,7 +423,6 @@ impl<W: Write> BufWriter<W> {
///
/// 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<W> {
BufWriter::with_capacity(DEFAULT_BUF_SIZE, inner)
}
@@ -482,7 +440,6 @@ impl<W: Write> BufWriter<W> {
/// 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<W> {
BufWriter {
inner: Some(inner),
@@ -531,7 +488,6 @@ impl<W: Write> BufWriter<W> {
/// // 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.
@@ -549,7 +505,6 @@ impl<W: Write> BufWriter<W> {
/// // 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.
@@ -571,7 +526,6 @@ impl<W: Write> BufWriter<W> {
/// // 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<W, IntoInnerError<BufWriter<W>>> {
match self.flush_buf() {
Err(e) => Err(IntoInnerError(self, e)),
@@ -580,7 +534,6 @@ impl<W: Write> BufWriter<W> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Write> Write for BufWriter<W> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
if self.buf.len() + buf.len() > self.buf.capacity() {
@@ -600,7 +553,6 @@ impl<W: Write> Write for BufWriter<W> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Write> fmt::Debug for BufWriter<W> where W: fmt::Debug {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.debug_struct("BufWriter")
@@ -610,7 +562,6 @@ impl<W: Write> fmt::Debug for BufWriter<W> where W: fmt::Debug {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Write + Seek> Seek for BufWriter<W> {
/// Seek to the offset, in bytes, in the underlying writer.
///
@@ -620,7 +571,6 @@ impl<W: Write + Seek> Seek for BufWriter<W> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Write> Drop for BufWriter<W> {
fn drop(&mut self) {
if self.inner.is_some() && !self.panicked {
@@ -659,7 +609,6 @@ impl<W> IntoInnerError<W> {
/// }
/// };
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn error(&self) -> &Error { &self.1 }
/// Returns the buffered writer instance which generated the error.
@@ -692,23 +641,13 @@ impl<W> IntoInnerError<W> {
/// }
/// };
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn into_inner(self) -> W { self.0 }
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<W> From<IntoInnerError<W>> for Error {
fn from(iie: IntoInnerError<W>) -> Error { iie.1 }
}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<W: Send + fmt::Debug> error::Error for IntoInnerError<W> {
- fn description(&self) -> &str {
- error::Error::description(self.error())
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
impl<W> fmt::Display for IntoInnerError<W> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.error().fmt(f)
@@ -766,7 +705,6 @@ impl<W> fmt::Display for IntoInnerError<W> {
/// Ok(())
/// }
/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
pub struct LineWriter<W: Write> {
inner: BufWriter<W>,
need_flush: bool,
@@ -787,7 +725,6 @@ impl<W: Write> LineWriter<W> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn new(inner: W) -> LineWriter<W> {
// Lines typically aren't that long, don't use a giant buffer
LineWriter::with_capacity(1024, inner)
@@ -808,7 +745,6 @@ impl<W: Write> LineWriter<W> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn with_capacity(cap: usize, inner: W) -> LineWriter<W> {
LineWriter {
inner: BufWriter::with_capacity(cap, inner),
@@ -832,7 +768,6 @@ impl<W: Write> LineWriter<W> {
/// 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.
@@ -855,7 +790,6 @@ impl<W: Write> LineWriter<W> {
/// 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.
@@ -881,7 +815,6 @@ impl<W: Write> LineWriter<W> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>> {
self.inner.into_inner().map_err(|IntoInnerError(buf, e)| {
IntoInnerError(LineWriter {
@@ -892,7 +825,6 @@ impl<W: Write> LineWriter<W> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Write> Write for LineWriter<W> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
if self.need_flush {
@@ -937,7 +869,6 @@ impl<W: Write> Write for LineWriter<W> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Write> fmt::Debug for LineWriter<W> 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 8ac5257..c65ed2a 100644
--- a/cursor.rs
+++ b/cursor.rs
@@ -10,7 +10,7 @@
use io::prelude::*;
-use cmp;
+use core::cmp;
use io::{self, Initializer, SeekFrom, Error, ErrorKind};
/// A `Cursor` wraps another type and provides it with a
@@ -78,7 +78,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<T> {
inner: T,
@@ -101,7 +100,6 @@ impl<T> Cursor<T> {
/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
/// # force_inference(&buff);
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn new(inner: T) -> Cursor<T> {
Cursor { pos: 0, inner: inner }
}
@@ -119,7 +117,6 @@ impl<T> Cursor<T> {
///
/// 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.
@@ -135,7 +132,6 @@ impl<T> Cursor<T> {
///
/// 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.
@@ -154,7 +150,6 @@ impl<T> Cursor<T> {
///
/// 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.
@@ -176,7 +171,6 @@ impl<T> Cursor<T> {
/// 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.
@@ -196,11 +190,9 @@ impl<T> Cursor<T> {
/// 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<T> io::Seek for Cursor<T> where T: AsRef<[u8]> {
fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
let (base_pos, offset) = match style {
@@ -221,17 +213,16 @@ impl<T> io::Seek for Cursor<T> where T: AsRef<[u8]> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<T> Read for Cursor<T> where T: AsRef<[u8]> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
- 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(())
}
@@ -242,12 +233,16 @@ impl<T> Read for Cursor<T> where T: AsRef<[u8]> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> BufRead for Cursor<T> where T: AsRef<[u8]> {
- fn fill_buf(&mut self) -> io::Result<&[u8]> {
+impl<T> Cursor<T> 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<T> BufRead for Cursor<T> 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; }
}
@@ -261,6 +256,7 @@ fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<us
/// Compensate removal of some impls per
/// https://github.com/rust-lang/rust/pull/49305#issuecomment-376293243
+#[cfg(feature="collections")]
#[cfg(any(target_pointer_width = "16",
target_pointer_width = "32"))]
fn try_into(n: u64) -> Result<usize, ()> {
@@ -271,12 +267,14 @@ fn try_into(n: u64) -> Result<usize, ()> {
}
}
+#[cfg(feature="collections")]
#[cfg(any(target_pointer_width = "64"))]
fn try_into(n: u64) -> Result<usize, ()> {
Ok(n as usize)
}
// Resizing write implementation
+#[cfg(feature="collections")]
fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {
let pos: usize = try_into(*pos_mut).map_err(|_| {
Error::new(ErrorKind::InvalidInput,
@@ -303,7 +301,6 @@ fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usi
Ok(buf.len())
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Write for Cursor<&'a mut [u8]> {
#[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
@@ -312,7 +309,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<u8>> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
vec_write(&mut self.pos, self.inner, buf)
@@ -320,7 +317,7 @@ impl<'a> Write for Cursor<&'a mut Vec<u8>> {
fn flush(&mut self) -> io::Result<()> { Ok(()) }
}
-#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(feature = "collections")]
impl Write for Cursor<Vec<u8>> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
vec_write(&mut self.pos, &mut self.inner, buf)
@@ -328,8 +325,8 @@ impl Write for Cursor<Vec<u8>> {
fn flush(&mut self) -> io::Result<()> { Ok(()) }
}
-#[stable(feature = "cursor_box_slice", since = "1.5.0")]
-impl Write for Cursor<Box<[u8]>> {
+#[cfg(feature = "alloc")]
+impl Write for Cursor<::alloc::boxed::Box<[u8]>> {
#[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
slice_write(&mut self.pos, &mut self.inner, buf)
diff --git a/error.rs b/error.rs
index bdd675e..3acdadf 100644
--- a/error.rs
+++ b/error.rs
@@ -8,11 +8,16 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-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.
@@ -48,7 +53,6 @@ use convert::From;
/// Ok(buffer)
/// }
/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
pub type Result<T> = result::Result<T, Error>;
/// The error type for I/O operations of the [`Read`], [`Write`], [`Seek`], and
@@ -62,12 +66,10 @@ pub type Result<T> = result::Result<T, Error>;
/// [`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)
@@ -77,13 +79,16 @@ impl fmt::Debug for Error {
enum Repr {
Os(i32),
Simple(ErrorKind),
+ #[cfg(feature="alloc")]
Custom(Box<Custom>),
+ #[cfg(not(feature="alloc"))]
+ Custom(Custom),
}
#[derive(Debug)]
struct Custom {
kind: ErrorKind,
- error: Box<error::Error+Send+Sync>,
+ error: String,
}
/// A list specifying general categories of I/O error.
@@ -95,47 +100,34 @@ 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)]
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.
///
@@ -147,10 +139,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)`].
@@ -161,15 +151,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
@@ -178,15 +165,10 @@ 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,
/// A marker variant that tells the compiler that users of this enum cannot
/// match it exhaustively.
- #[unstable(feature = "io_error_internals",
- reason = "better expressed through extensible enums that this \
- enum cannot be exhaustively matched against",
- issue = "0")]
#[doc(hidden)]
__Nonexhaustive,
}
@@ -219,7 +201,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<ErrorKind> for Error {
#[inline]
fn from(kind: ErrorKind) -> Error {
@@ -248,14 +229,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<E>(kind: ErrorKind, error: E) -> Error
- where E: Into<Box<error::Error+Send+Sync>>
+ where E: Into<String>
{
Self::_new(kind, error.into())
}
- fn _new(kind: ErrorKind, error: Box<error::Error+Send+Sync>) -> Error {
+ fn _new(kind: ErrorKind, error: String) -> Error {
Error {
repr: Repr::Custom(Box::new(Custom {
kind,
@@ -264,24 +244,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
@@ -307,7 +269,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) }
}
@@ -338,7 +299,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<i32> {
match self.repr {
Repr::Os(i) => Some(i),
@@ -372,12 +332,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<&(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),
}
}
@@ -443,12 +402,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 (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),
}
}
@@ -477,8 +435,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<Box<error::Error+Send+Sync>> {
+ pub fn into_inner(self) -> Option<String> {
match self.repr {
Repr::Os(..) => None,
Repr::Simple(..) => None,
@@ -504,10 +461,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,
}
@@ -519,22 +475,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()),
@@ -542,24 +494,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(),
- }
- }
-
- fn cause(&self) -> Option<&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<T: Sync+Send>() {}
_is_sync_send::<Error>();
diff --git a/impls.rs b/impls.rs
index fe1179a..452b8b7 100644
--- a/impls.rs
+++ b/impls.rs
@@ -8,15 +8,18 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-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<usize> {
@@ -28,11 +31,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<u8>) -> io::Result<usize> {
(**self).read_to_end(buf)
}
+ #[cfg(feature="collections")]
#[inline]
fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
(**self).read_to_string(buf)
@@ -43,7 +48,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<usize> { (**self).write(buf) }
@@ -61,12 +65,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<u64> { (**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() }
@@ -85,7 +88,7 @@ impl<'a, B: BufRead + ?Sized> BufRead for &'a mut B {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(feature="alloc")]
impl<R: Read + ?Sized> Read for Box<R> {
#[inline]
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
@@ -97,11 +100,13 @@ impl<R: Read + ?Sized> Read for Box<R> {
(**self).initializer()
}
+ #[cfg(feature="collections")]
#[inline]
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
(**self).read_to_end(buf)
}
+ #[cfg(feature="collections")]
#[inline]
fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
(**self).read_to_string(buf)
@@ -112,7 +117,7 @@ impl<R: Read + ?Sized> Read for Box<R> {
(**self).read_exact(buf)
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(feature="alloc")]
impl<W: Write + ?Sized> Write for Box<W> {
#[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) }
@@ -130,12 +135,12 @@ impl<W: Write + ?Sized> Write for Box<W> {
(**self).write_fmt(fmt)
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(feature="alloc")]
impl<S: Seek + ?Sized> Seek for Box<S> {
#[inline]
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) }
}
-#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(feature="collections")]
impl<B: BufRead + ?Sized> BufRead for Box<B> {
#[inline]
fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() }
@@ -161,7 +166,6 @@ impl<B: BufRead + ?Sized> BufRead for Box<B> {
///
/// 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<usize> {
@@ -207,6 +211,7 @@ impl<'a> Read for &'a [u8] {
Ok(())
}
+ #[cfg(feature="collections")]
#[inline]
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
buf.extend_from_slice(*self);
@@ -216,7 +221,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) }
@@ -230,7 +235,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<usize> {
@@ -256,7 +260,7 @@ impl<'a> Write for &'a mut [u8] {
/// Write is implemented for `Vec<u8>` 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<u8> {
#[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
diff --git a/mod.rs b/mod.rs
index 2b4644b..fbdb8e6 100644
--- a/mod.rs
+++ b/mod.rs
@@ -267,50 +267,36 @@
//! [`Result`]: ../result/enum.Result.html
//! [`.unwrap()`]: ../result/enum.Result.html#method.unwrap
-#![stable(feature = "rust1", since = "1.0.0")]
-
-use cmp;
-use core::str as core_str;
-use error as std_error;
-use fmt;
-use result;
-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::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<u8>, len: usize }
+#[cfg(feature="collections")]
impl<'a> Drop for Guard<'a> {
fn drop(&mut self) {
unsafe { self.buf.set_len(self.len); }
@@ -335,6 +321,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<F>(buf: &mut String, f: F) -> Result<usize>
where F: FnOnce(&mut Vec<u8>) -> Result<usize>
{
@@ -362,6 +349,7 @@ fn append_to_string<F>(buf: &mut String, f: F) -> Result<usize>
//
// 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: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<usize> {
let start_len = buf.len();
let mut g = Guard { len: buf.len(), buf: buf };
@@ -465,7 +453,6 @@ fn read_to_end<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<usize>
/// [`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
@@ -522,7 +509,6 @@ pub trait Read {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
/// Determines if this `Read`er can work with buffers of uninitialized
@@ -547,7 +533,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()
@@ -600,7 +585,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<u8>) -> Result<usize> {
read_to_end(self, buf)
}
@@ -643,7 +628,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<usize> {
// Note that we do *not* call `.read_to_end()` here. We are passing
// `&mut Vec<u8>` (the raw contents of `buf`) into the `read_to_end`
@@ -706,7 +691,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) {
@@ -758,7 +742,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.
@@ -795,58 +778,10 @@ pub trait Read {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
fn bytes(self) -> Bytes<Self> where Self: Sized {
Bytes { inner: self }
}
- /// Transforms this `Read` instance to an [`Iterator`] over [`char`]s.
- ///
- /// This adaptor will attempt to interpret this reader as a UTF-8 encoded
- /// sequence of characters. The returned iterator will return [`None`] once
- /// EOF is reached for this reader. Otherwise each element yielded will be a
- /// [`Result`]`<`[`char`]`, E>` where `E` may contain information about what I/O error
- /// occurred or where decoding failed.
- ///
- /// Currently this adaptor will discard intermediate data read, and should
- /// be avoided if this is not desired.
- ///
- /// # Examples
- ///
- /// [`File`]s implement `Read`:
- ///
- /// [`File`]: ../fs/struct.File.html
- /// [`Iterator`]: ../../std/iter/trait.Iterator.html
- /// [`Result`]: ../../std/result/enum.Result.html
- /// [`char`]: ../../std/primitive.char.html
- /// [`None`]: ../../std/option/enum.Option.html#variant.None
- ///
- /// ```no_run
- /// #![feature(io)]
- /// use std::io;
- /// use std::io::prelude::*;
- /// use std::fs::File;
- ///
- /// fn main() -> io::Result<()> {
- /// let mut f = File::open("foo.txt")?;
- ///
- /// for c in f.chars() {
- /// println!("{}", c.unwrap());
- /// }
- /// 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(since = "1.27.0", reason = "Use str::from_utf8 instead:
- https://doc.rust-lang.org/nightly/std/str/struct.Utf8Error.html#examples")]
- #[allow(deprecated)]
- fn chars(self) -> Chars<Self> where Self: Sized {
- Chars { inner: self }
- }
-
/// Creates an adaptor which will chain this stream with another.
///
/// The returned `Read` instance will first read all bytes from this object
@@ -877,7 +812,6 @@ pub trait Read {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
fn chain<R: Read>(self, next: R) -> Chain<Self, R> where Self: Sized {
Chain { first: self, second: next, done_first: false }
}
@@ -913,20 +847,17 @@ pub trait Read {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
fn take(self, limit: u64) -> Take<Self> 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)
@@ -940,21 +871,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() {
@@ -997,7 +925,6 @@ impl Initializer {
/// Ok(())
/// }
/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
#[doc(spotlight)]
pub trait Write {
/// Write a buffer into this object, returning how many bytes were written.
@@ -1046,7 +973,6 @@ pub trait Write {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
fn write(&mut self, buf: &[u8]) -> Result<usize>;
/// Flush this output stream, ensuring that all intermediately buffered
@@ -1072,7 +998,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.
@@ -1105,7 +1030,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) {
@@ -1157,7 +1081,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
@@ -1213,7 +1136,6 @@ pub trait Write {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
fn by_ref(&mut self) -> &mut Self where Self: Sized { self }
}
@@ -1243,7 +1165,6 @@ pub trait Write {
/// Ok(())
/// }
/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
pub trait Seek {
/// Seek to an offset, in bytes, in a stream.
///
@@ -1259,7 +1180,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<u64>;
}
@@ -1269,29 +1189,26 @@ pub trait Seek {
///
/// [`Seek`]: trait.Seek.html
#[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: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>)
-> Result<usize> {
let mut read = 0;
@@ -1371,7 +1288,7 @@ fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>)
/// }
/// ```
///
-#[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.
///
@@ -1416,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,
@@ -1438,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.
@@ -1494,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<u8>) -> Result<usize> {
read_until(self, byte, buf)
}
@@ -1553,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<usize> {
// Note that we are not calling the `.read_until` method here, but
// rather our hardcoded implementation. For more details as to why, see
@@ -1594,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<Self> where Self: Sized {
Split { buf: self, delim: byte }
}
@@ -1633,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<Self> where Self: Sized {
Lines { buf: self }
}
@@ -1645,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<T, U> {
first: T,
second: U,
@@ -1671,7 +1581,6 @@ impl<T, U> Chain<T, U> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "more_io_inner_methods", since = "1.20.0")]
pub fn into_inner(self) -> (T, U) {
(self.first, self.second)
}
@@ -1694,7 +1603,6 @@ impl<T, U> Chain<T, U> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "more_io_inner_methods", since = "1.20.0")]
pub fn get_ref(&self) -> (&T, &U) {
(&self.first, &self.second)
}
@@ -1721,13 +1629,11 @@ impl<T, U> Chain<T, U> {
/// 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<T: fmt::Debug, U: fmt::Debug> fmt::Debug for Chain<T, U> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Chain")
@@ -1737,7 +1643,6 @@ impl<T: fmt::Debug, U: fmt::Debug> fmt::Debug for Chain<T, U> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Read, U: Read> Read for Chain<T, U> {
fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
if !self.done_first {
@@ -1759,7 +1664,7 @@ impl<T: Read, U: Read> Read for Chain<T, U> {
}
}
-#[stable(feature = "chain_bufread", since = "1.9.0")]
+#[cfg(feature="collections")]
impl<T: BufRead, U: BufRead> BufRead for Chain<T, U> {
fn fill_buf(&mut self) -> Result<&[u8]> {
if !self.done_first {
@@ -1786,7 +1691,6 @@ impl<T: BufRead, U: BufRead> BufRead for Chain<T, U> {
/// 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<T> {
inner: T,
@@ -1821,7 +1725,6 @@ impl<T> Take<T> {
/// 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
@@ -1847,7 +1750,6 @@ impl<T> Take<T> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "take_set_limit", since = "1.27.0")]
pub fn set_limit(&mut self, limit: u64) {
self.limit = limit;
}
@@ -1872,7 +1774,6 @@ impl<T> Take<T> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "io_take_into_inner", since = "1.15.0")]
pub fn into_inner(self) -> T {
self.inner
}
@@ -1897,7 +1798,6 @@ impl<T> Take<T> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "more_io_inner_methods", since = "1.20.0")]
pub fn get_ref(&self) -> &T {
&self.inner
}
@@ -1926,13 +1826,11 @@ impl<T> Take<T> {
/// 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<T: Read> Read for Take<T> {
fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
// Don't call into inner reader at all at EOF because it may still block
@@ -1951,7 +1849,7 @@ impl<T: Read> Read for Take<T> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(feature="collections")]
impl<T: BufRead> BufRead for Take<T> {
fn fill_buf(&mut self) -> Result<&[u8]> {
// Don't call into inner reader at all at EOF because it may still block
@@ -1990,13 +1888,11 @@ fn read_one_byte(reader: &mut Read) -> Option<Result<u8>> {
/// 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<R> {
inner: R,
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<R: Read> Iterator for Bytes<R> {
type Item = Result<u8>;
@@ -2005,104 +1901,6 @@ impl<R: Read> Iterator for Bytes<R> {
}
}
-/// An iterator over the `char`s of a reader.
-///
-/// This struct is generally created by calling [`chars`][chars] on a reader.
-/// 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")]
-#[rustc_deprecated(since = "1.27.0", reason = "Use str::from_utf8 instead:
- https://doc.rust-lang.org/nightly/std/str/struct.Utf8Error.html#examples")]
-#[derive(Debug)]
-#[allow(deprecated)]
-pub struct Chars<R> {
- inner: R,
-}
-
-/// An enumeration of possible errors that can be generated from the `Chars`
-/// adapter.
-#[unstable(feature = "io", reason = "awaiting stability of Read::chars",
- issue = "27802")]
-#[rustc_deprecated(since = "1.27.0", reason = "Use str::from_utf8 instead:
- https://doc.rust-lang.org/nightly/std/str/struct.Utf8Error.html#examples")]
-#[derive(Debug)]
-#[allow(deprecated)]
-pub enum CharsError {
- /// Variant representing that the underlying stream was read successfully
- /// but it did not contain valid utf8 data.
- NotUtf8,
-
- /// Variant representing that an I/O error occurred.
- Other(Error),
-}
-
-#[unstable(feature = "io", reason = "awaiting stability of Read::chars",
- issue = "27802")]
-#[allow(deprecated)]
-impl<R: Read> Iterator for Chars<R> {
- type Item = result::Result<char, CharsError>;
-
- fn next(&mut self) -> Option<result::Result<char, CharsError>> {
- let first_byte = match read_one_byte(&mut self.inner)? {
- Ok(b) => b,
- Err(e) => return Some(Err(CharsError::Other(e))),
- };
- let width = core_str::utf8_char_width(first_byte);
- if width == 1 { return Some(Ok(first_byte as char)) }
- if width == 0 { return Some(Err(CharsError::NotUtf8)) }
- let mut buf = [first_byte, 0, 0, 0];
- {
- let mut start = 1;
- while start < width {
- match self.inner.read(&mut buf[start..width]) {
- Ok(0) => return Some(Err(CharsError::NotUtf8)),
- Ok(n) => start += n,
- Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
- Err(e) => return Some(Err(CharsError::Other(e))),
- }
- }
- }
- Some(match str::from_utf8(&buf[..width]).ok() {
- Some(s) => Ok(s.chars().next().unwrap()),
- None => Err(CharsError::NotUtf8),
- })
- }
-}
-
-#[unstable(feature = "io", reason = "awaiting stability of Read::chars",
- issue = "27802")]
-#[allow(deprecated)]
-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")]
-#[allow(deprecated)]
-impl fmt::Display for CharsError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- match *self {
- CharsError::NotUtf8 => {
- "byte stream did not contain valid utf8".fmt(f)
- }
- CharsError::Other(ref e) => e.fmt(f),
- }
- }
-}
-
/// An iterator over the contents of an instance of `BufRead` split on a
/// particular byte.
///
@@ -2110,14 +1908,14 @@ 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")]
#[derive(Debug)]
pub struct Split<B> {
buf: B,
delim: u8,
}
-#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(feature="collections")]
impl<B: BufRead> Iterator for Split<B> {
type Item = Result<Vec<u8>>;
@@ -2142,13 +1940,13 @@ impl<B: BufRead> Iterator for Split<B> {
/// `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<B> {
buf: B,
}
-#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(feature="collections")]
impl<B: BufRead> Iterator for Lines<B> {
type Item = Result<String>;
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 195310a..20755b7 100644
--- a/util.rs
+++ b/util.rs
@@ -10,9 +10,10 @@
#![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};
+use core::mem;
+#[cfg(feature="collections")] use io::BufRead;
/// Copies the entire contents of a reader into a writer.
///
@@ -44,7 +45,6 @@ use mem;
/// Ok(())
/// }
/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64>
where R: Read, W: Write
{
@@ -73,7 +73,6 @@ pub fn copy<R: ?Sized, W: ?Sized>(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.
@@ -93,10 +92,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<usize> { Ok(0) }
@@ -106,7 +103,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(&[]) }
@@ -114,7 +112,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 { .. }")
@@ -127,7 +124,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.
@@ -144,10 +140,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: byte } }
-#[stable(feature = "rust1", since = "1.0.0")]
impl Read for Repeat {
#[inline]
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
@@ -163,7 +157,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 { .. }")
@@ -176,7 +169,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.
@@ -193,10 +185,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<usize> { Ok(buf.len()) }
@@ -204,7 +194,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 { .. }")
Copy Permalink