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

//!This crate provides simple and cute logger.
//!
//!## Feautres
//!
//!- `timestamp` - Enables timestamps in logs by means of `chrono`. Enabled by default
//!- `color` - Enables coloring of log level. Enabled by default.
//!
//!## Usage
//!
//!```rust
//!fn main() {
//!    cute_log::init();
//!    log::info!("it works!");
//!}
//!```
//!
//!## Log level control
//!
//!The logger is made without any builtin filters.
//!
//!You can either control logs through compile time features of `log` crate.
//!Or use `set_max_level` from the `log` crate.
//!
//!## Supported platforms
//!
//!- Android - via NDK logging library, therefore it must be linked.
//!- Wasm - via web console API.
//!- Any other platform with `std` available.

pub extern crate log;

mod io;

///Simple Logger implementation
///
///It provides logger without filtering with following format:
///`<level> [<date and time>] - <args> at <file>:<line>`
///
///Timestamp can be turned off by disabling default features
pub struct Logger;

impl Logger {
    #[inline]
    ///Logger printer.
    pub fn print(record: &log::Record) {
        io::print(record);
    }

    #[inline]
    ///Sets `log` max level
    pub fn set_max_level(level: log::LevelFilter) {
        log::set_max_level(level);
    }

    #[inline]
    ///Initialize self as `log` global logger.
    pub fn set_logger(&'static self) -> Result<(), log::SetLoggerError> {
        log::set_logger(self)
    }
}

impl log::Log for Logger {
    #[inline(always)]
    fn enabled(&self, _: &log::Metadata) -> bool {
        true
    }

    #[inline]
    fn log(&self, record: &log::Record) {
        Self::print(record);
    }

    #[inline(always)]
    fn flush(&self) {
    }
}

#[inline(always)]
///Sets global logger as [init](fn.init.html) only in debug mode.
pub fn debug_init() -> Result<(), log::SetLoggerError> {
    #[cfg(debug_assertions)]
    {
        init()
    }
    #[cfg(not(debug_assertions))]
    {
        Ok(())
    }
}

#[inline]
///Sets global logger with log level Trace
pub fn init() -> Result<(), log::SetLoggerError> {
    init_with_max_level(log::LevelFilter::Trace)
}

#[inline(always)]
///Sets global logger as [init_with_max_level](fn.init_with_max_level.html) only in debug mode.
pub fn debug_init_with_max_level(_level: log::LevelFilter) -> Result<(), log::SetLoggerError> {
    #[cfg(debug_assertions)]
    {
        init_with_max_level(_level)
    }
    #[cfg(not(debug_assertions))]
    {
        Ok(())
    }
}

///Sets logger with max log level.
pub fn init_with_max_level(level: log::LevelFilter) -> Result<(), log::SetLoggerError> {
    static INSTANCE: Logger = Logger;
    log::set_max_level(level);
    log::set_logger(&INSTANCE)
}