Crate channel_io

A simple helper library to convert Senders/Receivers into Writers/Readers.

Examples

Using a receiver as a reader

use std::io::Read;

use bytes::Bytes;
use channel_io::ChannelReader;
use flume::bounded;


let (tx, rx) = bounded(10);
let sender_thread = std::thread::spawn(move || {
    for i in 0..10 {
        let buffer = Bytes::from(vec![i; 10]);
        tx.send(buffer).unwrap();
    }
});

sender_thread.join().unwrap();

let mut reader = ChannelReader::new(rx);
let mut buffer = vec![];
reader.read_to_end(&mut buffer).unwrap();
assert_eq!(buffer.len(), 100);

Using a sender as a writer

use std::io::Write;

use bytes::Bytes;
use channel_io::ChannelWriter;
use flume::{bounded, Receiver, Sender};


let (tx, rx): (Sender<Bytes>, Receiver<Bytes>) = bounded(10);
let sender_thread = std::thread::spawn(move || {
    let mut total_read = 0;
    while let Ok(bytes) = rx.recv() {
        total_read += bytes.len();
    }
    total_read
});

let mut writer = ChannelWriter::new(tx);
writer.write_all(b"Let's add a happy little tree.").unwrap();
writer.write_all(b"And maybe a little snowcap right over here.").unwrap();
writer.flush().unwrap();
// Note we must drop the writer to dropt he sender to allow the thread to close
drop(writer);

let bytes_read = sender_thread.join().unwrap();
assert_eq!(bytes_read, 73);

Structs

ChannelReader

A channel reader that reads bytes from a Receiver<Bytes>

ChannelWriter

A channel writer that writes bytes to a Sender<Bytes>.

Constants

BUFSIZE

The default buffer size to use (128K)