finetime 0.8.1

High-fidelity time library for applications where sub-nanosecond accuracy and exact arithmetic are needed
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

//! Implementation of parsing for time-of-day. Also incorporates a helper struct that wraps such
//! combinations of hour, minute, and second.

use crate::{
    errors::{NumberParsingError, TimeOfDayParsingError},
    parse::DecimalNumber,
};

/// Wrapper for a time-of-day, as used primarily for parsing. Explicitly used only for parsing
/// because it cannot "correctly" encapsulate whether the given time is valid: an associated time
/// scale is needed for that, to determine whether leap seconds apply.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub(crate) struct TimeOfDay {
    pub(crate) hour: u8,
    pub(crate) minute: u8,
    pub(crate) second: u8,
    pub(crate) subseconds: DecimalNumber,
}

impl TimeOfDay {
    /// Parses a time-of-day based on the input string. Accepts only the extended complete local
    /// time-of-day format described in ISO 8601, section 5.3.1.2. However, we do not accept a
    /// leading time designator ('T'). Rather, this designator is expected only in the full
    /// date-time parsing, to simplify the implementation (since this struct is not public-facing
    /// anyway).
    pub(crate) fn parse_partial(mut string: &str) -> Result<(Self, &str), TimeOfDayParsingError> {
        // Parse hour component
        let (hour, consumed_bytes) = lexical_core::parse_partial(string.as_bytes())?;
        if consumed_bytes != 2 {
            return Err(TimeOfDayParsingError::HourRepresentationNotTwoDigits);
        }
        string = string.get(consumed_bytes..).unwrap();

        // Parse hour-minute delimiter
        if string.starts_with(':') {
            string = string.get(1..).unwrap();
        } else {
            return Err(TimeOfDayParsingError::ExpectedHourMinuteDelimiter);
        }

        // Parse minute component
        let (minute, consumed_bytes) = lexical_core::parse_partial(string.as_bytes())?;
        if consumed_bytes != 2 {
            return Err(TimeOfDayParsingError::MinuteRepresentationNotTwoDigits);
        }
        string = string.get(consumed_bytes..).unwrap();

        // Parse minute-second delimiter
        if string.starts_with(':') {
            string = string.get(1..).unwrap();
        } else {
            return Err(TimeOfDayParsingError::ExpectedMinuteSecondDelimiter);
        }

        // Parse second component
        // First, we parse only the integer part
        let (second, consumed_bytes) = lexical_core::parse_partial(string.as_bytes())?;
        if consumed_bytes != 2 {
            return Err(TimeOfDayParsingError::IntegerSecondRepresentationNotTwoDigits);
        }
        string = string.get(consumed_bytes..).unwrap();

        // Then, we parse the fractional remainder, if any
        let subseconds = if string.starts_with('.') {
            string = string.get(1..).unwrap();
            let (fraction, fractional_digits) = lexical_core::parse_partial(string.as_bytes())?;
            string = string.get(fractional_digits..).unwrap();
            let fractional_digits = fractional_digits
                .try_into()
                .map_err(|_| NumberParsingError::TooManyFractionalDigits { fractional_digits })?;
            DecimalNumber {
                integer: 0,
                fraction,
                fractional_digits,
            }
        } else {
            DecimalNumber::ZERO
        };

        Ok((
            TimeOfDay {
                hour,
                minute,
                second,
                subseconds,
            },
            string,
        ))
    }
}