1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
use crate::io::{AsyncRead, ReadBuf}; use std::io; use std::pin::Pin; use std::task::{Context, Poll}; cfg_io_util! { /// An async reader which yields one byte over and over and over and over and /// over and... /// /// This struct is generally created by calling [`repeat`][repeat]. Please /// see the documentation of `repeat()` for more details. /// /// This is an asynchronous version of [`std::io::Repeat`][std]. /// /// [repeat]: fn@repeat /// [std]: std::io::Repeat #[derive(Debug)] pub struct Repeat { byte: u8, } /// Creates an instance of an async reader that infinitely repeats one byte. /// /// All reads from this reader will succeed by filling the specified buffer with /// the given byte. /// /// This is an asynchronous version of [`std::io::repeat`][std]. /// /// [std]: std::io::repeat /// /// # Examples /// /// ``` /// use tokio::io::{self, AsyncReadExt}; /// /// #[tokio::main] /// async fn main() { /// let mut buffer = [0; 3]; /// io::repeat(0b101).read_exact(&mut buffer).await.unwrap(); /// assert_eq!(buffer, [0b101, 0b101, 0b101]); /// } /// ``` pub fn repeat(byte: u8) -> Repeat { Repeat { byte } } } impl AsyncRead for Repeat { #[inline] fn poll_read( self: Pin<&mut Self>, _: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<io::Result<()>> { // TODO: could be faster, but should we unsafe it? while buf.remaining() != 0 { buf.put_slice(&[self.byte]); } Poll::Ready(Ok(())) } } #[cfg(test)] mod tests { use super::*; #[test] fn assert_unpin() { crate::is_unpin::<Repeat>(); } }