deep-time 0.1.0-beta.30

High-precision, no-std, no-alloc date-time library, leap-seconds, time scales, relativistic time, and a powerful date & duration parser
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
154

use crate::{Dt, MAX_YEAR, MIN_YEAR, Parts, Scale};

/// 6-digit legacy date: YYMMDD (e.g. "240315")
#[inline]
pub(crate) fn parse_yymmdd(input: &str) -> Option<Dt> {
    let parsed = Parts::from_strptime("%y%m%d", input, true, true, false).ok()?;
    parsed.to_dt().ok()
}

/// Parses year-month (no day) with flexible separators:
/// - year-first: `"2024-03"`, `"2024/3"`, `"2024.03"`, `"-2024-03"`, `"+2024-05"`, …
/// - month-first: `"03/2024"`, `"3-2024"`, `"12.2024"` (4-digit year only)
///
/// Day defaults to the 1st. Month-first requires a 4-digit year so `"03/24"` stays
/// ambiguous/rejected rather than guessing century.
pub(crate) fn parse_yyyy_mm(bytes: &[u8]) -> Option<Dt> {
    parse_yyyy_mm_year_first(bytes).or_else(|| parse_mm_yyyy(bytes))
}

#[inline]
fn ymd_first_of_month(year: i32, month: u32) -> Option<Dt> {
    if month == 0 || month > 12 {
        return None;
    }
    if !(MIN_YEAR..=MAX_YEAR).contains(&year) {
        return None;
    }
    Some(Dt::from_ymd(
        year as i64,
        month as u8,
        1,
        Scale::UTC,
        0,
        0,
        0,
        0,
    ))
}

/// Year-first: optional sign, year digits, separator, 1–2 digit month.
fn parse_yyyy_mm_year_first(bytes: &[u8]) -> Option<Dt> {
    let len = bytes.len();

    let (sign, mut pos) = match bytes.first() {
        Some(b'+') => (1i32, 1),
        Some(b'-') => (-1i32, 1),
        _ => (1i32, 0),
    };

    let mut year = 0i32;
    let year_start = pos;
    while pos < len && bytes[pos].is_ascii_digit() {
        year = year * 10 + (bytes[pos] - b'0') as i32;
        pos += 1;
    }
    if pos == year_start || pos == len {
        return None;
    }

    if !matches!(bytes.get(pos), Some(b'-' | b'/' | b'.')) {
        return None;
    }
    pos += 1;

    let month = match len - pos {
        1 => {
            let b = bytes[pos];
            if !b.is_ascii_digit() {
                return None;
            }
            (b - b'0') as u32
        }
        2 => {
            let b1 = bytes[pos];
            let b2 = bytes[pos + 1];
            if !b1.is_ascii_digit() || !b2.is_ascii_digit() {
                return None;
            }
            10 * (b1 - b'0') as u32 + (b2 - b'0') as u32
        }
        _ => return None,
    };

    ymd_first_of_month(year * sign, month)
}

/// Month-first: 1–2 digit month, separator, exactly 4 digit year.
fn parse_mm_yyyy(bytes: &[u8]) -> Option<Dt> {
    let len = bytes.len();
    let mut pos = 0usize;

    let month_start = pos;
    while pos < len && bytes[pos].is_ascii_digit() {
        pos += 1;
        if pos - month_start > 2 {
            return None;
        }
    }
    let month_digits = pos - month_start;
    if month_digits == 0 {
        return None;
    }
    let month = match month_digits {
        1 => (bytes[month_start] - b'0') as u32,
        2 => 10 * (bytes[month_start] - b'0') as u32 + (bytes[month_start + 1] - b'0') as u32,
        _ => return None,
    };

    if !matches!(bytes.get(pos), Some(b'-' | b'/' | b'.')) {
        return None;
    }
    pos += 1;

    // Exactly four year digits keeps MM/YY out of this path.
    if len - pos != 4 {
        return None;
    }
    let mut year = 0i32;
    for &b in &bytes[pos..pos + 4] {
        if !b.is_ascii_digit() {
            return None;
        }
        year = year * 10 + (b - b'0') as i32;
    }

    ymd_first_of_month(year, month)
}

/// 6-digit year-month: "202403" or "-202403"
pub(crate) fn parse_yyyymm(s: &str) -> Option<Dt> {
    let (y_str, m_str) = if let Some(rest) = s.strip_prefix('-') {
        if rest.len() != 6 {
            return None;
        }
        (&rest[0..4], &rest[4..6])
    } else {
        if s.len() != 6 {
            return None;
        }
        (&s[0..4], &s[4..6])
    };

    if let (Ok(mut y), Ok(m)) = (y_str.parse::<i32>(), m_str.parse::<u32>()) {
        if s.starts_with('-') {
            y = -y;
        }
        if (1..=12).contains(&m) && (crate::MIN_YEAR..=crate::MAX_YEAR).contains(&y) {
            let parsed =
                Parts::from_strptime("%Y%m", s.trim_start_matches('-'), true, true, true).ok()?;
            return parsed.to_dt().ok();
        }
    }
    None
}