bit-bounds 1.0.0

Helper traits for const generic bitwise bounds
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

//!
//! Helper traits for const generic bounds
//!
//! ```rust
//! #![allow(incomplete_features)]
//! #![feature(generic_const_exprs)]
//!
//! use bit_bounds::{IsPowerOf2, usize::*};
//!
//! struct Buffer<const N: usize> {
//!   inner: [usize; N],
//! }
//!
//! impl<const N: usize> Buffer<N>
//! where
//!   Int<N>: IsPowerOf2
//! {
//!   pub const fn new() -> Self {
//!     Buffer { inner: [0; N] }
//!   }
//! }
//!
//! fn extract_index<const N: usize>(counter: usize) -> usize
//! where
//!   Int<N>: IsPowerOf2,
//!   Int<N>: BitsAllClear<{ (u32::MAX as usize) << 32 }>,
//! {
//!   (counter >> 32) & (N - 1)
//! }
//! ```

#![allow(incomplete_features)]
#![feature(generic_const_exprs)]

#![no_std]

use const_assert::{Assert, IsTrue};

pub trait IsPowerOf2 {}

macro_rules! define_bit_bounds {
  ($ty:ident) => {
    pub mod $ty {
      use super::*;
      pub trait BitsAllSet<const M: $ty> {}
      pub trait BitsAnySet<const M: $ty> {}
      pub trait BitsAllClear<const M: $ty> {}
      pub trait BitsAnyClear<const M: $ty> {}

      pub struct Int<const N: $ty>;
      impl<const N: $ty> IsPowerOf2 for Int<N> where Assert<{ N == N.next_power_of_two() }>: IsTrue {}
      impl<const N: $ty, const M: $ty> BitsAllSet<M> for Int<N> where Assert<{ N & M == M }>: IsTrue {}
      impl<const N: $ty, const M: $ty> BitsAnySet<M> for Int<N> where Assert<{ N & M != 0 }>: IsTrue {}
      impl<const N: $ty, const M: $ty> BitsAllClear<M> for Int<N> where Assert<{ (N ^ M) & M == M }>: IsTrue {}
      impl<const N: $ty, const M: $ty> BitsAnyClear<M> for Int<N> where Assert<{ N & M != M }>: IsTrue {}
    }
  };
}

define_bit_bounds!(u8);
define_bit_bounds!(u16);
define_bit_bounds!(u32);
define_bit_bounds!(u64);
define_bit_bounds!(u128);
define_bit_bounds!(usize);