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
115
116
117

// Copyright (c) 2024, donnie4w <donnie4w@gmail.com>
// All rights reserved.
// https://github.com/donnie4w/tklog
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Trace log macros, call secondary macro processing logic

#[macro_export]
macro_rules! traces {
    ($logger:expr, $($arg:expr),+) => {
        $crate::logs_common!($logger, $crate::LEVEL::Trace, $($arg),*);
    };
    () => {};
}

//Debug log macro, call secondary macro processing logic
#[macro_export]
macro_rules! debugs {
    ($logger:expr, $($arg:expr),+) => {
        $crate::logs_common!($logger, $crate::LEVEL::Debug, $($arg),*);
    };
    () => {};
}

//Info log macro, call secondary macro processing logic
#[macro_export]
macro_rules! infos {
    ($logger:expr, $($arg:expr),+) => {
        $crate::logs_common!($logger, $crate::LEVEL::Info, $($arg),*);
    };
    () => {};
}

// Error log macro, call secondary macro processing logic
#[macro_export]
macro_rules! warns {
    ($logger:expr, $($arg:expr),+) => {
        $crate::logs_common!($logger, $crate::LEVEL::Warn, $($arg),*);
    };
    () => {};
}

// Error log macro, call secondary macro processing logic
#[macro_export]
macro_rules! errors {
    ($logger:expr, $($arg:expr),+) => {
        $crate::logs_common!($logger, $crate::LEVEL::Error, $($arg),*);
    };
    () => {};
}

// Fatal log macro, call secondary macro processing logic
#[macro_export]
macro_rules! fatals {
    ($logger:expr, $($arg:expr),+) => {
        $crate::logs_common!($logger, $crate::LEVEL::Fatal, $($arg),*);
    };
    () => {};
}

#[macro_export]
macro_rules! formats {
    ($logger:expr, $level:expr, $($arg:expr),*) => {
        let level:$crate::LEVEL = $level;
        unsafe {
            let log:&mut Arc<Mutex<tklog::sync::Logger>> = $logger;
            let mut logger  = log.lock().unwrap();
            let module = module_path!();
            if logger.get_level(module) <= level {
                let mut file = "";
                let mut line = 0;
                if logger.is_file_line(module) {
                    file = file!();
                    line = line!();
                }
                let ss = logger.fmt(module,$level, file, line, format!($($arg),*));
                logger.print(module,ss.as_str());
            }
        }
    };
    () => {};
}

#[macro_export]
macro_rules! logs_common {
    ($logger:expr, $level:expr, $($arg:expr),*) => {
        unsafe {
            let  log:&mut Arc<Mutex<tklog::sync::Logger>> = $logger;
            let mut logger  = log.lock().unwrap();
            let module = module_path!();
            if logger.get_level(module) <= $level {
                let formatted_args: Vec<String> = vec![$(format!("{}", $arg)),*];
                let mut file = "";
                let mut line = 0;
                if logger.is_file_line(module) {
                    file = file!();
                    line = line!();
                }
                let msg: String = formatted_args.join(",");
                let ss = logger.fmt(module,$level, file, line, msg);
                logger.print(module, ss.as_str());
            }
        }
    };
    () => {};
}