utls 0.7.5

A simple utilities library for stuff I actually use sometimes, with a large focus on convenience and lack of dependencies.
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

//! Display implementations for anything that would benefit from them
#[cfg(feature = "watcher")]
use crate::watcher::Watcher;
use std::fmt;

#[cfg(feature = "progress_bar")]
use super::prog::*;

// Display implementation for PBState
#[cfg(feature = "progress_bar")]
impl fmt::Display for PBState {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            PBState::Running => write!(f, "Running"),
            PBState::Finished => write!(f, "Finished"),
            PBState::Abandoned => write!(f, "Abandoned (failed?)"),
        }
    }
}

// Display implementation for PBStatistics
#[cfg(feature = "progress_bar")]
impl fmt::Display for PBStatistics {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        writeln!(f, "Progress Bar Statistics:")?;
        writeln!(f, "Target Update Frequency: {:?}", self.target_update_freq)?;
        writeln!(
            f,
            "Minimum Update Interval: {:?}",
            self.actual_min_update.unwrap_or_default()
        )?;
        writeln!(
            f,
            "Maximum Update Interval: {:?}",
            self.actual_max_update.unwrap_or_default()
        )?;
        writeln!(
            f,
            "Average Update Interval: {:?}",
            self.actual_avg_update.unwrap_or_default()
        )?;
        writeln!(f, "Total Updates: {}", self.total_updates)?;
        writeln!(
            f,
            "Total Duration: {:?}",
            self.total_duration.unwrap_or_default()
        )?;
        write!(f, "Advanced Statistics Enabled: {}", self.adv_enabled)
    }
}

#[cfg(feature = "progress_bar")]
impl fmt::Display for PB {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.gen_immut(),)
    }
}

#[cfg(feature = "watcher")]
impl<T: PartialEq + Send + 'static + std::fmt::Display> fmt::Display for Watcher<T> {
    // Copied directly from fmt/mod.rs
    ///  Formats the value using the given formatter.
    /// # Errors

    /// This function should return [`Err`] if, and only if, the provided [`Formatter`] returns [`Err`].
    /// String formatting is considered an infallible operation; this function only
    /// returns a [`Result`] because writing to the underlying stream might fail and it must
    /// provide a way to propagate the fact that an error has occurred back up the stack.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::fmt;
    ///
    /// struct Position {
    ///     longitude: f32,
    ///     latitude: f32,
    /// }
    ///
    /// impl fmt::Display for Position {
    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    ///         write!(f, "({}, {})", self.longitude, self.latitude)
    ///     }
    /// }
    ///
    /// assert_eq!(
    ///     "(1.987, 2.983)",
    ///     format!("{}", Position { longitude: 1.987, latitude: 2.983, }),
    /// );
    /// ```
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "Value: {}\nChanged: {:#?}\nShutdown: {:#?}",
            self.value.lock().unwrap(),
            self.changed.lock().unwrap(),
            self.shutdown.lock().unwrap()
        )
    }
}

#[cfg(feature = "watcher")]
impl<T: PartialEq + Send + 'static + std::fmt::Debug> Watcher<T> {
    /// This is used when `T` does not implement Display, but it does implement Debug
    #[allow(dead_code)]
    pub fn fmt_dbg(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "Value: {:#?}\nChanged: {:#?}\nShutdown: {:#?}",
            self.value.lock().unwrap(),
            self.changed.lock().unwrap(),
            self.shutdown.lock().unwrap()
        )
    }
}