oxygen_orbit/
logger.rs

1use colored::Colorize;
2use chrono::prelude::Local;
3
4pub enum LogLevel {
5    All,
6    Info,
7    Warning,
8    Error,
9    Fatal,
10}
11
12pub enum LogMessage<'a> {
13    Message(&'a str),
14    InfoMessage(&'a str),
15    WarningMessage(&'a str),
16    ErrorMessage(&'a str),
17    FatalMessage(&'a str),
18}
19
20pub struct Logger<'a> {
21    pub log_name: &'a str,
22    pub log_level: LogLevel,
23}
24
25impl<'a> Logger<'a> {
26    pub fn new(log_name: &'a str, log_level: LogLevel) -> Logger {
27        Logger {
28            log_name,
29            log_level: log_level,
30        }
31    }
32
33    pub fn set_level(&mut self, log_level: LogLevel) {
34        self.log_level = log_level;
35    }
36
37    pub fn log(&self, message: LogMessage) {
38        let  t_timestamp = format!("{}", Local::now());
39        let mut t_timestamp = t_timestamp.split(" ");
40        let datetime = t_timestamp.next().unwrap();
41        let time = t_timestamp.next().unwrap();
42        let mut time_split = time.split(".");
43
44        let timestamp = format!("{} {}.{:.4}", datetime, time_split.next().unwrap(), time_split.next().unwrap());
45
46        let result = match self.log_level {
47            LogLevel::All => {
48                match message {
49                    LogMessage::Message(text) => {
50                        (String::from(format!("\n({})[{}] Any: {}\n", self.log_name, timestamp, text))).blue()
51                    },
52                    LogMessage::InfoMessage(text) => {
53                        (String::from(format!("\n({})[{}] Info: {}\n", self.log_name, timestamp, text))).green()
54                    },
55                    LogMessage::WarningMessage(text) => {
56                        (String::from(format!("\n({})[{}] Warning: {}\n", self.log_name, timestamp, text))).yellow()
57                    },
58                    LogMessage::ErrorMessage(text) => {
59                        (String::from(format!("\n({})[{}] Error: {}\n", self.log_name, timestamp, text))).red()
60                    },
61                    LogMessage::FatalMessage(text) => {
62                        (String::from(format!("\n({})[{}] Fatal: {}\n", self.log_name, timestamp, text))).black().on_red()
63                    }
64                }
65            },
66            LogLevel::Info => {
67                match message {
68                    LogMessage::InfoMessage(text) => {
69                        (String::from(format!("\n({})[{}] Info: {}\n", self.log_name, timestamp, text))).green()
70                    },
71                    LogMessage::WarningMessage(text) => {
72                        (String::from(format!("\n({})[{}] Warning: {}\n", self.log_name, timestamp, text))).yellow()
73                    },
74                    LogMessage::ErrorMessage(text) => {
75                        (String::from(format!("\n({})[{}] Error: {}\n", self.log_name, timestamp, text))).red()
76                    },
77                    LogMessage::FatalMessage(text) => {
78                        (String::from(format!("\n({})[{}] Fatal: {}\n", self.log_name, timestamp, text))).black().on_red()
79                    }
80                    _ => "".normal(),
81                }
82            },
83            LogLevel::Warning => {
84                match message {
85                    LogMessage::WarningMessage(text) => {
86                        (String::from(format!("\n({})[{}] Warning: {}\n", self.log_name, timestamp, text))).yellow()
87                    },
88                    LogMessage::ErrorMessage(text) => {
89                        (String::from(format!("\n({})[{}] Error: {}\n", self.log_name, timestamp, text))).red()
90                    },
91                    LogMessage::FatalMessage(text) => {
92                        (String::from(format!("\n({})[{}] Fatal: {}\n", self.log_name, timestamp, text))).black().on_red()
93                    },
94                    _ => "".normal(),
95                }
96            },
97            LogLevel::Error => {
98                match message {
99                    LogMessage::ErrorMessage(text) => {
100                        (String::from(format!("\n({})[{}] Error: {}\n", self.log_name, timestamp, text))).red()
101                    },
102                    LogMessage::FatalMessage(text) => {
103                        (String::from(format!("\n({})[{}] Fatal: {}\n", self.log_name, timestamp, text))).black().on_red()
104                    },
105                    _ => "".normal(),
106                }
107            },
108            LogLevel::Fatal => {
109                match message {
110                    LogMessage::FatalMessage(text) => {
111                        (String::from(format!("\n({})[{}] Fatal: {}\n", self.log_name, timestamp, text))).black().on_red()
112                    },
113                    _ => "".normal(),
114                }
115            }
116        };
117
118        print!("{}", result);
119    }
120}