use-ion 0.1.0

Ion identity and charge 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
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use std::fmt;

use crate::{ChargeSign, IonValidationError};

/// A nonzero ionic charge magnitude.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ChargeMagnitude(u8);

impl ChargeMagnitude {
    /// Creates a charge magnitude.
    ///
    /// # Errors
    ///
    /// Returns [`IonValidationError::ZeroChargeMagnitude`] when `magnitude` is zero.
    pub const fn new(magnitude: u8) -> Result<Self, IonValidationError> {
        if magnitude == 0 {
            Err(IonValidationError::ZeroChargeMagnitude)
        } else {
            Ok(Self(magnitude))
        }
    }

    /// Returns the magnitude value.
    #[must_use]
    pub const fn get(self) -> u8 {
        self.0
    }
}

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

/// A nonzero signed ionic charge.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct IonCharge {
    sign: ChargeSign,
    magnitude: ChargeMagnitude,
}

impl IonCharge {
    /// Creates a positive ion charge.
    ///
    /// # Errors
    ///
    /// Returns [`IonValidationError::ZeroChargeMagnitude`] when `magnitude` is zero.
    pub const fn positive(magnitude: u8) -> Result<Self, IonValidationError> {
        Ok(Self {
            sign: ChargeSign::Positive,
            magnitude: match ChargeMagnitude::new(magnitude) {
                Ok(value) => value,
                Err(error) => return Err(error),
            },
        })
    }

    /// Creates a negative ion charge.
    ///
    /// # Errors
    ///
    /// Returns [`IonValidationError::ZeroChargeMagnitude`] when `magnitude` is zero.
    pub const fn negative(magnitude: u8) -> Result<Self, IonValidationError> {
        Ok(Self {
            sign: ChargeSign::Negative,
            magnitude: match ChargeMagnitude::new(magnitude) {
                Ok(value) => value,
                Err(error) => return Err(error),
            },
        })
    }

    /// Returns the charge sign.
    #[must_use]
    pub const fn sign(self) -> ChargeSign {
        self.sign
    }

    /// Returns the charge magnitude as a primitive value.
    #[must_use]
    pub const fn magnitude(self) -> u8 {
        self.magnitude.get()
    }

    /// Returns the charge magnitude wrapper.
    #[must_use]
    pub const fn magnitude_value(self) -> ChargeMagnitude {
        self.magnitude
    }

    /// Returns `true` for a positive charge.
    #[must_use]
    pub const fn is_positive(self) -> bool {
        self.sign.is_positive()
    }

    /// Returns `true` for a negative charge.
    #[must_use]
    pub const fn is_negative(self) -> bool {
        self.sign.is_negative()
    }

    /// Returns `true` for a cation charge.
    #[must_use]
    pub const fn is_cation(self) -> bool {
        self.is_positive()
    }

    /// Returns `true` for an anion charge.
    #[must_use]
    pub const fn is_anion(self) -> bool {
        self.is_negative()
    }
}

impl fmt::Display for IonCharge {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.magnitude.get() == 1 {
            write!(formatter, "{}", self.sign)
        } else {
            write!(formatter, "{}{}", self.magnitude, self.sign)
        }
    }
}