# tokio::io::AsyncReadExt - Rust
API documentation for the Rust `AsyncReadExt` trait in crate `tokio`.
Keywords: rust, rustlang, rust-lang, AsyncReadExt

# Trait tokio::io::AsyncReadExt [−] [src]

    pub trait AsyncReadExt: AsyncRead {
        fn chain<R>(self, next: R) -> Chain<Self, R>
        where
            Self: Sized,
            R: AsyncRead,
        { ... }
        fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self>
        where
            Self: Unpin,
        { ... }
        fn read_buf<'a, B>(&'a mut self, buf: &'a mut B) -> ReadBuf<'a, Self, B>
        where
            Self: Sized + Unpin,
            B: BufMut,
        { ... }
        fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self>
        where
            Self: Unpin,
        { ... }
        fn read_u8<'a>(&'a mut self) -> ReadU8<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_i8<'a>(&'a mut self) -> ReadI8<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_u16<'a>(&'a mut self) -> ReadU16<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_i16<'a>(&'a mut self) -> ReadI16<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_u32<'a>(&'a mut self) -> ReadU32<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_i32<'a>(&'a mut self) -> ReadI32<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_u64<'a>(&'a mut self) -> ReadU64<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_i64<'a>(&'a mut self) -> ReadI64<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_u128<'a>(&'a mut self) -> ReadU128<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_i128<'a>(&'a mut self) -> ReadI128<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_u16_le<'a>(&'a mut self) -> ReadU16Le<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_i16_le<'a>(&'a mut self) -> ReadI16Le<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_u32_le<'a>(&'a mut self) -> ReadU32Le<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_i32_le<'a>(&'a mut self) -> ReadI32Le<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_u64_le<'a>(&'a mut self) -> ReadU64Le<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_i64_le<'a>(&'a mut self) -> ReadI64Le<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_u128_le<'a>(&'a mut self) -> ReadU128Le<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_i128_le<'a>(&'a mut self) -> ReadI128Le<&'a mut Self>
        where
            Self: Unpin,
        { ... }
        fn read_to_end<'a>(
            &'a mut self,
            buf: &'a mut Vec<u8>
        ) -> ReadToEnd<'a, Self>
        where
            Self: Unpin,
        { ... }
        fn read_to_string<'a>(
            &'a mut self,
            dst: &'a mut String
        ) -> ReadToString<'a, Self>
        where
            Self: Unpin,
        { ... }
        fn take(self, limit: u64) -> Take<Self>
        where
            Self: Sized,
        { ... }
    }

Reads bytes from a source.

Implemented as an extension trait, adding utility methods to all `AsyncRead` types. Callers will tend to import this trait instead of `AsyncRead`.

    use tokio::fs::File;
    use tokio::io::{self, AsyncReadExt};

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut f = File::open("foo.txt").await?;
        let mut buffer = [0; 10];

        // The `read` method is defined by this trait.
        let n = f.read(&mut buffer[..]).await?;

        Ok(())
    }

See module documentation for more details.

## Provided methods

