layered-io 0.23.1

I/O traits extending Read and Write
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use super::{Bufferable, Status};
use crate::to_std_io_read_result;
use futures_io::AsyncRead;
use std::io::{self, IoSliceMut};
use std::pin::Pin;
use std::task::{Context, Poll};

/// An extension of [`AsyncRead`], with `read_with_status` and
/// `read_vectored_with_status` which return status information and zero is not
/// special-cased. It also allows streams to specify a `minimum_buffer_size`.
pub trait AsyncReadLayered: AsyncRead + Bufferable {
    /// Like [`AsyncRead::poll_read`], but also returns a `Status`.
    fn poll_read_with_status(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        buf: &mut [u8],
    ) -> Poll<io::Result<(usize, Status)>>;

    /// Like [`AsyncRead::poll_read_vectored`], but also returns a `Status`.
    #[inline]
    fn poll_read_vectored_with_status(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        bufs: &mut [IoSliceMut<'_>],
    ) -> Poll<io::Result<(usize, Status)>> {
        default_poll_read_vectored_with_status(self, cx, bufs)
    }

    /// Some streams require a buffer of at least a certain size.
    #[inline]
    fn minimum_buffer_size(&self) -> usize {
        0
    }
}

/// Default implementation of [`AsyncRead::poll_read`] in terms of
/// [`AsyncReadLayered::poll_read_with_status`].
#[inline]
pub fn default_poll_read<Inner: AsyncReadLayered + ?Sized>(
    inner: Pin<&mut Inner>,
    cx: &mut Context<'_>,
    buf: &mut [u8],
) -> Poll<io::Result<usize>> {
    inner
        .poll_read_with_status(cx, buf)
        .map(|result| result.and_then(to_std_io_read_result))
}

/// Default implementation of [`AsyncRead::poll_read_vectored`] in terms of
/// [`AsyncReadLayered::poll_read_vectored_with_status`].
pub fn default_poll_read_vectored<Inner: AsyncReadLayered + ?Sized>(
    inner: Pin<&mut Inner>,
    cx: &mut Context<'_>,
    bufs: &mut [IoSliceMut<'_>],
) -> Poll<io::Result<usize>> {
    inner
        .poll_read_vectored_with_status(cx, bufs)
        .map(|result| result.and_then(to_std_io_read_result))
}

/// Default implementation of
/// [`AsyncReadLayered::poll_read_vectored_with_status`] in terms of
/// [`AsyncReadLayered::poll_read_with_status`].
pub fn default_poll_read_vectored_with_status<Inner: AsyncReadLayered + ?Sized>(
    inner: Pin<&mut Inner>,
    cx: &mut Context<'_>,
    bufs: &mut [IoSliceMut<'_>],
) -> Poll<io::Result<(usize, Status)>> {
    let buf = bufs
        .iter_mut()
        .find(|b| !b.is_empty())
        .map_or(&mut [][..], |b| &mut **b);
    inner.poll_read_with_status(cx, buf)
}

impl<R: AsyncReadLayered + Unpin> AsyncReadLayered for Box<R> {
    #[inline]
    fn poll_read_with_status(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        buf: &mut [u8],
    ) -> Poll<io::Result<(usize, Status)>> {
        Pin::new(&mut **self).poll_read_with_status(cx, buf)
    }

    #[inline]
    fn poll_read_vectored_with_status(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        bufs: &mut [IoSliceMut<'_>],
    ) -> Poll<io::Result<(usize, Status)>> {
        Pin::new(&mut **self).poll_read_vectored_with_status(cx, bufs)
    }

    #[inline]
    fn minimum_buffer_size(&self) -> usize {
        Pin::new(&**self).minimum_buffer_size()
    }
}

impl<R: AsyncReadLayered + Unpin> AsyncReadLayered for &mut R {
    #[inline]
    fn poll_read_with_status(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        buf: &mut [u8],
    ) -> Poll<io::Result<(usize, Status)>> {
        AsyncReadLayered::poll_read_with_status(Pin::new(*self), cx, buf)
    }

    #[inline]
    fn poll_read_vectored_with_status(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        bufs: &mut [IoSliceMut<'_>],
    ) -> Poll<io::Result<(usize, Status)>> {
        AsyncReadLayered::poll_read_vectored_with_status(Pin::new(&mut **self), cx, bufs)
    }

    #[inline]
    fn minimum_buffer_size(&self) -> usize {
        (**self).minimum_buffer_size()
    }
}