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

use std::sync::Mutex;

lazy_static! {
    static ref LOGGER: Mutex<Option<Box<dyn Logger>>> = Mutex::new(None);
}

#[derive(Debug, Copy, Clone)]
pub enum Log {
    Info,
    Warning,
    Error,
    Debug,
}

pub trait Logger: Send + Sync {
    fn log(&mut self, mode: Log, message: String);
}

pub struct DefaultLogger;

impl Logger for DefaultLogger {
    fn log(&mut self, mode: Log, message: String) {
        match mode {
            Log::Info => println!("[INFO] {}", message),
            Log::Warning => eprintln!("[WARNING] {}", message),
            Log::Error => eprintln!("[ERROR] {}", message),
            Log::Debug => eprintln!("[DEBUG] {}", message),
        }
    }
}

pub fn logger_setup<L>(instance: L)
where
    L: Logger + 'static,
{
    if let Ok(mut logger) = LOGGER.lock() {
        *logger = Some(Box::new(instance));
    }
}

pub fn logger_log(mode: Log, message: String) {
    if let Ok(mut logger) = LOGGER.lock() {
        if let Some(ref mut logger) = *logger {
            logger.log(mode, message);
        }
    }
}

#[macro_export]
macro_rules! log {
    ($lvl:expr, $($arg:tt)+) => ({
        $crate::log::logger_log($lvl, format!(
            "[{}: {} | {}]:\n{}",
            file!(),
            line!(),
            module_path!(),
            format_args!($($arg)+)
        ))
    })
}

#[macro_export]
macro_rules! info {
    ($($arg:tt)*) => (log!($crate::log::Log::Info, $($arg)*))
}

#[macro_export]
macro_rules! warn {
    ($($arg:tt)*) => (log!($crate::log::Log::Warning, $($arg)*))
}

#[macro_export]
macro_rules! error {
    ($($arg:tt)*) => (log!($crate::log::Log::Error, $($arg)*))
}

#[macro_export]
macro_rules! debug {
    ($($arg:tt)*) => (log!($crate::log::Log::Debug, $($arg)*))
}