Coverage Report

Created: 2025-02-21 07:11

/rust/registry/src/index.crates.io-6f17d22bba15001f/tokio-1.43.0/src/io/join.rs
Line
Count
Source (jump to first uncovered line)
1
//! Join two values implementing `AsyncRead` and `AsyncWrite` into a single one.
2
3
use crate::io::{AsyncBufRead, AsyncRead, AsyncWrite, ReadBuf};
4
5
use std::io;
6
use std::pin::Pin;
7
use std::task::{Context, Poll};
8
9
/// Join two values implementing `AsyncRead` and `AsyncWrite` into a
10
/// single handle.
11
0
pub fn join<R, W>(reader: R, writer: W) -> Join<R, W>
12
0
where
13
0
    R: AsyncRead,
14
0
    W: AsyncWrite,
15
0
{
16
0
    Join { reader, writer }
17
0
}
18
19
pin_project_lite::pin_project! {
20
    /// Joins two values implementing `AsyncRead` and `AsyncWrite` into a
21
    /// single handle.
22
    #[derive(Debug)]
23
    pub struct Join<R, W> {
24
        #[pin]
25
        reader: R,
26
        #[pin]
27
        writer: W,
28
    }
29
}
30
31
impl<R, W> Join<R, W>
32
where
33
    R: AsyncRead,
34
    W: AsyncWrite,
35
{
36
    /// Splits this `Join` back into its `AsyncRead` and `AsyncWrite`
37
    /// components.
38
0
    pub fn into_inner(self) -> (R, W) {
39
0
        (self.reader, self.writer)
40
0
    }
41
42
    /// Returns a reference to the inner reader.
43
0
    pub fn reader(&self) -> &R {
44
0
        &self.reader
45
0
    }
46
47
    /// Returns a reference to the inner writer.
48
0
    pub fn writer(&self) -> &W {
49
0
        &self.writer
50
0
    }
51
52
    /// Returns a mutable reference to the inner reader.
53
0
    pub fn reader_mut(&mut self) -> &mut R {
54
0
        &mut self.reader
55
0
    }
56
57
    /// Returns a mutable reference to the inner writer.
58
0
    pub fn writer_mut(&mut self) -> &mut W {
59
0
        &mut self.writer
60
0
    }
61
62
    /// Returns a pinned mutable reference to the inner reader.
63
0
    pub fn reader_pin_mut(self: Pin<&mut Self>) -> Pin<&mut R> {
64
0
        self.project().reader
65
0
    }
66
67
    /// Returns a pinned mutable reference to the inner writer.
68
0
    pub fn writer_pin_mut(self: Pin<&mut Self>) -> Pin<&mut W> {
69
0
        self.project().writer
70
0
    }
71
}
72
73
impl<R, W> AsyncRead for Join<R, W>
74
where
75
    R: AsyncRead,
76
{
77
0
    fn poll_read(
78
0
        self: Pin<&mut Self>,
79
0
        cx: &mut Context<'_>,
80
0
        buf: &mut ReadBuf<'_>,
81
0
    ) -> Poll<Result<(), io::Error>> {
82
0
        self.project().reader.poll_read(cx, buf)
83
0
    }
84
}
85
86
impl<R, W> AsyncWrite for Join<R, W>
87
where
88
    W: AsyncWrite,
89
{
90
0
    fn poll_write(
91
0
        self: Pin<&mut Self>,
92
0
        cx: &mut Context<'_>,
93
0
        buf: &[u8],
94
0
    ) -> Poll<Result<usize, io::Error>> {
95
0
        self.project().writer.poll_write(cx, buf)
96
0
    }
97
98
0
    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
99
0
        self.project().writer.poll_flush(cx)
100
0
    }
101
102
0
    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
103
0
        self.project().writer.poll_shutdown(cx)
104
0
    }
105
106
0
    fn poll_write_vectored(
107
0
        self: Pin<&mut Self>,
108
0
        cx: &mut Context<'_>,
109
0
        bufs: &[io::IoSlice<'_>],
110
0
    ) -> Poll<Result<usize, io::Error>> {
111
0
        self.project().writer.poll_write_vectored(cx, bufs)
112
0
    }
113
114
0
    fn is_write_vectored(&self) -> bool {
115
0
        self.writer.is_write_vectored()
116
0
    }
117
}
118
119
impl<R, W> AsyncBufRead for Join<R, W>
120
where
121
    R: AsyncBufRead,
122
{
123
0
    fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<&[u8]>> {
124
0
        self.project().reader.poll_fill_buf(cx)
125
0
    }
126
127
0
    fn consume(self: Pin<&mut Self>, amt: usize) {
128
0
        self.project().reader.consume(amt)
129
0
    }
130
}