#delimiter #slice #tokio #async-read #byte-stream #async-buf-read #read-until

read_until_slice

AsyncBufRead::read_until extension to take a slice as a delimiter instead of a single u8

10 releases

0.1.9 Feb 16, 2025
0.1.8 Dec 20, 2024
0.1.7 Sep 22, 2024
0.1.6 Aug 9, 2024
0.1.2 Feb 18, 2024

#414 in Asynchronous

Download history 3/week @ 2024-11-13 7/week @ 2024-11-20 5/week @ 2024-11-27 7/week @ 2024-12-04 25/week @ 2024-12-11 127/week @ 2024-12-18 4/week @ 2024-12-25 4/week @ 2025-01-01 7/week @ 2025-01-08 2/week @ 2025-02-05 122/week @ 2025-02-12 16/week @ 2025-02-19 16/week @ 2025-02-26

156 downloads per month
Used in 3 crates (2 directly)

MIT license

9KB
103 lines

read_until_slice  LICENSE crates.io Version Documentation

The tokio io-util feature provides the method:

pub async fn read_until(&mut self, delimiter: u8, buf: Vec<u8>) -> Result<usize>

on impl AsyncBufRead + Unpin.

This reads from an async buffered reader until either EOF or the delimiter is reached.

While useful, it is limited to a single byte delimiter.

This crate extends this by taking a slice as a delimiter instead of a single byte.

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

on the same impl AsyncBufRead + Unpin.

Example

// Open socket
let stream = TcpStream::connect(addr)
    .await
    .expect("could not connect to remote address");
// Split stream into reader and writer halves
let (reader, mut writer) = split(stream);
// Buffer read stream
let mut reader = BufReader::new(reader);
...
// Read until new line delimiter into buffer
let mut buffer = vec![];
let delimiter = b"\r\n";
let n = reader.read_until(delimiter, &mut buffer)
    .await
    .expect("could not read from socket");
assert_eq!(n, buffer.len());
if buffer.ends_with(delimiter) {
    println!("end of line delimiter reached");
} else {
    println!("end of stream reached");
}

Dependencies

~2.2–8MB
~50K SLoC