humfmt 0.6.0

Ergonomic human-readable formatting toolkit for Rust
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

use core::fmt;

use super::DurationOptions;

#[derive(Copy, Clone)]
struct Unit {
    nanos: u128,
    short: &'static str,
    long_singular: &'static str,
    long_plural: &'static str,
}

const UNITS: [Unit; 7] = [
    Unit {
        nanos: 86_400_000_000_000,
        short: "d",
        long_singular: "day",
        long_plural: "days",
    },
    Unit {
        nanos: 3_600_000_000_000,
        short: "h",
        long_singular: "hour",
        long_plural: "hours",
    },
    Unit {
        nanos: 60_000_000_000,
        short: "m",
        long_singular: "minute",
        long_plural: "minutes",
    },
    Unit {
        nanos: 1_000_000_000,
        short: "s",
        long_singular: "second",
        long_plural: "seconds",
    },
    Unit {
        nanos: 1_000_000,
        short: "ms",
        long_singular: "millisecond",
        long_plural: "milliseconds",
    },
    Unit {
        nanos: 1_000,
        short: "us",
        long_singular: "microsecond",
        long_plural: "microseconds",
    },
    Unit {
        nanos: 1,
        short: "ns",
        long_singular: "nanosecond",
        long_plural: "nanoseconds",
    },
];

// Index of the "second" unit, used as the placeholder for zero durations.
const SECOND_UNIT_IDX: usize = 3;

pub fn format_duration(
    f: &mut fmt::Formatter<'_>,
    value: core::time::Duration,
    options: &DurationOptions,
) -> fmt::Result {
    let mut remaining = value.as_nanos();
    let mut written = 0u8;
    let max_units = options.max_units;

    if remaining == 0 {
        return write_unit(f, 0, &UNITS[SECOND_UNIT_IDX], options.long_units);
    }

    for unit in &UNITS {
        if remaining < unit.nanos {
            continue;
        }

        let count = remaining / unit.nanos;
        remaining %= unit.nanos;

        if written != 0 {
            f.write_str(" ")?;
        }

        write_unit(f, count, unit, options.long_units)?;
        written += 1;

        if written >= max_units {
            break;
        }
    }

    Ok(())
}

fn write_unit(
    f: &mut fmt::Formatter<'_>,
    count: u128,
    unit: &Unit,
    long_units: bool,
) -> fmt::Result {
    if long_units {
        let label = if count == 1 {
            unit.long_singular
        } else {
            unit.long_plural
        };
        write!(f, "{count} {label}")
    } else {
        let short = unit.short;
        write!(f, "{count}{short}")
    }
}