aragog 0.17.1

A simple lightweight object-document mapper for ArangoDB
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

#![allow(clippy::missing_const_for_fn)]
use crate::Error;

/// Output of a [`TransactionDatabaseConnection`]`::safe_execute`
///
/// [`TransactionDatabaseConnection`]: crate::transaction::TransactionDatabaseConnection
#[must_use]
pub enum TransactionOutput<T> {
    /// The transaction was committed
    Committed(T),
    /// The transaction was aborted due to an error
    Aborted(Error),
}

impl<T> TransactionOutput<T> {
    /// Was the transaction committed
    #[inline]
    pub const fn is_committed(&self) -> bool {
        matches!(self, Self::Committed(_))
    }

    /// Was the transaction aborted
    #[inline]
    pub fn is_aborted(&self) -> bool {
        !self.is_committed()
    }

    /// Returns the contained [`Self::Committed`] value, consuming the self value.
    ///
    /// # Panics
    ///
    /// Panics if the self value equals [`Self::Aborted`].
    #[inline]
    pub fn unwrap(self) -> T {
        match self {
            Self::Committed(v) => v,
            Self::Aborted(err) => panic!(
                "called `TransactionOuput::unwrap()` on an `Aborted` value {}",
                err
            ),
        }
    }

    /// transform the output to a `Option<T>`
    #[inline]
    pub fn ok(self) -> Option<T> {
        match self {
            Self::Committed(v) => Some(v),
            Self::Aborted(_) => None,
        }
    }

    /// transform the output to a `Option<Error>`
    #[inline]
    pub fn err(self) -> Option<Error> {
        match self {
            Self::Committed(_) => None,
            Self::Aborted(err) => Some(err),
        }
    }

    /// Returns the contained [Committed] value, consuming the self value.
    ///
    /// # Panics
    ///
    /// Panics if the value is a [Aborted] with a custom panic message provided by msg
    ///
    /// [Committed]: Self::Committed
    /// [Aborted]: Self::Aborted
    #[inline]
    pub fn expect(self, msg: &str) -> T {
        match self {
            Self::Committed(v) => v,
            Self::Aborted(e) => panic!("{}: {:?}", msg, e),
        }
    }
}

impl<T> From<TransactionOutput<T>> for Result<T, Error> {
    fn from(output: TransactionOutput<T>) -> Self {
        match output {
            TransactionOutput::Committed(v) => Ok(v),
            TransactionOutput::Aborted(err) => Err(err),
        }
    }
}