gix-error 0.3.1

A crate of the gitoxide project to provide common errors and error-handling 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

use std::borrow::Cow;
use std::fmt::{Display, Formatter};

use crate::Message;

/// An error caused by malformed or internally inconsistent data.
#[derive(Debug)]
pub struct CorruptionError {
    /// The error message.
    pub message: Cow<'static, str>,
}

impl CorruptionError {
    /// Create a new instance that displays the given `message`.
    pub fn new(message: impl Into<Cow<'static, str>>) -> Self {
        CorruptionError {
            message: message.into(),
        }
    }
}

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

impl std::error::Error for CorruptionError {}

impl From<Message> for CorruptionError {
    fn from(Message(msg): Message) -> Self {
        CorruptionError::new(msg)
    }
}

impl From<String> for CorruptionError {
    fn from(msg: String) -> Self {
        CorruptionError::new(msg)
    }
}

impl From<&'static str> for CorruptionError {
    fn from(msg: &'static str) -> Self {
        CorruptionError::new(msg)
    }
}

/// An error indicating that a requested resource does not exist.
#[derive(Debug)]
pub struct NotFoundError {
    /// The error message.
    pub message: Cow<'static, str>,
}

impl NotFoundError {
    /// Create a new instance that displays the given `message`.
    pub fn new(message: impl Into<Cow<'static, str>>) -> Self {
        NotFoundError {
            message: message.into(),
        }
    }
}

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

impl std::error::Error for NotFoundError {}

impl From<Message> for NotFoundError {
    fn from(Message(msg): Message) -> Self {
        NotFoundError::new(msg)
    }
}

impl From<String> for NotFoundError {
    fn from(msg: String) -> Self {
        NotFoundError::new(msg)
    }
}

impl From<&'static str> for NotFoundError {
    fn from(msg: &'static str) -> Self {
        NotFoundError::new(msg)
    }
}

/// A transparent wrapper for dependency-specific errors known to be retryable.
#[derive(Debug)]
pub struct RetryableError(Box<dyn std::error::Error + Send + Sync + 'static>);

impl RetryableError {
    /// Mark `source` as retryable.
    pub fn new(source: impl std::error::Error + Send + Sync + 'static) -> Self {
        RetryableError(Box::new(source))
    }
}

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

impl std::error::Error for RetryableError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(self.0.as_ref())
    }
}