interprocess 2.4.0

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);
    };
}