### `fn chain<R>(self, next: R) -> Chain<Self, R> where
Self: Sized,
R: AsyncRead,` [src]

Creates a new `AsyncRead` instance that chains this stream with `next`.

The returned `AsyncRead` instance will first read all bytes from this object until EOF is encountered. Afterwards the output is equivalent to the output of `next`.

# Examples

`File`s implement `AsyncRead`:

    use tokio::fs::File;
    use tokio::io::{self, AsyncReadExt};

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let f1 = File::open("foo.txt").await?;
        let f2 = File::open("bar.txt").await?;

        let mut handle = f1.chain(f2);
        let mut buffer = String::new();

        // read the value into a String. We could use any AsyncRead
        // method here, this is just one example.
        handle.read_to_string(&mut buffer).await?;
        Ok(())
    }

### `fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> where
Self: Unpin,` [src]

Pulls some bytes from this source into the specified buffer, returning how many bytes were read.

Equivalent to:

ⓘ

    async fn read(&mut self, buf: &mut [u8]) -> io::Result<usize>;

This function does not provide any guarantees about whether it completes immediately or asynchronously

If the return value of this method is `Ok(n)`, then it must be guaranteed that `0 <= n <= buf.len()`. A nonzero `n` value indicates that the buffer `buf` has been filled in with `n` bytes of data from this source. If `n` is `0`, then it can indicate one of two scenarios:

1. This reader has reached its "end of file" and will likely no longer be able to produce bytes. Note that this does not mean that the reader will always no longer be able to produce bytes.
2. The buffer specified was 0 bytes in length.

No guarantees are provided about the contents of `buf` when this function is called, implementations cannot rely on any property of the contents of `buf` being `true`. It is recommended that implementations only write data to `buf` instead of reading its contents.

Correspondingly, however, callers of this method may not assume any guarantees about how the implementation uses `buf`. It is possible that the code that's supposed to write to the buffer might also read from it. It is your responsibility to make sure that `buf` is initialized before calling `read`.

# Errors

If this function encounters any form of I/O or other error, an error variant will be returned. If an error is returned then it must be guaranteed that no bytes were read.

# Examples

`File`s implement `Read`:

    use tokio::fs::File;
    use tokio::io::{self, AsyncReadExt};

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut f = File::open("foo.txt").await?;
        let mut buffer = [0; 10];

        // read up to 10 bytes
        let n = f.read(&mut buffer[..]).await?;

        println!("The bytes: {:?}", &buffer[..n]);
        Ok(())
    }

### `fn read_buf<'a, B>(&'a mut self, buf: &'a mut B) -> ReadBuf<'a, Self, B> where
Self: Sized + Unpin,
B: BufMut,` [src]

Pulls some bytes from this source into the specified buffer, advancing the buffer's internal cursor.

Equivalent to:

ⓘ

    async fn read_buf<B: BufMut>(&mut self, buf: &mut B) -> io::Result<usize>;

Usually, only a single `read` syscall is issued, even if there is more space in the supplied buffer.

This function does not provide any guarantees about whether it completes immediately or asynchronously

# Return

On a successful read, the number of read bytes is returned. If the supplied buffer is not empty and the function returns `Ok(0)` then the source has reached an "end-of-file" event.

# Errors

If this function encounters any form of I/O or other error, an error variant will be returned. If an error is returned then it must be guaranteed that no bytes were read.

# Examples

`File` implements `Read` and `BytesMut` implements `BufMut`:

    use tokio::fs::File;
    use tokio::io::{self, AsyncReadExt};

    use bytes::BytesMut;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut f = File::open("foo.txt").await?;
        let mut buffer = BytesMut::with_capacity(10);

        assert!(buffer.is_empty());

        // read up to 10 bytes, note that the return value is not needed
        // to access the data that was read as `buffer`'s internal
        // cursor is updated.
        f.read_buf(&mut buffer).await?;

        println!("The bytes: {:?}", &buffer[..]);
        Ok(())
    }

### `fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> where
Self: Unpin,` [src]

Reads the exact number of bytes required to fill `buf`.

Equivalent to:

ⓘ

    async fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<usize>;

This function reads as many bytes as necessary to completely fill the specified buffer `buf`.

# Errors

If the operation encounters an "end of file" before completely filling the buffer, it returns an error of the kind `ErrorKind::UnexpectedEof`. The contents of `buf` are unspecified in this case.

If any other read error is encountered then the operation immediately returns. The contents of `buf` are unspecified in this case.

If this operation returns an error, it is unspecified how many bytes it has read, but it will never read more than would be necessary to completely fill the buffer.

# Examples

`File`s implement `Read`:

    use tokio::fs::File;
    use tokio::io::{self, AsyncReadExt};

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut f = File::open("foo.txt").await?;
        let mut buffer = [0; 10];

        // read exactly 10 bytes
        f.read_exact(&mut buffer).await?;
        Ok(())
    }

### `fn read_u8<'a>(&'a mut self) -> ReadU8<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 8 bit integer from the underlying reader.

Equivalent to:

ⓘ

    async fn read_u8(&mut self) -> io::Result<u8>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read unsigned 8 bit integers from an `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![2, 5]);

        assert_eq!(2, reader.read_u8().await?);
        assert_eq!(5, reader.read_u8().await?);

        Ok(())
    }

### `fn read_i8<'a>(&'a mut self) -> ReadI8<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 8 bit integer from the underlying reader.

Equivalent to:

