From 45ecdc83758d26d698572e0f6ca57b9624332db0 Mon Sep 17 00:00:00 2001 From: defyrlt Date: Mon, 21 Dec 2015 16:49:07 +0200 Subject: Removed usage of `drop` from `std::net::UdpSocket` docs Resolves #30507 --- src/libstd/net/udp.rs | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) (limited to 'src/libstd') diff --git a/src/libstd/net/udp.rs b/src/libstd/net/udp.rs index b212d4d32aa..db49a77d89d 100644 --- a/src/libstd/net/udp.rs +++ b/src/libstd/net/udp.rs @@ -27,18 +27,19 @@ use time::Duration; /// use std::net::UdpSocket; /// /// # fn foo() -> std::io::Result<()> { -/// let mut socket = try!(UdpSocket::bind("127.0.0.1:34254")); +/// { +/// let mut socket = try!(UdpSocket::bind("127.0.0.1:34254")); /// -/// let mut buf = [0; 10]; -/// let (amt, src) = try!(socket.recv_from(&mut buf)); +/// // read from the socket +/// let mut buf = [0; 10]; +/// let (amt, src) = try!(socket.recv_from(&mut buf)); /// -/// // Send a reply to the socket we received data from -/// let buf = &mut buf[..amt]; -/// buf.reverse(); -/// try!(socket.send_to(buf, &src)); -/// -/// drop(socket); // close the socket -/// # Ok(()) +/// // send a reply to the socket we received data from +/// let buf = &mut buf[..amt]; +/// buf.reverse(); +/// try!(socket.send_to(buf, &src)); +/// # Ok(()) +/// } // the socket is closed here /// # } /// ``` #[stable(feature = "rust1", since = "1.0.0")] -- cgit 1.4.1-3-g733a5 From 6d388da45f5ef64dc9742bcb31df5e7572b438ac Mon Sep 17 00:00:00 2001 From: Tshepang Lekhonkhobe Date: Thu, 24 Dec 2015 02:52:27 +0200 Subject: doc: add some links for io::stdio --- src/libstd/io/stdio.rs | 49 +++++++++++++++++++++++++++++++++++-------------- 1 file changed, 35 insertions(+), 14 deletions(-) (limited to 'src/libstd') diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs index 120e56d8079..e51453180a7 100644 --- a/src/libstd/io/stdio.rs +++ b/src/libstd/io/stdio.rs @@ -133,14 +133,17 @@ fn handle_ebadf(r: io::Result, default: T) -> io::Result { /// A handle to the standard input stream of a process. /// /// Each handle is a shared reference to a global buffer of input data to this -/// process. A handle can be `lock`'d to gain full access to `BufRead` methods +/// process. A handle can be `lock`'d to gain full access to [BufRead] methods /// (e.g. `.lines()`). Writes to this handle are otherwise locked with respect /// to other writes. /// /// This handle implements the `Read` trait, but beware that concurrent reads /// of `Stdin` must be executed with care. /// -/// Created by the function `io::stdin()`. +/// Created by the [io::stdin] method. +/// +/// [io::stdin]: fn.stdin.html +/// [BufRead]: trait.BufRead.html #[stable(feature = "rust1", since = "1.0.0")] pub struct Stdin { inner: Arc>>>, @@ -148,8 +151,12 @@ pub struct Stdin { /// A locked reference to the `Stdin` handle. /// -/// This handle implements both the `Read` and `BufRead` traits and is -/// constructed via the `lock` method on `Stdin`. +/// This handle implements both the [Read] and [BufRead] traits, and +/// is constructed via the [Stdin::lock] method. +/// +/// [Read]: trait.Read.html +/// [BufRead]: trait.BufRead.html +/// [Stdin::lock]: struct.Stdin.html#method.lock #[stable(feature = "rust1", since = "1.0.0")] pub struct StdinLock<'a> { inner: MutexGuard<'a, BufReader>>, @@ -221,8 +228,11 @@ impl Stdin { /// guard. /// /// The lock is released when the returned lock goes out of scope. The - /// returned guard also implements the `Read` and `BufRead` traits for + /// returned guard also implements the [Read] and [BufRead] traits for /// accessing the underlying data. + /// + /// [Read]: trait.Read.html + /// [BufRead]: trait.BufRead.html #[stable(feature = "rust1", since = "1.0.0")] pub fn lock(&self) -> StdinLock { StdinLock { inner: self.inner.lock().unwrap_or_else(|e| e.into_inner()) } @@ -231,7 +241,9 @@ impl Stdin { /// Locks this handle and reads a line of input into the specified buffer. /// /// For detailed semantics of this method, see the documentation on - /// `BufRead::read_line`. + /// [BufRead::read_line]. + /// + /// [BufRead::read_line]: trait.BufRead.html#method.read_line /// /// # Examples /// @@ -314,7 +326,9 @@ const OUT_MAX: usize = ::usize::MAX; /// output stream. Access is also synchronized via a lock and explicit control /// over locking is available via the `lock` method. /// -/// Created by the function `io::stdout()`. +/// Created by the [io::stdout] method. +/// +/// [io::stdout]: fn.stdout.html #[stable(feature = "rust1", since = "1.0.0")] pub struct Stdout { // FIXME: this should be LineWriter or BufWriter depending on the state of @@ -325,8 +339,11 @@ pub struct Stdout { /// A locked reference to the `Stdout` handle. /// -/// This handle implements the `Write` trait and is constructed via the `lock` -/// method on `Stdout`. +/// This handle implements the [Write] trait, and is constructed via +/// the [Stdout::lock] method. +/// +/// [Write]: trait.Write.html +/// [Stdout::lock]: struct.Stdout.html#method.lock #[stable(feature = "rust1", since = "1.0.0")] pub struct StdoutLock<'a> { inner: ReentrantMutexGuard<'a, RefCell>>>, @@ -336,9 +353,9 @@ pub struct StdoutLock<'a> { /// /// Each handle returned is a reference to a shared global buffer whose access /// is synchronized via a mutex. If you need more explicit control over -/// locking, see the [lock() method][lock]. +/// locking, see the [Stdout::lock] method. /// -/// [lock]: struct.Stdout.html#method.lock +/// [Stdout::lock]: struct.Stdout.html#method.lock /// /// # Examples /// @@ -424,7 +441,9 @@ impl<'a> Write for StdoutLock<'a> { /// A handle to the standard error stream of a process. /// -/// For more information, see `stderr` +/// For more information, see the [io::stderr] method. +/// +/// [io::stderr]: fn.stderr.html #[stable(feature = "rust1", since = "1.0.0")] pub struct Stderr { inner: Arc>>>, @@ -432,8 +451,10 @@ pub struct Stderr { /// A locked reference to the `Stderr` handle. /// -/// This handle implements the `Write` trait and is constructed via the `lock` -/// method on `Stderr`. +/// This handle implements the `Write` trait and is constructed via +/// the [Stderr::lock] method. +/// +/// [Stderr::lock]: struct.Stderr.html#method.lock #[stable(feature = "rust1", since = "1.0.0")] pub struct StderrLock<'a> { inner: ReentrantMutexGuard<'a, RefCell>>, -- cgit 1.4.1-3-g733a5 From a4da9aced97090c594f54e7e5f10bc1d1ada8348 Mon Sep 17 00:00:00 2001 From: Tshepang Lekhonkhobe Date: Wed, 30 Dec 2015 12:41:04 +0200 Subject: doc: add graves --- src/libstd/io/stdio.rs | 46 +++++++++++++++++++++++----------------------- 1 file changed, 23 insertions(+), 23 deletions(-) (limited to 'src/libstd') diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs index e51453180a7..863e84be093 100644 --- a/src/libstd/io/stdio.rs +++ b/src/libstd/io/stdio.rs @@ -133,17 +133,17 @@ fn handle_ebadf(r: io::Result, default: T) -> io::Result { /// A handle to the standard input stream of a process. /// /// Each handle is a shared reference to a global buffer of input data to this -/// process. A handle can be `lock`'d to gain full access to [BufRead] methods +/// process. A handle can be `lock`'d to gain full access to [`BufRead`] methods /// (e.g. `.lines()`). Writes to this handle are otherwise locked with respect /// to other writes. /// /// This handle implements the `Read` trait, but beware that concurrent reads /// of `Stdin` must be executed with care. /// -/// Created by the [io::stdin] method. +/// Created by the [`io::stdin`] method. /// -/// [io::stdin]: fn.stdin.html -/// [BufRead]: trait.BufRead.html +/// [`io::stdin`]: fn.stdin.html +/// [`BufRead`]: trait.BufRead.html #[stable(feature = "rust1", since = "1.0.0")] pub struct Stdin { inner: Arc>>>, @@ -151,12 +151,12 @@ pub struct Stdin { /// A locked reference to the `Stdin` handle. /// -/// This handle implements both the [Read] and [BufRead] traits, and -/// is constructed via the [Stdin::lock] method. +/// This handle implements both the [`Read`] and [`BufRead`] traits, and +/// is constructed via the [`Stdin::lock`] method. /// -/// [Read]: trait.Read.html -/// [BufRead]: trait.BufRead.html -/// [Stdin::lock]: struct.Stdin.html#method.lock +/// [`Read`]: trait.Read.html +/// [`BufRead`]: trait.BufRead.html +/// [`Stdin::lock`]: struct.Stdin.html#method.lock #[stable(feature = "rust1", since = "1.0.0")] pub struct StdinLock<'a> { inner: MutexGuard<'a, BufReader>>, @@ -166,7 +166,7 @@ pub struct StdinLock<'a> { /// /// Each handle returned is a reference to a shared global buffer whose access /// is synchronized via a mutex. If you need more explicit control over -/// locking, see the [lock() method][lock]. +/// locking, see the [`lock() method`][lock]. /// /// [lock]: struct.Stdin.html#method.lock /// @@ -228,7 +228,7 @@ impl Stdin { /// guard. /// /// The lock is released when the returned lock goes out of scope. The - /// returned guard also implements the [Read] and [BufRead] traits for + /// returned guard also implements the [`Read`] and [`BufRead`] traits for /// accessing the underlying data. /// /// [Read]: trait.Read.html @@ -241,9 +241,9 @@ impl Stdin { /// Locks this handle and reads a line of input into the specified buffer. /// /// For detailed semantics of this method, see the documentation on - /// [BufRead::read_line]. + /// [`BufRead::read_line`]. /// - /// [BufRead::read_line]: trait.BufRead.html#method.read_line + /// [`BufRead::read_line`]: trait.BufRead.html#method.read_line /// /// # Examples /// @@ -326,9 +326,9 @@ const OUT_MAX: usize = ::usize::MAX; /// output stream. Access is also synchronized via a lock and explicit control /// over locking is available via the `lock` method. /// -/// Created by the [io::stdout] method. +/// Created by the [`io::stdout`] method. /// -/// [io::stdout]: fn.stdout.html +/// [`io::stdout`]: fn.stdout.html #[stable(feature = "rust1", since = "1.0.0")] pub struct Stdout { // FIXME: this should be LineWriter or BufWriter depending on the state of @@ -339,11 +339,11 @@ pub struct Stdout { /// A locked reference to the `Stdout` handle. /// -/// This handle implements the [Write] trait, and is constructed via -/// the [Stdout::lock] method. +/// This handle implements the [`Write`] trait, and is constructed via +/// the [`Stdout::lock`] method. /// -/// [Write]: trait.Write.html -/// [Stdout::lock]: struct.Stdout.html#method.lock +/// [`Write`]: trait.Write.html +/// [`Stdout::lock`]: struct.Stdout.html#method.lock #[stable(feature = "rust1", since = "1.0.0")] pub struct StdoutLock<'a> { inner: ReentrantMutexGuard<'a, RefCell>>>, @@ -441,9 +441,9 @@ impl<'a> Write for StdoutLock<'a> { /// A handle to the standard error stream of a process. /// -/// For more information, see the [io::stderr] method. +/// For more information, see the [`io::stderr`] method. /// -/// [io::stderr]: fn.stderr.html +/// [`io::stderr`]: fn.stderr.html #[stable(feature = "rust1", since = "1.0.0")] pub struct Stderr { inner: Arc>>>, @@ -452,9 +452,9 @@ pub struct Stderr { /// A locked reference to the `Stderr` handle. /// /// This handle implements the `Write` trait and is constructed via -/// the [Stderr::lock] method. +/// the [`Stderr::lock`] method. /// -/// [Stderr::lock]: struct.Stderr.html#method.lock +/// [`Stderr::lock`]: struct.Stderr.html#method.lock #[stable(feature = "rust1", since = "1.0.0")] pub struct StderrLock<'a> { inner: ReentrantMutexGuard<'a, RefCell>>, -- cgit 1.4.1-3-g733a5