cbitmap 0.3.2

A conventional, compact and core (no_std) bitmap.
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

//! Implementations of [`From`] and [`Into`] for `Bitmap`, `BitRef` and `BitRefMut`.
//!
//! Allowing converting between them and a set of native types like [`bool`].

use crate::bitmap::*;

impl<const BYTES: usize> Default for Bitmap<BYTES> {
    /// Default bitmap. All the bits are set to 0.
    fn default() -> Self {
        Bitmap::<BYTES>::new()
    }
}

// Into

impl<const BYTES: usize> Into<[u8; BYTES]> for Bitmap<BYTES> {
    /// Give the inner array of bitmap.
    ///
    /// # See
    /// [`Bitmap`].
    fn into(self) -> [u8; BYTES] {
        match BYTES == 0 {
            true => [0; BYTES],
            false => self.bits,
        }
    }
}

impl<'map, const BYTES: usize> Into<bool> for BitRef<'map, BYTES> {
    /// Give the value of the referenced bit.
    ///
    /// # See
    /// [`BitRef`].
    fn into(self) -> bool {
        self.value
    }
}

impl<'map, const BYTES: usize> Into<bool> for BitRefMut<'map, BYTES> {
    /// Give the value of the reverence bit.
    /// # See
    /// [`BitRefMut`].
    fn into(self) -> bool {
        self.value
    }
}
// From

impl<const BYTES: usize, const N: usize> From<[u8; N]> for Bitmap<BYTES> {
    /// Convert a array `[u8; N]` into `Bitmap<BYTES>`.
    ///
    /// The generics `N` and `BYTES` has not to be equal.
    /// If `N < BYTES`, the bitmap will have `BYTES - N`
    /// bytes of leading zero.
    ///
    /// # Examples
    /// ```
    /// use cbitmap::bitmap::*;
    ///
    /// let map = Bitmap::<2>::from([0u8; 2]);
    /// ```
    /// 
    /// There are also aliases for integer types:
    /// ```
    /// use cbitmap::bitmap::*;
    /// 
    /// let map = Bitmap::<1>::from(0u8);
    /// ```
    fn from(value: [u8; N]) -> Self {
        match BYTES == 0 {
            true => Bitmap::<BYTES>::new(),
            false => Bitmap {
                bits: __copy_bytes(value),
            },
        }
    }
}

macro_rules! impl_from {
    ($t:ty) => {
        impl<const BYTES: usize> From<$t> for Bitmap<BYTES> {
            fn from(value: $t) -> Self {
                let arr: [u8; core::mem::size_of::<$t>()] = unsafe { core::mem::transmute(value) };
                Bitmap::<BYTES>::from(arr)
            }
        }
    };
}

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