bitbag 0.3.0

A useful struct for dealing with bit flags
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

//! `#[derive(Trait)]` adds a `PossibleFlagsT: Trait` bound, which is not required.
//! So manually implement here.

use crate::{BitBag, Flags};
use core::{
    fmt,
    hash::{Hash, Hasher},
};

/// Ignores unrecognised bits
impl<FlagsT: Flags> PartialEq for BitBag<FlagsT> {
    fn eq(&self, other: &Self) -> bool {
        self.repr() & FlagsT::ALL == other.repr() & FlagsT::ALL
    }
}

impl<FlagsT: Flags> Eq for BitBag<FlagsT> {}

/// Ignores unrecognised bits
impl<FlagsT: Flags> Hash for BitBag<FlagsT> {
    fn hash<H: Hasher>(&self, state: &mut H) {
        (self.repr() & FlagsT::ALL).hash(state);
    }
}

impl<FlagsT: Flags> fmt::Debug for BitBag<FlagsT> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        struct Set<T>(T);
        impl<T> fmt::Debug for Set<T>
        where
            T: Iterator + Clone,
            T::Item: fmt::Debug,
        {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                f.debug_set().entries(self.0.clone()).finish()
            }
        }

        let names = FlagsT::VARIANTS
            .iter()
            .filter_map(|(name, _, repr)| self.is_set_raw(*repr).then_some(*name));

        f.debug_struct(FlagsT::NAME)
            .field("flags", &Set(names))
            .field("bits", &format_args!("{:#b}", self.0))
            .field(
                "unrecognized_bits",
                &format_args!("{:#b}", self.unrecognised_bits().unwrap_or_default()),
            )
            .finish()
    }
}

impl<FlagsT: Flags> Clone for BitBag<FlagsT> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<FlagsT: Flags> Copy for BitBag<FlagsT> {}

impl<FlagsT: Flags> Default for BitBag<FlagsT> {
    fn default() -> Self {
        Self::empty()
    }
}