hyperlit-base 0.1.0

A software documentation tool documentation embedded in source files - base crate
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

use error_stack::{Context, Report};
use std::error::Error;
use std::fmt::{Debug, Display, Formatter};

pub struct HyperlitError(pub Report<HyperlitErrorContext>);

pub struct HyperlitErrorContext {
    pub context: Box<dyn Context>,
}

impl Debug for HyperlitError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}

impl HyperlitErrorContext {
    #[track_caller]
    pub fn new<T: Context>(context: T) -> HyperlitErrorContext {
        HyperlitErrorContext {
            context: Box::new(context),
        }
    }

    #[track_caller]
    pub fn from_string<T: Into<String>>(message: T) -> HyperlitErrorContext {
        HyperlitErrorContext {
            context: Box::new(GeneralError {
                message: message.into(),
            }),
        }
    }
}

pub struct BoxedErrorContext {
    pub error: BoxedError,
}

pub type BoxedError = Box<dyn Error + Send + Sync + 'static>;

impl BoxedErrorContext {
    #[track_caller]
    pub fn new(error: BoxedError) -> BoxedErrorContext {
        BoxedErrorContext { error }
    }
}

impl Display for BoxedErrorContext {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(&self.error, f)
    }
}

impl Debug for BoxedErrorContext {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.error, f)
    }
}

impl Error for BoxedErrorContext {}

impl HyperlitErrorContext {
    pub fn from_context<T: Context>(context: T) -> HyperlitErrorContext {
        HyperlitErrorContext {
            context: Box::new(context),
        }
    }
}

impl Display for HyperlitErrorContext {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(&self.context, f)
    }
}

impl Debug for HyperlitErrorContext {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.context, f)
    }
}

impl Error for HyperlitErrorContext {}

pub struct GeneralError {
    pub message: String,
}

impl Display for GeneralError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(&self.message, f)
    }
}

impl Debug for GeneralError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.message, f)
    }
}

impl Error for GeneralError {}

impl Display for HyperlitError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(&self.0, f)
    }
}

impl HyperlitError {
    #[track_caller]
    pub fn change_context<S: Into<String>>(self, message: S) -> Self {
        Self(
            self.0
                .change_context(HyperlitErrorContext::from_string(message.into())),
        )
    }
}

impl HyperlitError {
    #[track_caller]
    pub fn new<T: Context>(error: T) -> HyperlitError {
        HyperlitError(Report::new(HyperlitErrorContext::from_context(error)))
    }

    #[track_caller]
    pub fn from_string<T: Into<String>>(message: T) -> HyperlitError {
        HyperlitError(Report::new(HyperlitErrorContext::from_string(message)))
    }

    #[track_caller]
    pub fn from_boxed(error: BoxedError) -> HyperlitErrorContext {
        HyperlitErrorContext {
            context: Box::new(BoxedErrorContext::new(error)),
        }
    }
}

impl<T: Context> From<T> for HyperlitError {
    #[track_caller]
    fn from(error: T) -> Self {
        Self::new(error)
    }
}

#[macro_export]
macro_rules! bail {
    ($($args:tt)+) => {
        return Err($crate::err!($($args)+))
    }
}

#[macro_export]
macro_rules! err {
    ($($args:tt)+) => {
        $crate::error::HyperlitError::from_string(format!($($args)+))
    };
}