vexillo 0.2.1

A bit flags macro.
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
137
138
139
140
141
142
143
144
145

use ::core::cmp::Ordering;
use ::core::ops::Range;
pub use vexmacro::const_binary_search_fn;
#[doc(hidden)]
pub use vexproc::flags;

mod private {
    pub trait Sealed {}
}

pub trait MustBeUnsignedInt: private::Sealed + Clone + Copy {}

macro_rules! mark_types {
    ($($type:ty),+$(,)?) => {
        $(
            impl private::Sealed for $type {}
            impl MustBeUnsignedInt for $type {}
        )*
    };
}

mark_types!(
    u8,
    u16,
    u32,
    u64,
    // TODO: It might be a good idea to exclude u128, but I can't remember why.
    u128,
    // usize is excluded due to variable width.
    // Variable width breaks serialization between targets.
    // usize,
);

pub const fn mask_type_check<MaskType: MustBeUnsignedInt>() {}

#[doc(hidden)]
#[macro_export]
macro_rules! mask_type_check {
    ($type:ty) => {
        const _: () = { $crate::internal::mask_type_check::<$type>(); };
    };
}

pub const fn const_cmp_str(lhs: &str, rhs: &str) -> Ordering {
    let min_len = if lhs.len() <= rhs.len() {
        lhs.len()
    } else {
        rhs.len()
    };
    let mut byte_index = 0usize;
    let lhs = lhs.as_bytes();
    let rhs = rhs.as_bytes();
    while byte_index < min_len {
        if lhs[byte_index] < rhs[byte_index] {
            return Ordering::Less;
        } else if lhs[byte_index] > rhs[byte_index] {
            return Ordering::Greater;
        }
        byte_index += 1;
    }
    if lhs.len() == rhs.len() {
        Ordering::Equal
    } else if lhs.len() <= rhs.len() {
        Ordering::Less
    } else {
        Ordering::Greater
    }
}

pub struct ConstCounter<T> {
    pub count: T,
}

macro_rules! counter_impls {
    ($($count_ty:ty),*$(,)?) => {
        $(
            impl ConstCounter<$count_ty> {
                #[must_use]
                #[inline(always)]
                pub const fn next(&mut self) -> $count_ty {
                    let next = self.count;
                    self.count += 1;
                    next
                }
                
                #[must_use]
                #[inline(always)]
                pub const fn incr(&mut self) {
                    _=self.next();
                }
            }
        )*
    };
}

impl<T> ConstCounter<T> {
    #[must_use]
    #[inline(always)]
    pub const fn new(start: T) -> Self {
        Self {
            count: start,
        }
    }
}

counter_impls!(
    u8,
    u16,
    u32,
    u64,
    usize,
);

#[derive(Clone, Copy)]
pub struct MaskIndex {
    pub mask: usize,
    pub bit: u32,
}

impl MaskIndex {
    #[must_use]
    #[inline(always)]
    pub const fn new(index: u32, bit_size: u32) -> Self {
        Self {
            mask: (index / bit_size) as usize,
            bit: index % bit_size,
        }
    }
}

#[must_use]
#[track_caller]
#[inline(always)]
pub const fn subslice<T>(slice: &[T], range: Range<usize>) -> &[T] {
    assert!(
        range.end <= slice.len() && range.start <= range.end,
        "Range out of bounds."
    );
    unsafe {
        ::core::slice::from_raw_parts(
            slice.as_ptr().add(range.start),
            range.end - range.start
        )
    }
}