Трейт AsyncReadExt

Создаёт новый экземпляр AsyncRead, объединяющий этот поток с next.

Возвращённый экземпляр AsyncRead сначала прочитает из этого объекта все байты до достижения EOF. После этого результат будет эквивалентен результату next.

Примеры

File реализуют 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(())
}

Извлекает из этого источника некоторое количество байтов в указанный буфер и возвращает количество прочитанных байтов.

Эквивалентно:

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

Этот метод не гарантирует, что выполнение завершится немедленно, а не асинхронно.

Возвращаемое значение

Если возвращаемое значение этого метода — Ok(n), то должно быть гарантировано, что 0 <= n <= buf.len(). Ненулевое значение n указывает, что буфер buf был заполнен n байтами данных из этого источника. Если n равно 0, это может указывать на один из двух сценариев:

1. Этот читатель достиг «конца файла» и, вероятно, больше не сможет выдавать байты. Обратите внимание, что это не означает, что читатель всегда больше не сможет выдавать байты.
2. Указанный буфер имеет длину 0 байт.

Никаких гарантий относительно содержимого buf при вызове этой функции не предоставляется; реализации не могут полагаться на истинность каких-либо свойств содержимого buf. Рекомендуется, чтобы реализации только записывали данные в buf, а не читали его содержимое.

Однако, соответственно, вызывающие стороны этого метода не должны рассчитывать на какие-либо гарантии относительно того, как реализация использует buf. Возможно, что код, предназначенный для записи в буфер, также будет читать из него. Вы обязаны убедиться, что buf инициализирован до вызова read.

Ошибки

Если эта функция столкнётся с какой-либо ошибкой ввода-вывода или другой ошибкой, будет возвращён вариант ошибки. Если возвращена ошибка, должно быть гарантировано, что байты не были прочитаны.

Безопасность отмены

Этот метод безопасен при отмене. Если использовать его как ветвь в tokio::select! и первой завершится другая ветвь, будет гарантировано, что данные не были прочитаны.

Примеры

File реализуют 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(())
}

Извлекает из этого источника некоторое количество байтов в указанный буфер, продвигая внутренний курсор буфера.

Эквивалентно:

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

Обычно выполняется только один системный вызов read, даже если в переданном буфере есть дополнительное свободное место.

Этот метод не гарантирует, что выполнение завершится немедленно, а не асинхронно.

Возвращаемое значение

Ненулевое значение n указывает, что буфер buf был заполнен n байтами данных из этого источника. Если n равно 0, это может указывать на один из двух сценариев:

1. Этот читатель достиг «конца файла» и, вероятно, больше не сможет выдавать байты. Обратите внимание, что это не означает, что читатель всегда больше не сможет выдавать байты.
2. Указанный буфер не имел свободной ёмкости.

Ошибки

Если эта функция столкнётся с какой-либо ошибкой ввода-вывода или другой ошибкой, будет возвращён вариант ошибки. Если возвращена ошибка, должно быть гарантировано, что байты не были прочитаны.

Безопасность отмены

Этот метод безопасен при отмене. Если использовать его как ветвь в tokio::select! и первой завершится другая ветвь, будет гарантировано, что данные не были прочитаны.

Примеры

File реализует Read, а BytesMut реализует 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());
    assert!(buffer.capacity() >= 10);

    // note that the return value is not needed to access the data
    // that was read as `buffer`'s internal cursor is updated.
    //
    // this might read more than 10 bytes if the capacity of `buffer`
    // is larger than 10.
    f.read_buf(&mut buffer).await?;

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

Считывает точное количество байтов, необходимое для заполнения buf.

Эквивалентно:

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

Эта функция считывает столько байтов, сколько необходимо для полного заполнения указанного буфера buf.

Ошибки

Если до полного заполнения буфера операция достигает «конца файла», она возвращает ошибку вида ErrorKind::UnexpectedEof. В этом случае содержимое buf не определено.

При возникновении любой другой ошибки чтения операция немедленно завершается. В этом случае содержимое buf не определено.

Если эта операция возвращает ошибку, количество считанных ею байтов не определено, но она никогда не считывает больше байтов, чем необходимо для полного заполнения буфера.

