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

use crate::{BitBag, Flags};

impl<FlagsT: Flags> core::iter::FromIterator<FlagsT> for BitBag<FlagsT> {
    fn from_iter<T: IntoIterator<Item = FlagsT>>(iter: T) -> Self {
        BitBag::empty().set_each(iter).build()
    }
}

impl<FlagsT: Flags> IntoIterator for BitBag<FlagsT> {
    type Item = &'static FlagsT;
    type IntoIter = BitBagIterator<FlagsT>;
    fn into_iter(self) -> Self::IntoIter {
        Self::IntoIter {
            bag: self,
            variant_iterator: FlagsT::VARIANTS.iter(),
        }
    }
}

#[derive(Debug, Clone)]
pub struct BitBagIterator<FlagsT: Flags> {
    bag: BitBag<FlagsT>,
    variant_iterator: core::slice::Iter<'static, (&'static str, FlagsT, FlagsT::Repr)>,
}

impl<FlagsT: Flags> Iterator for BitBagIterator<FlagsT> {
    type Item = &'static FlagsT;
    fn next(&mut self) -> Option<Self::Item> {
        let Self {
            bag,
            variant_iterator,
        } = self;
        variant_iterator
            .by_ref()
            .map(|(_, value, _)| value)
            .find(|&value| bag.is_set_raw(value.to_repr()))
    }
}