ⓘ

    async fn read_i8(&mut self) -> io::Result<i8>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read unsigned 8 bit integers from an `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![0x02, 0xfb]);

        assert_eq!(2, reader.read_i8().await?);
        assert_eq!(-5, reader.read_i8().await?);

        Ok(())
    }

### `fn read_u16<'a>(&'a mut self) -> ReadU16<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 16-bit integer in big-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_u16(&mut self) -> io::Result<u16>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read unsigned 16 bit big-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![2, 5, 3, 0]);

        assert_eq!(517, reader.read_u16().await?);
        assert_eq!(768, reader.read_u16().await?);
        Ok(())
    }

### `fn read_i16<'a>(&'a mut self) -> ReadI16<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 16-bit integer in big-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_i16(&mut self) -> io::Result<i16>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read signed 16 bit big-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![0x00, 0xc1, 0xff, 0x7c]);

        assert_eq!(193, reader.read_i16().await?);
        assert_eq!(-132, reader.read_i16().await?);
        Ok(())
    }

### `fn read_u32<'a>(&'a mut self) -> ReadU32<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 32-bit integer in big-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_u32(&mut self) -> io::Result<u32>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read unsigned 32-bit big-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![0x00, 0x00, 0x01, 0x0b]);

        assert_eq!(267, reader.read_u32().await?);
        Ok(())
    }

### `fn read_i32<'a>(&'a mut self) -> ReadI32<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 32-bit integer in big-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_i32(&mut self) -> io::Result<i32>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read signed 32-bit big-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![0xff, 0xff, 0x7a, 0x33]);

        assert_eq!(-34253, reader.read_i32().await?);
        Ok(())
    }

### `fn read_u64<'a>(&'a mut self) -> ReadU64<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 64-bit integer in big-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_u64(&mut self) -> io::Result<u64>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read unsigned 64-bit big-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![
            0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83
        ]);

        assert_eq!(918733457491587, reader.read_u64().await?);
        Ok(())
    }

### `fn read_i64<'a>(&'a mut self) -> ReadI64<&'a mut Self> where
Self: Unpin,` [src]

Reads an signed 64-bit integer in big-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_i64(&mut self) -> io::Result<i64>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read signed 64-bit big-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0]);

        assert_eq!(i64::min_value(), reader.read_i64().await?);
        Ok(())
    }

### `fn read_u128<'a>(&'a mut self) -> ReadU128<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 128-bit integer in big-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_u128(&mut self) -> io::Result<u128>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read unsigned 128-bit big-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![
            0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83,
            0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83
        ]);

        assert_eq!(16947640962301618749969007319746179, reader.read_u128().await?);
        Ok(())
    }

### `fn read_i128<'a>(&'a mut self) -> ReadI128<&'a mut Self> where
Self: Unpin,` [src]

Reads an signed 128-bit integer in big-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_i128(&mut self) -> io::Result<i128>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read signed 128-bit big-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![
            0x80, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0
        ]);

        assert_eq!(i128::min_value(), reader.read_i128().await?);
        Ok(())
    }

### `fn read_u16_le<'a>(&'a mut self) -> ReadU16Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 16-bit integer in little-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_u16_le(&mut self) -> io::Result<u16>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read unsigned 16 bit little-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![2, 5, 3, 0]);

        assert_eq!(1282, reader.read_u16_le().await?);
        assert_eq!(3, reader.read_u16_le().await?);
        Ok(())
    }

### `fn read_i16_le<'a>(&'a mut self) -> ReadI16Le<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 16-bit integer in little-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_i16_le(&mut self) -> io::Result<i16>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read signed 16 bit little-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![0x00, 0xc1, 0xff, 0x7c]);

        assert_eq!(-16128, reader.read_i16_le().await?);
        assert_eq!(31999, reader.read_i16_le().await?);
        Ok(())
    }

### `fn read_u32_le<'a>(&'a mut self) -> ReadU32Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 32-bit integer in little-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_u32_le(&mut self) -> io::Result<u32>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read unsigned 32-bit little-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![0x00, 0x00, 0x01, 0x0b]);

        assert_eq!(184614912, reader.read_u32_le().await?);
        Ok(())
    }

### `fn read_i32_le<'a>(&'a mut self) -> ReadI32Le<&'a mut Self> where
Self: Unpin,` [src]

Reads a signed 32-bit integer in little-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_i32_le(&mut self) -> io::Result<i32>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read signed 32-bit little-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![0xff, 0xff, 0x7a, 0x33]);

        assert_eq!(863698943, reader.read_i32_le().await?);
        Ok(())
    }

### `fn read_u64_le<'a>(&'a mut self) -> ReadU64Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 64-bit integer in little-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_u64_le(&mut self) -> io::Result<u64>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read unsigned 64-bit little-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![
            0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83
        ]);

        assert_eq!(9477368352180732672, reader.read_u64_le().await?);
        Ok(())
    }

