/rust/registry/src/index.crates.io-1949cf8c6b5b557f/futures-io-0.3.21/src/lib.rs

Source
//! Asynchronous I/O
//!
//! This crate contains the `AsyncRead`, `AsyncWrite`, `AsyncSeek`, and
//! `AsyncBufRead` traits, the asynchronous analogs to
//! `std::io::{Read, Write, Seek, BufRead}`. The primary difference is
//! that these traits integrate with the asynchronous task system.
//!
//! All items of this library are only available when the `std` feature of this
//! library is activated, and it is activated by default.

#![cfg_attr(not(feature = "std"), no_std)]
#![warn(missing_debug_implementations, missing_docs, rust_2018_idioms, unreachable_pub)]
// It cannot be included in the published code because this lints have false positives in the minimum required version.
#![cfg_attr(test, warn(single_use_lifetimes))]
#![doc(test(
    no_crate_inject,
    attr(
        deny(warnings, rust_2018_idioms, single_use_lifetimes),
        allow(dead_code, unused_assignments, unused_variables)
    )
))]
#![cfg_attr(docsrs, feature(doc_cfg))]

#[cfg(feature = "std")]
mod if_std {
    use std::io;
    use std::ops::DerefMut;
    use std::pin::Pin;
    use std::task::{Context, Poll};

    // Re-export some types from `std::io` so that users don't have to deal
    // with conflicts when `use`ing `futures::io` and `std::io`.
    #[allow(unreachable_pub)] // https://github.com/rust-lang/rust/issues/57411
    #[doc(no_inline)]
    pub use io::{Error, ErrorKind, IoSlice, IoSliceMut, Result, SeekFrom};

    /// Read bytes asynchronously.
    ///
    /// This trait is analogous to the `std::io::Read` trait, but integrates
    /// with the asynchronous task system. In particular, the `poll_read`
    /// method, unlike `Read::read`, will automatically queue the current task
    /// for wakeup and return if data is not yet available, rather than blocking
    /// the calling thread.
    pub trait AsyncRead {
        /// Attempt to read from the `AsyncRead` into `buf`.
        ///
        /// On success, returns `Poll::Ready(Ok(num_bytes_read))`.
        ///
        /// If no data is available for reading, the method returns
        /// `Poll::Pending` and arranges for the current task (via
        /// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
        /// readable or is closed.
        ///
        /// # Implementation
        ///
        /// This function may not return errors of kind `WouldBlock` or
        /// `Interrupted`.  Implementations must convert `WouldBlock` into
        /// `Poll::Pending` and either internally retry or convert
        /// `Interrupted` into another error kind.
        fn poll_read(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
            buf: &mut [u8],
        ) -> Poll<Result<usize>>;

        /// Attempt to read from the `AsyncRead` into `bufs` using vectored
        /// IO operations.
        ///
        /// This method is similar to `poll_read`, but allows data to be read
        /// into multiple buffers using a single operation.
        ///
        /// On success, returns `Poll::Ready(Ok(num_bytes_read))`.
        ///
        /// If no data is available for reading, the method returns
        /// `Poll::Pending` and arranges for the current task (via
        /// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
        /// readable or is closed.
        /// By default, this method delegates to using `poll_read` on the first
        /// nonempty buffer in `bufs`, or an empty one if none exists. Objects which
        /// support vectored IO should override this method.
        ///
        /// # Implementation
        ///
        /// This function may not return errors of kind `WouldBlock` or
        /// `Interrupted`.  Implementations must convert `WouldBlock` into
        /// `Poll::Pending` and either internally retry or convert
        /// `Interrupted` into another error kind.
        fn poll_read_vectored(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
            bufs: &mut [IoSliceMut<'_>],
        ) -> Poll<Result<usize>> {
            for b in bufs {
                if !b.is_empty() {
                    return self.poll_read(cx, b);
                }
            }

            self.poll_read(cx, &mut [])
        }
    }

    /// Write bytes asynchronously.
    ///
    /// This trait is analogous to the `std::io::Write` trait, but integrates
    /// with the asynchronous task system. In particular, the `poll_write`
    /// method, unlike `Write::write`, will automatically queue the current task
    /// for wakeup and return if the writer cannot take more data, rather than blocking
    /// the calling thread.
    pub trait AsyncWrite {
        /// Attempt to write bytes from `buf` into the object.
        ///
        /// On success, returns `Poll::Ready(Ok(num_bytes_written))`.
        ///
        /// If the object is not ready for writing, the method returns
        /// `Poll::Pending` and arranges for the current task (via
        /// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
        /// writable or is closed.
        ///
        /// # Implementation
        ///
        /// This function may not return errors of kind `WouldBlock` or
        /// `Interrupted`.  Implementations must convert `WouldBlock` into
        /// `Poll::Pending` and either internally retry or convert
        /// `Interrupted` into another error kind.
        ///
        /// `poll_write` must try to make progress by flushing the underlying object if
        /// that is the only way the underlying object can become writable again.
        fn poll_write(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
            buf: &[u8],
        ) -> Poll<Result<usize>>;

