mid-net 1.0.0

Network adapter for the `middleware` protocol implementation
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use tokio::{
    io::{
        AsyncReadExt,
        AsyncWriteExt,
        BufReader,
    },
    net::{
        tcp::{
            ReadHalf,
            WriteHalf,
        },
        TcpStream,
    },
};

use crate::{
    reader::MidReader,
    writer::MidWriter,
};

pub trait ReaderUnderlyingExt: AsyncReadExt + Unpin {}
pub trait WriterUnderlyingExt: AsyncWriteExt + Unpin {}

impl<T: AsyncReadExt + Unpin> ReaderUnderlyingExt for T {}
impl<T: AsyncWriteExt + Unpin> WriterUnderlyingExt for T {}

pub trait MidStreamExt {
    /// Create `Middleware` rw handles from the
    /// [`TcpStream`]
    fn as_rw_handles<C, D>(
        &mut self,
        compressor: C,
        decompressor: D,
    ) -> (MidReader<ReadHalf<'_>, D>, MidWriter<WriteHalf<'_>, C>);

    /// Create `Middleware` rw handles with the buffered
    /// reader
    fn as_buffered_rw_handles<C, D>(
        &mut self,
        compressor: C,
        decompressor: D,
        buffer_size: usize,
    ) -> (
        MidReader<BufReader<ReadHalf<'_>>, D>,
        MidWriter<WriteHalf<'_>, C>,
    );
}

impl MidStreamExt for TcpStream {
    fn as_rw_handles<C, D>(
        &mut self,
        compressor: C,
        decompressor: D,
    ) -> (MidReader<ReadHalf<'_>, D>, MidWriter<WriteHalf<'_>, C>) {
        let (read, write) = self.split();
        (
            MidReader::new(read, decompressor),
            MidWriter::new(write, compressor),
        )
    }

    fn as_buffered_rw_handles<C, D>(
        &mut self,
        compressor: C,
        decompressor: D,
        buffer_size: usize,
    ) -> (
        MidReader<BufReader<ReadHalf<'_>>, D>,
        MidWriter<WriteHalf<'_>, C>,
    ) {
        let (read, write) = self.split();
        (
            MidReader::new_buffered(read, decompressor, buffer_size),
            MidWriter::new(write, compressor),
        )
    }
}