rust container for mapping to next unset bit.

bitunset.rs

fn bit_mask_index(mask:u64) -> Option<usize> {
    match mask {
        0 => None,
        1 => Some(0),
        2 => Some(1),
        4 => Some(2),
        8 => Some(3),
        16 => Some(4),
        32 => Some(5),
        64 => Some(6),
        128 => Some(7),
        256 => Some(8),
        512 => Some(9),
        1024 => Some(10),
        2048 => Some(11),
        4096 => Some(12),
        8192 => Some(13),
        16384 => Some(14),
        32768 => Some(15),
        65536 => Some(16),
        131072 => Some(17),
        262144 => Some(18),
        524288 => Some(19),
        1048576 => Some(20),
        2097152 => Some(21),
        4194304 => Some(22),
        8388608 => Some(23),
        16777216 => Some(24),
        33554432 => Some(25),
        67108864 => Some(26),
        134217728 => Some(27),
        268435456 => Some(28),
        536870912 => Some(29),
        1073741824 => Some(30),
        2147483648 => Some(31),
        4294967296 => Some(32),
        8589934592 => Some(33),
        17179869184 => Some(34),
        34359738368 => Some(35),
        68719476736 => Some(36),
        137438953472 => Some(37),
        274877906944 => Some(38),
        549755813888 => Some(39),
        1099511627776 => Some(40),
        2199023255552 => Some(41),
        4398046511104 => Some(42),
        8796093022208 => Some(43),
        17592186044416 => Some(44),
        35184372088832 => Some(45),
        70368744177664 => Some(46),
        140737488355328 => Some(47),
        281474976710656 => Some(48),
        562949953421312 => Some(49),
        1125899906842624 => Some(50),
        2251799813685248 => Some(51),
        4503599627370496 => Some(52),
        9007199254740992 => Some(53),
        18014398509481984 => Some(54),
        36028797018963968 => Some(55),
        72057594037927936 => Some(56),
        144115188075855872 => Some(57),
        288230376151711744 => Some(58),
        576460752303423488 => Some(59),
        1152921504606846976 => Some(60),
        2305843009213693952 => Some(61),
        4611686018427387904 => Some(62),
        9223372036854775808 => Some(63),
        _ => panic!("Unexpected mask {}", mask)
    }
}

fn find_unset_bit(num:u64) -> u64 {
    !num & (num + 1)
}

fn find_first_set_bit(num:u64) -> u64 {
    num & (-(num as i64) as u64)
}

#[derive(Copy, Debug, Clone)]
struct BitPlace(u64);

impl BitPlace {
    fn new(num:u64) -> Self {
        BitPlace(num)
    }
    
    fn get_unset(&self) -> u64 {
        find_unset_bit(self.0)
    }
    
    fn get_set(&self) -> u64 {
        find_first_set_bit(self.0)
    }
    
    fn take_bit(&mut self, mask:u64) {
        self.0 |= mask;
    }
}

struct BitSpan(BitPlace, [ BitPlace ; 64 ]);

impl BitSpan {
    fn new() -> Self {
        BitSpan(BitPlace::new(0), [BitPlace::new(0); 64])
    }
}

fn main() {
   println!("{}", find_unset_bit(0b0101));
   println!("{}", find_first_set_bit(0b0100));
   println!("{}", i64::MAX as u64);
}