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

use log::{LevelFilter};
use crate::appender::{FastLogFormat, LogAppender, RecordFormat};
use crate::consts::LogSize;
use crate::filter::{Filter, NoFilter};
use crate::plugin::console::ConsoleAppender;
use crate::plugin::file::FileAppender;
use crate::plugin::file_loop::FileLoopAppender;
use crate::plugin::file_split::{FileSplitAppender, Packer, RollingType};

pub struct Config {
    pub appends: Vec<Box<dyn LogAppender>>,
    pub level: LevelFilter,
    pub filter: Box<dyn Filter>,
    pub format: Box<dyn RecordFormat>,
    pub chan_len: Option<usize>,
}

impl Default for Config {
    fn default() -> Self {
        Self {
            appends: vec![],
            level: LevelFilter::Info,
            filter: Box::new(NoFilter {}),
            format: Box::new(FastLogFormat::new()),
            chan_len: Some(100000),
        }
    }
}

impl Config {
    pub fn new() -> Self {
        Self::default()
    }

    /// set log LevelFilter
    pub fn level(mut self, level: LevelFilter) -> Self {
        self.level = level;
        self
    }
    /// set log Filter
    pub fn filter<F: Filter + 'static>(mut self, filter: F) -> Self {
        self.filter = Box::new(filter);
        self
    }
    /// set log format
    pub fn format<F: RecordFormat + 'static>(mut self, format: F) -> Self {
        self.format = Box::new(format);
        self
    }
    /// add a ConsoleAppender
    pub fn console(mut self) -> Self {
        self.appends.push(Box::new(ConsoleAppender {}));
        self
    }
    /// add a FileAppender
    pub fn file(mut self, file: &str) -> Self {
        self.appends.push(Box::new(FileAppender::new(file)));
        self
    }
    /// add a FileLoopAppender
    pub fn file_loop(mut self, file: &str, max_temp_size: LogSize) -> Self {
        self.appends.push(Box::new(FileLoopAppender::new(file, max_temp_size)));
        self
    }
    /// add a FileSplitAppender
    pub fn file_split<P: Packer + 'static>(mut self, file_path: &str,
                                           max_temp_size: LogSize,
                                           rolling_type: RollingType,
                                           packer: P, ) -> Self {
        self.appends.push(Box::new(FileSplitAppender::new(file_path, max_temp_size, rolling_type, Box::new(packer))));
        self
    }
    /// add a custom LogAppender
    pub fn custom<Appender: LogAppender + 'static>(mut self, arg: Appender) -> Self {
        self.appends.push(Box::new(arg));
        self
    }

    /// if none=> unbounded() channel,if Some =>  bounded(len) channel
    pub fn chan_len(mut self, len: Option<usize>) -> Self {
        self.chan_len = len;
        self
    }
}