use-reaction 0.1.0

Chemical reaction representation primitives for RustUse
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

use std::fmt;

use crate::ReactionDirection;

/// A reaction arrow style.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum ReactionArrow {
    /// Forward reaction arrow.
    #[default]
    Forward,
    /// Reverse reaction arrow.
    Reverse,
    /// Reversible reaction arrow.
    Reversible,
    /// Equilibrium reaction arrow.
    Equilibrium,
}

impl ReactionArrow {
    /// Returns the lightweight direction label for this arrow.
    #[must_use]
    pub const fn direction(self) -> ReactionDirection {
        match self {
            Self::Forward => ReactionDirection::Forward,
            Self::Reverse => ReactionDirection::Reverse,
            Self::Reversible => ReactionDirection::Reversible,
            Self::Equilibrium => ReactionDirection::Equilibrium,
        }
    }

    /// Returns `true` for reversible or equilibrium arrows.
    #[must_use]
    pub const fn is_reversible(self) -> bool {
        matches!(self, Self::Reversible | Self::Equilibrium)
    }

    /// Returns `true` for [`Self::Forward`].
    #[must_use]
    pub const fn is_forward(self) -> bool {
        matches!(self, Self::Forward)
    }

    /// Returns `true` for [`Self::Reverse`].
    #[must_use]
    pub const fn is_reverse(self) -> bool {
        matches!(self, Self::Reverse)
    }
}

impl fmt::Display for ReactionArrow {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        let value = match self {
            Self::Forward => "->",
            Self::Reverse => "<-",
            Self::Reversible => "<->",
            Self::Equilibrium => "⇌",
        };

        formatter.write_str(value)
    }
}