rs-simple-logging 0.2.0

Simple logging
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

use crate::Severity;

pub trait LogWrite: Sync + Send {
    fn write(&self, serialized: &str, level: Severity);
}

struct FnWrite<W, L> {
    internal: W,
    check_level: L,
}

impl<W, L> LogWrite for FnWrite<W, L>
where
    W: Fn(&str, Severity) + Sync + Send,
    L: Fn(Severity) -> bool + Sync + Send,
{
    fn write(&self, serialized: &str, level: Severity) {
        match (self.check_level)(level) {
            false => {}
            true => (self.internal)(serialized, level),
        }
    }
}

pub fn log_writer_new_from_fn<W, L>(internal: W, check_level: L) -> impl LogWrite
where
    W: Fn(&str, Severity) + Sync + Send,
    L: Fn(Severity) -> bool + Sync + Send,
{
    FnWrite {
        internal,
        check_level,
    }
}

pub fn log_writer_new_std_default_from_fn<L>(check_level: L) -> impl LogWrite
where
    L: Fn(Severity) -> bool + Sync + Send,
{
    log_writer_new_from_fn(
        |serialized: &str, level: Severity| match level {
            Severity::Trace => println!("{serialized}"),
            Severity::Debug => println!("{serialized}"),
            Severity::Info => println!("{serialized}"),
            Severity::Warn => eprintln!("{serialized}"),
            Severity::Error => eprintln!("{serialized}"),
            Severity::Fatal => eprintln!("{serialized}"),
        },
        check_level,
    )
}

pub fn level_checker_from_lower_bound(
    lb_inclusive: Severity,
) -> impl Fn(Severity) -> bool + Send + Sync {
    let lbi: u8 = lb_inclusive.into();
    move |level: Severity| {
        let u: u8 = level.into();
        lbi <= u
    }
}

pub fn log_writer_new_std_default_from_lower_bound(lb_inclusive: Severity) -> impl LogWrite {
    log_writer_new_std_default_from_fn(level_checker_from_lower_bound(lb_inclusive))
}