67 lines
1.6 KiB
Rust
67 lines
1.6 KiB
Rust
use futures_core::ready;
|
|
use futures_core::task::{Context, Poll};
|
|
use futures_io::{AsyncRead, IoSliceMut};
|
|
use std::fmt;
|
|
use std::io;
|
|
use std::pin::Pin;
|
|
|
|
/// Reader for the [`repeat()`] function.
|
|
#[must_use = "readers do nothing unless polled"]
|
|
pub struct Repeat {
|
|
byte: u8,
|
|
}
|
|
|
|
/// Creates an instance of a reader that infinitely repeats one byte.
|
|
///
|
|
/// All reads from this reader will succeed by filling the specified buffer with
|
|
/// the given byte.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # futures::executor::block_on(async {
|
|
/// use futures::io::{self, AsyncReadExt};
|
|
///
|
|
/// let mut buffer = [0; 3];
|
|
/// let mut reader = io::repeat(0b101);
|
|
/// reader.read_exact(&mut buffer).await.unwrap();
|
|
/// assert_eq!(buffer, [0b101, 0b101, 0b101]);
|
|
/// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
|
|
/// ```
|
|
pub fn repeat(byte: u8) -> Repeat {
|
|
Repeat { byte }
|
|
}
|
|
|
|
impl AsyncRead for Repeat {
|
|
#[inline]
|
|
fn poll_read(
|
|
self: Pin<&mut Self>,
|
|
_: &mut Context<'_>,
|
|
buf: &mut [u8],
|
|
) -> Poll<io::Result<usize>> {
|
|
for slot in &mut *buf {
|
|
*slot = self.byte;
|
|
}
|
|
Poll::Ready(Ok(buf.len()))
|
|
}
|
|
|
|
#[inline]
|
|
fn poll_read_vectored(
|
|
mut self: Pin<&mut Self>,
|
|
cx: &mut Context<'_>,
|
|
bufs: &mut [IoSliceMut<'_>],
|
|
) -> Poll<io::Result<usize>> {
|
|
let mut nwritten = 0;
|
|
for buf in bufs {
|
|
nwritten += ready!(self.as_mut().poll_read(cx, buf))?;
|
|
}
|
|
Poll::Ready(Ok(nwritten))
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for Repeat {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.pad("Repeat { .. }")
|
|
}
|
|
}
|