speedate 0.17.0

Fast and simple datetime, date, time and duration parsing
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

use crate::{ConfigError, MicrosecondsPrecisionOverflowBehavior};
use std::str::FromStr;

#[derive(Debug, Clone, Copy, Default, PartialEq)]
pub enum TimestampUnit {
    /// Interpret as seconds since the UNIX epoch.
    Second,
    /// Interpret as milliseconds since the UNIX epoch.
    Millisecond,
    /// Let the parser infer units based on value length.
    #[default]
    Infer,
}

impl FromStr for TimestampUnit {
    type Err = ConfigError;
    fn from_str(value: &str) -> Result<Self, ConfigError> {
        match value.to_lowercase().as_str() {
            "s" => Ok(Self::Second),
            "ms" => Ok(Self::Millisecond),
            "infer" => Ok(Self::Infer),
            _ => Err(ConfigError::UnknownTimestampUnitString),
        }
    }
}
/// Configuration for parsing `Date`.
#[derive(Debug, Clone, Default, PartialEq)]
pub struct DateConfig {
    /// How to interpret numeric timestamps (seconds, milliseconds, etc.).
    pub timestamp_unit: TimestampUnit,
}

#[derive(Debug, Clone, Default)]
pub struct DateConfigBuilder {
    timestamp_unit: Option<TimestampUnit>,
}

impl DateConfigBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn timestamp_unit(mut self, timestamp_unit: TimestampUnit) -> Self {
        self.timestamp_unit = Some(timestamp_unit);
        self
    }
    pub fn build(self) -> DateConfig {
        DateConfig {
            timestamp_unit: self.timestamp_unit.unwrap_or_default(),
        }
    }
}

impl DateConfig {
    pub fn builder() -> DateConfigBuilder {
        DateConfigBuilder::new()
    }
}

/// Configuration for parsing `DateTime`.
#[derive(Debug, Clone, Default, PartialEq)]
pub struct DateTimeConfig {
    /// How to interpret numeric timestamps (seconds, milliseconds, etc.).
    pub timestamp_unit: TimestampUnit,
    /// Configuration used when parsing the time component.
    pub time_config: TimeConfig,
}

/// Builder for [`DateTimeConfig`].
#[derive(Debug, Clone, Default)]
pub struct DateTimeConfigBuilder {
    timestamp_unit: Option<TimestampUnit>,
    time_config: Option<TimeConfig>,
}

impl DateTimeConfigBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn timestamp_unit(mut self, timestamp_unit: TimestampUnit) -> Self {
        self.timestamp_unit = Some(timestamp_unit);
        self
    }

    pub fn time_config(mut self, time_config: TimeConfig) -> Self {
        self.time_config = Some(time_config);
        self
    }

    pub fn build(self) -> DateTimeConfig {
        DateTimeConfig {
            timestamp_unit: self.timestamp_unit.unwrap_or_default(),
            time_config: self.time_config.unwrap_or_default(),
        }
    }
}

impl DateTimeConfig {
    pub fn builder() -> DateTimeConfigBuilder {
        DateTimeConfigBuilder::new()
    }
}

#[derive(Debug, Clone, Default, PartialEq)]
pub struct TimeConfig {
    pub microseconds_precision_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
    pub unix_timestamp_offset: Option<i32>,
}

impl TimeConfig {
    pub fn builder() -> TimeConfigBuilder {
        TimeConfigBuilder::new()
    }
}

#[derive(Debug, Clone, Default)]
pub struct TimeConfigBuilder {
    microseconds_precision_overflow_behavior: Option<MicrosecondsPrecisionOverflowBehavior>,
    unix_timestamp_offset: Option<i32>,
}

impl TimeConfigBuilder {
    pub fn new() -> Self {
        Self::default()
    }
    pub fn microseconds_precision_overflow_behavior(
        mut self,
        microseconds_precision_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
    ) -> Self {
        self.microseconds_precision_overflow_behavior = Some(microseconds_precision_overflow_behavior);
        self
    }
    pub fn unix_timestamp_offset(mut self, unix_timestamp_offset: Option<i32>) -> Self {
        self.unix_timestamp_offset = unix_timestamp_offset;
        self
    }
    pub fn build(self) -> TimeConfig {
        TimeConfig {
            microseconds_precision_overflow_behavior: self.microseconds_precision_overflow_behavior.unwrap_or_default(),
            unix_timestamp_offset: self.unix_timestamp_offset,
        }
    }
}