Struct ReadHalf

pub struct ReadHalf<'a>(/* private fields */);

Available on crate feature tcp only.

Read half of a TcpStream.

Implementations

impl ReadHalf<'_>

pub fn poll_peek( &mut self, cx: &mut Context<'_>, buf: &mut [u8], ) -> Poll<Result<usize>>

Attempt to receive data on the socket, without removing that data from the queue, registering the current task for wakeup if data is not yet available.

See the TcpStream::poll_peek level documenation for more details.

Examples

use tokio::io;
use tokio::net::TcpStream;

use futures::future::poll_fn;

#[tokio::main]
async fn main() -> io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:8000").await?;
    let (mut read_half, _) = stream.split();
    let mut buf = [0; 10];

    poll_fn(|cx| {
        read_half.poll_peek(cx, &mut buf)
    }).await?;

    Ok(())
}

pub async fn peek(&mut self, buf: &mut [u8]) -> Result<usize>

Receives data on the socket from the remote address to which it is connected, without removing that data from the queue. On success, returns the number of bytes peeked.

See the TcpStream::peek level documenation for more details.

Examples

use tokio::net::TcpStream;
use tokio::prelude::*;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Connect to a peer
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
    let (mut read_half, _) = stream.split();

    let mut b1 = [0; 10];
    let mut b2 = [0; 10];

    // Peek at the data
    let n = read_half.peek(&mut b1).await?;

    // Read the data
    assert_eq!(n, read_half.read(&mut b2[..n]).await?);
    assert_eq!(&b1[..n], &b2[..n]);

    Ok(())
}

Trait Implementations

impl AsRef<TcpStream> for ReadHalf<'_>

fn as_ref(&self) -> &TcpStream

Converts this type into a shared reference of the (usually inferred) input type.

impl AsyncRead for ReadHalf<'_>

unsafe fn prepare_uninitialized_buffer(&self, _: &mut [MaybeUninit<u8>]) -> bool

Prepares an uninitialized buffer to be safe to pass to read. Returns true if the supplied buffer was zeroed out.

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8], ) -> Poll<Result<usize>>

Attempt to read from the AsyncRead into buf.

fn poll_read_buf<B: BufMut>( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut B, ) -> Poll<Result<usize>>

where Self: Sized,

Pull some bytes from this source into the specified BufMut, returning how many bytes were read.

impl<'a> Debug for ReadHalf<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.