nyandere 0.1.2

i help with keeping track of purchases. meow
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

//! Offering, selling and buying need a common denominator.

use std::{num::ParseIntError, ops::RangeInclusive, str::FromStr};

use thiserror::Error;

use crate::aux::Stack;

/// Global trade item number. The number behind the barcode you find in stores.
///
/// Internationally standardized.
/// This encompasses typical products one would buy off-the-shelf
/// as well ase more specialized cases like books and smaller products.
///
/// # Note on validation
///
/// While there are only limited possibilities for the lengths of GTINs
/// (namely, 8, 10, 13, 14), this is not validated.
/// Any positive number with at most 14 digits in base 10 is accepted.
/// Shorter ones are just padded with zeroes at the start.
///
/// # Resources
///
/// - <https://en.wikipedia.org/wiki/Global_Trade_Item_Number>
// largest number representable by 14 digits is `10^14 - 1`,
// which requires `ceil(log2(10^14 - 1)) = 47` bits
// next largest int is u64
// which has the nice side effect of "automatically" padding shorter GTINs with zeroes
#[derive(Stack!)]
pub struct Gtin(u64);

impl Gtin {
    /// The largest possible GTIN has 14 digits. For now, that is.
    pub const DIGITS_MIN: u8 = 8;
    pub const DIGITS_MAX: u8 = 14;
    pub const DIGITS_RANGE: RangeInclusive<u8> = Self::DIGITS_MIN..=Self::DIGITS_MAX;
    pub const MAX: Self = Self(10u64.pow(Self::DIGITS_MAX as u32) - 1);

    /// Interpret the integer as-is as GTIN.
    ///
    /// # Errors
    ///
    /// Returns an error if the integer is longer than 14 digits.
    pub fn new(source: u64) -> Result<Self, OutOfRangeError> {
        let gtin = Self(source);

        if gtin.digits() > Self::DIGITS_MAX {
            return Err(OutOfRangeError {
                orig: source,
                n: gtin.digits(),
            });
        }

        Ok(gtin)
    }

    #[must_use]
    pub fn get(&self) -> u64 {
        self.0
    }

    /// How many digits are in this GTIN
    /// when represented in base 10?
    #[must_use]
    pub fn digits(&self) -> u8 {
        let n = self.0;
        if n == 0 { 1 } else { n.ilog10() as u8 + 1 }
    }
}

impl FromStr for Gtin {
    type Err = GtinParseError;
    fn from_str(source: &str) -> Result<Self, Self::Err> {
        let parsed = source.parse()?;

        // note: the u8 cast is fine,
        // ceil(log10(2^64 - 1)) = 20,
        // so 20 digits can be at max in a u64
        let digits = source.len() as u8;
        if !Self::DIGITS_RANGE.contains(&digits) {
            return Err(OutOfRangeError {
                orig: parsed,
                n: digits,
            }
            .into());
        }

        let gtin = Self::new(parsed)?;
        Ok(gtin)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Error)]
pub enum GtinParseError {
    #[error("couldn't parse as an integer: {0}")]
    ExpectedInteger(#[from] ParseIntError),
    #[error("valid int, but out of range: {0}")]
    OutOfRange(#[from] OutOfRangeError),
}

#[derive(Debug, Clone, PartialEq, Eq, Error)]
#[error(
    "`{orig}` contains {n} digits, which is not in the allowed range [{}, {}]",
    Gtin::DIGITS_MIN,
    Gtin::DIGITS_MAX
)]
pub struct OutOfRangeError {
    pub orig: u64,
    pub n: u8,
}