flagged 0.1.0

Bitflag-based warning type
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

use enumflags2::{BitFlag, BitFlags};

#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct Flagged<T, F: BitFlag> {
    pub value: T,
    pub flags: BitFlags<F>,
}

impl<T: Default, F: BitFlag> Default for Flagged<T, F> {
    fn default() -> Self {
        Self {
            value: Default::default(),
            flags: Default::default(),
        }
    }
}

impl<T, F: BitFlag> Flagged<T, F> {
    pub fn and_then<U>(self, f: impl FnOnce(T) -> Flagged<U, F>) -> Flagged<U, F> {
        let inner = f(self.value);
        Flagged {
            value: inner.value,
            flags: self.flags | inner.flags, //merge flags
        }
    }

    pub fn into_result(self) -> Result<T, BitFlags<F>> {
        if self.flags != BitFlags::EMPTY {
            Err(self.flags)
        } else {
            Ok(self.value)
        }
    }

    pub fn into_result_against(self, flags: BitFlags<F>) -> Result<T, BitFlags<F>> {
        if self.flags.intersects(flags) {
            Err(self.flags & flags) //only include error flags
        } else {
            Ok(self.value)
        }
    }
}

impl<T, F: BitFlag> From<T> for Flagged<T, F> {
    fn from(value: T) -> Self {
        Self {
            value,
            flags: BitFlags::EMPTY,
        }
    }
}

impl<T, F: BitFlag> FromIterator<Flagged<T, F>> for Flagged<Vec<T>, F> {
    fn from_iter<I: IntoIterator<Item = Flagged<T, F>>>(iter: I) -> Self {
        let mut value = vec![];
        let mut flags = BitFlags::EMPTY;
        for flagged in iter {
            value.push(flagged.value);
            flags |= flagged.flags;
        }
        Self { value, flags }
    }
}