Skip to main content

relay_server/managed/
utils.rs

1use crate::managed::{Counted, Managed, OutcomeError, Rejected};
2use crate::services::outcome::Outcome;
3
4/// Extension trait for Results, which adds convenience functions to work with errors and [`Managed`].
5pub trait ManagedResult<T, E> {
6    /// Reject the entire [`Managed`] instance with `E`.
7    fn reject<M>(self, managed: &Managed<M>) -> Result<T, Rejected<E::Error>>
8    where
9        Self: Sized,
10        M: Counted,
11        E: OutcomeError;
12
13    /// Reject two [`Managed`] instances while still only returning a single [`Rejected`] error in
14    /// the result.
15    fn reject2<M, N>(
16        self,
17        managed1: &Managed<M>,
18        managed2: &Managed<N>,
19    ) -> Result<T, Rejected<E::Error>>
20    where
21        Self: Sized,
22        M: Counted,
23        N: Counted,
24        E: OutcomeError;
25
26    /// Wraps the error of the [`Result`] with an outcome.
27    fn with_outcome(self, outcome: Outcome) -> Result<T, (Outcome, E)>
28    where
29        Self: Sized;
30}
31
32impl<T, E> ManagedResult<T, E> for Result<T, E> {
33    fn reject<M>(self, managed: &Managed<M>) -> Result<T, Rejected<E::Error>>
34    where
35        Self: Sized,
36        M: Counted,
37        E: OutcomeError,
38    {
39        self.map_err(|err| managed.reject_err(err))
40    }
41
42    fn reject2<M, N>(
43        self,
44        managed1: &Managed<M>,
45        managed2: &Managed<N>,
46    ) -> Result<T, Rejected<E::Error>>
47    where
48        Self: Sized,
49        M: Counted,
50        N: Counted,
51        E: OutcomeError,
52    {
53        self.map_err(|err| {
54            let (outcome, err) = err.consume();
55            let _ = managed1.reject_err(outcome.clone());
56            let r = managed2.reject_err(outcome);
57            r.map(|_| err)
58        })
59    }
60
61    fn with_outcome(self, outcome: Outcome) -> Result<T, (Outcome, E)>
62    where
63        Self: Sized,
64    {
65        self.map_err(|err| (outcome, err))
66    }
67}