aboutsummaryrefslogtreecommitdiff
path: root/ctr-std/src/io/mod.rs
diff options
context:
space:
mode:
Diffstat (limited to 'ctr-std/src/io/mod.rs')
-rw-r--r--ctr-std/src/io/mod.rs622
1 files changed, 315 insertions, 307 deletions
diff --git a/ctr-std/src/io/mod.rs b/ctr-std/src/io/mod.rs
index 33d11eb..b02e133 100644
--- a/ctr-std/src/io/mod.rs
+++ b/ctr-std/src/io/mod.rs
@@ -24,21 +24,21 @@
//! example, [`Read`] adds a [`read`][`Read::read`] method, which we can use on
//! [`File`]s:
//!
-//! ```
+//! ```no_run
//! use std::io;
//! use std::io::prelude::*;
//! use std::fs::File;
//!
-//! # fn foo() -> io::Result<()> {
-//! let mut f = File::open("foo.txt")?;
-//! let mut buffer = [0; 10];
+//! fn main() -> io::Result<()> {
+//! let mut f = File::open("foo.txt")?;
+//! let mut buffer = [0; 10];
//!
-//! // read up to 10 bytes
-//! f.read(&mut buffer)?;
+//! // read up to 10 bytes
+//! f.read(&mut buffer)?;
//!
-//! println!("The bytes: {:?}", buffer);
-//! # Ok(())
-//! # }
+//! println!("The bytes: {:?}", buffer);
+//! Ok(())
+//! }
//! ```
//!
//! [`Read`] and [`Write`] are so important, implementors of the two traits have a
@@ -52,25 +52,25 @@
//! how the reading happens. [`Seek`] lets you control where the next byte is
//! coming from:
//!
-//! ```
+//! ```no_run
//! use std::io;
//! use std::io::prelude::*;
//! use std::io::SeekFrom;
//! use std::fs::File;
//!
-//! # fn foo() -> io::Result<()> {
-//! let mut f = File::open("foo.txt")?;
-//! let mut buffer = [0; 10];
+//! fn main() -> io::Result<()> {
+//! let mut f = File::open("foo.txt")?;
+//! let mut buffer = [0; 10];
//!
-//! // skip to the last 10 bytes of the file
-//! f.seek(SeekFrom::End(-10))?;
+//! // skip to the last 10 bytes of the file
+//! f.seek(SeekFrom::End(-10))?;
//!
-//! // read up to 10 bytes
-//! f.read(&mut buffer)?;
+//! // read up to 10 bytes
+//! f.read(&mut buffer)?;
//!
-//! println!("The bytes: {:?}", buffer);
-//! # Ok(())
-//! # }
+//! println!("The bytes: {:?}", buffer);
+//! Ok(())
+//! }
//! ```
//!
//! [`BufRead`] uses an internal buffer to provide a number of other ways to read, but
@@ -87,70 +87,70 @@
//! For example, [`BufReader`] works with the [`BufRead`] trait to add extra
//! methods to any reader:
//!
-//! ```
+//! ```no_run
//! use std::io;
//! use std::io::prelude::*;
//! use std::io::BufReader;
//! use std::fs::File;
//!
-//! # fn foo() -> io::Result<()> {
-//! let f = File::open("foo.txt")?;
-//! let mut reader = BufReader::new(f);
-//! let mut buffer = String::new();
+//! fn main() -> io::Result<()> {
+//! let f = File::open("foo.txt")?;
+//! let mut reader = BufReader::new(f);
+//! let mut buffer = String::new();
//!
-//! // read a line into buffer
-//! reader.read_line(&mut buffer)?;
+//! // read a line into buffer
+//! reader.read_line(&mut buffer)?;
//!
-//! println!("{}", buffer);
-//! # Ok(())
-//! # }
+//! println!("{}", buffer);
+//! Ok(())
+//! }
//! ```
//!
//! [`BufWriter`] doesn't add any new ways of writing; it just buffers every call
//! to [`write`][`Write::write`]:
//!
-//! ```
+//! ```no_run
//! use std::io;
//! use std::io::prelude::*;
//! use std::io::BufWriter;
//! use std::fs::File;
//!
-//! # fn foo() -> io::Result<()> {
-//! let f = File::create("foo.txt")?;
-//! {
-//! let mut writer = BufWriter::new(f);
+//! fn main() -> io::Result<()> {
+//! let f = File::create("foo.txt")?;
+//! {
+//! let mut writer = BufWriter::new(f);
//!
-//! // write a byte to the buffer
-//! writer.write(&[42])?;
+//! // write a byte to the buffer
+//! writer.write(&[42])?;
//!
-//! } // the buffer is flushed once writer goes out of scope
+//! } // the buffer is flushed once writer goes out of scope
//!
-//! # Ok(())
-//! # }
+//! Ok(())
+//! }
//! ```
//!
//! ## Standard input and output
//!
//! A very common source of input is standard input:
//!
-//! ```
+//! ```no_run
//! use std::io;
//!
-//! # fn foo() -> io::Result<()> {
-//! let mut input = String::new();
+//! fn main() -> io::Result<()> {
+//! let mut input = String::new();
//!
-//! io::stdin().read_line(&mut input)?;
+//! io::stdin().read_line(&mut input)?;
//!
-//! println!("You typed: {}", input.trim());
-//! # Ok(())
-//! # }
+//! println!("You typed: {}", input.trim());
+//! Ok(())
+//! }
//! ```
//!
//! Note that you cannot use the [`?` operator] in functions that do not return
//! a [`Result<T, E>`][`Result`] (e.g. `main`). Instead, you can call [`.unwrap()`]
//! or `match` on the return value to catch any possible errors:
//!
-//! ```
+//! ```no_run
//! use std::io;
//!
//! let mut input = String::new();
@@ -160,14 +160,14 @@
//!
//! And a very common source of output is standard output:
//!
-//! ```
+//! ```no_run
//! use std::io;
//! use std::io::prelude::*;
//!
-//! # fn foo() -> io::Result<()> {
-//! io::stdout().write(&[42])?;
-//! # Ok(())
-//! # }
+//! fn main() -> io::Result<()> {
+//! io::stdout().write(&[42])?;
+//! Ok(())
+//! }
//! ```
//!
//! Of course, using [`io::stdout`] directly is less common than something like
@@ -179,22 +179,21 @@
//! ways of iterating over I/O. For example, [`Lines`] is used to split over
//! lines:
//!
-//! ```
+//! ```no_run
//! use std::io;
//! use std::io::prelude::*;
//! use std::io::BufReader;
//! use std::fs::File;
//!
-//! # fn foo() -> io::Result<()> {
-//! let f = File::open("foo.txt")?;
-//! let reader = BufReader::new(f);
+//! fn main() -> io::Result<()> {
+//! let f = File::open("foo.txt")?;
+//! let reader = BufReader::new(f);
//!
-//! for line in reader.lines() {
-//! println!("{}", line?);
+//! for line in reader.lines() {
+//! println!("{}", line?);
+//! }
+//! Ok(())
//! }
-//!
-//! # Ok(())
-//! # }
//! ```
//!
//! ## Functions
@@ -203,13 +202,13 @@
//! features. For example, we can use three of these functions to copy everything
//! from standard input to standard output:
//!
-//! ```
+//! ```no_run
//! use std::io;
//!
-//! # fn foo() -> io::Result<()> {
-//! io::copy(&mut io::stdin(), &mut io::stdout())?;
-//! # Ok(())
-//! # }
+//! fn main() -> io::Result<()> {
+//! io::copy(&mut io::stdin(), &mut io::stdout())?;
+//! Ok(())
+//! }
//! ```
//!
//! [functions-list]: #functions-1
@@ -416,47 +415,47 @@ fn read_to_end<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<usize>
///
/// [`File`]s implement `Read`:
///
-/// ```
-/// # use std::io;
+/// ```no_run
+/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
-/// # fn foo() -> io::Result<()> {
-/// let mut f = File::open("foo.txt")?;
-/// let mut buffer = [0; 10];
+/// fn main() -> io::Result<()> {
+/// let mut f = File::open("foo.txt")?;
+/// let mut buffer = [0; 10];
///
-/// // read up to 10 bytes
-/// f.read(&mut buffer)?;
+/// // read up to 10 bytes
+/// f.read(&mut buffer)?;
///
-/// let mut buffer = vec![0; 10];
-/// // read the whole file
-/// f.read_to_end(&mut buffer)?;
+/// let mut buffer = vec![0; 10];
+/// // read the whole file
+/// f.read_to_end(&mut buffer)?;
///
-/// // read into a String, so that you don't need to do the conversion.
-/// let mut buffer = String::new();
-/// f.read_to_string(&mut buffer)?;
+/// // read into a String, so that you don't need to do the conversion.
+/// let mut buffer = String::new();
+/// f.read_to_string(&mut buffer)?;
///
-/// // and more! See the other methods for more details.
-/// # Ok(())
-/// # }
+/// // and more! See the other methods for more details.
+/// Ok(())
+/// }
/// ```
///
/// Read from [`&str`] because [`&[u8]`][slice] implements `Read`:
///
-/// ```
+/// ```no_run
/// # use std::io;
/// use std::io::prelude::*;
///
-/// # fn foo() -> io::Result<()> {
-/// let mut b = "This string will be read".as_bytes();
-/// let mut buffer = [0; 10];
+/// fn main() -> io::Result<()> {
+/// let mut b = "This string will be read".as_bytes();
+/// let mut buffer = [0; 10];
///
-/// // read up to 10 bytes
-/// b.read(&mut buffer)?;
+/// // read up to 10 bytes
+/// b.read(&mut buffer)?;
///
-/// // etc... it works exactly as a File does!
-/// # Ok(())
-/// # }
+/// // etc... it works exactly as a File does!
+/// Ok(())
+/// }
/// ```
///
/// [`read()`]: trait.Read.html#tymethod.read
@@ -509,19 +508,19 @@ pub trait Read {
/// [`ErrorKind::Interrupted`]: ../../std/io/enum.ErrorKind.html#variant.Interrupted
/// [`File`]: ../fs/struct.File.html
///
- /// ```
+ /// ```no_run
/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut f = File::open("foo.txt")?;
- /// let mut buffer = [0; 10];
+ /// fn main() -> io::Result<()> {
+ /// let mut f = File::open("foo.txt")?;
+ /// let mut buffer = [0; 10];
///
- /// // read up to 10 bytes
- /// f.read(&mut buffer[..])?;
- /// # Ok(())
- /// # }
+ /// // read up to 10 bytes
+ /// f.read(&mut buffer[..])?;
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
@@ -582,20 +581,25 @@ pub trait Read {
/// [`ErrorKind::Interrupted`]: ../../std/io/enum.ErrorKind.html#variant.Interrupted
/// [`File`]: ../fs/struct.File.html
///
- /// ```
+ /// ```no_run
/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut f = File::open("foo.txt")?;
- /// let mut buffer = Vec::new();
+ /// fn main() -> io::Result<()> {
+ /// let mut f = File::open("foo.txt")?;
+ /// let mut buffer = Vec::new();
///
- /// // read the whole file
- /// f.read_to_end(&mut buffer)?;
- /// # Ok(())
- /// # }
+ /// // read the whole file
+ /// f.read_to_end(&mut buffer)?;
+ /// Ok(())
+ /// }
/// ```
+ ///
+ /// (See also the [`std::fs::read`] convenience function for reading from a
+ /// file.)
+ ///
+ /// [`std::fs::read`]: ../fs/fn.read.html
#[stable(feature = "rust1", since = "1.0.0")]
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize> {
read_to_end(self, buf)
@@ -621,19 +625,24 @@ pub trait Read {
///
/// [file]: ../fs/struct.File.html
///
- /// ```
+ /// ```no_run
/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut f = File::open("foo.txt")?;
- /// let mut buffer = String::new();
+ /// fn main() -> io::Result<()> {
+ /// let mut f = File::open("foo.txt")?;
+ /// let mut buffer = String::new();
///
- /// f.read_to_string(&mut buffer)?;
- /// # Ok(())
- /// # }
+ /// f.read_to_string(&mut buffer)?;
+ /// Ok(())
+ /// }
/// ```
+ ///
+ /// (See also the [`std::fs::read_to_string`] convenience function for
+ /// reading from a file.)
+ ///
+ /// [`std::fs::read_to_string`]: ../fs/fn.read_to_string.html
#[stable(feature = "rust1", since = "1.0.0")]
fn read_to_string(&mut self, buf: &mut String) -> Result<usize> {
// Note that we do *not* call `.read_to_end()` here. We are passing
@@ -683,19 +692,19 @@ pub trait Read {
/// [`ErrorKind::Interrupted`]: ../../std/io/enum.ErrorKind.html#variant.Interrupted
/// [`ErrorKind::UnexpectedEof`]: ../../std/io/enum.ErrorKind.html#variant.UnexpectedEof
///
- /// ```
+ /// ```no_run
/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut f = File::open("foo.txt")?;
- /// let mut buffer = [0; 10];
+ /// fn main() -> io::Result<()> {
+ /// let mut f = File::open("foo.txt")?;
+ /// let mut buffer = [0; 10];
///
- /// // read exactly 10 bytes
- /// f.read_exact(&mut buffer)?;
- /// # Ok(())
- /// # }
+ /// // read exactly 10 bytes
+ /// f.read_exact(&mut buffer)?;
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "read_exact", since = "1.6.0")]
fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<()> {
@@ -726,28 +735,28 @@ pub trait Read {
///
/// [file]: ../fs/struct.File.html
///
- /// ```
+ /// ```no_run
/// use std::io;
/// use std::io::Read;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut f = File::open("foo.txt")?;
- /// let mut buffer = Vec::new();
- /// let mut other_buffer = Vec::new();
+ /// fn main() -> io::Result<()> {
+ /// let mut f = File::open("foo.txt")?;
+ /// let mut buffer = Vec::new();
+ /// let mut other_buffer = Vec::new();
///
- /// {
- /// let reference = f.by_ref();
+ /// {
+ /// let reference = f.by_ref();
///
- /// // read at most 5 bytes
- /// reference.take(5).read_to_end(&mut buffer)?;
+ /// // read at most 5 bytes
+ /// reference.take(5).read_to_end(&mut buffer)?;
///
- /// } // drop our &mut reference so we can use f again
+ /// } // drop our &mut reference so we can use f again
///
- /// // original file still usable, read the rest
- /// f.read_to_end(&mut other_buffer)?;
- /// # Ok(())
- /// # }
+ /// // original file still usable, read the rest
+ /// f.read_to_end(&mut other_buffer)?;
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn by_ref(&mut self) -> &mut Self where Self: Sized { self }
@@ -772,19 +781,19 @@ pub trait Read {
/// [`Err`]: ../../std/result/enum.Result.html#variant.Err
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
- /// ```
+ /// ```no_run
/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut f = File::open("foo.txt")?;
+ /// fn main() -> io::Result<()> {
+ /// let mut f = File::open("foo.txt")?;
///
- /// for byte in f.bytes() {
- /// println!("{}", byte.unwrap());
+ /// for byte in f.bytes() {
+ /// println!("{}", byte.unwrap());
+ /// }
+ /// Ok(())
/// }
- /// # Ok(())
- /// # }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn bytes(self) -> Bytes<Self> where Self: Sized {
@@ -812,20 +821,20 @@ pub trait Read {
/// [`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 foo() -> io::Result<()> {
- /// let mut f = File::open("foo.txt")?;
+ /// fn main() -> io::Result<()> {
+ /// let mut f = File::open("foo.txt")?;
///
- /// for c in f.chars() {
- /// println!("{}", c.unwrap());
+ /// for c in f.chars() {
+ /// println!("{}", c.unwrap());
+ /// }
+ /// Ok(())
/// }
- /// # Ok(())
- /// # }
/// ```
#[unstable(feature = "io", reason = "the semantics of a partial read/write \
of where errors happen is currently \
@@ -847,23 +856,23 @@ pub trait Read {
///
/// [file]: ../fs/struct.File.html
///
- /// ```
+ /// ```no_run
/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut f1 = File::open("foo.txt")?;
- /// let mut f2 = File::open("bar.txt")?;
+ /// fn main() -> io::Result<()> {
+ /// let mut f1 = File::open("foo.txt")?;
+ /// let mut f2 = File::open("bar.txt")?;
///
- /// let mut handle = f1.chain(f2);
- /// let mut buffer = String::new();
+ /// let mut handle = f1.chain(f2);
+ /// let mut buffer = String::new();
///
- /// // read the value into a String. We could use any Read method here,
- /// // this is just one example.
- /// handle.read_to_string(&mut buffer)?;
- /// # Ok(())
- /// # }
+ /// // read the value into a String. We could use any Read method here,
+ /// // this is just one example.
+ /// handle.read_to_string(&mut buffer)?;
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn chain<R: Read>(self, next: R) -> Chain<Self, R> where Self: Sized {
@@ -885,21 +894,21 @@ pub trait Read {
/// [`Ok(0)`]: ../../std/result/enum.Result.html#variant.Ok
/// [`read()`]: trait.Read.html#tymethod.read
///
- /// ```
+ /// ```no_run
/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut f = File::open("foo.txt")?;
- /// let mut buffer = [0; 5];
+ /// fn main() -> io::Result<()> {
+ /// let mut f = File::open("foo.txt")?;
+ /// let mut buffer = [0; 5];
///
- /// // read at most five bytes
- /// let mut handle = f.take(5);
+ /// // read at most five bytes
+ /// let mut handle = f.take(5);
///
- /// handle.read(&mut buffer)?;
- /// # Ok(())
- /// # }
+ /// handle.read(&mut buffer)?;
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn take(self, limit: u64) -> Take<Self> where Self: Sized {
@@ -974,16 +983,16 @@ impl Initializer {
///
/// # Examples
///
-/// ```
+/// ```no_run
/// use std::io::prelude::*;
/// use std::fs::File;
///
-/// # fn foo() -> std::io::Result<()> {
-/// let mut buffer = File::create("foo.txt")?;
+/// fn main() -> std::io::Result<()> {
+/// let mut buffer = File::create("foo.txt")?;
///
-/// buffer.write(b"some bytes")?;
-/// # Ok(())
-/// # }
+/// buffer.write(b"some bytes")?;
+/// Ok(())
+/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(spotlight)]
@@ -1022,17 +1031,17 @@ pub trait Write {
///
/// # Examples
///
- /// ```
+ /// ```no_run
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> std::io::Result<()> {
- /// let mut buffer = File::create("foo.txt")?;
+ /// fn main() -> std::io::Result<()> {
+ /// let mut buffer = File::create("foo.txt")?;
///
- /// // Writes some prefix of the byte string, not necessarily all of it.
- /// buffer.write(b"some bytes")?;
- /// # Ok(())
- /// # }
+ /// // Writes some prefix of the byte string, not necessarily all of it.
+ /// buffer.write(b"some bytes")?;
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn write(&mut self, buf: &[u8]) -> Result<usize>;
@@ -1047,18 +1056,18 @@ pub trait Write {
///
/// # Examples
///
- /// ```
+ /// ```no_run
/// use std::io::prelude::*;
/// use std::io::BufWriter;
/// use std::fs::File;
///
- /// # fn foo() -> std::io::Result<()> {
- /// let mut buffer = BufWriter::new(File::create("foo.txt")?);
+ /// fn main() -> std::io::Result<()> {
+ /// let mut buffer = BufWriter::new(File::create("foo.txt")?);
///
- /// buffer.write(b"some bytes")?;
- /// buffer.flush()?;
- /// # Ok(())
- /// # }
+ /// buffer.write(b"some bytes")?;
+ /// buffer.flush()?;
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn flush(&mut self) -> Result<()>;
@@ -1082,16 +1091,16 @@ pub trait Write {
///
/// # Examples
///
- /// ```
+ /// ```no_run
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> std::io::Result<()> {
- /// let mut buffer = File::create("foo.txt")?;
+ /// fn main() -> std::io::Result<()> {
+ /// let mut buffer = File::create("foo.txt")?;
///
- /// buffer.write_all(b"some bytes")?;
- /// # Ok(())
- /// # }
+ /// buffer.write_all(b"some bytes")?;
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn write_all(&mut self, mut buf: &[u8]) -> Result<()> {
@@ -1131,19 +1140,19 @@ pub trait Write {
///
/// # Examples
///
- /// ```
+ /// ```no_run
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> std::io::Result<()> {
- /// let mut buffer = File::create("foo.txt")?;
+ /// fn main() -> std::io::Result<()> {
+ /// let mut buffer = File::create("foo.txt")?;
///
- /// // this call
- /// write!(buffer, "{:.*}", 2, 1.234567)?;
- /// // turns into this:
- /// buffer.write_fmt(format_args!("{:.*}", 2, 1.234567))?;
- /// # Ok(())
- /// # }
+ /// // this call
+ /// write!(buffer, "{:.*}", 2, 1.234567)?;
+ /// // turns into this:
+ /// buffer.write_fmt(format_args!("{:.*}", 2, 1.234567))?;
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()> {
@@ -1187,19 +1196,19 @@ pub trait Write {
///
/// # Examples
///
- /// ```
+ /// ```no_run
/// use std::io::Write;
/// use std::fs::File;
///
- /// # fn foo() -> std::io::Result<()> {
- /// let mut buffer = File::create("foo.txt")?;
+ /// fn main() -> std::io::Result<()> {
+ /// let mut buffer = File::create("foo.txt")?;
///
- /// let reference = buffer.by_ref();
+ /// let reference = buffer.by_ref();
///
- /// // we can use reference just like our original buffer
- /// reference.write_all(b"some bytes")?;
- /// # Ok(())
- /// # }
+ /// // we can use reference just like our original buffer
+ /// reference.write_all(b"some bytes")?;
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn by_ref(&mut self) -> &mut Self where Self: Sized { self }
@@ -1217,19 +1226,19 @@ pub trait Write {
///
/// [file]: ../fs/struct.File.html
///
-/// ```
+/// ```no_run
/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
/// use std::io::SeekFrom;
///
-/// # fn foo() -> io::Result<()> {
-/// let mut f = File::open("foo.txt")?;
+/// fn main() -> io::Result<()> {
+/// let mut f = File::open("foo.txt")?;
///
-/// // move the cursor 42 bytes from the start of the file
-/// f.seek(SeekFrom::Start(42))?;
-/// # Ok(())
-/// # }
+/// // move the cursor 42 bytes from the start of the file
+/// f.seek(SeekFrom::Start(42))?;
+/// Ok(())
+/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub trait Seek {
@@ -1320,7 +1329,7 @@ fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>)
///
/// A locked standard input implements `BufRead`:
///
-/// ```
+/// ```no_run
/// use std::io;
/// use std::io::prelude::*;
///
@@ -1342,21 +1351,21 @@ fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>)
/// [`lines`]: #method.lines
/// [`Read`]: trait.Read.html
///
-/// ```
+/// ```no_run
/// use std::io::{self, BufReader};
/// use std::io::prelude::*;
/// use std::fs::File;
///
-/// # fn foo() -> io::Result<()> {
-/// let f = File::open("foo.txt")?;
-/// let f = BufReader::new(f);
+/// fn main() -> io::Result<()> {
+/// let f = File::open("foo.txt")?;
+/// let f = BufReader::new(f);
///
-/// for line in f.lines() {
-/// println!("{}", line.unwrap());
-/// }
+/// for line in f.lines() {
+/// println!("{}", line.unwrap());
+/// }
///
-/// # Ok(())
-/// # }
+/// Ok(())
+/// }
/// ```
///
#[stable(feature = "rust1", since = "1.0.0")]
@@ -1383,7 +1392,7 @@ pub trait BufRead: Read {
///
/// A locked standard input implements `BufRead`:
///
- /// ```
+ /// ```no_run
/// use std::io;
/// use std::io::prelude::*;
///
@@ -1437,8 +1446,6 @@ pub trait BufRead: Read {
///
/// If successful, this function will return the total number of bytes read.
///
- /// An empty buffer returned indicates that the stream has reached EOF.
- ///
/// # Errors
///
/// This function will ignore all instances of [`ErrorKind::Interrupted`] and
@@ -1508,6 +1515,8 @@ pub trait BufRead: Read {
/// error is encountered then `buf` may contain some bytes already read in
/// the event that all data read so far was valid UTF-8.
///
+ /// [`read_until`]: #method.read_until
+ ///
/// # Examples
///
/// [`std::io::Cursor`][`Cursor`] is a type that implements `BufRead`. In
@@ -1645,19 +1654,19 @@ impl<T, U> Chain<T, U> {
///
/// # Examples
///
- /// ```
- /// # use std::io;
+ /// ```no_run
+ /// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut foo_file = File::open("foo.txt")?;
- /// let mut bar_file = File::open("bar.txt")?;
+ /// fn main() -> io::Result<()> {
+ /// let mut foo_file = File::open("foo.txt")?;
+ /// let mut bar_file = File::open("bar.txt")?;
///
- /// let chain = foo_file.chain(bar_file);
- /// let (foo_file, bar_file) = chain.into_inner();
- /// # Ok(())
- /// # }
+ /// let chain = foo_file.chain(bar_file);
+ /// let (foo_file, bar_file) = chain.into_inner();
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "more_io_inner_methods", since = "1.20.0")]
pub fn into_inner(self) -> (T, U) {
@@ -1668,19 +1677,19 @@ impl<T, U> Chain<T, U> {
///
/// # Examples
///
- /// ```
- /// # use std::io;
+ /// ```no_run
+ /// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut foo_file = File::open("foo.txt")?;
- /// let mut bar_file = File::open("bar.txt")?;
+ /// fn main() -> io::Result<()> {
+ /// let mut foo_file = File::open("foo.txt")?;
+ /// let mut bar_file = File::open("bar.txt")?;
///
- /// let chain = foo_file.chain(bar_file);
- /// let (foo_file, bar_file) = chain.get_ref();
- /// # Ok(())
- /// # }
+ /// let chain = foo_file.chain(bar_file);
+ /// let (foo_file, bar_file) = chain.get_ref();
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "more_io_inner_methods", since = "1.20.0")]
pub fn get_ref(&self) -> (&T, &U) {
@@ -1695,19 +1704,19 @@ impl<T, U> Chain<T, U> {
///
/// # Examples
///
- /// ```
- /// # use std::io;
+ /// ```no_run
+ /// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut foo_file = File::open("foo.txt")?;
- /// let mut bar_file = File::open("bar.txt")?;
+ /// fn main() -> io::Result<()> {
+ /// let mut foo_file = File::open("foo.txt")?;
+ /// let mut bar_file = File::open("bar.txt")?;
///
- /// let mut chain = foo_file.chain(bar_file);
- /// let (foo_file, bar_file) = chain.get_mut();
- /// # Ok(())
- /// # }
+ /// let mut chain = foo_file.chain(bar_file);
+ /// let (foo_file, bar_file) = chain.get_mut();
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "more_io_inner_methods", since = "1.20.0")]
pub fn get_mut(&mut self) -> (&mut T, &mut U) {
@@ -1794,20 +1803,20 @@ impl<T> Take<T> {
///
/// # Examples
///
- /// ```
+ /// ```no_run
/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let f = File::open("foo.txt")?;
+ /// fn main() -> io::Result<()> {
+ /// let f = File::open("foo.txt")?;
///
- /// // read at most five bytes
- /// let handle = f.take(5);
+ /// // read at most five bytes
+ /// let handle = f.take(5);
///
- /// println!("limit: {}", handle.limit());
- /// # Ok(())
- /// # }
+ /// println!("limit: {}", handle.limit());
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn limit(&self) -> u64 { self.limit }
@@ -1819,24 +1828,23 @@ impl<T> Take<T> {
///
/// # Examples
///
- /// ```
- /// #![feature(take_set_limit)]
+ /// ```no_run
/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let f = File::open("foo.txt")?;
+ /// fn main() -> io::Result<()> {
+ /// let f = File::open("foo.txt")?;
///
- /// // read at most five bytes
- /// let mut handle = f.take(5);
- /// handle.set_limit(10);
+ /// // read at most five bytes
+ /// let mut handle = f.take(5);
+ /// handle.set_limit(10);
///
- /// assert_eq!(handle.limit(), 10);
- /// # Ok(())
- /// # }
+ /// assert_eq!(handle.limit(), 10);
+ /// Ok(())
+ /// }
/// ```
- #[unstable(feature = "take_set_limit", issue = "42781")]
+ #[stable(feature = "take_set_limit", since = "1.27.0")]
pub fn set_limit(&mut self, limit: u64) {
self.limit = limit;
}
@@ -1845,21 +1853,21 @@ impl<T> Take<T> {
///
/// # Examples
///
- /// ```
+ /// ```no_run
/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut file = File::open("foo.txt")?;
+ /// fn main() -> io::Result<()> {
+ /// let mut file = File::open("foo.txt")?;
///
- /// let mut buffer = [0; 5];
- /// let mut handle = file.take(5);
- /// handle.read(&mut buffer)?;
+ /// let mut buffer = [0; 5];
+ /// let mut handle = file.take(5);
+ /// handle.read(&mut buffer)?;
///
- /// let file = handle.into_inner();
- /// # Ok(())
- /// # }
+ /// let file = handle.into_inner();
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "io_take_into_inner", since = "1.15.0")]
pub fn into_inner(self) -> T {
@@ -1870,21 +1878,21 @@ impl<T> Take<T> {
///
/// # Examples
///
- /// ```
+ /// ```no_run
/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut file = File::open("foo.txt")?;
+ /// fn main() -> io::Result<()> {
+ /// let mut file = File::open("foo.txt")?;
///
- /// let mut buffer = [0; 5];
- /// let mut handle = file.take(5);
- /// handle.read(&mut buffer)?;
+ /// let mut buffer = [0; 5];
+ /// let mut handle = file.take(5);
+ /// handle.read(&mut buffer)?;
///
- /// let file = handle.get_ref();
- /// # Ok(())
- /// # }
+ /// let file = handle.get_ref();
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "more_io_inner_methods", since = "1.20.0")]
pub fn get_ref(&self) -> &T {
@@ -1899,21 +1907,21 @@ impl<T> Take<T> {
///
/// # Examples
///
- /// ```
+ /// ```no_run
/// use std::io;
/// use std::io::prelude::*;
/// use std::fs::File;
///
- /// # fn foo() -> io::Result<()> {
- /// let mut file = File::open("foo.txt")?;
+ /// fn main() -> io::Result<()> {
+ /// let mut file = File::open("foo.txt")?;
///
- /// let mut buffer = [0; 5];
- /// let mut handle = file.take(5);
- /// handle.read(&mut buffer)?;
+ /// let mut buffer = [0; 5];
+ /// let mut handle = file.take(5);
+ /// handle.read(&mut buffer)?;
///
- /// let file = handle.get_mut();
- /// # Ok(())
- /// # }
+ /// let file = handle.get_mut();
+ /// Ok(())
+ /// }
/// ```
#[stable(feature = "more_io_inner_methods", since = "1.20.0")]
pub fn get_mut(&mut self) -> &mut T {
generated by cgit v1.2.3 (git 2.25.1) at 2026-04-22 03:19:08 +0000