errorx 0.0.1

error and result types/utilities.
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

mod to_error;

pub use to_error::*;

#[cfg(feature = "macros")]
pub use errorx_macros::*;

#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Error {
    path: String,
    name: Option<String>,
    code: Option<u16>,
    message: Option<String>,
    children: Vec<Self>,
}

impl Error {
    pub fn new() -> ErrorBuilder {
        return ErrorBuilder::new();
    }

    pub fn path(&self) -> &str {
        return &self.path;
    }

    pub fn name(&self) -> Option<&str> {
        return match &self.name {
            None => None,
            Some(v) => Some(&v),
        };
    }

    pub fn code(&self) -> Option<u16> {
        return self.code;
    }

    pub fn message(&self) -> Option<&str> {
        return match &self.message {
            None => None,
            Some(v) => Some(&v),
        };
    }

    pub fn children(&self) -> &[Self] {
        return &self.children;
    }
}
impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if let Some(name) = &self.name {
            write!(f, "{}", name)?;

            if self.message.is_some() {
                write!(f, ": ")?;
            }
        }

        if let Some(message) = &self.message {
            write!(f, "{}", message)?;
        }

        if self.children.is_empty() {
            return Ok(());
        }

        write!(f, " [")?;

        for (i, error) in self.children.iter().enumerate() {
            write!(f, "\n\t{}", error)?;

            if i < self.children.len() - 1 {
                write!(f, ",")?;
            }
        }

        return write!(f, "]");
    }
}

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        if self.children.len() > 0 {
            let source = self.children.first().unwrap();
            return Some(source);
        }

        return None;
    }
}

///
/// Builder
///
#[derive(Debug, Clone)]
pub struct ErrorBuilder(Error);

impl ErrorBuilder {
    pub fn new() -> Self {
        return Self(Error {
            path: String::new(),
            name: None,
            code: None,
            message: None,
            children: vec![],
        });
    }

    pub fn with_path(&self, path: &str) -> Self {
        let mut next = self.clone();
        next.0.path = path.to_string();
        return next;
    }

    pub fn with_name(&self, name: &str) -> Self {
        let mut next = self.clone();
        next.0.name = Some(name.to_string());
        return next;
    }

    pub fn with_code(&self, code: u16) -> Self {
        let mut next = self.clone();
        next.0.code = Some(code);
        return next;
    }

    pub fn with_message(&self, message: &str) -> Self {
        let mut next = self.clone();
        next.0.message = Some(message.to_string());
        return next;
    }

    pub fn with_message_string(&self, message: String) -> Self {
        let mut next = self.clone();
        next.0.message = Some(message);
        return next;
    }

    pub fn with_child(&self, error: Error) -> Self {
        let mut next = self.clone();
        next.0.children.push(error);
        return next;
    }

    pub fn with_children(&self, errors: &[Error]) -> Self {
        let mut next = self.clone();

        for error in errors {
            next.0.children.push(error.clone());
        }

        return next;
    }

    pub fn build(&self) -> Error {
        return self.0.clone();
    }
}