# [−] [src] Struct tokio::net::tcp::OwnedReadHalf

    pub struct OwnedReadHalf { /* fields omitted */ }

Owned read half of a `TcpStream`, created by `into_split`.

Reading from an `OwnedReadHalf` is usually done using the convenience methods found on the `AsyncReadExt` trait.

## Implementations

### `impl OwnedReadHalf` [src]

#### `pub fn reunite(self, other: OwnedWriteHalf) -> Result<TcpStream, ReuniteError>` [src]

Attempts to put the two halves of a `TcpStream` back together and recover the original socket. Succeeds only if the two halves originated from the same call to `into_split`.

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

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.

Note that on multiple calls to `poll_peek` or `poll_read`, only the `Waker` from the `Context` passed to the most recent call is scheduled to receive a wakeup.

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

# Examples

    use tokio::io::{self, ReadBuf};
    use tokio::net::TcpStream;

    use futures::future::poll_fn;

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

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

        Ok(())
    }

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

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::io::AsyncReadExt;
    use std::error::Error;

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

The `read` method is defined on the `AsyncReadExt` trait.

## Trait Implementations

### `impl AsRef<TcpStream> for OwnedReadHalf` [src]

#### `fn as_ref(&self) -> &TcpStream` [src]

Performs the conversion.

### `impl AsyncRead for OwnedReadHalf` [src]

#### `fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>
) -> Poll<Result<()>>` [src]

Attempts to read from the `AsyncRead` into `buf`. Read more

### `impl Debug for OwnedReadHalf` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl !RefUnwindSafe for OwnedReadHalf`

### `impl Send for OwnedReadHalf`

### `impl Sync for OwnedReadHalf`

### `impl Unpin for OwnedReadHalf`

### `impl !UnwindSafe for OwnedReadHalf`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.