bitit 0.1.2

Bitwise iteration over integers.
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
130
131
132
133
134
135
136

use std::{
    mem::size_of,
    ops::{
        BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not, Shl, ShlAssign, Shr,
        ShrAssign,
    },
};

/// A pure binary integer (`u8`, `i8`, `u16`, etc.).
pub trait Binary:
    Sized
    + Copy
    + PartialEq
    + Eq
    + BitOr<Output = Self>
    + BitAnd<Output = Self>
    + BitXor<Output = Self>
    + Not<Output = Self>
    + Shl<u32, Output = Self>
    + Shr<u32, Output = Self>
    + BitOrAssign
    + BitAndAssign
    + BitXorAssign
    + ShlAssign<u32>
    + ShrAssign<u32>
{
    /// The max bit index of the value starting from zero.
    /// Same as the number of bits minus one.
    const MAX_BIT_IDX: u32;

    /// All bits zero.
    const ZERO: Self;

    /// All bits one.
    const FULL: Self;

    /// Only the least significant bit is one.
    const ONE: Self;

    /// Only the most significant bit is one.
    const TOP: Self;

    /// Returns `true` if the value has at least one bit set to 0.
    fn has_zero(self) -> bool {
        self != Self::FULL
    }

    /// Returns `true` if the value has at least one bit set to 1.
    fn has_one(self) -> bool {
        self != Self::ZERO
    }

    /// Returns the number of trailing 0s.
    fn trailing_zeros(self) -> u32;

    /// Returns the number of trailing 1s.
    fn trailing_ones(self) -> u32;

    /// Returns the number of leading 0s.
    fn leading_zeros(self) -> u32;

    /// Returns the number of leading 1s.
    fn leading_ones(self) -> u32;

    /// Returns the value's least significant 0-bit, or `0` if there is none.
    fn lowest_zero(self) -> Self;

    /// Returns the value's least significant 1-bit, or `0` if there is none.
    fn lowest_one(self) -> Self;

    /// Returns the value's most significant 0-bit, or `0` if there is none.
    fn highest_zero(self) -> Self;

    /// Returns the value's most significant 1-bit, or `0` if there is none.
    fn highest_one(self) -> Self;
}

macro_rules! impl_binary {
    ($($t:ident),*) => {
        $(
            impl Binary for $t {
                const MAX_BIT_IDX: u32 = (size_of::<Self>() as u32 * 8) - 1;

                const ZERO: Self = 0 as _;

                const FULL: Self = !Self::ZERO;

                const ONE: Self = 1 as _;

                const TOP: Self = Self::ONE << Self::MAX_BIT_IDX;

                #[inline(always)]
                fn trailing_zeros(self) -> u32 {
                    self.trailing_zeros()
                }

                #[inline(always)]
                fn trailing_ones(self) -> u32 {
                    self.trailing_ones()
                }

                #[inline(always)]
                fn leading_zeros(self) -> u32 {
                    self.leading_zeros()
                }

                #[inline(always)]
                fn leading_ones(self) -> u32 {
                    self.leading_ones()
                }

                #[inline(always)]
                fn lowest_zero(self) -> Self {
                    Self::ONE.unbounded_shl(self.trailing_ones())
                }

                #[inline(always)]
                fn lowest_one(self) -> Self {
                    Self::ONE.unbounded_shl(self.trailing_zeros())
                }

                #[inline(always)]
                fn highest_zero(self) -> Self {
                    Self::TOP.unbounded_shr(self.leading_ones())
                }

                #[inline(always)]
                fn highest_one(self) -> Self {
                    Self::TOP.unbounded_shr(self.leading_zeros())
                }
            }
        )*
    };
}

impl_binary!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, usize, isize);