tz-rs 0.7.3

A pure Rust reimplementation of libc functions localtime, gmtime and mktime.
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Parsing error types.

use core::error::Error;
use core::fmt;
use core::num::ParseIntError;
use core::str::Utf8Error;

/// Parse data error
#[non_exhaustive]
#[derive(Debug)]
pub enum ParseDataError {
    /// Unexpected end of data
    UnexpectedEof,
    /// Invalid data
    InvalidData,
}

impl fmt::Display for ParseDataError {
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        match self {
            Self::UnexpectedEof => f.write_str("unexpected end of data"),
            Self::InvalidData => f.write_str("invalid data"),
        }
    }
}

impl Error for ParseDataError {}

/// Unified error type for parsing a TZ string
#[non_exhaustive]
#[derive(Debug)]
pub enum TzStringError {
    /// UTF-8 error
    Utf8(Utf8Error),
    /// Integer parsing error
    ParseInt(ParseIntError),
    /// Parse data error
    ParseData(ParseDataError),
    /// Invalid offset hour
    InvalidOffsetHour,
    /// Invalid offset minute
    InvalidOffsetMinute,
    /// Invalid offset second
    InvalidOffsetSecond,
    /// Invalid day time hour
    InvalidDayTimeHour,
    /// Invalid day time minute
    InvalidDayTimeMinute,
    /// Invalid day time second
    InvalidDayTimeSecond,
    /// Missing DST start and end rules
    MissingDstStartEndRules,
    /// Remaining data was found after parsing TZ string
    RemainingData,
    /// Empty TZ string
    Empty,
}

impl fmt::Display for TzStringError {
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        match self {
            Self::Utf8(error) => error.fmt(f),
            Self::ParseInt(error) => error.fmt(f),
            Self::ParseData(error) => error.fmt(f),
            Self::InvalidOffsetHour => f.write_str("invalid offset hour"),
            Self::InvalidOffsetMinute => f.write_str("invalid offset minute"),
            Self::InvalidOffsetSecond => f.write_str("invalid offset second"),
            Self::InvalidDayTimeHour => f.write_str("invalid day time hour"),
            Self::InvalidDayTimeMinute => f.write_str("invalid day time minute"),
            Self::InvalidDayTimeSecond => f.write_str("invalid day time second"),
            Self::MissingDstStartEndRules => f.write_str("missing DST start and end rules"),
            Self::RemainingData => f.write_str("remaining data after parsing TZ string"),
            Self::Empty => f.write_str("empty TZ string"),
        }
    }
}

impl Error for TzStringError {}

impl From<Utf8Error> for TzStringError {
    fn from(error: Utf8Error) -> Self {
        Self::Utf8(error)
    }
}

impl From<ParseIntError> for TzStringError {
    fn from(error: ParseIntError) -> Self {
        Self::ParseInt(error)
    }
}

impl From<ParseDataError> for TzStringError {
    fn from(error: ParseDataError) -> Self {
        Self::ParseData(error)
    }
}

/// Unified error type for parsing a TZif file
#[non_exhaustive]
#[derive(Debug)]
pub enum TzFileError {
    /// UTF-8 error
    Utf8(Utf8Error),
    /// Parse data error
    ParseData(ParseDataError),
    /// Invalid magic number
    InvalidMagicNumber,
    /// Unsupported TZif version
    UnsupportedTzFileVersion,
    /// Invalid header
    InvalidHeader,
    /// Invalid footer
    InvalidFooter,
    /// Invalid DST indicator
    InvalidDstIndicator,
    /// Invalid time zone designation char index
    InvalidTimeZoneDesignationCharIndex,
    /// Invalid couple of standard/wall and UT/local indicators
    InvalidStdWallUtLocal,
    /// Remaining data after the end of a TZif v1 data block
    RemainingDataV1,
}

impl fmt::Display for TzFileError {
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        match self {
            Self::Utf8(error) => error.fmt(f),
            Self::ParseData(error) => error.fmt(f),
            Self::InvalidMagicNumber => f.write_str("invalid magic number"),
            Self::UnsupportedTzFileVersion => write!(f, "unsupported TZ file version"),
            Self::InvalidHeader => f.write_str("invalid header"),
            Self::InvalidFooter => f.write_str("invalid footer"),
            Self::InvalidDstIndicator => f.write_str("invalid DST indicator"),
            Self::InvalidTimeZoneDesignationCharIndex => f.write_str("invalid time zone designation char index"),
            Self::InvalidStdWallUtLocal => f.write_str("invalid couple of standard/wall and UT/local indicators"),
            Self::RemainingDataV1 => f.write_str("remaining data after the end of a TZif v1 data block"),
        }
    }
}

impl Error for TzFileError {}

impl From<Utf8Error> for TzFileError {
    fn from(error: Utf8Error) -> Self {
        Self::Utf8(error)
    }
}

impl From<ParseDataError> for TzFileError {
    fn from(error: ParseDataError) -> Self {
        Self::ParseData(error)
    }
}