simple-datetime-rs 0.3.0

A high-performance, lightweight date and time library for Rust with dramatically faster parsing, memory-efficient operations, and chrono-compatible formatting
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

pub fn find_any<'a, 'b, T: PartialEq>(
    input: &'a [T],
    check_set: &'b [T],
) -> Option<(&'a T, usize)> {
    for i in 0..input.len() {
        if value_in(&input[i], check_set) {
            return Some((&input[i], i));
        }
    }
    None
}
#[inline]
pub fn value_in<T: PartialEq>(value: &T, set: &[T]) -> bool {
    for v in set {
        if v == value {
            return true;
        }
    }
    false
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_value_in() {
        let set = [1, 2, 3, 4, 5];

        assert!(value_in(&1, &set));
        assert!(value_in(&3, &set));
        assert!(value_in(&5, &set));

        assert!(!value_in(&0, &set));
        assert!(!value_in(&6, &set));
        assert!(!value_in(&10, &set));

        let empty_set: [i32; 0] = [];
        assert!(!value_in(&1, &empty_set));
    }

    #[test]
    fn test_value_in_strings() {
        let set = ["hello", "world", "test"];

        assert!(value_in(&"hello", &set));
        assert!(value_in(&"world", &set));
        assert!(value_in(&"test", &set));
        assert!(!value_in(&"not_in_set", &set));
    }

    #[test]
    fn test_find_any() {
        let input = [1, 2, 3, 4, 5, 6];
        let check_set = [3, 7, 9];

        let result = find_any(&input, &check_set);
        assert!(result.is_some());
        let (value, index) = result.unwrap();
        assert_eq!(*value, 3);
        assert_eq!(index, 2);
    }

    #[test]
    fn test_find_any_not_found() {
        let input = [1, 2, 3, 4, 5];
        let check_set = [6, 7, 8];

        let result = find_any(&input, &check_set);
        assert!(result.is_none());
    }

    #[test]
    fn test_find_any_empty_input() {
        let input: [i32; 0] = [];
        let check_set = [1, 2, 3];

        let result = find_any(&input, &check_set);
        assert!(result.is_none());
    }

    #[test]
    fn test_find_any_empty_check_set() {
        let input = [1, 2, 3, 4, 5];
        let check_set: [i32; 0] = [];

        let result = find_any(&input, &check_set);
        assert!(result.is_none());
    }

    #[test]
    fn test_find_any_first_match() {
        let input = [1, 2, 3, 4, 5];
        let check_set = [2, 3, 4];

        let result = find_any(&input, &check_set);
        assert!(result.is_some());
        let (value, index) = result.unwrap();
        assert_eq!(*value, 2);
        assert_eq!(index, 1);
    }

    #[test]
    fn test_find_any_strings() {
        let input = ["hello", "world", "test", "rust"];
        let check_set = ["test", "python"];

        let result = find_any(&input, &check_set);
        assert!(result.is_some());
        let (value, index) = result.unwrap();
        assert_eq!(*value, "test");
        assert_eq!(index, 2);
    }
}