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

#![cfg_attr(not(unix), allow(dead_code, unused_macros))]

use std::fmt::{self, Display, Formatter};

macro_rules! bitwidths {
    ($($nam:ident),+ $(,)?) => {[$((stringify!($nam), $nam::BITS, $nam::MIN == 0)),+]};
}
macro_rules! sizes {
    ($($nam:ident),+ $(,)?) => {[$((stringify!($nam), ::std::mem::size_of::<$nam>())),+]};
}
fn maxlen2<T>(a: &[(&str, T)]) -> usize { a.iter().map(|&(nm, _)| nm.len()).max().unwrap_or(0) }
fn maxlen3<T>(a: &[(&str, T, bool)]) -> usize {
    a.iter().map(|&(nm, _, _)| nm.len()).max().unwrap_or(0)
}

pub fn print_bitwidths(bw: &[(&str, u32, bool)]) {
    let width = maxlen3(bw);
    bw.iter().for_each(|&(nm, bw, un)| {
        println!("{nm:width$} : {bw:>2} bits {:>2}signed", val_if(un, "un"))
    });
}
pub fn print_sizes(sz: &[(&str, usize)]) {
    let width = maxlen2(sz);
    sz.iter().for_each(|&(nm, sz)| println!("{nm:width$} : {sz:>3} bytes"));
}
pub fn print_signedness(nm: &str, signed: bool) {
    println!("{nm} is {}signed", if signed { "" } else { "un" })
}

pub fn display_if<T: Display>(cond: bool, v: T) -> OptionDisplay<T> {
    OptionDisplay::new(cond.then_some(v))
}
#[allow(clippy::obfuscated_if_else)]
pub fn val_if<T: Default>(cond: bool, v: T) -> T { cond.then_some(v).unwrap_or_default() }
#[derive(Copy, Clone, Debug)]
pub struct OptionDisplay<T>(Option<T>);
impl<T> OptionDisplay<T> {
    pub const fn new(v: Option<T>) -> Self { Self(v) }
}
impl<T> From<T> for OptionDisplay<T> {
    fn from(v: T) -> Self { Self(Some(v)) }
}
impl<T> Default for OptionDisplay<T> {
    fn default() -> Self { Self(None) }
}
impl<T: Display> Display for OptionDisplay<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        if let Some(v) = &self.0 {
            Display::fmt(v, f)?;
        }
        Ok(())
    }
}

pub const fn display_fn<T: Fn(&mut Formatter<'_>) -> fmt::Result>(v: T) -> DisplayFn<T> {
    DisplayFn(v)
}
#[derive(Copy, Clone, Debug, Default)]
pub struct DisplayFn<T>(T);
impl<T> From<T> for DisplayFn<T> {
    fn from(v: T) -> Self { Self(v) }
}
impl<T: Fn(&mut Formatter<'_>) -> fmt::Result> Display for DisplayFn<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { (self.0)(f) }
}

pub trait ResultExt: Sized {
    type Ok;
    type Err: Display;
    fn get_err(&self) -> Option<&Self::Err>;
    fn unwrap_or_else(self, f: impl FnOnce(Self::Err) -> Self::Ok) -> Self::Ok;

    fn report_error(self, msg: &str) -> Self {
        report_error_str(self.get_err(), msg);
        self
    }
    fn report_error_if(self, toggle: bool, msg: &str) -> Self {
        if toggle {
            report_error_str(self.get_err(), msg);
        }
        self
    }
    fn report_error_args(self, msg: fmt::Arguments<'_>) -> Self {
        report_error(self.get_err(), msg);
        self
    }
    fn report_error_args_if(self, toggle: bool, msg: fmt::Arguments<'_>) -> Self {
        if toggle {
            report_error(self.get_err(), msg);
        }
        self
    }
    fn set_if_error<T>(self, out: &mut T, val: T) -> Self {
        if self.get_err().is_some() {
            *out = val;
        }
        self
    }
    fn unwrap_or_exit(self, msg: &str) -> Self::Ok {
        report_error_str(self.get_err(), msg);
        self.unwrap_or_else(forget_error_and_die)
    }
    fn unwrap_or_exit_args(self, msg: fmt::Arguments<'_>) -> Self::Ok {
        report_error(self.get_err(), msg);
        self.unwrap_or_else(forget_error_and_die)
    }
}
#[inline(never)]
fn report_error<E: Display>(e: Option<&E>, msg: fmt::Arguments<'_>) {
    if let Some(e) = e {
        println!("{msg}: {e}");
    }
}
#[inline(never)]
fn report_error_str<E: Display>(e: Option<&E>, msg: &str) {
    if let Some(e) = e {
        println!("{msg}: {e}");
    }
}
fn forget_error_and_die<T, E>(e: E) -> T {
    std::mem::forget(e);
    std::process::exit(1);
}
impl<T, E: Display> ResultExt for Result<T, E> {
    type Ok = T;
    type Err = E;
    fn get_err(&self) -> Option<&E> { self.as_ref().err() }
    fn unwrap_or_else(self, f: impl FnOnce(E) -> T) -> T { self.unwrap_or_else(f) }
}