range_checker 0.1.0

derive-macro crate aimed to provide declarative bounds checking and filtering for structure.
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

fn main() {
    let mut a = TestStruct {
        v0: 20,
        v1: -3.0,
        v3: 1,
        ..Default::default()
    };

    // dbg!(range_checker::Check::check(&a));
    // dbg!(range_checker::CheckVerbose::check(&a));

    let _ = dbg!(a.check_with_fallback());

    dbg!(&a);

    let _ = dbg!(a.check());
}

use range_checker::Check;
use range_checker::CheckVerbose;

#[derive(Debug, Default, Check)]
struct TestStruct {
    #[range(..=5)]
    #[range(20..)]
    #[filter(|x| x % 2 != 0)]
    #[fallback(255)]
    pub v0: u8,
    #[range(-1.0..=5.0)]
    #[fallback(3.1)]
    v1: f32,
    #[filter(|x| x > 8.0)]
    #[fallback(9.9)]
    v2: f64,
    #[range(..-1)]
    #[fallback(|x| {println!("test fallback closure."); x - 5})]
    v3: isize,
}

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

    #[derive(Debug, Default, Check)]
    struct TestCheckStruct {
        #[range(..=5)]
        #[range(20..)]
        #[filter(|x| x % 2 != 0)]
        #[fallback(255)]
        pub v0: u8,
        #[range(-1.0..=5.0)]
        #[fallback(3.1)]
        v1: f32,
        #[filter(|x| x > 8.0)]
        #[fallback(9.9)]
        v2: f64,
        #[range(..-1)]
        #[fallback(|x| x - 5)]
        v3: isize,
    }

    #[test]
    fn basic_check_Check() {
        let mut a = TestCheckStruct {
            v0: 20,
            v1: -3.0,
            v3: 1,
            ..Default::default()
        };
    
        let _ = dbg!(a.check_with_fallback());
    
        dbg!(&a);
    
        let _ = dbg!(a.check());
    }

    #[derive(Debug, Default, CheckVerbose)]
    struct TestCheckVerboseStruct {
        #[range(..=5)]
        #[range(20..)]
        #[filter(|x| x % 2 != 0)]
        #[fallback(255)]
        pub v0: u8,
        #[range(-1.0..=5.0)]
        #[fallback(3.1)]
        v1: f32,
        #[filter(|x| x > 8.0)]
        #[fallback(9.9)]
        v2: f64,
        #[range(..-1)]
        #[fallback(|x| x - 5)]
        v3: isize,
    }

    #[test]
    fn basic_check_CheckVerbose() {
        let mut a = TestCheckVerboseStruct {
            v0: 20,
            v1: -3.0,
            v3: 1,
            ..Default::default()
        };
    
        let _ = dbg!(a.check_with_fallback());
    
        dbg!(&a);
    
        let _ = dbg!(a.check());
    }
}