use-bond 0.1.0

Chemical bond 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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use std::fmt;

use crate::BondValidationError;

/// A rational fractional bond order.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FractionalBondOrder {
    numerator: u32,
    denominator: u32,
}

impl FractionalBondOrder {
    /// Creates a fractional bond order.
    ///
    /// # Errors
    ///
    /// Returns [`BondValidationError::ZeroFractionalBondOrderNumerator`] when `numerator` is zero,
    /// or [`BondValidationError::ZeroFractionalBondOrderDenominator`] when `denominator` is zero.
    pub const fn new(numerator: u32, denominator: u32) -> Result<Self, BondValidationError> {
        if numerator == 0 {
            Err(BondValidationError::ZeroFractionalBondOrderNumerator)
        } else if denominator == 0 {
            Err(BondValidationError::ZeroFractionalBondOrderDenominator)
        } else {
            Ok(Self {
                numerator,
                denominator,
            })
        }
    }

    /// Returns the numerator.
    #[must_use]
    pub const fn numerator(self) -> u32 {
        self.numerator
    }

    /// Returns the denominator.
    #[must_use]
    pub const fn denominator(self) -> u32 {
        self.denominator
    }
}

impl fmt::Display for FractionalBondOrder {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(formatter, "{}/{}", self.numerator, self.denominator)
    }
}

/// A lightweight bond order label.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum BondOrder {
    /// Single bond order.
    Single,
    /// Double bond order.
    Double,
    /// Triple bond order.
    Triple,
    /// Quadruple bond order.
    Quadruple,
    /// Aromatic bond order.
    Aromatic,
    /// Rational fractional bond order.
    Fractional(FractionalBondOrder),
    /// Unknown or intentionally unspecified bond order.
    Unknown,
}

impl fmt::Display for BondOrder {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Single => formatter.write_str("single"),
            Self::Double => formatter.write_str("double"),
            Self::Triple => formatter.write_str("triple"),
            Self::Quadruple => formatter.write_str("quadruple"),
            Self::Aromatic => formatter.write_str("aromatic"),
            Self::Fractional(order) => write!(formatter, "{order}"),
            Self::Unknown => formatter.write_str("unknown"),
        }
    }
}