human-time 0.1.7

This is a library for human readable elapsed time string
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

#![allow(clippy::unwrap_used)]

use std::time::Duration;

pub use human_time_macros::elapsed;

// Time units in microseconds: (unit label, microseconds per unit)
const UNITS: [(&str, u128); 6] = [
    ("d", 86400000000),   // day = 24 * 60 * 60 * 1_000_000
    ("h", 3600000000),    // hour = 60 * 60 * 1_000_000
    ("m", 60000000),      // minute = 60 * 1_000_000
    ("s", 1000000),       // second = 1_000_000
    ("ms", 1000),         // millisecond = 1_000
    ("μs", 1),            // microsecond = 1
];

pub trait ToHumanTimeString {
    fn to_human_time_string(&self) -> String;
    fn to_human_time_string_with_format<F, F1>(&self, time_fmt: F, res_fmt: F1) -> String
    where
        F: Fn(u128, &str) -> String,
        F1: Fn(String, String) -> String;
}

impl ToHumanTimeString for Duration {
    fn to_human_time_string(&self) -> String {
        crate::human_time(*self)
    }

    fn to_human_time_string_with_format<F, F1>(&self, time_fmt: F, res_fmt: F1) -> String
    where
        F: Fn(u128, &str) -> String,
        F1: Fn(String, String) -> String,
    {
        human_time_with_format(*self, time_fmt, res_fmt)
    }
}

pub fn human_time(d: Duration) -> String {
    human_time_with_format(
        d,
        |n, unit| format!("{}{}", n, unit),
        |acc, item| format!("{},{}", acc, item),
    )
}

// Convert Duration to human-readable string with custom format closures.
//
// - `time_fmt`: formats each time component, e.g., `|n, unit| format!("{}{}", n, unit)`
// - `res_fmt`: combines all components, e.g., `|acc, item| format!("{},{}", acc, item)`
pub fn human_time_with_format<F, F1>(d: Duration, time_fmt: F, res_fmt: F1) -> String
where
    F: Fn(u128, &str) -> String,
    F1: Fn(String, String) -> String,
{
    // Step 1: Calculate count for each unit, building (count, unit) pairs
    let mut map: Vec<(u128, &str)> = Vec::new();
    let mut μs = d.as_micros();
    for (unit, n_μs) in UNITS {
        map.push((μs / n_μs, unit));
        μs %= n_μs;
    }

    // Step 2: Filter out zero counts, format each component, then reduce to final string
    match map
        .into_iter()
        .filter_map(|(n, u)| if n > 0 { Some(time_fmt(n, u)) } else { None })
        .reduce(res_fmt)
    {
        Some(val) => val,
        // Duration was zero, return "0" in smallest unit
        None => time_fmt(0, UNITS.last().unwrap().0),
    }
}