bitpiece 2.5.0

bitfields for rust
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

#[macro_export]
macro_rules! bitpiece_check_const_assert_bits_eq {
    {$t: ty, $a: expr, $b: expr} => {
        if !<$t as $crate::BitPiece>::Converter::const_eq($a, $b) {
            panic!()
        }
    };
}

#[macro_export]
macro_rules! bitpiece_check_gen_values_to_check {
    ($t: ty, $supports_any_bit_pattern: literal) => {{
        type Converter = <$t as $crate::BitPiece>::Converter;

        const MAX_VAL: u64 = Converter::to_bits(<$t as $crate::BitPiece>::ONES) as u64;

        const VALUES_TO_CHECK: &[$t] = if $supports_any_bit_pattern {
            &[
                <$t as $crate::BitPiece>::ZEROES,
                <$t as $crate::BitPiece>::ONES,
                <$t as $crate::BitPiece>::MIN,
                <$t as $crate::BitPiece>::MAX,
                Converter::from_bits(
                    (0x31d6b601fb4faeb8u64 & MAX_VAL) as <$t as $crate::BitPiece>::Bits,
                ),
                Converter::from_bits(
                    (0xe9bd79bf8ca99263u64 & MAX_VAL) as <$t as $crate::BitPiece>::Bits,
                ),
            ]
        } else {
            &[
                <$t as $crate::BitPiece>::ZEROES,
                <$t as $crate::BitPiece>::ONES,
                <$t as $crate::BitPiece>::MIN,
                <$t as $crate::BitPiece>::MAX,
            ]
        };
        VALUES_TO_CHECK
    }};
}

#[macro_export]
macro_rules! bitpiece_check_do_for_each_value {
    {$t: ty, $value_var_name: ident, $supports_any_bit_pattern: literal, $body: block} => {
        let values_to_check = $crate::bitpiece_check_gen_values_to_check!{$t, $supports_any_bit_pattern};
        // can't use qualified path for `const_for`, must instead import it, since the `const_for` macro calls itself
        // in a non-hygiene way inside of its body.
        use $crate::const_for;
        const_for!(i in 0..values_to_check.len() => {
            let $value_var_name = values_to_check[i];
            $body
        });
    };
}
#[macro_export]
macro_rules! bitpiece_check_base_impl {
    {$t: ty, $supports_any_bit_pattern: literal} => {
        const _: () = {
            type Converter = <$t as $crate::BitPiece>::Converter;
            $crate::bitpiece_check_do_for_each_value!($t, value, $supports_any_bit_pattern, {
                $crate::bitpiece_check_const_assert_bits_eq!{
                    $t,
                    value,
                    Converter::from_bits(Converter::to_bits(value))
                };
                $crate::bitpiece_check_const_assert_bits_eq!{
                    $t,
                    value,
                    Converter::try_from_bits(Converter::to_bits(value)).unwrap()
                };
            });
        };
    };
}

#[macro_export]
macro_rules! bitpiece_check_fields_impl {
    {$t: ty, $supports_any_bit_pattern: literal} => {
        const _: () = {
            type Converter = <$t as $crate::BitPiece>::Converter;
            $crate::bitpiece_check_do_for_each_value!($t, value, $supports_any_bit_pattern, {
                $crate::bitpiece_check_const_assert_bits_eq!(
                    $t,
                    value,
                    Converter::from_fields(Converter::to_fields(value))
                );
            });
        };
    };
}

#[macro_export]
macro_rules! bitpiece_check_mut_impl {
    {$t: ty, $supports_any_bit_pattern: literal} => {
        const _: () = {
            type Converter = <$t as $crate::BitPiece>::Converter;
            type MutRefTy<'a> = <$t as $crate::BitPieceHasMutRef>::MutRef<'a>;
            $crate::bitpiece_check_do_for_each_value!($t, value, $supports_any_bit_pattern, {
                $crate::bitpiece_check_do_for_each_value!($t, value2, $supports_any_bit_pattern, {
                    let mut storage = Converter::to_bits(value) as u64;
                    let mut mut_ref = MutRefTy::new(BitPieceStorageMutRef::U64(&mut storage), 0);
                    $crate::bitpiece_check_const_assert_bits_eq!(
                        $t,
                        value,
                        mut_ref.get()
                    );
                    mut_ref.set(value2);
                    $crate::bitpiece_check_const_assert_bits_eq!(
                        $t,
                        value2,
                        mut_ref.get()
                    );
                });
            });
        };
    };
}

#[macro_export]
macro_rules! bitpiece_check_full_impl {
    {$t: ty, $supports_any_bit_pattern: literal} => {
        #[cfg(test)]
        const _: () = {
            bitpiece_check_base_impl! { $t, $supports_any_bit_pattern }
            bitpiece_check_fields_impl! { $t, $supports_any_bit_pattern }
            bitpiece_check_mut_impl! { $t, $supports_any_bit_pattern }
        };
    };
}