nuclear-router 0.0.1

A simple and fast router
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

#![allow(unsafe_code)]

use std::{mem, slice};

pub unsafe trait BitStorage: Sized {
    fn bit_size() -> usize {
        mem::size_of::<Self>() * 8
    }

    fn as_bytes(&self) -> &[u8] {
        unsafe { slice::from_raw_parts(self as *const _ as *const u8, Self::bit_size() / 8) }
    }
    fn as_bytes_mut(&mut self) -> &mut [u8] {
        unsafe { slice::from_raw_parts_mut(self as *mut _ as *mut u8, Self::bit_size() / 8) }
    }
}

unsafe impl BitStorage for [u128; 4] {}
unsafe impl BitStorage for u128 {}

#[derive(Debug, Clone)]
pub struct FixedBitSet<S: BitStorage> {
    buf: S,
}

impl<S: BitStorage> FixedBitSet<S> {
    pub fn zero() -> Self {
        Self {
            buf: unsafe { mem::zeroed() },
        }
    }

    pub fn one() -> Self {
        let mut set = Self {
            buf: unsafe { mem::MaybeUninit::uninit().assume_init() },
        };
        set.buf
            .as_bytes_mut()
            .iter_mut()
            .for_each(|x| *x = u8::max_value());
        set
    }

    pub fn intersect_with(&mut self, other: &Self) {
        self.buf
            .as_bytes_mut()
            .iter_mut()
            .zip(other.buf.as_bytes().iter())
            .for_each(|(lhs, rhs)| *lhs &= rhs)
    }

    pub fn get_inner(&self) -> &S {
        &self.buf
    }

    pub fn set(&mut self, index: usize, bit: bool) {
        let idx = index / 8;
        let offset: u8 = (index % 8) as _;
        let mask = (bit as u8) << offset;
        let bytes = self.buf.as_bytes_mut();
        let pos: &mut u8 = match bytes.get_mut(idx) {
            Some(pos) => pos,
            None => panic!(
                "bitset index out of bound: index = {}, bound = {}",
                index,
                S::bit_size()
            ),
        };
        *pos |= mask
    }

    pub fn is_zero(&self) -> bool {
        self.buf.as_bytes().iter().all(|&x| x == 0)
    }

    pub fn iter_ones(&self) -> impl Iterator<Item = usize> + '_ {
        self.buf
            .as_bytes()
            .iter()
            .flat_map(|&x| crate::table::TABLE[x as usize])
            .cloned()
    }
}