typekin 0.8.0

new-type pattern with concept of Friends borrowed from c++, no-std and fully const
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

#![allow(dead_code)]

#[cfg(test)]
mod test {
    #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
    #[repr(u8)]
    #[typekin::bitflag(
        friends = [u8(conv = self, level = [Bit])],
        integral = [
            friends = [u8(conv = self, level = [Full])],
            konst = false,
        ],
    )]
    pub enum Thingy {
        FirstThing = 0,
        ReadThing = 0b001,
        WritersBlock = 0b010,
        Execute = 0b100,
    }

    #[test]
    fn value_makes_from_borrowed_integral_friend() {
        let raw = 0b011u8;
        let it = ThingyValue::of(&raw);
        assert_eq!(it.raw(), raw);
    }

    #[test]
    fn value_makes_from_mutably_borrowed_integral_friend() {
        let mut raw = 0b011u8;
        let it = ThingyValue::of(&mut raw);
        assert_eq!(it.raw(), raw);
        assert_eq!(raw, 0b011u8);
    }

    #[test]
    fn enum_left_bitwise_accepts_borrowed_generated_value_friend() {
        let rhs = Thingy::WritersBlock.into_value();
        let it = Thingy::ReadThing | &rhs;
        assert_eq!(it.raw(), 0b011);
    }

    #[test]
    fn enum_left_bitwise_accepts_mutably_borrowed_generated_value_friend() {
        let mut rhs = Thingy::WritersBlock.into_value();
        let it = Thingy::ReadThing | &mut rhs;
        assert_eq!(it.raw(), 0b011);
        assert_eq!(rhs.raw(), 0b010);
    }

    #[test]
    fn enum_left_bitwise_accepts_borrowed_configured_friend() {
        let rhs = 0b010u8;
        let it = Thingy::ReadThing | &rhs;
        assert_eq!(it.raw(), 0b011);
    }

    #[test]
    fn value_left_bitwise_accepts_borrowed_generated_enum_friend() {
        let value = Thingy::ReadThing.into_value();
        let it = value | &Thingy::WritersBlock;
        assert_eq!(it.raw(), 0b011);
    }
}

#[cfg(test)]
mod cfg_test_value_type_name_suffix {
    #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
    #[repr(u8)]
    #[typekin::bitflag(
        value_name_suffix = "Holder",
        integral = [
            konst = false,
        ],
    )]
    pub enum Thingy {
        FirstThing = 0,
        ReadThing = 0b001,
        WritersBlock = 0b010,
        Execute = 0b100,
    }

    #[test]
    fn validate_flag_value_name_suffix() {
        let _ = ThingyHolder::all();
    }
}

#[cfg(test)]
mod cfg_test_value_type_name {
    #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
    #[repr(u8)]
    #[typekin::bitflag(
        value_name = "Thingies",
        value_name_suffix = "",
        integral = [
            konst = false,
        ],
    )]
    pub enum Thingy {
        FirstThing = 0,
        ReadThing = 0b001,
        WritersBlock = 0b010,
        Execute = 0b100,
    }

    #[test]
    fn validate_flag_value_name() {
        let _ = Thingies::all();
    }
}