interprocess 2.2.2

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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use super::r#trait;
use crate::{local_socket::Name, TryClone};
use std::io::{self, prelude::*, IoSlice, IoSliceMut};

#[cfg(unix)]
use crate::os::unix::uds_local_socket as uds_impl;
#[cfg(windows)]
use crate::os::windows::named_pipe::local_socket as np_impl;

impmod! {local_socket::dispatch_sync}

macro_rules! dispatch_read {
	(@iw $ty:ident) => {
		#[inline]
		fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
			dispatch!($ty: x in self => x.read(buf))
		}
		#[inline]
		fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
			dispatch!($ty: x in self => x.read_vectored(bufs))
		}
	};
	($ty:ident) => {
		impl Read for &$ty {
			dispatch_read!(@iw $ty);
		}
		impl Read for $ty {
			dispatch_read!(@iw $ty);
		}
	};
}
macro_rules! dispatch_write {
	(@iw $ty:ident) => {
		#[inline]
		fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
			dispatch!($ty: x in self => x.write(buf))
		}
		#[inline]
		fn flush(&mut self) -> io::Result<()> {
			Ok(())
		}
		#[inline]
		fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
			dispatch!($ty: x in self => x.write_vectored(bufs))
		}
	};
	($ty:ident) => {
		/// Flushing is an always successful no-op.
		impl Write for &$ty {
			dispatch_write!(@iw $ty);
		}
		/// Flushing is an always successful no-op.
		impl Write for $ty {
			dispatch_write!(@iw $ty);
		}
	};
}

mkenum!(
/// Local socket byte stream, obtained either from [`Listener`](super::super::Listener) or by
/// connecting to an existing local socket.
///
/// # Examples
///
/// ## Basic client
/// ```no_run
#[doc = doctest_file::include_doctest!("examples/local_socket/sync/stream.rs")]
/// ```
Stream);
impl r#trait::Stream for Stream {
	type RecvHalf = RecvHalf;
	type SendHalf = SendHalf;

	#[inline]
	fn connect(name: Name<'_>) -> io::Result<Self> {
		dispatch_sync::connect(name)
	}
	#[inline]
	fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
		dispatch!(Self: x in self => x.set_nonblocking(nonblocking))
	}
	fn split(self) -> (RecvHalf, SendHalf) {
		match self {
			#[cfg(windows)]
			Stream::NamedPipe(s) => {
				let (rh, sh) = s.split();
				(RecvHalf::NamedPipe(rh), SendHalf::NamedPipe(sh))
			}
			#[cfg(unix)]
			Stream::UdSocket(s) => {
				let (rh, sh) = s.split();
				(RecvHalf::UdSocket(rh), SendHalf::UdSocket(sh))
			}
		}
	}
	fn reunite(rh: RecvHalf, sh: SendHalf) -> ReuniteResult {
		match (rh, sh) {
			#[cfg(windows)]
			(RecvHalf::NamedPipe(rh), SendHalf::NamedPipe(sh)) => np_impl::Stream::reunite(rh, sh)
				.map(From::from)
				.map_err(|e| e.convert_halves()),
			#[cfg(unix)]
			(RecvHalf::UdSocket(rh), SendHalf::UdSocket(sh)) => uds_impl::Stream::reunite(rh, sh)
				.map(From::from)
				.map_err(|e| e.convert_halves()),
			#[allow(unreachable_patterns)]
			(rh, sh) => Err(ReuniteError { rh, sh }),
		}
	}
}
impl TryClone for Stream {
	fn try_clone(&self) -> io::Result<Self> {
		dispatch!(Self: x in self => x.try_clone()).map(From::from)
	}
}
multimacro! {
	Stream,
	dispatch_read,
	dispatch_write,
}

mkenum!(
/// Receive half of a local socket stream, obtained by splitting a [`Stream`].
"local_socket::" RecvHalf);
impl r#trait::RecvHalf for RecvHalf {
	type Stream = Stream;
}
dispatch_read!(RecvHalf);

mkenum!(
/// Send half of a local socket stream, obtained by splitting a [`Stream`].
"local_socket::" SendHalf);
impl r#trait::SendHalf for SendHalf {
	type Stream = Stream;
}
dispatch_write!(SendHalf);

/// [`ReuniteError`](crate::error::ReuniteError) for [`Stream`].
pub type ReuniteError = crate::error::ReuniteError<RecvHalf, SendHalf>;

/// Result type for [`.reunite()`](trait::Stream::reunite) on [`Stream`].
pub type ReuniteResult = r#trait::ReuniteResult<Stream>;