#tokio #buffered #streams #asynchronous-io #support

bufstream

Buffered I/O for streams where each read/write half is separately buffered

5 releases

Uses old Rust 2015

0.1.4 Sep 27, 2018
0.1.3 Apr 26, 2017
0.1.2 Apr 29, 2016
0.1.1 May 13, 2015
0.1.0 May 5, 2015
Download history 5464/week @ 2020-04-12 5432/week @ 2020-04-19 5748/week @ 2020-04-26 5171/week @ 2020-05-03 5840/week @ 2020-05-10 6016/week @ 2020-05-17 5173/week @ 2020-05-24 5870/week @ 2020-05-31 6995/week @ 2020-06-07 6618/week @ 2020-06-14 6339/week @ 2020-06-21 6214/week @ 2020-06-28 6643/week @ 2020-07-05 5804/week @ 2020-07-12 6007/week @ 2020-07-19 6685/week @ 2020-07-26

26,109 downloads per month
Used in 174 crates (52 directly)

MIT/Apache

11KB
138 lines

bufstream

Buffered I/O streams for reading/writing

Build Status

Documentation

Usage

[dependencies]
bufstream = "0.1"

Tokio

There is support for tokio's AsyncRead + AsyncWrite traits through the tokio feature. When using this crate with asynchronous IO, make sure to properly flush the stream before dropping it since IO during drop may cause panics. For the same reason you should stay away from BufStream::into_inner.


lib.rs:

A crate for separately buffered streams.

This crate provides a BufStream type which provides buffering of both the reading and writing halves of a Read + Write type. Each half is completely independently buffered of the other, which may not always be desired. For example BufStream<File> may have surprising semantics.

Usage

[dependencies]
bufstream = "0.1"
use std::io::prelude::*;
use std::net::TcpStream;
use bufstream::BufStream;


let stream = TcpStream::connect("localhost:4000").unwrap();
let mut buf = BufStream::new(stream);
buf.read(&mut [0; 1024]).unwrap();
buf.write(&[0; 1024]).unwrap();

Async I/O

This crate optionally can support async I/O streams with the Tokio stack via the tokio feature of this crate:

bufstream = { version = "0.2", features = ["tokio"] }

All methods are internally capable of working with streams that may return ErrorKind::WouldBlock when they're not ready to perform the particular operation.

Note that care needs to be taken when using these objects, however. The Tokio runtime, in particular, requires that data is fully flushed before dropping streams. For compatibility with blocking streams all streams are flushed/written when they are dropped, and this is not always a suitable time to perform I/O. If I/O streams are flushed before drop, however, then these operations will be a noop.

Dependencies

~89KB