io-stream 0.0.2

Set of I/O-free coroutines and runtimes to manage streams
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

//! The standard, blocking stream runtime.

use std::io::{self, Read, Write};

use log::trace;

use crate::io::{StreamIo, StreamOutput};

/// The standard, blocking filesystem runtime handler.
///
/// This handler makes use of standard modules [`std::io`] to process
/// [`StreamIo`].
pub fn handle(stream: impl Read + Write, io: StreamIo) -> io::Result<StreamIo> {
    match io {
        StreamIo::Read(io) => read(stream, io),
        StreamIo::Write(io) => write(stream, io),
    }
}

pub fn read(mut stream: impl Read, input: Result<StreamOutput, Vec<u8>>) -> io::Result<StreamIo> {
    let mut buffer = match input {
        Ok(output) => return Ok(StreamIo::Read(Ok(output))),
        Err(buffer) => buffer,
    };

    trace!("reading bytes synchronously");
    let bytes_count = stream.read(&mut buffer)?;

    let output = StreamOutput {
        buffer,
        bytes_count,
    };

    Ok(StreamIo::Read(Ok(output)))
}

pub fn write(mut stream: impl Write, input: Result<StreamOutput, Vec<u8>>) -> io::Result<StreamIo> {
    let bytes = match input {
        Ok(output) => return Ok(StreamIo::Write(Ok(output))),
        Err(bytes) => bytes,
    };

    trace!("writing bytes synchronously");
    let bytes_count = stream.write(&bytes)?;

    let output = StreamOutput {
        buffer: bytes,
        bytes_count,
    };

    Ok(StreamIo::Write(Ok(output)))
}