Compiler Explorer

Source code

use std::time::Duration;
/// Parse a string (as read directly from disk, so a [u8]) as decimal
/// seconds and nanoseconds since the Unix epoch, into a Duration object.
pub fn parse_decimal_timestamp(data: &[u8]) -> Option<(u64, u32)> {
        // An f64 can only represent Unix timestamps with full nanosecond
    // precision if they are within ±2**53 nanoseconds of
    // 1970-01-01T00:00:00.000000000Z.  This is a smaller range than
    // you might expect: only from 6pm on September 18, 1969 until 6am
    // on April 15, 1970.  So, we cannot use f64 as an intermediary here.

let mut secs: u64 = 0;
    let mut nanos: u32 = 0;

'parse: {
        let mut chars_iter = data.iter().copied();

// Parse full seconds
        'seconds: {
            for c in chars_iter.by_ref() {
                match c {
                    digit @ b'0'..=b'9' => {
                        secs = secs.checked_mul(10)?.checked_add((digit - b'0').into())?
                    }
                    b'.' => break 'seconds, // Jump to nanoseconds parse code.
                    _ => return None,
                }
            }

// Skip nanosecond parse code, because no `.` was encountered.
            break 'parse;
        }

// Parse nanoseconds
        let mut decimals_left: u32 = 9;
        while decimals_left > 0 {
            match chars_iter.next() {
                Some(digit @ b'0'..=b'9') => {
                    nanos = nanos.checked_mul(10)?.checked_add((digit - b'0').into())?;
                    decimals_left -= 1;
                }
                Some(_) => return None,
                None => {
                    nanos *= 10_u32.pow(decimals_left);
                    break 'parse;
                }
            }
        }

// Validate remaining nanoseconds
        if !chars_iter.all(|c| c.is_ascii_digit()) {
            return None;
        }
    }

Some((secs, nanos))
}