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

//! Derive macros that implement raw handle manipulation in terms of safe handle manipulation from
//! Rust 1.63+. Lifetime arguments on impls can be specified in curly braces.

macro_rules! derive_asraw {
	(@impl
		$({$($forcl:tt)*})?
		$ty:ty,
		$hty:ident, $trt:ident, $mtd:ident,
		$strt:ident, $smtd:ident, $cfg:ident) => {
		#[cfg($cfg)]
		impl $(<$($forcl)*>)? ::std::os::$cfg::io::$trt for $ty {
			#[inline]
			fn $mtd(&self) -> ::std::os::$cfg::io::$hty {
				let h = ::std::os::$cfg::io::$strt::$smtd(self);
				::std::os::$cfg::io::$trt::$mtd(&h)
			}
		}
	};
	($({$($forcl:tt)*})? $ty:ty, windows) => {
		derive_asraw!(
			@impl
			$({$($forcl)*})? $ty,
			RawHandle, AsRawHandle, as_raw_handle,
			AsHandle, as_handle, windows);
	};
	($({$($forcl:tt)*})? $ty:ty, unix) => {
		derive_asraw!(
			@impl
			$({$($forcl)*})? $ty,
			RawFd, AsRawFd, as_raw_fd,
			AsFd, as_fd, unix);
	};
	($({$($forcl:tt)*})? $ty:ty) => {
		derive_asraw!($({$($forcl)*})? $ty, windows);
		derive_asraw!($({$($forcl)*})? $ty, unix);
	};
}

macro_rules! derive_intoraw {
	(@impl
		$({$($forcl:tt)*})?
		$ty:ty,
		$hty:ident, $ohty:ident,
		$trt:ident, $mtd:ident, $cfg:ident) => {
		#[cfg($cfg)]
		impl $(<$($forcl)*>)? ::std::os::$cfg::io::$trt for $ty {
			#[inline]
			fn $mtd(self) -> ::std::os::$cfg::io::$hty {
				let h = <std::os::$cfg::io::$ohty as ::std::convert::From<_>>::from(self);
				::std::os::$cfg::io::$trt::$mtd(h)
			}
		}
	};
	($({$($forcl:tt)*})? $ty:ty, windows) => {
		derive_intoraw!(
			@impl
			$({$($forcl)*})? $ty,
			RawHandle, OwnedHandle,
			IntoRawHandle, into_raw_handle, windows);
	};
	($({$($forcl:tt)*})? $ty:ty, unix) => {
		derive_intoraw!(
			@impl
			$({$($forcl)*})? $ty,
			RawFd, OwnedFd,
			IntoRawFd, into_raw_fd, unix);
	};
	($({$($forcl:tt)*})? $ty:ty) => {
		derive_intoraw!($({$($forcl)*})? $ty, windows);
		derive_intoraw!($({$($forcl)*})? $ty, unix);
	};
}

macro_rules! derive_asintoraw {
	($({$($forcl:tt)*})? $ty:ty, windows) => {
		derive_asraw!($({$($forcl)*})? $ty, windows);
		derive_intoraw!($({$($forcl)*})? $ty, windows);
	};
	($({$($forcl:tt)*})? $ty:ty, unix) => {
		derive_asraw!($({$($forcl)*})? $ty, unix);
		derive_intoraw!($({$($forcl)*})? $ty, unix);
	};
	($({$($forcl:tt)*})? $ty:ty) => {
		derive_asintoraw!($({$($forcl)*})? $ty, windows);
		derive_asintoraw!($({$($forcl)*})? $ty, unix);
	};
}

macro_rules! derive_fromraw {
	(@impl
		$({$($forcl:tt)*})?
		$ty:ty,
		$hty:ident, $ohty:ident,
		$trt:ident, $mtd:ident, $cfg:ident) => {
		#[cfg($cfg)]
		impl $(<$($forcl)*>)? ::std::os::$cfg::io::$trt for $ty {
			#[inline]
			unsafe fn $mtd(fd: ::std::os::$cfg::io::$hty) -> Self {
				let h: ::std::os::$cfg::io::$ohty = unsafe { ::std::os::$cfg::io::$trt::$mtd(fd) };
				::std::convert::From::from(h)
			}
		}
	};
	($({$($forcl:tt)*})? $ty:ty, windows) => {
		derive_fromraw!(
			@impl
			$({$($forcl)*})? $ty,
			RawHandle, OwnedHandle,
			FromRawHandle, from_raw_handle, windows);
	};
	($({$($forcl:tt)*})? $ty:ty, unix) => {
		derive_fromraw!(
			@impl
			$({$($forcl)*})? $ty,
			RawFd, OwnedFd,
			FromRawFd, from_raw_fd, unix);
	};
	($({$($forcl:tt)*})? $ty:ty) => {
		derive_fromraw!($({$($forcl)*})? $ty, windows);
		derive_fromraw!($({$($forcl)*})? $ty, unix);
	};
}

macro_rules! derive_raw {
	($({$($forcl:tt)*})? $ty:ty, windows) => {
		derive_asintoraw!($({$($forcl)*})? $ty, windows);
		derive_fromraw!($({$($forcl)*})? $ty, windows);
	};
	($({$($forcl:tt)*})? $ty:ty, unix) => {
		derive_asintoraw!($({$($forcl)*})? $ty, unix);
		derive_fromraw!($({$($forcl)*})? $ty, unix);
	};
	($({$($forcl:tt)*})? $ty:ty) => {
		derive_asintoraw!($({$($forcl)*})? $ty);
		derive_fromraw!($({$($forcl)*})? $ty);
	};
}