idem-handler 0.1.0

Common handler mechanism used in other idemio products.
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::fmt::{Display, Formatter};
use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, Not};

#[derive(Debug)]
pub struct HandlerExecutionError {
    message: String,
}

impl Display for HandlerExecutionError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "Fatal error: {}", self.message)
    }
}

pub struct HandlerStatus {
    pub(crate) code: Code,
    message: Option<&'static str>,
    details: Option<&'static str>,
}

impl HandlerStatus {
    pub fn code(&self) -> Code {
        self.code
    }
    pub fn message(&self) -> &'static str {
        self.message.unwrap_or_else(|| "")
    }

    pub fn details(&self) -> &'static str {
        self.details.unwrap_or_else(|| "")
    }

    pub fn new(code: Code) -> HandlerStatus {
        Self {
            code,
            message: None,
            details: None,
        }
    }

    pub fn set_message(mut self, message: &'static str) -> HandlerStatus {
        self.message = Some(message);
        self
    }

    pub fn set_details(mut self, description: &'static str) -> HandlerStatus {
        self.details = Some(description);
        self
    }
}

#[derive(Clone, Copy)]
pub struct Code(pub i32);

impl Code {
    pub const OK: Self = Self(1);
    pub const REQUEST_COMPLETED: Self = Self(1 << 1);
    pub const SERVER_ERROR: Self = Self(1 << 2);
    pub const CLIENT_ERROR: Self = Self(1 << 3);
    pub const DISABLED: Self = Self(1 << 4);
    pub const TIMEOUT: Self = Self(1 << 5);
    pub const CONTINUE: Self = Self(1 << 6);

    pub fn any_flags(&self, flags: Code) -> bool {
        self.0 & flags.0 != 0
    }

    pub fn any_flags_clear(&self, flags: Code) -> bool {
        self.0 & flags.0 != flags.0
    }

    pub fn all_flags(&self, flags: Code) -> bool {
        self.0 & flags.0 == flags.0
    }

    pub fn all_flags_clear(&self, flags: Code) -> bool {
        self.0 & flags.0 == 0
    }
}

impl PartialEq for Code {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
    }
}

impl BitOrAssign for Code {
    fn bitor_assign(&mut self, rhs: Self) {
        self.0 |= rhs.0
    }
}

impl BitAndAssign for Code {
    fn bitand_assign(&mut self, rhs: Self) {
        self.0 &= rhs.0
    }
}

impl Not for Code {
    type Output = Self;

    fn not(self) -> Self::Output {
        Self(!self.0)
    }
}

impl BitAnd for Code {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self::Output {
        Self(self.0 & rhs.0)
    }
}

impl BitOr for Code {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self::Output {
        Self(self.0 | rhs.0)
    }
}

#[cfg(test)]
mod tests {
    use crate::status::Code;

    #[test]
    fn test_status_flags() {
        let mut test_code = Code::OK;
        test_code |= Code::REQUEST_COMPLETED;
        assert!(test_code.all_flags(Code::OK | Code::REQUEST_COMPLETED));
        assert!(test_code.all_flags_clear(Code::DISABLED | Code::TIMEOUT | Code::CONTINUE | Code::CLIENT_ERROR | Code::SERVER_ERROR));
    }

    #[test]
    fn test_status_constructs() {
        let test_code1 = Code::OK | Code::SERVER_ERROR;
        let test_code2 = Code::from(test_code1 | Code::REQUEST_COMPLETED);
        assert!(test_code2.all_flags(Code::OK | Code::SERVER_ERROR | Code::REQUEST_COMPLETED));
    }
}