bbk47_toolbox 0.1.0

bbk47 tools
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 std::cmp::Ordering;
use std::io::{self, Write};
use std::sync::Mutex;

#[derive(PartialEq, Eq)]
pub enum LogLevel {
    Debug,
    Info,
    Warn,
    Error,
}



impl PartialOrd for LogLevel {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        match (self, other) {
            (&LogLevel::Error, &LogLevel::Error) => Some(Ordering::Equal),
            (&LogLevel::Error, _) => Some(Ordering::Greater),
            (_, &LogLevel::Error) => Some(Ordering::Less),
            (&LogLevel::Warn, &LogLevel::Warn) => Some(Ordering::Equal),
            (&LogLevel::Warn, _) => Some(Ordering::Greater),
            (_, &LogLevel::Warn) => Some(Ordering::Less),
            (&LogLevel::Info, &LogLevel::Info) => Some(Ordering::Equal),
            (&LogLevel::Info, _) => Some(Ordering::Greater),
            (_, &LogLevel::Info) => Some(Ordering::Less),
            (&LogLevel::Debug, &LogLevel::Debug) => Some(Ordering::Equal),
        }
    }
}

impl Ord for LogLevel {
    fn cmp(&self, other: &Self) -> Ordering {
        match (self, other) {
            (&LogLevel::Error, &LogLevel::Error) 
            | (&LogLevel::Warn, &LogLevel::Warn)
            | (&LogLevel::Info, &LogLevel::Info)
            | (&LogLevel::Debug, &LogLevel::Debug) => Ordering::Equal,
            (&LogLevel::Error, _) => Ordering::Greater,
            (_, &LogLevel::Error) => Ordering::Less,
            (&LogLevel::Warn, &LogLevel::Info) 
            | (&LogLevel::Warn, &LogLevel::Debug) 
            | (&LogLevel::Info, &LogLevel::Debug) => Ordering::Greater,
            (_, _) => Ordering::Less,
        }
    }
}


pub struct Logger {
    level: LogLevel,
    writer: Mutex<Box<dyn Write + Send>>,
}

impl Logger {
    pub fn new(level: LogLevel) -> Self {
        Logger {
            level,
            writer: Mutex::new(Box::new(io::stdout())),
        }
    }

    pub fn set_writer(&self, writer: Box<dyn Write + Send>) {
        *self.writer.lock().unwrap() = writer;
    }

    fn log(&self, level: LogLevel, message: &str) {
        if level >= self.level {
            let mut writer = self.writer.lock().unwrap();
            writeln!(writer.as_mut(), "{}: {}", level_str(level), message).unwrap();
        }
    }

    pub fn debug(&self, message: &str) {
        self.log(LogLevel::Debug, message);
    }

    pub fn info(&self, message: &str) {
        self.log(LogLevel::Info, message);
    }

    pub fn warn(&self, message: &str) {
        self.log(LogLevel::Warn, message);
    }

    pub fn error(&self, message: &str) {
        self.log(LogLevel::Error, message);
    }
}

fn level_str(level: LogLevel) -> &'static str {
    match level {
        LogLevel::Debug => "DEBUG",
        LogLevel::Info => "INFO",
        LogLevel::Warn => "WARN",
        LogLevel::Error => "ERROR",
    }
}

// fn main() {
//     let logger = Logger::new(LogLevel::Info);

//     // 记录 INFO 级别的日志
//     logger.info("Hello, world!");

//     // 记录 DEBUG 级别的日志（但由于日志级别设为 INFO，因此不会输出）
//     logger.debug("This is a debug message.");

//     // 将日志写入文件
//     logger.set_writer(Box::new(BufWriter::new(File::create("log.txt").unwrap())));

//     // 记录 WARN 级别的日志，将会输出到文件中
//     logger.warn("Something went wrong.");
// }