rapid 0.0.1

Rapid console application development
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

//use failure;

macro_rules! traverse_err {
    ($error:expr, $action_first:expr, $action_others:expr) => {
        let mut cause: &::failure::Fail = $error;

        $action_first(cause);

        while let Some(inner_cause) = cause.cause() {
            $action_others(inner_cause);
            cause = inner_cause
        }
    };
}

pub trait FailMethods {
    fn traverse<F: FnMut(String)>(&self, action: F);
    fn log_error(&self);
    fn log_warning(&self);
    fn stringify(&self) -> String;
}

impl<T> FailMethods for T where T: ::failure::Fail {
    fn traverse<F: FnMut(String)>(&self, action: F) {
        (self as &::failure::Fail).traverse(action)
    }

    fn log_error(&self) {
        (self as &::failure::Fail).log_error()
    }

    fn log_warning(&self) {
        (self as &::failure::Fail).log_warning()
    }

    fn stringify(&self) -> String {
        (self as &::failure::Fail).stringify()
    }
}

impl FailMethods for ::failure::Fail {
    fn traverse<F: FnMut(String)>(&self, mut action: F) {
        traverse_err! {
            self,
            |failure| action(format!("{}", failure)),
            |failure| action(format!("  caused by: {}",failure))
        }
    }

    fn log_error(&self) {
        traverse_err! {
            self,
            |failure| error!("{}", failure),
            |failure| error!("  caused by: {}",failure)
        }
    }

    fn log_warning(&self) {
        traverse_err! {
            self,
            |failure| warn!("{}", failure),
            |failure| warn!("  caused by: {}",failure)
        }
    }

    fn stringify(&self) -> String {
        let mut result = String::new();

        self.traverse(|msg| result.push_str(&msg));

        result
    }
}

pub trait ErrorMethods {
    fn traverse<F: FnMut(String)>(&self, action: F);
    fn log_error(&self);
    fn log_warning(&self);
    fn stringify(&self) -> String;
}

impl ErrorMethods for ::failure::Error {
    fn traverse<F: FnMut(String)>(&self, action: F) {
        self.cause().traverse(action)
    }

    fn log_error(&self) {
        self.cause().log_error()
    }

    fn log_warning(&self) {
        self.cause().log_warning()
    }

    fn stringify(&self) -> String {
        self.cause().stringify()
    }
}