Безопасность при отмене

Этот метод не является безопасным при отмене. Если метод используется в качестве ветви в tokio::select! и первой завершается другая ветвь, некоторые данные уже могли быть считаны в buf.

Примеры

File реализуют 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 len = 10;
    let mut buffer = vec![0; len];

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

Считывает беззнаковое 8-битное целое число из базового источника чтения.

Эквивалентно:

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

Чтобы избежать чрезмерного количества системных вызовов, рекомендуется использовать буферизованный источник чтения.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод безопасен при отмене. Если метод используется в качестве ветви в tokio::select! и первой завершается другая ветвь, гарантируется, что никакие данные не были считаны.

Примеры

Считывание беззнаковых 8-битных целых чисел из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![2, 5]);

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

Ok(())

Считывает знаковое 8-битное целое число из базового источника чтения.

Эквивалентно:

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

Чтобы избежать чрезмерного количества системных вызовов, рекомендуется использовать буферизованный источник чтения.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод безопасен при отмене. Если метод используется в качестве ветви в tokio::select! и первой завершается другая ветвь, гарантируется, что никакие данные не были считаны.

Примеры

Считывание беззнаковых 8-битных целых чисел из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![0x02, 0xfb]);

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

Ok(())

Считывает беззнаковое 16-битное целое число в порядке от старшего байта к младшему из базового источника чтения.

Эквивалентно:

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

Чтобы избежать чрезмерного количества системных вызовов, рекомендуется использовать буферизованный источник чтения.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод не является безопасным при отмене. Если метод используется в качестве ветви в tokio::select! и первой завершается другая ветвь, некоторые данные могут быть потеряны.

Примеры

Считывание беззнаковых 16-битных целых чисел в порядке от старшего байта к младшему из AsyncRead:

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

use std::io::Cursor;

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(())

Считывает знаковое 16-битное целое число в порядке от старшего байта к младшему из базового источника чтения.

Эквивалентно:

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

Чтобы избежать чрезмерного количества системных вызовов, рекомендуется использовать буферизованный источник чтения.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод не является безопасным при отмене. Если метод используется в качестве ветви в tokio::select! и первой завершается другая ветвь, некоторые данные могут быть потеряны.

Примеры

Считывание знаковых 16-битных целых чисел в порядке от старшего байта к младшему из AsyncRead:

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

use std::io::Cursor;

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(())

Считывает беззнаковое 32-битное целое число в порядке от старшего байта к младшему из базового средства чтения.

Эквивалентно:

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

Рекомендуется использовать буферизованное средство чтения, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод небезопасен при отмене. Если метод используется как одна из ветвей в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Считывание беззнаковых 32-битных целых чисел в порядке от старшего байта к младшему из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![0x00, 0x00, 0x01, 0x0b]);

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

Считывает знаковое 32-битное целое число в порядке от старшего байта к младшему из базового средства чтения.

Эквивалентно:

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

Рекомендуется использовать буферизованное средство чтения, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод небезопасен при отмене. Если метод используется как одна из ветвей в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Считывание знаковых 32-битных целых чисел в порядке от старшего байта к младшему из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![0xff, 0xff, 0x7a, 0x33]);

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

Считывает беззнаковое 64-битное целое число в порядке от старшего байта к младшему из базового средства чтения.

Эквивалентно:

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

Рекомендуется использовать буферизованное средство чтения, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод небезопасен при отмене. Если метод используется как одна из ветвей в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Считывание беззнаковых 64-битных целых чисел в порядке от старшего байта к младшему из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![
    0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83
]);

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

Считывает знаковое 64-битное целое число в порядке от старшего байта к младшему из базового средства чтения.

Эквивалентно:

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

Рекомендуется использовать буферизованное средство чтения, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод небезопасен при отмене. Если метод используется как одна из ветвей в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Считывание знаковых 64-битных целых чисел в порядке от старшего байта к младшему из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0]);

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

Считывает беззнаковое 128-битное целое число в порядке от старшего байта к младшему из базового средства чтения.

Эквивалентно:

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