        /// Attempt to write bytes from `bufs` into the object using vectored
        /// IO operations.
        ///
        /// This method is similar to `poll_write`, but allows data from multiple buffers to be written
        /// using a single operation.
        ///
        /// On success, returns `Poll::Ready(Ok(num_bytes_written))`.
        ///
        /// If the object is not ready for writing, the method returns
        /// `Poll::Pending` and arranges for the current task (via
        /// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
        /// writable or is closed.
        ///
        /// By default, this method delegates to using `poll_write` on the first
        /// nonempty buffer in `bufs`, or an empty one if none exists. Objects which
        /// support vectored IO should override this method.
        ///
        /// # Implementation
        ///
        /// This function may not return errors of kind `WouldBlock` or
        /// `Interrupted`.  Implementations must convert `WouldBlock` into
        /// `Poll::Pending` and either internally retry or convert
        /// `Interrupted` into another error kind.
        fn poll_write_vectored(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
            bufs: &[IoSlice<'_>],
        ) -> Poll<Result<usize>> {
            for b in bufs {
                if !b.is_empty() {
                    return self.poll_write(cx, b);
                }
            }

            self.poll_write(cx, &[])
        }

        /// Attempt to flush the object, ensuring that any buffered data reach
        /// their destination.
        ///
        /// On success, returns `Poll::Ready(Ok(()))`.
        ///
        /// If flushing cannot immediately complete, this method returns
        /// `Poll::Pending` and arranges for the current task (via
        /// `cx.waker().wake_by_ref()`) to receive a notification when the object can make
        /// progress towards flushing.
        ///
        /// # Implementation
        ///
        /// This function may not return errors of kind `WouldBlock` or
        /// `Interrupted`.  Implementations must convert `WouldBlock` into
        /// `Poll::Pending` and either internally retry or convert
        /// `Interrupted` into another error kind.
        ///
        /// It only makes sense to do anything here if you actually buffer data.
        fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>;

        /// Attempt to close the object.
        ///
        /// On success, returns `Poll::Ready(Ok(()))`.
        ///
        /// If closing cannot immediately complete, this function returns
        /// `Poll::Pending` and arranges for the current task (via
        /// `cx.waker().wake_by_ref()`) to receive a notification when the object can make
        /// progress towards closing.
        ///
        /// # Implementation
        ///
        /// This function may not return errors of kind `WouldBlock` or
        /// `Interrupted`.  Implementations must convert `WouldBlock` into
        /// `Poll::Pending` and either internally retry or convert
        /// `Interrupted` into another error kind.
        fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>;
    }

    /// Seek bytes asynchronously.
    ///
    /// This trait is analogous to the `std::io::Seek` trait, but integrates
    /// with the asynchronous task system. In particular, the `poll_seek`
    /// method, unlike `Seek::seek`, will automatically queue the current task
    /// for wakeup and return if data is not yet available, rather than blocking
    /// the calling thread.
    pub trait AsyncSeek {
        /// Attempt to seek to an offset, in bytes, in a stream.
        ///
        /// A seek beyond the end of a stream is allowed, but behavior is defined
        /// by the implementation.
        ///
        /// If the seek operation completed successfully,
        /// this method returns the new position from the start of the stream.
        /// That position can be used later with [`SeekFrom::Start`].
        ///
        /// # Errors
        ///
        /// Seeking to a negative offset is considered an error.
        ///
        /// # Implementation
        ///
        /// This function may not return errors of kind `WouldBlock` or
        /// `Interrupted`.  Implementations must convert `WouldBlock` into
        /// `Poll::Pending` and either internally retry or convert
        /// `Interrupted` into another error kind.
        fn poll_seek(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
            pos: SeekFrom,
        ) -> Poll<Result<u64>>;
    }

    /// Read bytes asynchronously.
    ///
    /// This trait is analogous to the `std::io::BufRead` trait, but integrates
    /// with the asynchronous task system. In particular, the `poll_fill_buf`
    /// method, unlike `BufRead::fill_buf`, will automatically queue the current task
    /// for wakeup and return if data is not yet available, rather than blocking
    /// the calling thread.
    pub trait AsyncBufRead: AsyncRead {
        /// Attempt to return the contents of the internal buffer, filling it with more data
        /// from the inner reader if it is empty.
        ///
        /// On success, returns `Poll::Ready(Ok(buf))`.
        ///
        /// If no data is available for reading, the method returns
        /// `Poll::Pending` and arranges for the current task (via
        /// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
        /// readable or is closed.
        ///
        /// This function is a lower-level call. It needs to be paired with the
        /// [`consume`] method to function properly. When calling this
        /// method, none of the contents will be "read" in the sense that later
        /// calling [`poll_read`] may return the same contents. As such, [`consume`] must
        /// be called with the number of bytes that are consumed from this buffer to
        /// ensure that the bytes are never returned twice.
        ///
        /// [`poll_read`]: AsyncRead::poll_read
        /// [`consume`]: AsyncBufRead::consume
        ///
        /// An empty buffer returned indicates that the stream has reached EOF.
        ///
        /// # Implementation
        ///
        /// This function may not return errors of kind `WouldBlock` or
        /// `Interrupted`.  Implementations must convert `WouldBlock` into
        /// `Poll::Pending` and either internally retry or convert
        /// `Interrupted` into another error kind.
        fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>>;

