srenblad/rust-core_io
1
0
Fork 0
forked from abdul124/rust-core_io
Code Pull Requests Activity
0320cb152d
rust-core_io/patches/56d288fa46e04cd5faf53d369a1a640a97e2bb08.patch

1959 lines
63 KiB
Diff
Raw Normal View History

Update to 2021-03-25
2021-03-30 23:56:22 +08:00
diff --git a/buffered/bufreader.rs b/buffered/bufreader.rs
index 8fe29f0..e0f677c 100644
--- a/buffered/bufreader.rs
+++ b/buffered/bufreader.rs
@@ -1,6 +1,7 @@
-use crate::cmp;
-use crate::fmt;
+use core::cmp;
+use core::fmt;
use crate::io::{self, BufRead, Initializer, IoSliceMut, Read, Seek, SeekFrom, DEFAULT_BUF_SIZE};
+use crate::io::prelude::*;
/// The `BufReader<R>` struct adds buffering to any reader.
///
@@ -41,7 +42,6 @@ use crate::io::{self, BufRead, Initializer, IoSliceMut, Read, Seek, SeekFrom, DE
/// Ok(())
/// }
/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
pub struct BufReader<R> {
inner: R,
buf: Box<[u8]>,
@@ -65,7 +65,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)
}
@@ -86,7 +85,6 @@ impl<R: Read> BufReader<R> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn with_capacity(capacity: usize, inner: R) -> BufReader<R> {
unsafe {
let mut buffer = Vec::with_capacity(capacity);
@@ -116,7 +114,6 @@ impl<R> BufReader<R> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn get_ref(&self) -> &R {
&self.inner
}
@@ -139,7 +136,6 @@ impl<R> BufReader<R> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn get_mut(&mut self) -> &mut R {
&mut self.inner
}
@@ -167,7 +163,6 @@ impl<R> BufReader<R> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "bufreader_buffer", since = "1.37.0")]
pub fn buffer(&self) -> &[u8] {
&self.buf[self.pos..self.cap]
}
@@ -190,7 +185,6 @@ impl<R> BufReader<R> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "buffered_io_capacity", since = "1.46.0")]
pub fn capacity(&self) -> usize {
self.buf.len()
}
@@ -214,7 +208,6 @@ impl<R> BufReader<R> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn into_inner(self) -> R {
self.inner
}
@@ -232,7 +225,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 {
@@ -252,7 +244,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
@@ -294,7 +285,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
@@ -314,7 +304,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,
@@ -327,7 +316,6 @@ where
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<R: Seek> Seek for BufReader<R> {
/// Seek to an offset, in bytes, in the underlying reader.
///
diff --git a/buffered/bufwriter.rs b/buffered/bufwriter.rs
index 3ec272f..4ff75ab 100644
--- a/buffered/bufwriter.rs
+++ b/buffered/bufwriter.rs
@@ -1,7 +1,8 @@
-use crate::fmt;
+use core::fmt;
use crate::io::{
self, Error, ErrorKind, IntoInnerError, IoSlice, Seek, SeekFrom, Write, DEFAULT_BUF_SIZE,
};
+use crate::io::prelude::*;
/// Wraps a writer and buffers its output.
///
@@ -62,7 +63,6 @@ use crate::io::{
/// [`TcpStream::write`]: Write::write
/// [`TcpStream`]: crate::net::TcpStream
/// [`flush`]: Write::flush
-#[stable(feature = "rust1", since = "1.0.0")]
pub struct BufWriter<W: Write> {
inner: Option<W>,
buf: Vec<u8>,
@@ -84,7 +84,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)
}
@@ -102,7 +101,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(capacity: usize, inner: W) -> BufWriter<W> {
BufWriter { inner: Some(inner), buf: Vec::with_capacity(capacity), panicked: false }
}
@@ -197,7 +195,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()
}
@@ -217,7 +214,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()
}
@@ -235,7 +231,6 @@ impl<W: Write> BufWriter<W> {
/// // See how many bytes are currently buffered
/// let bytes_buffered = buf_writer.buffer().len();
/// ```
- #[stable(feature = "bufreader_buffer", since = "1.37.0")]
pub fn buffer(&self) -> &[u8] {
&self.buf
}
@@ -255,7 +250,6 @@ impl<W: Write> BufWriter<W> {
/// // Calculate how many bytes can be written without flushing
/// let without_flush = capacity - buf_writer.buffer().len();
/// ```
- #[stable(feature = "buffered_io_capacity", since = "1.46.0")]
pub fn capacity(&self) -> usize {
self.buf.capacity()
}
@@ -279,7 +273,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::new(self, e)),
@@ -288,7 +281,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() {
@@ -352,7 +344,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,
@@ -365,7 +356,6 @@ where
}
}
-#[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.
///
@@ -376,7 +366,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 {
diff --git a/buffered/linewriter.rs b/buffered/linewriter.rs
index 502c6e3..3d6e7e9 100644
--- a/buffered/linewriter.rs
+++ b/buffered/linewriter.rs
@@ -1,4 +1,4 @@
-use crate::fmt;
+use core::fmt;
use crate::io::{self, buffered::LineWriterShim, BufWriter, IntoInnerError, IoSlice, Write};
/// Wraps a writer and buffers output to it, flushing whenever a newline
@@ -63,7 +63,6 @@ use crate::io::{self, buffered::LineWriterShim, BufWriter, IntoInnerError, IoSli
/// Ok(())
/// }
/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
pub struct LineWriter<W: Write> {
inner: BufWriter<W>,
}
@@ -83,7 +82,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)
@@ -104,7 +102,6 @@ impl<W: Write> LineWriter<W> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn with_capacity(capacity: usize, inner: W) -> LineWriter<W> {
LineWriter { inner: BufWriter::with_capacity(capacity, inner) }
}
@@ -125,7 +122,6 @@ impl<W: Write> LineWriter<W> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn get_ref(&self) -> &W {
self.inner.get_ref()
}
@@ -150,7 +146,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()
}
@@ -178,13 +173,11 @@ 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(|err| err.new_wrapped(|inner| LineWriter { inner }))
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Write> Write for LineWriter<W> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
LineWriterShim::new(&mut self.inner).write(buf)
@@ -215,7 +208,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,
diff --git a/buffered/linewritershim.rs b/buffered/linewritershim.rs
index a80d08d..20bd401 100644
--- a/buffered/linewritershim.rs
+++ b/buffered/linewritershim.rs
@@ -1,5 +1,5 @@
use crate::io::{self, BufWriter, IoSlice, Write};
-use crate::memchr;
+use crate::io::memchr;
/// Private helper struct for implementing the line-buffered writing logic.
/// This shim temporarily wraps a BufWriter, and uses its internals to
diff --git a/buffered/mod.rs b/buffered/mod.rs
index f9caeaf..c21de5c 100644
--- a/buffered/mod.rs
+++ b/buffered/mod.rs
@@ -8,14 +8,13 @@ mod linewritershim;
#[cfg(test)]
mod tests;
-use crate::error;
-use crate::fmt;
+use core::fmt;
use crate::io::Error;
-pub use bufreader::BufReader;
-pub use bufwriter::BufWriter;
-pub use linewriter::LineWriter;
-use linewritershim::LineWriterShim;
+pub use self::bufreader::BufReader;
+pub use self::bufwriter::BufWriter;
+pub use self::linewriter::LineWriter;
+use self::linewritershim::LineWriterShim;
/// An error returned by [`BufWriter::into_inner`] which combines an error that
/// happened while writing out the buffer, and the buffered writer object
@@ -42,7 +41,6 @@ use linewritershim::LineWriterShim;
/// };
/// ```
#[derive(Debug)]
-#[stable(feature = "rust1", since = "1.0.0")]
pub struct IntoInnerError<W>(W, Error);
impl<W> IntoInnerError<W> {
@@ -87,7 +85,6 @@ impl<W> IntoInnerError<W> {
/// }
/// };
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn error(&self) -> &Error {
&self.1
}
@@ -122,28 +119,17 @@ 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> {
- #[allow(deprecated, deprecated_in_future)]
- 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)
diff --git a/cursor.rs b/cursor.rs
index 5733735..0fdd84a 100644
--- a/cursor.rs
+++ b/cursor.rs
@@ -3,10 +3,10 @@ mod tests;
use crate::io::prelude::*;
-use crate::cmp;
+use core::cmp;
use crate::io::{self, Error, ErrorKind, Initializer, IoSlice, IoSliceMut, SeekFrom};
-use core::convert::TryInto;
+#[cfg(feature="collections")] use core::convert::TryInto;
/// A `Cursor` wraps an in-memory buffer and provides it with a
/// [`Seek`] implementation.
@@ -70,7 +70,6 @@ use core::convert::TryInto;
/// 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, Default, Eq, PartialEq)]
pub struct Cursor<T> {
inner: T,
@@ -93,7 +92,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 }
}
@@ -111,7 +109,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
}
@@ -129,7 +126,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
}
@@ -150,7 +146,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
}
@@ -174,7 +169,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
}
@@ -196,13 +190,11 @@ 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]>,
@@ -242,13 +234,12 @@ where
}
}
-#[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)
}
@@ -271,7 +262,7 @@ where
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(())
}
@@ -282,15 +273,24 @@ where
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> BufRead for Cursor<T>
+impl<T> Cursor<T>
where
T: AsRef<[u8]>,
{
- fn fill_buf(&mut self) -> io::Result<&[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;
}
@@ -323,6 +323,7 @@ fn slice_write_vectored(
}
// 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 = (*pos_mut).try_into().map_err(|_| {
Error::new(
@@ -351,6 +352,7 @@ fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usi
Ok(buf.len())
}
+#[cfg(feature="collections")]
fn vec_write_vectored(
pos_mut: &mut u64,
vec: &mut Vec<u8>,
@@ -363,7 +365,6 @@ fn vec_write_vectored(
Ok(nwritten)
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl Write for Cursor<&mut [u8]> {
#[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
@@ -386,7 +387,7 @@ impl Write for Cursor<&mut [u8]> {
}
}
-#[stable(feature = "cursor_mut_vec", since = "1.25.0")]
+#[cfg(feature="collections")]
impl Write for Cursor<&mut Vec<u8>> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
vec_write(&mut self.pos, self.inner, buf)
@@ -407,7 +408,7 @@ impl Write for Cursor<&mut Vec<u8>> {
}
}
-#[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)
@@ -428,8 +429,8 @@ impl Write for Cursor<Vec<u8>> {
}
}
-#[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 ba0f0a0..826f11d 100644
--- a/error.rs
+++ b/error.rs
@@ -1,11 +1,17 @@
#[cfg(test)]
mod tests;
-use crate::convert::From;
-use crate::error;
-use crate::fmt;
-use crate::result;
-use crate::sys;
+use core::convert::From;
+use core::fmt;
+use core::result;
+
+use core::convert::Into;
+use core::marker::{Send, Sync};
+use core::option::Option::{self, Some, None};
+#[cfg(feature="alloc")] use alloc::boxed::Box;
+#[cfg(not(feature="alloc"))] use ::FakeBox as Box;
+#[cfg(feature="collections")] use collections::string::String;
+#[cfg(not(feature="collections"))] use ::ErrorString as String;
/// A specialized [`Result`] type for I/O operations.
///
@@ -41,7 +47,6 @@ use crate::sys;
/// 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
@@ -54,12 +59,10 @@ pub type Result<T> = result::Result<T, Error>;
/// [`Read`]: crate::io::Read
/// [`Write`]: crate::io::Write
/// [`Seek`]: crate::io::Seek
-#[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)
@@ -69,13 +72,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<dyn error::Error + Send + Sync>,
+ error: String,
}
/// A list specifying general categories of I/O error.
@@ -87,48 +93,35 @@ struct Custom {
///
/// [`io::Error`]: Error
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-#[stable(feature = "rust1", since = "1.0.0")]
#[allow(deprecated)]
#[non_exhaustive]
pub enum ErrorKind {
/// An entity was not found, often a file.
- #[stable(feature = "rust1", since = "1.0.0")]
NotFound,
/// The operation lacked the necessary privileges to complete.
- #[stable(feature = "rust1", since = "1.0.0")]
PermissionDenied,
/// The connection was refused by the remote server.
- #[stable(feature = "rust1", since = "1.0.0")]
ConnectionRefused,
/// The connection was reset by the remote server.
- #[stable(feature = "rust1", since = "1.0.0")]
ConnectionReset,
/// The connection was aborted (terminated) by the remote server.
- #[stable(feature = "rust1", since = "1.0.0")]
ConnectionAborted,
/// The network operation failed because it was not connected yet.
- #[stable(feature = "rust1", since = "1.0.0")]
NotConnected,
/// A socket address could not be bound because the address is already in
/// use elsewhere.
- #[stable(feature = "rust1", since = "1.0.0")]
AddrInUse,
/// A nonexistent interface was requested or the requested address was not
/// local.
- #[stable(feature = "rust1", since = "1.0.0")]
AddrNotAvailable,
/// The operation failed because a pipe was closed.
- #[stable(feature = "rust1", since = "1.0.0")]
BrokenPipe,
/// An entity already exists, often a file.
- #[stable(feature = "rust1", since = "1.0.0")]
AlreadyExists,
/// The operation needs to block to complete, but the blocking operation was
/// requested to not occur.
- #[stable(feature = "rust1", since = "1.0.0")]
WouldBlock,
/// A parameter was incorrect.
- #[stable(feature = "rust1", since = "1.0.0")]
InvalidInput,
/// Data not valid for the operation were encountered.
///
@@ -140,10 +133,8 @@ pub enum ErrorKind {
/// `InvalidData` if the file's contents are not valid UTF-8.
///
/// [`InvalidInput`]: ErrorKind::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)`].
@@ -154,12 +145,10 @@ pub enum ErrorKind {
///
/// [`write`]: crate::io::Write::write
/// [`Ok(0)`]: Ok
- #[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.
///
@@ -167,7 +156,6 @@ pub enum ErrorKind {
/// [`ErrorKind`] variant in the future. It is not recommended to match
/// an error against `Other` and to expect any additional characteristics,
/// e.g., a specific [`Error::raw_os_error`] return value.
- #[stable(feature = "rust1", since = "1.0.0")]
Other,
/// An error returned when an operation could not be completed because an
@@ -176,7 +164,6 @@ pub enum ErrorKind {
/// This typically means that an operation could only succeed if it read a
/// particular number of bytes but only a smaller number of bytes could be
/// read.
- #[stable(feature = "read_exact", since = "1.6.0")]
UnexpectedEof,
}
@@ -207,7 +194,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 {
/// Converts an [`ErrorKind`] into an [`Error`].
///
@@ -247,36 +233,17 @@ 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<dyn error::Error + Send + Sync>>,
+ E: Into<String>,
{
Self::_new(kind, error.into())
}
- fn _new(kind: ErrorKind, error: Box<dyn error::Error + Send + Sync>) -> Error {
+ fn _new(kind: ErrorKind, error: String) -> Error {
Error { repr: Repr::Custom(Box::new(Custom { kind, 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
@@ -302,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) }
}
@@ -336,7 +302,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 +337,11 @@ impl Error {
/// print_error(&Error::new(ErrorKind::Other, "oh no!"));
/// }
/// ```
- #[stable(feature = "io_error_inner", since = "1.3.0")]
- pub fn get_ref(&self) -> Option<&(dyn error::Error + Send + Sync + 'static)> {
+ pub fn get_ref(&self) -> Option<&String> {
match self.repr {
Repr::Os(..) => None,
Repr::Simple(..) => None,
- Repr::Custom(ref c) => Some(&*c.error),
+ Repr::Custom(ref c) => Some(&c.error),
}
}
@@ -443,12 +407,11 @@ impl Error {
/// print_error(&change_error(Error::new(ErrorKind::Other, MyError::new())));
/// }
/// ```
- #[stable(feature = "io_error_inner", since = "1.3.0")]
- pub fn get_mut(&mut self) -> Option<&mut (dyn error::Error + Send + Sync + 'static)> {
+ pub fn get_mut(&mut self) -> Option<&mut String> {
match self.repr {
Repr::Os(..) => None,
Repr::Simple(..) => None,
- Repr::Custom(ref mut c) => Some(&mut *c.error),
+ Repr::Custom(ref mut c) => Some(&mut c.error),
}
}
@@ -479,8 +442,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<dyn error::Error + Send + Sync>> {
+ pub fn into_inner(self) -> Option<String> {
match self.repr {
Repr::Os(..) => None,
Repr::Simple(..) => None,
@@ -506,10 +468,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,
}
@@ -522,8 +483,6 @@ impl fmt::Debug for Repr {
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(),
Repr::Custom(ref c) => fmt::Debug::fmt(&c, fmt),
Repr::Simple(kind) => fmt.debug_tuple("Kind").field(&kind).finish(),
@@ -531,13 +490,11 @@ impl fmt::Debug for Repr {
}
}
-#[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()),
@@ -545,34 +502,6 @@ impl fmt::Display for Error {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl error::Error for Error {
- #[allow(deprecated, deprecated_in_future)]
- fn description(&self) -> &str {
- match self.repr {
- Repr::Os(..) | Repr::Simple(..) => self.kind().as_str(),
- Repr::Custom(ref c) => c.error.description(),
- }
- }
-
- #[allow(deprecated)]
- fn cause(&self) -> Option<&dyn error::Error> {
- match self.repr {
- Repr::Os(..) => None,
- Repr::Simple(..) => None,
- Repr::Custom(ref c) => c.error.cause(),
- }
- }
-
- fn source(&self) -> Option<&(dyn error::Error + 'static)> {
- match self.repr {
- Repr::Os(..) => None,
- Repr::Simple(..) => None,
- Repr::Custom(ref c) => c.error.source(),
- }
- }
-}
-
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 6642610..efbe402 100644
--- a/impls.rs
+++ b/impls.rs
@@ -1,17 +1,21 @@
#[cfg(test)]
mod tests;
-use crate::cmp;
-use crate::fmt;
+use core::cmp;
+use core::fmt;
use crate::io::{
- self, BufRead, Error, ErrorKind, Initializer, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write,
+ self, Error, ErrorKind, Initializer, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write,
};
-use crate::mem;
+#[cfg(feature="collections")] use crate::io::BufRead;
+use core::mem;
+
+#[cfg(feature="alloc")] use alloc::boxed::Box;
+#[cfg(feature="collections")] use collections::string::String;
+#[cfg(feature="collections")] use collections::vec::Vec;
// =============================================================================
// Forwarding implementations
-#[stable(feature = "rust1", since = "1.0.0")]
impl<R: Read + ?Sized> Read for &mut R {
#[inline]
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
@@ -33,11 +37,13 @@ impl<R: Read + ?Sized> Read for &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)
@@ -48,7 +54,6 @@ impl<R: Read + ?Sized> Read for &mut R {
(**self).read_exact(buf)
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Write + ?Sized> Write for &mut W {
#[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
@@ -80,14 +85,13 @@ impl<W: Write + ?Sized> Write for &mut W {
(**self).write_fmt(fmt)
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl<S: Seek + ?Sized> Seek for &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<B: BufRead + ?Sized> BufRead for &mut B {
#[inline]
fn fill_buf(&mut self) -> io::Result<&[u8]> {
@@ -110,7 +114,7 @@ impl<B: BufRead + ?Sized> BufRead for &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> {
@@ -132,11 +136,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)
@@ -147,7 +153,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> {
@@ -179,14 +185,14 @@ 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]> {
@@ -230,7 +236,6 @@ impl Write for dyn ::realstd::io::LocalOutput {
///
/// 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 Read for &[u8] {
#[inline]
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
@@ -293,6 +298,7 @@ impl Read for &[u8] {
Ok(())
}
+ #[cfg(feature="collections")]
#[inline]
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
buf.extend_from_slice(*self);
@@ -302,7 +308,7 @@ impl Read for &[u8] {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(feature="collections")]
impl BufRead for &[u8] {
#[inline]
fn fill_buf(&mut self) -> io::Result<&[u8]> {
@@ -320,7 +326,6 @@ impl BufRead for &[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 Write for &mut [u8] {
#[inline]
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
@@ -366,7 +371,7 @@ impl Write for &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 e6efe6e..e647c6b 100644
--- a/mod.rs
+++ b/mod.rs
@@ -247,57 +247,46 @@
//! [`Result`]: crate::result::Result
//! [`.unwrap()`]: crate::result::Result::unwrap
-#![stable(feature = "rust1", since = "1.0.0")]
-
#[cfg(test)]
mod tests;
-use crate::cmp;
-use crate::fmt;
-use crate::memchr;
-use crate::ops::{Deref, DerefMut};
-use crate::ptr;
-use crate::slice;
-use crate::str;
-use crate::sys;
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use self::buffered::IntoInnerError;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use self::buffered::{BufReader, BufWriter, LineWriter};
-#[stable(feature = "rust1", since = "1.0.0")]
+use core::cmp;
+use core::fmt;
+#[cfg(not(core_memchr))]
+mod memchr;
+#[cfg(all(feature="collections",core_memchr))]
+use core::slice::memchr;
+use core::ops::{Deref, DerefMut};
+use core::ptr;
+use core::slice;
+use core::str;
+
+#[cfg(feature="collections")] pub use self::buffered::IntoInnerError;
+#[cfg(feature="collections")] pub use self::buffered::{BufReader, BufWriter, LineWriter};
+
pub use self::cursor::Cursor;
-#[stable(feature = "rust1", since = "1.0.0")]
pub use self::error::{Error, ErrorKind, Result};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use self::stdio::{stderr, stdin, stdout, Stderr, Stdin, Stdout};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use self::stdio::{StderrLock, StdinLock, StdoutLock};
-#[unstable(feature = "print_internals", issue = "none")]
-pub use self::stdio::{_eprint, _print};
-#[unstable(feature = "libstd_io_internals", issue = "42788")]
-#[doc(no_inline, hidden)]
-pub use self::stdio::{set_panic, set_print, LocalOutput};
-#[stable(feature = "rust1", since = "1.0.0")]
pub use self::util::{copy, empty, repeat, sink, Empty, Repeat, Sink};
-pub(crate) use self::stdio::clone_io;
+#[cfg(feature="collections")] use collections::string::String;
+#[cfg(feature="collections")] use collections::vec::Vec;
-mod buffered;
+#[cfg(feature="collections")] mod buffered;
mod cursor;
mod error;
mod impls;
pub mod prelude;
-mod stdio;
mod util;
-const DEFAULT_BUF_SIZE: usize = crate::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 Drop for Guard<'_> {
fn drop(&mut self) {
unsafe {
@@ -324,6 +313,7 @@ impl Drop for Guard<'_> {
// 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>,
@@ -351,10 +341,12 @@ where
//
// 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> {
read_to_end_with_reservation(r, buf, |_| 32)
}
+#[cfg(feature="collections")]
fn read_to_end_with_reservation<R, F>(
r: &mut R,
buf: &mut Vec<u8>,
@@ -488,7 +480,6 @@ where
/// [`std::io`]: self
/// [`File`]: crate::fs::File
/// [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
@@ -559,7 +550,6 @@ pub trait Read {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
/// Like `read`, except that it reads into a slice of buffers.
@@ -571,7 +561,6 @@ pub trait Read {
///
/// The default implementation calls `read` with either the first nonempty
/// buffer provided, or an empty one if none exists.
- #[stable(feature = "iovec", since = "1.36.0")]
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize> {
default_read_vectored(|b| self.read(b), bufs)
}
@@ -584,7 +573,6 @@ pub trait Read {
/// and coalesce writes into a single buffer for higher performance.
///
/// The default implementation returns `false`.
- #[unstable(feature = "can_vector", issue = "69941")]
fn is_read_vectored(&self) -> bool {
false
}
@@ -608,7 +596,6 @@ pub trait Read {
/// This method is unsafe because a `Read`er could otherwise return a
/// non-zeroing `Initializer` from another `Read` type without an `unsafe`
/// block.
- #[unstable(feature = "read_initializer", issue = "42788")]
#[inline]
unsafe fn initializer(&self) -> Initializer {
Initializer::zeroing()
@@ -660,7 +647,7 @@ pub trait Read {
/// file.)
///
/// [`std::fs::read`]: crate::fs::read
- #[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)
}
@@ -703,7 +690,7 @@ pub trait Read {
/// reading from a file.)
///
/// [`std::fs::read_to_string`]: crate::fs::read_to_string
- #[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`
@@ -767,7 +754,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) {
@@ -821,7 +807,6 @@ pub trait Read {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
fn by_ref(&mut self) -> &mut Self
where
Self: Sized,
@@ -858,7 +843,6 @@ pub trait Read {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
fn bytes(self) -> Bytes<Self>
where
Self: Sized,
@@ -896,7 +880,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,
@@ -935,7 +918,6 @@ pub trait Read {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
fn take(self, limit: u64) -> Take<Self>
where
Self: Sized,
@@ -944,22 +926,64 @@ pub trait Read {
}
}
+#[derive(Copy, Clone)]
+pub struct IoVecBuffer<'a>(&'a [u8]);
+
+impl<'a> IoVecBuffer<'a> {
+ #[inline]
+ pub fn new(buf: &'a [u8]) -> IoVecBuffer<'a> {
+ IoVecBuffer(buf)
+ }
+
+ #[inline]
+ pub fn advance(&mut self, n: usize) {
+ self.0 = &self.0[n..]
+ }
+
+ #[inline]
+ pub fn as_slice(&self) -> &[u8] {
+ self.0
+ }
+}
+
+pub struct IoVecMutBuffer<'a>(&'a mut [u8]);
+
+impl<'a> IoVecMutBuffer<'a> {
+ #[inline]
+ pub fn new(buf: &'a mut [u8]) -> IoVecMutBuffer<'a> {
+ IoVecMutBuffer(buf)
+ }
+
+ #[inline]
+ pub fn advance(&mut self, n: usize) {
+ let slice = core::mem::replace(&mut self.0, &mut []);
+ let (_, remaining) = slice.split_at_mut(n);
+ self.0 = remaining;
+ }
+
+ #[inline]
+ pub fn as_slice(&self) -> &[u8] {
+ self.0
+ }
+
+ #[inline]
+ pub fn as_mut_slice(&mut self) -> &mut [u8] {
+ self.0
+ }
+}
+
/// A buffer type used with `Read::read_vectored`.
///
/// It is semantically a wrapper around an `&mut [u8]`, but is guaranteed to be
/// ABI compatible with the `iovec` type on Unix platforms and `WSABUF` on
/// Windows.
-#[stable(feature = "iovec", since = "1.36.0")]
#[repr(transparent)]
-pub struct IoSliceMut<'a>(sys::io::IoSliceMut<'a>);
+pub struct IoSliceMut<'a>(IoVecMutBuffer<'a>);
-#[stable(feature = "iovec-send-sync", since = "1.44.0")]
unsafe impl<'a> Send for IoSliceMut<'a> {}
-#[stable(feature = "iovec-send-sync", since = "1.44.0")]
unsafe impl<'a> Sync for IoSliceMut<'a> {}
-#[stable(feature = "iovec", since = "1.36.0")]
impl<'a> fmt::Debug for IoSliceMut<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(self.0.as_slice(), fmt)
@@ -972,10 +996,9 @@ impl<'a> IoSliceMut<'a> {
/// # Panics
///
/// Panics on Windows if the slice is larger than 4GB.
- #[stable(feature = "iovec", since = "1.36.0")]
#[inline]
pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
- IoSliceMut(sys::io::IoSliceMut::new(buf))
+ IoSliceMut(IoVecMutBuffer::new(buf))
}
/// Advance the internal cursor of the slice.
@@ -1010,7 +1033,6 @@ impl<'a> IoSliceMut<'a> {
/// assert_eq!(bufs[0].deref(), [2; 14].as_ref());
/// assert_eq!(bufs[1].deref(), [3; 8].as_ref());
/// ```
- #[unstable(feature = "io_slice_advance", issue = "62726")]
#[inline]
pub fn advance<'b>(bufs: &'b mut [IoSliceMut<'a>], n: usize) -> &'b mut [IoSliceMut<'a>] {
// Number of buffers to remove.
@@ -1034,7 +1056,6 @@ impl<'a> IoSliceMut<'a> {
}
}
-#[stable(feature = "iovec", since = "1.36.0")]
impl<'a> Deref for IoSliceMut<'a> {
type Target = [u8];
@@ -1044,7 +1065,6 @@ impl<'a> Deref for IoSliceMut<'a> {
}
}
-#[stable(feature = "iovec", since = "1.36.0")]
impl<'a> DerefMut for IoSliceMut<'a> {
#[inline]
fn deref_mut(&mut self) -> &mut [u8] {
@@ -1057,18 +1077,14 @@ impl<'a> DerefMut for IoSliceMut<'a> {
/// It is semantically a wrapper around an `&[u8]`, but is guaranteed to be
/// ABI compatible with the `iovec` type on Unix platforms and `WSABUF` on
/// Windows.
-#[stable(feature = "iovec", since = "1.36.0")]
#[derive(Copy, Clone)]
#[repr(transparent)]
-pub struct IoSlice<'a>(sys::io::IoSlice<'a>);
+pub struct IoSlice<'a>(IoVecBuffer<'a>);
-#[stable(feature = "iovec-send-sync", since = "1.44.0")]
unsafe impl<'a> Send for IoSlice<'a> {}
-#[stable(feature = "iovec-send-sync", since = "1.44.0")]
unsafe impl<'a> Sync for IoSlice<'a> {}
-#[stable(feature = "iovec", since = "1.36.0")]
impl<'a> fmt::Debug for IoSlice<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(self.0.as_slice(), fmt)
@@ -1081,10 +1097,9 @@ impl<'a> IoSlice<'a> {
/// # Panics
///
/// Panics on Windows if the slice is larger than 4GB.
- #[stable(feature = "iovec", since = "1.36.0")]
#[inline]
pub fn new(buf: &'a [u8]) -> IoSlice<'a> {
- IoSlice(sys::io::IoSlice::new(buf))
+ IoSlice(IoVecBuffer::new(buf))
}
/// Advance the internal cursor of the slice.
@@ -1118,7 +1133,6 @@ impl<'a> IoSlice<'a> {
/// bufs = IoSlice::advance(bufs, 10);
/// assert_eq!(bufs[0].deref(), [2; 14].as_ref());
/// assert_eq!(bufs[1].deref(), [3; 8].as_ref());
- #[unstable(feature = "io_slice_advance", issue = "62726")]
#[inline]
pub fn advance<'b>(bufs: &'b mut [IoSlice<'a>], n: usize) -> &'b mut [IoSlice<'a>] {
// Number of buffers to remove.
@@ -1142,7 +1156,6 @@ impl<'a> IoSlice<'a> {
}
}
-#[stable(feature = "iovec", since = "1.36.0")]
impl<'a> Deref for IoSlice<'a> {
type Target = [u8];
@@ -1153,13 +1166,11 @@ impl<'a> Deref for IoSlice<'a> {
}
/// 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)
@@ -1173,21 +1184,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() {
@@ -1241,7 +1249,6 @@ impl Initializer {
/// `write` in a loop until its entire input has been written.
///
/// [`write_all`]: Write::write_all
-#[stable(feature = "rust1", since = "1.0.0")]
#[doc(spotlight)]
pub trait Write {
/// Write a buffer into this writer, returning how many bytes were written.
@@ -1288,7 +1295,6 @@ pub trait Write {
/// ```
///
/// [`Ok(n)`]: Ok
- #[stable(feature = "rust1", since = "1.0.0")]
fn write(&mut self, buf: &[u8]) -> Result<usize>;
/// Like [`write`], except that it writes from a slice of buffers.
@@ -1301,7 +1307,6 @@ pub trait Write {
/// buffer provided, or an empty one if none exists.
///
/// [`write`]: Write::write
- #[stable(feature = "iovec", since = "1.36.0")]
fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize> {
default_write_vectored(|b| self.write(b), bufs)
}
@@ -1316,7 +1321,6 @@ pub trait Write {
/// The default implementation returns `false`.
///
/// [`write_vectored`]: Write::write_vectored
- #[unstable(feature = "can_vector", issue = "69941")]
fn is_write_vectored(&self) -> bool {
false
}
@@ -1344,7 +1348,6 @@ pub trait Write {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
fn flush(&mut self) -> Result<()>;
/// Attempts to write an entire buffer into this writer.
@@ -1378,7 +1381,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) {
@@ -1440,7 +1442,6 @@ pub trait Write {
/// assert_eq!(writer, &[1, 2, 3, 4, 5, 6]);
/// # Ok(()) }
/// ```
- #[unstable(feature = "write_all_vectored", issue = "70436")]
fn write_all_vectored(&mut self, mut bufs: &mut [IoSlice<'_>]) -> Result<()> {
// Guarantee that bufs is empty if it contains no data,
// to avoid calling write_vectored if there is no data to be written.
@@ -1493,7 +1494,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
@@ -1549,7 +1549,6 @@ pub trait Write {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
fn by_ref(&mut self) -> &mut Self
where
Self: Sized,
@@ -1584,7 +1583,6 @@ pub trait Write {
/// Ok(())
/// }
/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
pub trait Seek {
/// Seek to an offset, in bytes, in a stream.
///
@@ -1598,7 +1596,6 @@ 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<u64>;
/// Returns the length of this stream (in bytes).
@@ -1635,7 +1632,6 @@ pub trait Seek {
/// Ok(())
/// }
/// ```
- #[unstable(feature = "seek_convenience", issue = "59359")]
fn stream_len(&mut self) -> Result<u64> {
let old_pos = self.stream_position()?;
let len = self.seek(SeekFrom::End(0))?;
@@ -1673,7 +1669,6 @@ pub trait Seek {
/// Ok(())
/// }
/// ```
- #[unstable(feature = "seek_convenience", issue = "59359")]
fn stream_position(&mut self) -> Result<u64> {
self.seek(SeekFrom::Current(0))
}
@@ -1683,29 +1678,26 @@ pub trait Seek {
///
/// It is used by the [`Seek`] trait.
#[derive(Copy, PartialEq, Eq, Clone, Debug)]
-#[stable(feature = "rust1", since = "1.0.0")]
pub enum SeekFrom {
/// Sets the offset to the provided number of bytes.
- #[stable(feature = "rust1", since = "1.0.0")]
- Start(#[stable(feature = "rust1", since = "1.0.0")] u64),
+ Start(u64),
/// Sets the offset to the size of this object plus the specified number of
/// bytes.
///
/// It is possible to seek beyond the end of an object, but it's an error to
/// seek before byte 0.
- #[stable(feature = "rust1", since = "1.0.0")]
- End(#[stable(feature = "rust1", since = "1.0.0")] i64),
+ End(i64),
/// Sets the offset to the current position plus the specified number of
/// bytes.
///
/// It is possible to seek beyond the end of an object, but it's an error to
/// seek before byte 0.
- #[stable(feature = "rust1", since = "1.0.0")]
- Current(#[stable(feature = "rust1", since = "1.0.0")] i64),
+ Current(i64),
}
+#[cfg(feature="collections")]
fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>) -> Result<usize> {
let mut read = 0;
loop {
@@ -1781,7 +1773,7 @@ fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>) -> R
/// Ok(())
/// }
/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(feature="collections")]
pub trait BufRead: Read {
/// Returns the contents of the internal buffer, filling it with more data
/// from the inner reader if it is empty.
@@ -1822,7 +1814,6 @@ pub trait BufRead: Read {
/// let length = buffer.len();
/// 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,
@@ -1844,7 +1835,6 @@ pub trait BufRead: Read {
/// that method's example includes an example of `consume()`.
///
/// [`fill_buf`]: BufRead::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.
@@ -1901,7 +1891,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)
}
@@ -1964,7 +1953,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
@@ -2003,7 +1991,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,
@@ -2040,7 +2027,6 @@ pub trait BufRead: Read {
/// # Errors
///
/// Each line of the iterator has the same error semantics as [`BufRead::read_line`].
- #[stable(feature = "rust1", since = "1.0.0")]
fn lines(self) -> Lines<Self>
where
Self: Sized,
@@ -2055,7 +2041,6 @@ pub trait BufRead: Read {
/// Please see the documentation of [`chain`] for more details.
///
/// [`chain`]: Read::chain
-#[stable(feature = "rust1", since = "1.0.0")]
pub struct Chain<T, U> {
first: T,
second: U,
@@ -2081,7 +2066,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)
}
@@ -2104,7 +2088,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)
}
@@ -2131,20 +2114,17 @@ 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").field("t", &self.first).field("u", &self.second).finish()
}
}
-#[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 {
@@ -2172,7 +2152,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 {
@@ -2197,7 +2177,6 @@ impl<T: BufRead, U: BufRead> BufRead for Chain<T, U> {
/// Please see the documentation of [`take`] for more details.
///
/// [`take`]: Read::take
-#[stable(feature = "rust1", since = "1.0.0")]
#[derive(Debug)]
pub struct Take<T> {
inner: T,
@@ -2230,7 +2209,6 @@ impl<T> Take<T> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
pub fn limit(&self) -> u64 {
self.limit
}
@@ -2258,7 +2236,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;
}
@@ -2283,7 +2260,6 @@ impl<T> Take<T> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "io_take_into_inner", since = "1.15.0")]
pub fn into_inner(self) -> T {
self.inner
}
@@ -2308,7 +2284,6 @@ impl<T> Take<T> {
/// Ok(())
/// }
/// ```
- #[stable(feature = "more_io_inner_methods", since = "1.20.0")]
pub fn get_ref(&self) -> &T {
&self.inner
}
@@ -2337,13 +2312,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
@@ -2361,6 +2334,7 @@ impl<T: Read> Read for Take<T> {
self.inner.initializer()
}
+ #[cfg(feature="collections")]
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize> {
// Pass in a reservation_size closure that respects the current value
// of limit for each read. If we hit the read limit, this prevents the
@@ -2369,7 +2343,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
@@ -2396,13 +2370,11 @@ impl<T: BufRead> BufRead for Take<T> {
/// Please see the documentation of [`bytes`] for more details.
///
/// [`bytes`]: Read::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>;
@@ -2426,14 +2398,14 @@ impl<R: Read> Iterator for Bytes<R> {
/// Please see the documentation of [`split`] for more details.
///
/// [`split`]: BufRead::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>>;
@@ -2458,13 +2430,13 @@ impl<B: BufRead> Iterator for Split<B> {
/// Please see the documentation of [`lines`] for more details.
///
/// [`lines`]: BufRead::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 3baab2b..7d96d23 100644
--- a/prelude.rs
+++ b/prelude.rs
@@ -8,7 +8,8 @@
//! use std::io::prelude::*;
//! ```
-#![stable(feature = "rust1", since = "1.0.0")]
+pub use super::{Read, Seek, Write};
+#[cfg(feature="collections")] pub use super::BufRead;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use super::{BufRead, Read, Seek, Write};
+#[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 dc05b96..aa7ee35 100644
--- a/util.rs
+++ b/util.rs
@@ -3,9 +3,10 @@
#[cfg(test)]
mod tests;
-use crate::fmt;
-use crate::io::{self, BufRead, ErrorKind, Initializer, IoSlice, IoSliceMut, Read, Write};
-use crate::mem::MaybeUninit;
+use core::fmt;
+use crate::io::{self, ErrorKind, Initializer, IoSlice, IoSliceMut, Read, Write};
+#[cfg(feature="collections")] use crate::io::BufRead;
+use core::mem::MaybeUninit;
/// Copies the entire contents of a reader into a writer.
///
@@ -45,7 +46,6 @@ use crate::mem::MaybeUninit;
/// 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,
@@ -81,7 +81,6 @@ where
///
/// This struct is generally created by calling [`empty()`]. Please see
/// the documentation of [`empty()`] for more details.
-#[stable(feature = "rust1", since = "1.0.0")]
pub struct Empty {
_priv: (),
}
@@ -101,12 +100,10 @@ pub struct Empty {
/// 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> {
@@ -118,7 +115,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]> {
@@ -128,7 +126,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 { .. }")
@@ -139,7 +136,6 @@ impl fmt::Debug for Empty {
///
/// This struct is generally created by calling [`repeat()`]. Please
/// see the documentation of [`repeat()`] for more details.
-#[stable(feature = "rust1", since = "1.0.0")]
pub struct Repeat {
byte: u8,
}
@@ -158,12 +154,10 @@ pub struct Repeat {
/// io::repeat(0b101).read_exact(&mut buffer).unwrap();
/// assert_eq!(buffer, [0b101, 0b101, 0b101]);
/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
pub fn repeat(byte: u8) -> Repeat {
Repeat { byte }
}
-#[stable(feature = "rust1", since = "1.0.0")]
impl Read for Repeat {
#[inline]
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
@@ -193,7 +187,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 { .. }")
@@ -204,7 +197,6 @@ impl fmt::Debug for Repeat {
///
/// This struct is generally created by calling [`sink`]. Please
/// see the documentation of [`sink()`] for more details.
-#[stable(feature = "rust1", since = "1.0.0")]
pub struct Sink {
_priv: (),
}
@@ -225,12 +217,10 @@ pub struct Sink {
/// 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> {
@@ -254,7 +244,6 @@ impl Write for Sink {
}
}
-#[stable(feature = "write_mt", since = "1.48.0")]
impl Write for &Sink {
#[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
@@ -278,7 +267,6 @@ impl Write for &Sink {
}
}
-#[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