Рекомендуется использовать буферизованное средство чтения, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод небезопасен при отмене. Если метод используется как одна из ветвей в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Считывание беззнаковых 128-битных целых чисел в порядке от старшего байта к младшему из AsyncRead:

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

use std::io::Cursor;

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(())

Читает знаковое 128-битное целое число из базового средства чтения в порядке от старшего байта к младшему.

Эквивалентно:

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

Рекомендуется использовать буферизованное средство чтения, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод не является безопасным при отмене. Если метод используется как ветвь в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Чтение знаковых 128-битных целых чисел в порядке от старшего байта к младшему из AsyncRead:

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

use std::io::Cursor;

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, reader.read_i128().await?);
Ok(())

Читает число с плавающей точкой 32-битного типа из базового средства чтения в порядке от старшего байта к младшему.

Эквивалентно:

async fn read_f32(&mut self) -> io::Result<f32>;

Рекомендуется использовать буферизованное средство чтения, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод не является безопасным при отмене. Если метод используется как ветвь в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Чтение числа с плавающей точкой 32-битного типа из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![0xff, 0x7f, 0xff, 0xff]);

assert_eq!(f32::MIN, reader.read_f32().await?);
Ok(())

Читает число с плавающей точкой 64-битного типа из базового средства чтения в порядке от старшего байта к младшему.

Эквивалентно:

async fn read_f64(&mut self) -> io::Result<f64>;

Рекомендуется использовать буферизованное средство чтения, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод не является безопасным при отмене. Если метод используется как ветвь в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Чтение числа с плавающей точкой 64-битного типа из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![
    0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
]);

assert_eq!(f64::MIN, reader.read_f64().await?);
Ok(())

Читает беззнаковое 16-битное целое число из базового средства чтения в порядке от младшего байта к старшему.

Эквивалентно:

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

Рекомендуется использовать буферизованное средство чтения, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод не является безопасным при отмене. Если метод используется как ветвь в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Чтение беззнаковых 16-битных целых чисел в порядке от младшего байта к старшему из AsyncRead:

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

use std::io::Cursor;

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(())

Читает знаковое 16-битное целое число из базового средства чтения в порядке от младшего байта к старшему.

Эквивалентно:

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

Рекомендуется использовать буферизованное средство чтения, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод не является безопасным при отмене. Если метод используется как ветвь в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Чтение знаковых 16-битных целых чисел в порядке от младшего байта к старшему из AsyncRead:

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

use std::io::Cursor;

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(())

Читает беззнаковое 32-битное целое число в порядке от младшего байта к старшему из нижележащего средства чтения.

Эквивалентно:

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

Чтобы избежать чрезмерного количества системных вызовов, рекомендуется использовать буферизованное средство чтения.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность отмены

Этот метод небезопасен при отмене. Если метод используется в качестве ветви в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Чтение беззнаковых 32-битных целых чисел в порядке от младшего байта к старшему из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![0x00, 0x00, 0x01, 0x0b]);

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

Читает знаковое 32-битное целое число в порядке от младшего байта к старшему из нижележащего средства чтения.

Эквивалентно:

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

Чтобы избежать чрезмерного количества системных вызовов, рекомендуется использовать буферизованное средство чтения.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность отмены

Этот метод небезопасен при отмене. Если метод используется в качестве ветви в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Чтение знаковых 32-битных целых чисел в порядке от младшего байта к старшему из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![0xff, 0xff, 0x7a, 0x33]);

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

Читает беззнаковое 64-битное целое число в порядке от младшего байта к старшему из нижележащего средства чтения.

Эквивалентно:

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

Чтобы избежать чрезмерного количества системных вызовов, рекомендуется использовать буферизованное средство чтения.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность отмены

Этот метод небезопасен при отмене. Если метод используется в качестве ветви в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Чтение беззнаковых 64-битных целых чисел в порядке от младшего байта к старшему из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![
    0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83
]);

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

Читает знаковое 64-битное целое число в порядке от младшего байта к старшему из нижележащего средства чтения.

Эквивалентно:

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

Чтобы избежать чрезмерного количества системных вызовов, рекомендуется использовать буферизованное средство чтения.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность отмены

