interprocess 2.4.7

Interprocess communication toolkit
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

#![allow(private_bounds)]

use {
    crate::{
        bound_util::{RefTokioAsyncRead, RefTokioAsyncWrite},
        local_socket::{traits::StreamCommon, ConnectOptions, Name},
        Sealed,
    },
    std::{future::Future, io},
    tokio::io::{AsyncRead, AsyncWrite},
};

/// Tokio local socket stream implementations.
///
/// Types on which this trait is implemented are variants of the
/// [`Stream` enum](super::enum::Stream). In addition, it is implemented on `Stream` itself, which
/// makes it a trait object of sorts. See its documentation for more on the semantics of the methods
/// seen here.
pub trait Stream:
    AsyncRead + RefTokioAsyncRead + AsyncWrite + RefTokioAsyncWrite + StreamCommon
{
    /// Receive half type returned by [`.split()`](Stream::split).
    #[allow(deprecated)]
    type RecvHalf: RecvHalf<Stream = Self>;
    /// Send half type returned by [`.split()`](Stream::split).
    #[allow(deprecated)]
    type SendHalf: SendHalf<Stream = Self>;

    /// Asynchronously connects to a local socket server.
    ///
    /// This is equivalent to `ConnectOptions::new().name(name).connect_tokio_as::<Self>()`.
    fn connect(name: Name<'_>) -> impl Future<Output = io::Result<Self>> + Send + Sync {
        async { ConnectOptions::new().name(name).connect_tokio_as::<Self>().await }
    }

    /// Splits a stream into a receive half and a send half.
    ///
    /// You probably want to avoid this mechanism for the following reasons:
    /// - Placing a stream in an `Rc` or `Arc` produces identical behavior,
    ///   since `&Stream` implements `Read` and `Write`
    /// - Dropping a half does not shut it down like it does with sockets,
    ///   which may be counterintuitive
    #[deprecated(
        since = "2.4.7",
        note = "\
placing a stream in an `Rc` or `Arc` achieves the same thing as splitting, since `&Stream` \
implements `AsyncRead` and `AsyncWrite`; also, dropping a half does not shut it down like it \
does with sockets, which may be counterintuitive"
    )]
    fn split(self) -> (Self::RecvHalf, Self::SendHalf);

    /// Attempts to reunite a receive half with a send half to yield the original stream back,
    /// returning both halves as an error if they belong to different streams.
    #[deprecated(
        since = "2.4.7",
        note = "\
placing a stream in an `Rc` or `Arc` achieves the same thing as splitting, since `&Stream` \
implements `AsyncRead` and `AsyncWrite`; also, dropping a half does not shut it down like it \
does with sockets, which may be counterintuitive"
    )]
    #[allow(deprecated)]
    fn reunite(rh: Self::RecvHalf, sh: Self::SendHalf) -> ReuniteResult<Self>;

    /// Connects to a local socket server using the specified options.
    ///
    /// This method typically shouldn't be called directly – use the creation methods on
    /// `ConnectOptions` (`connect_tokio`, `connect_tokio_as`) instead.
    // FUTURE add use<Self>
    fn from_options(
        options: &ConnectOptions<'_>,
    ) -> impl Future<Output = io::Result<Self>> + Send + Sync;
}

/// Receive halves of Tokio [`Stream`]s, obtained through [`.split()`](Stream::split).
///
/// Types on which this trait is implemented are variants of the
/// [`RecvHalf` enum](super::enum::RecvHalf). In addition, it is implemented on `RecvHalf` itself,
/// which makes it a trait object of sorts.
#[deprecated(
    since = "2.4.7",
    note = "\
placing a stream in an `Rc` or `Arc` achieves the same thing as splitting, since `&Stream` \
implements `AsyncRead` and `AsyncWrite`; also, dropping a half does not shut it down like it \
does with sockets, which may be counterintuitive"
)]
pub trait RecvHalf:
    AsyncRead + RefTokioAsyncRead + Send + Sync + Sized + Sealed + 'static
{
    /// The stream type the half is split from.
    type Stream: Stream;
}

/// Send halves of Tokio [`Stream`]s, obtained through [`.split()`](Stream::split).
///
/// Types on which this trait is implemented are variants of the
/// [`SendHalf` enum](super::enum::SendHalf). In addition, it is implemented on `SendHalf` itself,
/// which makes it a trait object of sorts.
#[deprecated(
    since = "2.4.7",
    note = "\
placing a stream in an `Rc` or `Arc` achieves the same thing as splitting, since `&Stream` \
implements `AsyncRead` and `AsyncWrite`; also, dropping a half does not shut it down like it \
does with sockets, which may be counterintuitive"
)]
pub trait SendHalf:
    AsyncWrite + RefTokioAsyncWrite + Send + Sync + Sized + Sealed + 'static
{
    /// The stream type the half is split from.
    type Stream: Stream;
}

/// [`ReuniteResult`](crate::error::ReuniteResult) for the [Tokio `Stream` trait](Stream).
#[deprecated(
    since = "2.4.7",
    note = "\
placing a stream in an `Rc` or `Arc` achieves the same thing as splitting, since `&Stream` \
implements `AsyncRead` and `AsyncWrite`; also, dropping a half does not shut it down like it \
does with sockets, which may be counterintuitive"
)]
#[allow(deprecated)]
pub type ReuniteResult<S> =
    crate::error::ReuniteResult<S, <S as Stream>::RecvHalf, <S as Stream>::SendHalf>;