### `fn read_i64_le<'a>(&'a mut self) -> ReadI64Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an signed 64-bit integer in little-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_i64_le(&mut self) -> io::Result<i64>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read signed 64-bit little-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0]);

        assert_eq!(128, reader.read_i64_le().await?);
        Ok(())
    }

### `fn read_u128_le<'a>(&'a mut self) -> ReadU128Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an unsigned 128-bit integer in little-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_u128_le(&mut self) -> io::Result<u128>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read unsigned 128-bit little-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![
            0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83,
            0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83
        ]);

        assert_eq!(174826588484952389081207917399662330624, reader.read_u128_le().await?);
        Ok(())
    }

### `fn read_i128_le<'a>(&'a mut self) -> ReadI128Le<&'a mut Self> where
Self: Unpin,` [src]

Reads an signed 128-bit integer in little-endian order from the underlying reader.

Equivalent to:

ⓘ

    async fn read_i128_le(&mut self) -> io::Result<i128>;

It is recommended to use a buffered reader to avoid excessive syscalls.

# Errors

This method returns the same errors as `AsyncReadExt::read_exact`.

# Examples

Read signed 128-bit little-endian integers from a `AsyncRead`:

    use tokio::io::{self, AsyncReadExt};

    use std::io::Cursor;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut reader = Cursor::new(vec![
            0x80, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0
        ]);

        assert_eq!(128, reader.read_i128_le().await?);
        Ok(())
    }

### `fn read_to_end<'a>(&'a mut self, buf: &'a mut Vec<u8>) -> ReadToEnd<'a, Self> where
Self: Unpin,` [src]

Reads all bytes until EOF in this source, placing them into `buf`.

Equivalent to:

ⓘ

    async fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize>;

All bytes read from this source will be appended to the specified buffer `buf`. This function will continuously call `read()` to append more data to `buf` until `read()` returns `Ok(0)`.

If successful, the total number of bytes read is returned.

# Errors

If a read error is encountered then the `read_to_end` operation immediately completes. Any bytes which have already been read will be appended to `buf`.

# Examples

`File`s implement `Read`:

    use tokio::io::{self, AsyncReadExt};
    use tokio::fs::File;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut f = File::open("foo.txt").await?;
        let mut buffer = Vec::new();

        // read the whole file
        f.read_to_end(&mut buffer).await?;
        Ok(())
    }

(See also the `tokio::fs::read` convenience function for reading from a file.)

### `fn read_to_string<'a>(
&'a mut self,
dst: &'a mut String
) -> ReadToString<'a, Self> where
Self: Unpin,` [src]

Reads all bytes until EOF in this source, appending them to `buf`.

Equivalent to:

ⓘ

    async fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize>;

If successful, the number of bytes which were read and appended to `buf` is returned.

# Errors

If the data in this stream is not valid UTF-8 then an error is returned and `buf` is unchanged.

See `read_to_end` for other error semantics.

# Examples

`File`s implement `Read`:

    use tokio::io::{self, AsyncReadExt};
    use tokio::fs::File;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let mut f = File::open("foo.txt").await?;
        let mut buffer = String::new();

        f.read_to_string(&mut buffer).await?;
        Ok(())
    }

(See also the `crate::fs::read_to_string` convenience function for reading from a file.)

### `fn take(self, limit: u64) -> Take<Self> where
Self: Sized,` [src]

Creates an adaptor which reads at most `limit` bytes from it.

This function returns a new instance of `AsyncRead` which will read at most `limit` bytes, after which it will always return EOF (`Ok(0)`). Any read errors will not count towards the number of bytes read and future calls to `read()` may succeed.

# Examples

`File`s implement `Read`:

    use tokio::io::{self, AsyncReadExt};
    use tokio::fs::File;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let f = File::open("foo.txt").await?;
        let mut buffer = [0; 5];

        // read at most five bytes
        let mut handle = f.take(5);

        handle.read(&mut buffer).await?;
        Ok(())
    }

Loading content...

## Implementors

### `impl<R: AsyncRead + ?Sized> AsyncReadExt for R` [src]

Loading content...