rsutil 0.1.26

`rsutil` is a Rust library providing common utilities.
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
115
116

//! A set of logging macros that provide different levels of logging: `trace`, `debug`, `info`,
//! `warn`, and `error`. These macros behave differently depending on whether the code is compiled
//! in debug or release mode.
//!
//! In debug mode (`debug_assertions` enabled), the macros use `println!` to output messages to the
//! console. In release mode (`debug_assertions` disabled), the macros delegate to the corresponding
//! logging macros from the `log` crate (`log::trace!`, `log::debug!`, etc.).
//!
//! # Macros
//!
//! - `trace!`: Logs very detailed information, typically used for tracing program execution.
//! - `debug!`: Logs debugging information, useful during development.
//! - `info!`: Logs general informational messages.
//! - `warn!`: Logs warnings about potential issues.
//! - `error!`: Logs error messages indicating serious problems.
//!
//! # Examples
//!
//! ```rust
//!
//! rsutil::trace!();
//! rsutil::trace!("This is a trace message: {}", 2);
//! rsutil::trace!("This is a trace", );
//! rsutil::debug!("Debugging value: {:?}", Box::new(42));
//! rsutil::info!("Application started successfully.");
//! rsutil::warn!("This might cause an issue: {}", "low disk space");
//! rsutil::error!("An error occurred: {}", "error message");
//! ```
//!
//! These macros are designed to make it easy to switch between debug and release logging behavior
//! without changing the code.

#[cfg(feature = "log4rs")]
mod log4rs;
#[cfg(feature = "log4rs")]
pub use log4rs::*;

mod cat;
pub use cat::*;

#[macro_export]
macro_rules! trace {
    () => {{}};

    ($($x:tt)*) => {{
        #[cfg(debug_assertions)]
        println!(
            "\x1b[95m[ TRACE] - {}\x1b[0m",
            format_args!($($x)*)
        );
        #[cfg(not(debug_assertions))]
        log::trace!($($x)*);
    }};
}

#[macro_export]
macro_rules! debug {
    () => {{
        println!();
    }};

    ($($x:tt)*) => {{
        #[cfg(debug_assertions)]
        println!(
            "\x1b[96m[ DEBUG] - {}\x1b[0m",
            format_args!($($x)*)
        );
        #[cfg(not(debug_assertions))]
        log::debug!($($x)*);
    }};
}

#[macro_export]
macro_rules! info {
    () => {{}};

    ($($x:tt)*) => {{
        #[cfg(debug_assertions)]
        println!(
            "\x1b[32m[  INFO] - {}\x1b[0m",
            format_args!($($x)*)
        );
        #[cfg(not(debug_assertions))]
        log::info!($($x)*);
    }};
}

#[macro_export]
macro_rules! warn {
    () => {{}};

    ($($x:tt)*) => {{
        #[cfg(debug_assertions)]
        println!(
            "\x1b[33m[  WARN] - {}\x1b[0m",
            format_args!($($x)*)
        );
        #[cfg(not(debug_assertions))]
        log::warn!($($x)*);
    }};
}

#[macro_export]
macro_rules! error {
    () => {{}};

    ($($x:tt)*) => {{
        #[cfg(debug_assertions)]
        println!(
            "\x1b[31m[ ERROR] - {}\x1b[0m",
            format_args!($($x)*)
        );
        #[cfg(not(debug_assertions))]
        log::error!($($x)*);
    }};
}