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

pub trait Logger {
    fn warn(&mut self, message: &str);

    fn err(&mut self, message: &str);
}

/// Simple Logger for [`Validator`](crate::validate::Validator) trait, storing messages in `Vec`
#[derive(Debug, Default)]
pub struct VecLogger {
    warnings: Vec<String>,
    errors: Vec<String>,
}

impl VecLogger {
    /// Get stored warnings
    pub fn warnings(&self) -> &[String] {
        &self.warnings
    }

    /// Get stored errors
    pub fn errors(&self) -> &[String] {
        &self.errors
    }
}

impl Logger for VecLogger {
    fn warn(&mut self, message: &str) {
        self.warnings.push(message.to_owned())
    }

    fn err(&mut self, message: &str) {
        self.errors.push(message.to_owned())
    }
}

/// Simple Logger for [`Validator`](crate::validate::Validator) trait, printing messages to `stderr`
#[derive(Debug, Default)]
pub struct StderrLogger;

impl Logger for StderrLogger {
    fn warn(&mut self, message: &str) {
        eprintln!("[W] {}", message);
    }

    fn err(&mut self, message: &str) {
        eprintln!("[E] {}", message);
    }
}

/// Simple Logger for [`Validator`](crate::validate::Validator) trait, using closures for `warn`/`err`.
#[derive(Debug, Default)]
pub struct CallbackLogger<W, E>
where
    W: FnMut(&str),
    E: FnMut(&str),
{
    warn: W,
    err: E,
}

impl<W, E> CallbackLogger<W, E>
where
    W: FnMut(&str),
    E: FnMut(&str),
{
    pub fn new(warn: W, err: E) -> Self {
        CallbackLogger { warn, err }
    }
}

impl<W, E> Logger for CallbackLogger<W, E>
where
    W: FnMut(&str),
    E: FnMut(&str),
{
    fn warn(&mut self, message: &str) {
        (self.warn)(message);
    }

    fn err(&mut self, message: &str) {
        (self.err)(message);
    }
}