simplelog 0.4.0

A simple and easy-to-use logging facility for Rust's log crate
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

use log::LogRecord;
use time;
use std::io::{Write, Error};
use ::Config;

#[inline(always)]
pub fn try_log<W>(config: &Config, record: &LogRecord, write: &mut W) -> Result<(), Error>
    where W: Write + Sized
{
    if config.time.is_some() && config.time.unwrap() <= record.level() {
        try!(write_time(write));
    }

    if config.level.is_some() && config.level.unwrap() <= record.level() {
        try!(write_level(record, write));
    }

    if config.target.is_some() && config.target.unwrap() <= record.level() {
        try!(write_target(record, write));
    }

    if config.location.is_some() && config.location.unwrap() <= record.level() {
        try!(write_location(record, write));
    }

    try!(write_args(record, write));
    try!(write.flush());
    Ok(())
}

#[inline(always)]
pub fn write_time<W>(write: &mut W) -> Result<(), Error>
    where W: Write + Sized
{
    let cur_time = time::now();
    try!(write!(write, "{:02}:{:02}:{:02} ",
                cur_time.tm_hour,
                cur_time.tm_min,
                cur_time.tm_sec));
    Ok(())
}

#[inline(always)]
pub fn write_level<W>(record: &LogRecord, write: &mut W) -> Result<(), Error>
    where W: Write + Sized
{
    try!(write!(write, "[{}] ", record.level()));
    Ok(())
}

#[inline(always)]
pub fn write_target<W>(record: &LogRecord, write: &mut W) -> Result<(), Error>
    where W: Write + Sized
{
    try!(write!(write, "{}: ", record.target()));
    Ok(())
}

#[inline(always)]
pub fn write_location<W>(record: &LogRecord, write: &mut W) -> Result<(), Error>
    where W: Write + Sized
{
    try!(write!(write, "[{}:{}] ",
        record.location().file(),
        record.location().line()));
    Ok(())
}

#[inline(always)]
pub fn write_args<W>(record: &LogRecord, write: &mut W) -> Result<(), Error>
    where W: Write + Sized
{
    try!(writeln!(write, "{}", record.args()));
    Ok(())
}