lr_trie 4.1.5

Left-Right trie is trie capable of mapping any string to any string.
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

#![allow(dead_code)] // leveraged by consumers
use std::isize;

pub fn address<T>(t: &T) -> usize {
    (t as *const T) as usize
}

pub fn vec_of_cap_or<F, T>(cap: usize, f: F, #[cfg(test)] grade: &mut usize) -> Vec<T>
where
    F: FnOnce() -> Vec<T>,
{
    let max_cap = isize::MAX as usize;
    if cap <= max_cap {
        #[cfg(test)]
        set_grade(grade, 1);

        let size = size_of::<T>();
        if let Some(b) = usize::checked_mul(size, cap) {
            #[cfg(test)]
            set_grade(grade, 2);

            if b <= max_cap {
                #[cfg(test)]
                set_grade(grade, 3);

                return Vec::<T>::with_capacity(cap);
            }
        }
    }

    return f();

    #[cfg(test)]
    const fn set_grade(grade: &mut usize, g: usize) {
        *grade = g;
    }
}

#[cfg(test)]
#[cfg(feature = "rh-aide-tests")]
mod tests_of_unit {
    use super::*;

    #[test]
    fn address_test() {
        let addr = 333;
        let ptr = addr as *const Vec<usize>;
        let _ref = unsafe { ptr.as_ref() }.unwrap();

        let test = address(_ref);
        assert_eq!(addr, test);
    }

    mod vec_of_cap_or {
        use super::super::vec_of_cap_or;

        #[test]
        fn within_max_capicity() {
            let max_cap = isize::MAX as usize;
            let mut grade = 0;
            let vec: Vec<u8> = vec_of_cap_or(max_cap, || Vec::with_capacity(0), &mut grade);
            assert_eq!(true, vec.capacity() == max_cap);
            assert_eq!(3, grade);
        }

        #[test]
        fn over_max_capicity_a() {
            let over_max_cap = (isize::MAX as usize) + 1;
            let mut grade = 0;
            let vec: Vec<u8> = vec_of_cap_or(over_max_cap, || Vec::with_capacity(0), &mut grade);
            assert_eq!(true, vec.capacity() == 0);
            assert_eq!(0, grade);
        }

        #[test]
        fn over_max_capicity_b() {
            let cap = isize::MAX as usize;
            let mut grade = 0;
            let vec: Vec<u64> = vec_of_cap_or(cap, || Vec::with_capacity(0), &mut grade);
            assert_eq!(true, vec.capacity() == 0);

            assert_eq!(1, grade);
        }

        #[test]
        fn over_max_capicity_c() {
            let cap = isize::MAX as usize;
            let mut grade = 0;
            let vec: Vec<u16> = vec_of_cap_or(cap, || Vec::with_capacity(0), &mut grade);
            assert_eq!(true, vec.capacity() == 0);

            assert_eq!(2, grade);
        }
    }
}

// cargo fmt & cargo test --release --features rh-aide-tests