        /// Tells this buffer that `amt` bytes have been consumed from the buffer,
        /// so they should no longer be returned in calls to [`poll_read`].
        ///
        /// This function is a lower-level call. It needs to be paired with the
        /// [`poll_fill_buf`] method to function properly. This function does
        /// not perform any I/O, it simply informs this object that some amount of
        /// its buffer, returned from [`poll_fill_buf`], has been consumed and should
        /// no longer be returned. As such, this function may do odd things if
        /// [`poll_fill_buf`] isn't called before calling it.
        ///
        /// The `amt` must be `<=` the number of bytes in the buffer returned by
        /// [`poll_fill_buf`].
        ///
        /// [`poll_read`]: AsyncRead::poll_read
        /// [`poll_fill_buf`]: AsyncBufRead::poll_fill_buf
        fn consume(self: Pin<&mut Self>, amt: usize);
    }

    macro_rules! deref_async_read {
        () => {
            fn poll_read(
                mut self: Pin<&mut Self>,
                cx: &mut Context<'_>,
                buf: &mut [u8],
            ) -> Poll<Result<usize>> {
                Pin::new(&mut **self).poll_read(cx, buf)
            }

            fn poll_read_vectored(
                mut self: Pin<&mut Self>,
                cx: &mut Context<'_>,
                bufs: &mut [IoSliceMut<'_>],
            ) -> Poll<Result<usize>> {
                Pin::new(&mut **self).poll_read_vectored(cx, bufs)
            }
        };
    }

    impl<T: ?Sized + AsyncRead + Unpin> AsyncRead for Box<T> {
        deref_async_read!();
    }

    impl<T: ?Sized + AsyncRead + Unpin> AsyncRead for &mut T {
        deref_async_read!();
    }

    impl<P> AsyncRead for Pin<P>
    where
        P: DerefMut + Unpin,
        P::Target: AsyncRead,
    {
        fn poll_read(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
            buf: &mut [u8],
        ) -> Poll<Result<usize>> {
            self.get_mut().as_mut().poll_read(cx, buf)
        }

        fn poll_read_vectored(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
            bufs: &mut [IoSliceMut<'_>],
        ) -> Poll<Result<usize>> {
            self.get_mut().as_mut().poll_read_vectored(cx, bufs)
        }
    }

    macro_rules! delegate_async_read_to_stdio {
        () => {
            fn poll_read(
                mut self: Pin<&mut Self>,
                _: &mut Context<'_>,
                buf: &mut [u8],
            ) -> Poll<Result<usize>> {
                Poll::Ready(io::Read::read(&mut *self, buf))
            }

            fn poll_read_vectored(
                mut self: Pin<&mut Self>,
                _: &mut Context<'_>,
                bufs: &mut [IoSliceMut<'_>],
            ) -> Poll<Result<usize>> {
                Poll::Ready(io::Read::read_vectored(&mut *self, bufs))
            }
        };
    }

    impl AsyncRead for &[u8] {
        delegate_async_read_to_stdio!();
    }

    macro_rules! deref_async_write {
        () => {
            fn poll_write(
                mut self: Pin<&mut Self>,
                cx: &mut Context<'_>,
                buf: &[u8],
            ) -> Poll<Result<usize>> {
                Pin::new(&mut **self).poll_write(cx, buf)
            }

            fn poll_write_vectored(
                mut self: Pin<&mut Self>,
                cx: &mut Context<'_>,
                bufs: &[IoSlice<'_>],
            ) -> Poll<Result<usize>> {
                Pin::new(&mut **self).poll_write_vectored(cx, bufs)
            }

            fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
                Pin::new(&mut **self).poll_flush(cx)
            }

            fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
                Pin::new(&mut **self).poll_close(cx)
            }
        };
    }

    impl<T: ?Sized + AsyncWrite + Unpin> AsyncWrite for Box<T> {
        deref_async_write!();
    }

    impl<T: ?Sized + AsyncWrite + Unpin> AsyncWrite for &mut T {
        deref_async_write!();
    }

    impl<P> AsyncWrite for Pin<P>
    where
        P: DerefMut + Unpin,
        P::Target: AsyncWrite,
    {
        fn poll_write(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
            buf: &[u8],
        ) -> Poll<Result<usize>> {
            self.get_mut().as_mut().poll_write(cx, buf)
        }

        fn poll_write_vectored(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
            bufs: &[IoSlice<'_>],
        ) -> Poll<Result<usize>> {
            self.get_mut().as_mut().poll_write_vectored(cx, bufs)
        }

        fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
            self.get_mut().as_mut().poll_flush(cx)
        }

        fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
            self.get_mut().as_mut().poll_close(cx)
        }
    }

    macro_rules! delegate_async_write_to_stdio {
        () => {
            fn poll_write(
                mut self: Pin<&mut Self>,
                _: &mut Context<'_>,
                buf: &[u8],
            ) -> Poll<Result<usize>> {
                Poll::Ready(io::Write::write(&mut *self, buf))
            }

            fn poll_write_vectored(
                mut self: Pin<&mut Self>,
                _: &mut Context<'_>,
                bufs: &[IoSlice<'_>],
            ) -> Poll<Result<usize>> {
                Poll::Ready(io::Write::write_vectored(&mut *self, bufs))
            }

            fn poll_flush(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<()>> {
                Poll::Ready(io::Write::flush(&mut *self))
            }

            fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
                self.poll_flush(cx)
            }
        };
    }

    impl AsyncWrite for Vec<u8> {
        delegate_async_write_to_stdio!();
    }

    macro_rules! deref_async_seek {
        () => {
            fn poll_seek(
                mut self: Pin<&mut Self>,
                cx: &mut Context<'_>,
                pos: SeekFrom,
            ) -> Poll<Result<u64>> {
                Pin::new(&mut **self).poll_seek(cx, pos)
            }
        };
    }

    impl<T: ?Sized + AsyncSeek + Unpin> AsyncSeek for Box<T> {
        deref_async_seek!();
    }

    impl<T: ?Sized + AsyncSeek + Unpin> AsyncSeek for &mut T {
        deref_async_seek!();
    }

    impl<P> AsyncSeek for Pin<P>
    where
        P: DerefMut + Unpin,
        P::Target: AsyncSeek,
    {
        fn poll_seek(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
            pos: SeekFrom,
        ) -> Poll<Result<u64>> {
            self.get_mut().as_mut().poll_seek(cx, pos)
        }
    }

    macro_rules! deref_async_buf_read {
        () => {
            fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>> {
                Pin::new(&mut **self.get_mut()).poll_fill_buf(cx)
            }

            fn consume(mut self: Pin<&mut Self>, amt: usize) {
                Pin::new(&mut **self).consume(amt)
            }
        };
    }

    impl<T: ?Sized + AsyncBufRead + Unpin> AsyncBufRead for Box<T> {
        deref_async_buf_read!();
    }

    impl<T: ?Sized + AsyncBufRead + Unpin> AsyncBufRead for &mut T {
        deref_async_buf_read!();
    }

    impl<P> AsyncBufRead for Pin<P>
    where
        P: DerefMut + Unpin,
        P::Target: AsyncBufRead,
    {
        fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>> {
            self.get_mut().as_mut().poll_fill_buf(cx)
        }

        fn consume(self: Pin<&mut Self>, amt: usize) {
            self.get_mut().as_mut().consume(amt)
        }
    }

    macro_rules! delegate_async_buf_read_to_stdio {
        () => {
            fn poll_fill_buf(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<&[u8]>> {
                Poll::Ready(io::BufRead::fill_buf(self.get_mut()))
            }

            fn consume(self: Pin<&mut Self>, amt: usize) {
                io::BufRead::consume(self.get_mut(), amt)
            }
        };
    }

    impl AsyncBufRead for &[u8] {
        delegate_async_buf_read_to_stdio!();
    }
}

#[cfg(feature = "std")]
pub use self::if_std::*;

Coverage Report

Created: 2025-11-16 06:34

Line	Count	Source
1		//! Asynchronous I/O
2		//!
3		//! This crate contains the `AsyncRead`, `AsyncWrite`, `AsyncSeek`, and
4		//! `AsyncBufRead` traits, the asynchronous analogs to
5		//! `std::io::{Read, Write, Seek, BufRead}`. The primary difference is
6		//! that these traits integrate with the asynchronous task system.
7		//!
8		//! All items of this library are only available when the `std` feature of this
9		//! library is activated, and it is activated by default.
10
11		#![cfg_attr(not(feature = "std"), no_std)]
12		#![warn(missing_debug_implementations, missing_docs, rust_2018_idioms, unreachable_pub)]
13		// It cannot be included in the published code because this lints have false positives in the minimum required version.
14		#![cfg_attr(test, warn(single_use_lifetimes))]
15		#![doc(test(
16		no_crate_inject,
17		attr(
18		deny(warnings, rust_2018_idioms, single_use_lifetimes),
19		allow(dead_code, unused_assignments, unused_variables)
20		)
21		))]
22		#![cfg_attr(docsrs, feature(doc_cfg))]
23
24		#[cfg(feature = "std")]
25		mod if_std {
26		use std::io;
27		use std::ops::DerefMut;
28		use std::pin::Pin;
29		use std::task::{Context, Poll};
30
31		// Re-export some types from `std::io` so that users don't have to deal
32		// with conflicts when `use`ing `futures::io` and `std::io`.
33		#[allow(unreachable_pub)] // https://github.com/rust-lang/rust/issues/57411
34		#[doc(no_inline)]
35		pub use io::{Error, ErrorKind, IoSlice, IoSliceMut, Result, SeekFrom};
36
37		/// Read bytes asynchronously.
38		///
39		/// This trait is analogous to the `std::io::Read` trait, but integrates
40		/// with the asynchronous task system. In particular, the `poll_read`
41		/// method, unlike `Read::read`, will automatically queue the current task
42		/// for wakeup and return if data is not yet available, rather than blocking
43		/// the calling thread.
44		pub trait AsyncRead {
45		/// Attempt to read from the `AsyncRead` into `buf`.
46		///
47		/// On success, returns `Poll::Ready(Ok(num_bytes_read))`.
48		///
49		/// If no data is available for reading, the method returns
50		/// `Poll::Pending` and arranges for the current task (via
51		/// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
52		/// readable or is closed.
53		///
54		/// # Implementation
55		///
56		/// This function may not return errors of kind `WouldBlock` or
57		/// `Interrupted`. Implementations must convert `WouldBlock` into
58		/// `Poll::Pending` and either internally retry or convert
59		/// `Interrupted` into another error kind.
60		fn poll_read(
61		self: Pin<&mut Self>,
62		cx: &mut Context<'_>,
63		buf: &mut [u8],
64		) -> Poll<Result<usize>>;
65
66		/// Attempt to read from the `AsyncRead` into `bufs` using vectored
67		/// IO operations.
68		///
69		/// This method is similar to `poll_read`, but allows data to be read
70		/// into multiple buffers using a single operation.
71		///
72		/// On success, returns `Poll::Ready(Ok(num_bytes_read))`.
73		///
74		/// If no data is available for reading, the method returns
75		/// `Poll::Pending` and arranges for the current task (via
76		/// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
77		/// readable or is closed.
78		/// By default, this method delegates to using `poll_read` on the first
79		/// nonempty buffer in `bufs`, or an empty one if none exists. Objects which
80		/// support vectored IO should override this method.
81		///
82		/// # Implementation
83		///
84		/// This function may not return errors of kind `WouldBlock` or
85		/// `Interrupted`. Implementations must convert `WouldBlock` into
86		/// `Poll::Pending` and either internally retry or convert
87		/// `Interrupted` into another error kind.
88	0	fn poll_read_vectored(
89	0	self: Pin<&mut Self>,
90	0	cx: &mut Context<'_>,
91	0	bufs: &mut [IoSliceMut<'_>],
92	0	) -> Poll<Result<usize>> {
93	0	for b in bufs {
94	0	if !b.is_empty() {
95	0	return self.poll_read(cx, b);
96	0	}
97		}
98
99	0	self.poll_read(cx, &mut [])
100	0	}
101		}
102
103		/// Write bytes asynchronously.
104		///
105		/// This trait is analogous to the `std::io::Write` trait, but integrates
106		/// with the asynchronous task system. In particular, the `poll_write`
107		/// method, unlike `Write::write`, will automatically queue the current task
108		/// for wakeup and return if the writer cannot take more data, rather than blocking
109		/// the calling thread.
110		pub trait AsyncWrite {
111		/// Attempt to write bytes from `buf` into the object.
112		///
113		/// On success, returns `Poll::Ready(Ok(num_bytes_written))`.
114		///
115		/// If the object is not ready for writing, the method returns
116		/// `Poll::Pending` and arranges for the current task (via
117		/// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
118		/// writable or is closed.
119		///
120		/// # Implementation
121		///
122		/// This function may not return errors of kind `WouldBlock` or
123		/// `Interrupted`. Implementations must convert `WouldBlock` into
124		/// `Poll::Pending` and either internally retry or convert
125		/// `Interrupted` into another error kind.
126		///
127		/// `poll_write` must try to make progress by flushing the underlying object if
128		/// that is the only way the underlying object can become writable again.
129		fn poll_write(
130		self: Pin<&mut Self>,
131		cx: &mut Context<'_>,
132		buf: &[u8],
133		) -> Poll<Result<usize>>;
134
135		/// Attempt to write bytes from `bufs` into the object using vectored
136		/// IO operations.
137		///
138		/// This method is similar to `poll_write`, but allows data from multiple buffers to be written
139		/// using a single operation.
140		///
141		/// On success, returns `Poll::Ready(Ok(num_bytes_written))`.
142		///
143		/// If the object is not ready for writing, the method returns
144		/// `Poll::Pending` and arranges for the current task (via
145		/// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
146		/// writable or is closed.
147		///
148		/// By default, this method delegates to using `poll_write` on the first
149		/// nonempty buffer in `bufs`, or an empty one if none exists. Objects which
150		/// support vectored IO should override this method.
151		///
152		/// # Implementation
153		///
154		/// This function may not return errors of kind `WouldBlock` or
155		/// `Interrupted`. Implementations must convert `WouldBlock` into
156		/// `Poll::Pending` and either internally retry or convert
157		/// `Interrupted` into another error kind.
158	0	fn poll_write_vectored(
159	0	self: Pin<&mut Self>,
160	0	cx: &mut Context<'_>,
161	0	bufs: &[IoSlice<'_>],
162	0	) -> Poll<Result<usize>> {
163	0	for b in bufs {
164	0	if !b.is_empty() {
165	0	return self.poll_write(cx, b);
166	0	}
167		}
168
169	0	self.poll_write(cx, &[])
170	0	}
171
172		/// Attempt to flush the object, ensuring that any buffered data reach
173		/// their destination.
174		///
175		/// On success, returns `Poll::Ready(Ok(()))`.
176		///
177		/// If flushing cannot immediately complete, this method returns
178		/// `Poll::Pending` and arranges for the current task (via
179		/// `cx.waker().wake_by_ref()`) to receive a notification when the object can make
180		/// progress towards flushing.
181		///
182		/// # Implementation
183		///
184		/// This function may not return errors of kind `WouldBlock` or
185		/// `Interrupted`. Implementations must convert `WouldBlock` into
186		/// `Poll::Pending` and either internally retry or convert
187		/// `Interrupted` into another error kind.
188		///
189		/// It only makes sense to do anything here if you actually buffer data.
190		fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>;
191
192		/// Attempt to close the object.
193		///
194		/// On success, returns `Poll::Ready(Ok(()))`.
195		///
196		/// If closing cannot immediately complete, this function returns
197		/// `Poll::Pending` and arranges for the current task (via
198		/// `cx.waker().wake_by_ref()`) to receive a notification when the object can make
199		/// progress towards closing.
200		///
201		/// # Implementation
202		///
203		/// This function may not return errors of kind `WouldBlock` or
204		/// `Interrupted`. Implementations must convert `WouldBlock` into
205		/// `Poll::Pending` and either internally retry or convert
206		/// `Interrupted` into another error kind.
207		fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>;
208		}
209
210		/// Seek bytes asynchronously.
211		///
212		/// This trait is analogous to the `std::io::Seek` trait, but integrates
213		/// with the asynchronous task system. In particular, the `poll_seek`
214		/// method, unlike `Seek::seek`, will automatically queue the current task
215		/// for wakeup and return if data is not yet available, rather than blocking
216		/// the calling thread.
217		pub trait AsyncSeek {
218		/// Attempt to seek to an offset, in bytes, in a stream.
219		///
220		/// A seek beyond the end of a stream is allowed, but behavior is defined
221		/// by the implementation.
222		///
223		/// If the seek operation completed successfully,
224		/// this method returns the new position from the start of the stream.
225		/// That position can be used later with [`SeekFrom::Start`].
226		///
227		/// # Errors
228		///
229		/// Seeking to a negative offset is considered an error.
230		///
231		/// # Implementation
232		///
233		/// This function may not return errors of kind `WouldBlock` or
234		/// `Interrupted`. Implementations must convert `WouldBlock` into
235		/// `Poll::Pending` and either internally retry or convert
236		/// `Interrupted` into another error kind.
237		fn poll_seek(
238		self: Pin<&mut Self>,
239		cx: &mut Context<'_>,
240		pos: SeekFrom,
241		) -> Poll<Result<u64>>;
242		}
243
244		/// Read bytes asynchronously.
245		///
246		/// This trait is analogous to the `std::io::BufRead` trait, but integrates
247		/// with the asynchronous task system. In particular, the `poll_fill_buf`
248		/// method, unlike `BufRead::fill_buf`, will automatically queue the current task
249		/// for wakeup and return if data is not yet available, rather than blocking
250		/// the calling thread.
251		pub trait AsyncBufRead: AsyncRead {
252		/// Attempt to return the contents of the internal buffer, filling it with more data
253		/// from the inner reader if it is empty.
254		///
255		/// On success, returns `Poll::Ready(Ok(buf))`.
256		///
257		/// If no data is available for reading, the method returns
258		/// `Poll::Pending` and arranges for the current task (via
259		/// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
260		/// readable or is closed.
261		///
262		/// This function is a lower-level call. It needs to be paired with the
263		/// [`consume`] method to function properly. When calling this
264		/// method, none of the contents will be "read" in the sense that later
265		/// calling [`poll_read`] may return the same contents. As such, [`consume`] must
266		/// be called with the number of bytes that are consumed from this buffer to
267		/// ensure that the bytes are never returned twice.
268		///
269		/// [`poll_read`]: AsyncRead::poll_read
270		/// [`consume`]: AsyncBufRead::consume
271		///
272		/// An empty buffer returned indicates that the stream has reached EOF.
273		///
274		/// # Implementation
275		///
276		/// This function may not return errors of kind `WouldBlock` or
277		/// `Interrupted`. Implementations must convert `WouldBlock` into
278		/// `Poll::Pending` and either internally retry or convert
279		/// `Interrupted` into another error kind.
280		fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>>;
281
282		/// Tells this buffer that `amt` bytes have been consumed from the buffer,
283		/// so they should no longer be returned in calls to [`poll_read`].
284		///
285		/// This function is a lower-level call. It needs to be paired with the
286		/// [`poll_fill_buf`] method to function properly. This function does
287		/// not perform any I/O, it simply informs this object that some amount of
288		/// its buffer, returned from [`poll_fill_buf`], has been consumed and should
289		/// no longer be returned. As such, this function may do odd things if
290		/// [`poll_fill_buf`] isn't called before calling it.
291		///
292		/// The `amt` must be `<=` the number of bytes in the buffer returned by
293		/// [`poll_fill_buf`].
294		///
295		/// [`poll_read`]: AsyncRead::poll_read
296		/// [`poll_fill_buf`]: AsyncBufRead::poll_fill_buf
297		fn consume(self: Pin<&mut Self>, amt: usize);
298		}
299
300		macro_rules! deref_async_read {
301		() => {
302	0	fn poll_read(
303	0	mut self: Pin<&mut Self>,
304	0	cx: &mut Context<'_>,
305	0	buf: &mut [u8],
306	0	) -> Poll<Result<usize>> {
307	0	Pin::new(&mut **self).poll_read(cx, buf)
308	0	} Unexecuted instantiation: <alloc::boxed::Box<_> as futures_io::if_std::AsyncRead>::poll_read Unexecuted instantiation: <&mut _ as futures_io::if_std::AsyncRead>::poll_read
309
310	0	fn poll_read_vectored(
311	0	mut self: Pin<&mut Self>,
312	0	cx: &mut Context<'_>,
313	0	bufs: &mut [IoSliceMut<'_>],
314	0	) -> Poll<Result<usize>> {
315	0	Pin::new(&mut **self).poll_read_vectored(cx, bufs)
316	0	} Unexecuted instantiation: <alloc::boxed::Box<_> as futures_io::if_std::AsyncRead>::poll_read_vectored Unexecuted instantiation: <&mut _ as futures_io::if_std::AsyncRead>::poll_read_vectored
317		};
318		}
319
320		impl<T: ?Sized + AsyncRead + Unpin> AsyncRead for Box<T> {
321		deref_async_read!();
322		}
323
324		impl<T: ?Sized + AsyncRead + Unpin> AsyncRead for &mut T {
325		deref_async_read!();
326		}
327
328		impl<P> AsyncRead for Pin<P>
329		where
330		P: DerefMut + Unpin,
331		P::Target: AsyncRead,
332		{
333	0	fn poll_read(
334	0	self: Pin<&mut Self>,
335	0	cx: &mut Context<'_>,
336	0	buf: &mut [u8],
337	0	) -> Poll<Result<usize>> {
338	0	self.get_mut().as_mut().poll_read(cx, buf)
339	0	}
340
341	0	fn poll_read_vectored(
342	0	self: Pin<&mut Self>,
343	0	cx: &mut Context<'_>,
344	0	bufs: &mut [IoSliceMut<'_>],
345	0	) -> Poll<Result<usize>> {
346	0	self.get_mut().as_mut().poll_read_vectored(cx, bufs)
347	0	}
348		}
349
350		macro_rules! delegate_async_read_to_stdio {
351		() => {
352	0	fn poll_read(
353	0	mut self: Pin<&mut Self>,
354	0	_: &mut Context<'_>,
355	0	buf: &mut [u8],
356	0	) -> Poll<Result<usize>> {
357	0	Poll::Ready(io::Read::read(&mut *self, buf))
358	0	}
359
360	0	fn poll_read_vectored(
361	0	mut self: Pin<&mut Self>,
362	0	_: &mut Context<'_>,
363	0	bufs: &mut [IoSliceMut<'_>],
364	0	) -> Poll<Result<usize>> {
365	0	Poll::Ready(io::Read::read_vectored(&mut *self, bufs))
366	0	}
367		};
368		}
369
370		impl AsyncRead for &[u8] {
371		delegate_async_read_to_stdio!();
372		}
373
374		macro_rules! deref_async_write {
375		() => {
376	0	fn poll_write(
377	0	mut self: Pin<&mut Self>,
378	0	cx: &mut Context<'_>,
379	0	buf: &[u8],
380	0	) -> Poll<Result<usize>> {
381	0	Pin::new(&mut **self).poll_write(cx, buf)
382	0	} Unexecuted instantiation: <alloc::boxed::Box<_> as futures_io::if_std::AsyncWrite>::poll_write Unexecuted instantiation: <&mut _ as futures_io::if_std::AsyncWrite>::poll_write
383
384	0	fn poll_write_vectored(
385	0	mut self: Pin<&mut Self>,
386	0	cx: &mut Context<'_>,
387	0	bufs: &[IoSlice<'_>],
388	0	) -> Poll<Result<usize>> {
389	0	Pin::new(&mut **self).poll_write_vectored(cx, bufs)
390	0	} Unexecuted instantiation: <alloc::boxed::Box<_> as futures_io::if_std::AsyncWrite>::poll_write_vectored Unexecuted instantiation: <&mut _ as futures_io::if_std::AsyncWrite>::poll_write_vectored
391
392	0	fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
393	0	Pin::new(&mut **self).poll_flush(cx)
394	0	} Unexecuted instantiation: <alloc::boxed::Box<_> as futures_io::if_std::AsyncWrite>::poll_flush Unexecuted instantiation: <&mut _ as futures_io::if_std::AsyncWrite>::poll_flush
395
396	0	fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
397	0	Pin::new(&mut **self).poll_close(cx)
398	0	} Unexecuted instantiation: <alloc::boxed::Box<_> as futures_io::if_std::AsyncWrite>::poll_close Unexecuted instantiation: <&mut _ as futures_io::if_std::AsyncWrite>::poll_close
399		};
400		}
401
402		impl<T: ?Sized + AsyncWrite + Unpin> AsyncWrite for Box<T> {
403		deref_async_write!();
404		}
405
406		impl<T: ?Sized + AsyncWrite + Unpin> AsyncWrite for &mut T {
407		deref_async_write!();
408		}
409
410		impl<P> AsyncWrite for Pin<P>
411		where
412		P: DerefMut + Unpin,
413		P::Target: AsyncWrite,
414		{
415	0	fn poll_write(
416	0	self: Pin<&mut Self>,
417	0	cx: &mut Context<'_>,
418	0	buf: &[u8],
419	0	) -> Poll<Result<usize>> {
420	0	self.get_mut().as_mut().poll_write(cx, buf)
421	0	}
422
423	0	fn poll_write_vectored(
424	0	self: Pin<&mut Self>,
425	0	cx: &mut Context<'_>,
426	0	bufs: &[IoSlice<'_>],
427	0	) -> Poll<Result<usize>> {
428	0	self.get_mut().as_mut().poll_write_vectored(cx, bufs)
429	0	}
430
431	0	fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
432	0	self.get_mut().as_mut().poll_flush(cx)
433	0	}
434
435	0	fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
436	0	self.get_mut().as_mut().poll_close(cx)
437	0	}
438		}
439
440		macro_rules! delegate_async_write_to_stdio {
441		() => {
442	0	fn poll_write(
443	0	mut self: Pin<&mut Self>,
444	0	_: &mut Context<'_>,
445	0	buf: &[u8],
446	0	) -> Poll<Result<usize>> {
447	0	Poll::Ready(io::Write::write(&mut *self, buf))
448	0	}
449
450	0	fn poll_write_vectored(
451	0	mut self: Pin<&mut Self>,
452	0	_: &mut Context<'_>,
453	0	bufs: &[IoSlice<'_>],
454	0	) -> Poll<Result<usize>> {
455	0	Poll::Ready(io::Write::write_vectored(&mut *self, bufs))
456	0	}
457
458	0	fn poll_flush(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<()>> {
459	0	Poll::Ready(io::Write::flush(&mut *self))
460	0	}
461
462	0	fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
463	0	self.poll_flush(cx)
464	0	}
465		};
466		}
467
468		impl AsyncWrite for Vec<u8> {
469		delegate_async_write_to_stdio!();
470		}
471
472		macro_rules! deref_async_seek {
473		() => {
474	0	fn poll_seek(
475	0	mut self: Pin<&mut Self>,
476	0	cx: &mut Context<'_>,
477	0	pos: SeekFrom,
478	0	) -> Poll<Result<u64>> {
479	0	Pin::new(&mut **self).poll_seek(cx, pos)
480	0	} Unexecuted instantiation: <alloc::boxed::Box<_> as futures_io::if_std::AsyncSeek>::poll_seek Unexecuted instantiation: <&mut _ as futures_io::if_std::AsyncSeek>::poll_seek
481		};
482		}
483
484		impl<T: ?Sized + AsyncSeek + Unpin> AsyncSeek for Box<T> {
485		deref_async_seek!();
486		}
487
488		impl<T: ?Sized + AsyncSeek + Unpin> AsyncSeek for &mut T {
489		deref_async_seek!();
490		}
491
492		impl<P> AsyncSeek for Pin<P>
493		where
494		P: DerefMut + Unpin,
495		P::Target: AsyncSeek,
496		{
497	0	fn poll_seek(
498	0	self: Pin<&mut Self>,
499	0	cx: &mut Context<'_>,
500	0	pos: SeekFrom,
501	0	) -> Poll<Result<u64>> {
502	0	self.get_mut().as_mut().poll_seek(cx, pos)
503	0	}
504		}
505
506		macro_rules! deref_async_buf_read {
507		() => {
508	0	fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>> {
509	0	Pin::new(&mut **self.get_mut()).poll_fill_buf(cx)
510	0	} Unexecuted instantiation: <alloc::boxed::Box<_> as futures_io::if_std::AsyncBufRead>::poll_fill_buf Unexecuted instantiation: <&mut _ as futures_io::if_std::AsyncBufRead>::poll_fill_buf
511
512	0	fn consume(mut self: Pin<&mut Self>, amt: usize) {
513	0	Pin::new(&mut **self).consume(amt)
514	0	} Unexecuted instantiation: <alloc::boxed::Box<_> as futures_io::if_std::AsyncBufRead>::consume Unexecuted instantiation: <&mut _ as futures_io::if_std::AsyncBufRead>::consume
515		};
516		}
517
518		impl<T: ?Sized + AsyncBufRead + Unpin> AsyncBufRead for Box<T> {
519		deref_async_buf_read!();
520		}
521
522		impl<T: ?Sized + AsyncBufRead + Unpin> AsyncBufRead for &mut T {
523		deref_async_buf_read!();
524		}
525
526		impl<P> AsyncBufRead for Pin<P>
527		where
528		P: DerefMut + Unpin,
529		P::Target: AsyncBufRead,
530		{
531	0	fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>> {
532	0	self.get_mut().as_mut().poll_fill_buf(cx)
533	0	}
534
535	0	fn consume(self: Pin<&mut Self>, amt: usize) {
536	0	self.get_mut().as_mut().consume(amt)
537	0	}
538		}
539
540		macro_rules! delegate_async_buf_read_to_stdio {
541		() => {
542	0	fn poll_fill_buf(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<&[u8]>> {
543	0	Poll::Ready(io::BufRead::fill_buf(self.get_mut()))
544	0	}
545
546	0	fn consume(self: Pin<&mut Self>, amt: usize) {
547	0	io::BufRead::consume(self.get_mut(), amt)
548	0	}
549		};
550		}
551
552		impl AsyncBufRead for &[u8] {
553		delegate_async_buf_read_to_stdio!();
554		}
555		}
556
557		#[cfg(feature = "std")]
558		pub use self::if_std::*;