g-err 0.1.0

Structured error type
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

extern crate alloc;
use alloc::boxed::Box;

use crate::GErrSource;
use crate::{
    Config,
    gerr::{GErr, Result},
    sealed,
};
use core::error::Error;
use core::panic::Location;

use alloc::borrow::Cow;

impl<T, E> sealed::Sealed for core::result::Result<T, E> {}

/// Extension for Result wrapping `E` as any error.
///
/// This is for general error, including GErr itself.
///
/// Passing GErr will be parsed as general error.
pub trait ResultExt<T>: sealed::Sealed {
    /// Wrap `E` inside GErr as source with manually-set id.
    #[track_caller]
    fn context<C: Config, D>(
        self,
        id: C::Id,
        message: impl Into<Cow<'static, str>>,
    ) -> Result<T, C, D>;

    /// Wrap `E` inside GErr as source with auto-generated id and code.
    #[track_caller]
    fn context_auto<C: Config, D>(self, message: impl Into<Cow<'static, str>>) -> Result<T, C, D>;

    /// Wrap `E` inside GErr
    #[track_caller]
    fn wrap_err<C: Config, D>(self, gerr: GErr<C, D>) -> Result<T, C, D>;
}

impl<T, E> ResultExt<T> for core::result::Result<T, E>
where
    E: Error + Send + Sync + 'static,
{
    #[track_caller]
    fn context<C: Config, D>(
        self,
        id: C::Id,
        message: impl Into<Cow<'static, str>>,
    ) -> Result<T, C, D> {
        let location = Location::caller();
        self.map_err(|source| {
            GErr::<C, D>::new_with_id_untracked(Some(id), message.into(), location)
                .add_source(source)
        })
    }

    #[track_caller]
    fn context_auto<C: Config, D>(self, message: impl Into<Cow<'static, str>>) -> Result<T, C, D> {
        let location = Location::caller();
        self.map_err(|source| {
            GErr::<C, D>::new_untracked(message.into(), location).add_source(source)
        })
    }

    #[track_caller]
    fn wrap_err<C: Config, D>(self, gerr: GErr<C, D>) -> Result<T, C, D> {
        self.map_err(|err| gerr.add_source(err))
    }
}

/// Result extension where `E` is GErr or any error implementing `Into<GErrSource>`.
///
/// Use this extension if you pass GErr or `Into<GErrSource>` from Result's E and want to keep the detail attributes.
pub trait GResultExt<T, E>: sealed::Sealed {
    /// Wrap `E` as GErr's source, where E is `Into<GErrSource>`, and id is manually-set.
    #[track_caller]
    fn gerr<C: Config, D>(
        self,
        id: C::Id,
        message: impl Into<Cow<'static, str>>,
    ) -> Result<T, C, D>;

    /// Wrap `E` as GErr's source, where E is `Into<GErrSource>`, and id is auto-generated.
    #[track_caller]
    fn gerr_auto<C: Config, D>(self, message: impl Into<Cow<'static, str>>) -> Result<T, C, D>;

    /// Wrap `E` inside GErr
    #[track_caller]
    fn wrap_gerr<C: Config, D>(self, gerr: GErr<C, D>) -> Result<T, C, D>;

    /// Box `E`
    fn boxed(self) -> core::result::Result<T, Box<E>>;
}

impl<T, E> GResultExt<T, E> for core::result::Result<T, E>
where
    E: Into<GErrSource> + Error + Send + Sync + 'static,
{
    #[track_caller]
    fn gerr<C: Config, D>(
        self,
        id: C::Id,
        message: impl Into<Cow<'static, str>>,
    ) -> Result<T, C, D> {
        let location = Location::caller();
        self.map_err(|source| {
            GErr::<C, D>::new_with_id_untracked(Some(id), message.into(), location)
                .add_source_gerr(source)
        })
    }

    #[track_caller]
    fn gerr_auto<C: Config, D>(self, message: impl Into<Cow<'static, str>>) -> Result<T, C, D> {
        let location = Location::caller();
        self.map_err(|source| {
            GErr::<C, D>::new_untracked(message.into(), location).add_source_gerr(source)
        })
    }

    /// Wrap `E` inside GErr
    #[track_caller]
    fn wrap_gerr<C: Config, D>(self, gerr: GErr<C, D>) -> Result<T, C, D> {
        self.map_err(|err| gerr.add_source_gerr(err))
    }

    #[inline]
    fn boxed(self) -> core::result::Result<T, Box<E>> {
        self.map_err(Box::new)
    }
}