tcio 0.1.2

Collection of utility types.
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
78
79
80
81
82
83

use std::{io, task::Poll};
use bytes::{Buf, BytesMut};

use crate::io::AsyncIoRead;

/// An [`AsyncIoRead`] with internal buffer.
///
/// The difference with tokio `AsyncBufRead` is that, the tokio version requires its internal
/// buffer to be empty to be able to read more data. Therefore, if the io buffer did not have
/// enough data, the receiver still also need an internal buffer of its own so that the io can read
/// more data.
///
/// This version did not requires io buffer to be empty to read more data, and receiver did not
/// requires its own internal buffer.
pub trait AsyncBufRead {
    /// Attempts to read from the underlying io into internal buffer, returning how many data read.
    fn poll_read_fill(&mut self, cx: &mut std::task::Context) -> Poll<io::Result<usize>>;

    /// Returns reference of internal buffer.
    fn chunk(&self) -> &[u8];

    /// Clear `cnt` data from the internal buffer.
    ///
    /// The `cnt` must be <= the number of bytes in the buffer returned
    /// [`chunk`][AsyncBufRead::chunk].
    fn consume(&mut self, cnt: usize);
}

impl<T: AsyncBufRead> AsyncBufRead for &mut T {
    fn poll_read_fill(&mut self, cx: &mut std::task::Context) -> Poll<io::Result<usize>> {
        T::poll_read_fill(self, cx)
    }

    fn chunk(&self) -> &[u8] {
        T::chunk(self)
    }

    fn consume(&mut self, cnt: usize) {
        T::consume(self, cnt);
    }
}

/// An implementation of [`AsyncBufRead`] with given [`AsyncIoRead`].
#[derive(Debug)]
pub struct BufReader<IO> {
    io: IO,
    buf: BytesMut,
}

impl<IO> BufReader<IO> {
    /// Creates a new [`BufReader`].
    #[inline]
    pub fn new(io: IO) -> Self {
        Self { io, buf: BytesMut::new() }
    }

    /// Creates a new [`BufReader`] with the specified internal buffer capacity.
    #[inline]
    pub fn with_capacity(io: IO, capacity: usize) -> Self {
        Self { io, buf: BytesMut::with_capacity(capacity) }
    }
}

impl<IO> AsyncBufRead for BufReader<IO>
where
    IO: AsyncIoRead
{
    #[inline]
    fn poll_read_fill(&mut self, cx: &mut std::task::Context) -> Poll<io::Result<usize>> {
        self.io.poll_read_buf(&mut self.buf, cx)
    }

    #[inline]
    fn chunk(&self) -> &[u8] {
        &self.buf
    }

    #[inline]
    fn consume(&mut self, cnt: usize) {
        self.buf.advance(cnt);
    }
}