sac13 0.1.1

The reference implementation for the SAC13 calendar system.
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

use core::num::NonZeroU8;

use crate::iterhelp::ByteSliceIter;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
/// A separator between date components in their textual representation. At most six ASCII characters long.
pub struct DateComponentSeparator {
    bytes: [u8; 6],
    len: NonZeroU8,
}

impl DateComponentSeparator {
    /// Length of the separator, in characters and bytes.
    #[allow(clippy::len_without_is_empty)] // It's never empty!
    pub fn len(&self) -> NonZeroU8 {
        self.len
    }

    /// Slice to raw separator data.
    pub fn as_bytes(&self) -> &[u8] {
        &self.bytes[0..self.len.get() as usize]
    }

    /// Separator as an ASCII str slice.
    pub fn as_str(&self) -> &str {
        str::from_utf8(self.as_bytes()).expect("Separator is ASCII only")
    }

    pub(crate) fn is_single_slash(&self) -> bool {
        let mut slash_found = false;

        for i in 0..self.len.get() as usize {
            let x = self.bytes[i];

            if x == b' ' {
                // ignore spaces
                continue;
            }

            if x != b'/' {
                // found something that was not a space and not a slash
                return false;
            }

            if slash_found {
                // there already was a slash so it can no longe be a "single_slash"
                return false;
            }

            slash_found = true;
        }

        true
    }

    pub(crate) fn parse(i: &mut ByteSliceIter) -> Option<Self> {
        let mut len: usize = 0;
        let mut data: [u8; 6] = [0; 6];

        loop {
            let Some(peeked) = i.peek() else {
                // reached the end, so we return
                break;
            };

            if peeked.is_ascii_alphanumeric() {
                // alphanumerics are not allowed in separators because
                // they represent component digits
                break;
            }

            if peeked == b'-'
                && len != 0
                && let Some(x) = i.peek_n(1)
                && x.is_ascii_alphanumeric()
            {
                break;
            }

            // Reached max size separator so we end parsing by returning None.
            if len >= data.len() {
                return None;
            }

            // if everything works out store data and continue
            data[len] = peeked;
            len += 1;

            _ = i.next();
        }

        Some(Self {
            len: NonZeroU8::new(len as u8)?,
            bytes: data,
        })
    }
}