ombre 0.6.7

Shadowy game and graphics library 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

//! Logging module.
use std::io::Write;
use std::time::SystemTime;

use log::{Level, Log, Metadata, Record, SetLoggerError};

struct Logger {
    level: Level,
    start: SystemTime,
}

impl Log for Logger {
    fn enabled(&self, metadata: &Metadata<'_>) -> bool {
        metadata.level() <= self.level
    }

    #[cfg(feature = "color-logging")]
    fn log(&self, record: &Record<'_>) {
        use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};

        if self.enabled(record.metadata()) {
            if record.level() == Level::Error {
                write(
                    record,
                    StandardStream::stderr(ColorChoice::Always),
                    self.start,
                );
            } else {
                write(
                    record,
                    StandardStream::stdout(ColorChoice::Always),
                    self.start,
                );
            }

            fn write(record: &log::Record<'_>, mut stream: StandardStream, start: SystemTime) {
                // SAFETY: `start` is the start time, therefore should be in the past.
                #[allow(clippy::unwrap_used)]
                let now = SystemTime::now().duration_since(start).unwrap();
                let message = format!(
                    "{:5} {:012} {}",
                    record.level(),
                    now.as_millis(),
                    record.args()
                );
                match record.level() {
                    Level::Info => stream.set_color(ColorSpec::new().set_fg(Some(Color::Cyan))),
                    Level::Error => stream
                        .set_color(ColorSpec::new().set_fg(Some(Color::Red)).set_intense(true)),
                    Level::Warn => stream.set_color(ColorSpec::new().set_fg(Some(Color::Yellow))),
                    Level::Debug => stream.set_color(ColorSpec::new().set_fg(None)),
                    Level::Trace => stream
                        .set_color(ColorSpec::new().set_fg(Some(Color::White)).set_dimmed(true)),
                }
                .ok();

                writeln!(stream, "{message}").ok();
            }
        }
    }

    #[cfg(not(feature = "color-logging"))]
    fn log(&self, record: &Record<'_>) {
        use std::io;

        if self.enabled(record.metadata()) {
            if record.level() == Level::Error {
                write(record, io::stderr(), self.start);
            } else {
                write(record, io::stdout(), self.start);
            }

            fn write(record: &log::Record<'_>, mut stream: impl io::Write, start: SystemTime) {
                let now = SystemTime::now().duration_since(start).unwrap();
                let message = format!(
                    "{:5} {:012} {}",
                    record.level(),
                    now.as_millis(),
                    record.args()
                );
                writeln!(stream, "{message}").ok();
            }
        }
    }

    fn flush(&self) {}
}

/// Initialize a new logger.
pub fn init(level: Level) -> Result<(), SetLoggerError> {
    let logger = Logger {
        level,
        start: SystemTime::now(),
    };
    log::set_boxed_logger(Box::new(logger))?;
    log::set_max_level(level.to_level_filter());

    Ok(())
}