hifitime 4.3.0

Ultra-precise date and time handling in Rust for scientific applications with leap second support
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

/*
* Hifitime
* Copyright (C) 2017-onward Christopher Rabotin <christopher.rabotin@gmail.com> et al. (cf. https://github.com/nyx-space/hifitime/graphs/contributors)
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*
* Documentation: https://nyxspace.com/
*/

use core::num::ParseIntError;
use snafu::prelude::*;

#[cfg(feature = "std")]
use std::io::ErrorKind as IOError;

use lexical_core::Error as LexicalError;

use crate::Weekday;

/// Errors handles all oddities which may occur in this library.
#[non_exhaustive]
#[derive(Debug, Snafu, PartialEq)]
#[snafu(visibility(pub(crate)))]
pub enum HifitimeError {
    InvalidGregorianDate,
    #[snafu(display("{source}, {details}"))]
    Parse {
        source: ParsingError,
        details: &'static str,
    },
    #[snafu(display("epoch initialization from system time failed"))]
    SystemTimeError,
    #[snafu(display("epoch computation failed because {source}"))]
    Duration {
        source: DurationError,
    },
    #[cfg(feature = "python")]
    #[snafu(display("python interop error: {reason}"))]
    PythonError {
        reason: String,
    },
}

#[cfg(feature = "python")]
impl From<pyo3::PyErr> for HifitimeError {
    fn from(err: pyo3::PyErr) -> Self {
        HifitimeError::PythonError {
            reason: err.to_string(),
        }
    }
}

#[cfg_attr(kani, derive(kani::Arbitrary))]
#[non_exhaustive]
#[derive(Debug, Snafu, PartialEq)]
pub enum DurationError {
    Overflow,
    Underflow,
}

#[non_exhaustive]
#[derive(Debug, Snafu, PartialEq)]
pub enum ParsingError {
    ParseIntError {
        err: ParseIntError,
    },
    NothingToParse,
    ValueError,
    TimeSystem,
    ISO8601,
    Lexical {
        err: LexicalError,
    },
    UnknownFormat,
    UnknownOrMissingUnit,
    UnsupportedTimeSystem,
    UnknownWeekday,
    UnknownMonthName,
    UnknownToken {
        token: char,
    },
    UnexpectedCharacter {
        found: char,
        option1: Option<char>,
        option2: Option<char>,
    },
    WeekdayMismatch {
        found: Weekday,
        expected: Weekday,
    },
    InvalidTimezone,
    #[cfg(feature = "std")]
    InOut {
        err: IOError,
    },
    #[cfg(feature = "ut1")]
    DownloadError {
        code: u16,
    },
}

#[cfg(test)]
mod tests {
    use crate::{HifitimeError, ParsingError, TimeScale};

    #[test]
    fn enum_eq() {
        // Check the equality compiles (if one compiles, then all asserts will work)
        assert!(HifitimeError::InvalidGregorianDate == HifitimeError::InvalidGregorianDate);
        assert!(ParsingError::ISO8601 == ParsingError::ISO8601);
        assert!(TimeScale::ET == TimeScale::ET);
    }
}