Этот метод небезопасен при отмене. Если метод используется в качестве ветви в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Чтение знаковых 64-битных целых чисел в порядке от младшего байта к старшему из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0]);

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

Читает беззнаковое 128-битное целое число в порядке от младшего байта к старшему из нижележащего средства чтения.

Эквивалентно:

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

Чтобы избежать чрезмерного количества системных вызовов, рекомендуется использовать буферизованное средство чтения.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность отмены

Этот метод небезопасен при отмене. Если метод используется в качестве ветви в tokio::select! и другая ветвь завершается первой, часть данных может быть потеряна.

Примеры

Чтение беззнаковых 128-битных целых чисел в порядке от младшего байта к старшему из AsyncRead:

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

use std::io::Cursor;

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(())

Считывает знаковое 128-битное целое число из базового источника в порядке от младшего байта к старшему.

Эквивалентно:

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

Рекомендуется использовать буферизованный читатель, чтобы избежать чрезмерного числа системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод не является безопасным при отмене. Если метод используется в качестве ветви в tokio::select! и другая ветвь завершается первой, некоторые данные могут быть потеряны.

Примеры

Считывание знаковых 128-битных целых чисел в порядке от младшего байта к старшему из AsyncRead:

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

use std::io::Cursor;

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(())

Считывает значение с плавающей точкой размером 32 бита из базового источника в порядке от младшего байта к старшему.

Эквивалентно:

async fn read_f32_le(&mut self) -> io::Result<f32>;

Рекомендуется использовать буферизованный читатель, чтобы избежать чрезмерного числа системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод не является безопасным при отмене. Если метод используется в качестве ветви в tokio::select! и другая ветвь завершается первой, некоторые данные могут быть потеряны.

Примеры

Считывание значения с плавающей точкой размером 32 бита из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![0xff, 0xff, 0x7f, 0xff]);

assert_eq!(f32::MIN, reader.read_f32_le().await?);
Ok(())

Считывает значение с плавающей точкой размером 64 бита из базового источника в порядке от младшего байта к старшему.

Эквивалентно:

async fn read_f64_le(&mut self) -> io::Result<f64>;

Рекомендуется использовать буферизованный читатель, чтобы избежать чрезмерного числа системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncReadExt::read_exact.

Безопасность при отмене

Этот метод не является безопасным при отмене. Если метод используется в качестве ветви в tokio::select! и другая ветвь завершается первой, некоторые данные могут быть потеряны.

Примеры

Считывание значения с плавающей точкой размером 64 бита из AsyncRead:

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

use std::io::Cursor;

let mut reader = Cursor::new(vec![
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff
]);

assert_eq!(f64::MIN, reader.read_f64_le().await?);
Ok(())

Считывает все байты из этого источника до EOF и помещает их в buf.

Эквивалентно:

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

Все байты, считанные из этого источника, будут добавлены в указанный буфер buf. Эта функция будет непрерывно вызывать read(), чтобы добавлять данные в buf, пока read() не вернёт Ok(0).

В случае успеха возвращается общее количество считанных байтов.

Ошибки

При возникновении ошибки чтения операция read_to_end немедленно завершается. Все уже считанные байты будут добавлены в buf.

Примеры

File реализуют 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(())
}

(См. также вспомогательную функцию tokio::fs::read для чтения из файла.)

Читает все байты из этого источника до EOF и добавляет их в buf.

Эквивалентно:

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

В случае успеха возвращается количество прочитанных байтов, добавленных в buf.

Ошибки

Если данные в этом потоке не являются допустимым UTF-8, возвращается ошибка, а buf остаётся без изменений.

Другие особенности обработки ошибок см. в read_to_end.

Примеры

File реализуют 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(())
}

(См. также вспомогательную функцию crate::fs::read_to_string для чтения из файла.)

Создаёт адаптер, который считывает из него не более limit байт.

Эта функция возвращает новый экземпляр AsyncRead, который считывает не более limit байт, после чего всегда возвращает EOF (Ok(0)). Ошибки чтения не учитываются в количестве прочитанных байтов, и последующие вызовы read() могут завершиться успешно.

Примеры

File реализуют 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(())
}