eset 0.1.0

A simple library for flags like enums.
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

use core::ops::{Sub, Not, BitAnd, BitOr, BitXor, BitAndAssign, BitOrAssign, BitXorAssign, SubAssign, Add, AddAssign};

use crate::{ReprEnum, ESet};

impl<T: ReprEnum, const S: char> Not for ESet<T, S> {
    type Output = ESet<T>;

    fn not(self) -> Self::Output {
        ESet(!self.0)
    }
}

impl<T: ReprEnum, R: Into<Self>, const S: char> BitAnd<R> for ESet<T, S> {
    type Output = ESet<T>;

    fn bitand(self, rhs: R) -> Self::Output {
        ESet(self.0 & rhs.into().0)
    }
}

impl<T: ReprEnum, R: Into<Self>, const S: char> BitOr<R> for ESet<T, S> {
    type Output = ESet<T>;

    fn bitor(self, rhs: R) -> Self::Output {
        ESet(self.0 | rhs.into().0)
    }
}

impl<T: ReprEnum, R: Into<Self>, const S: char> BitXor<R> for ESet<T, S> {
    type Output = ESet<T>;

    fn bitxor(self, rhs: R) -> Self::Output {
        ESet(self.0 ^ rhs.into().0)
    }
}

impl<T: ReprEnum, R: Into<Self>, const S: char> Add<R> for ESet<T, S> {
    type Output = ESet<T>;

    fn add(self, rhs: R) -> Self::Output {
        ESet(self.0 | rhs.into().0)
    }
}

impl<T: ReprEnum, R: Into<Self>, const S: char> Sub<R> for ESet<T, S> {
    type Output = ESet<T>;

    fn sub(self, rhs: R) -> Self::Output {
        ESet(self.0 ^ (self.0 & rhs.into().0))
    }
}

impl<T: ReprEnum, R: Into<Self>, const S: char> BitAndAssign<R> for ESet<T, S> {
    fn bitand_assign(&mut self, rhs: R) {
        self.0 &= rhs.into().0;
    }
}

impl<T: ReprEnum, R: Into<Self>, const S: char> BitOrAssign<R> for ESet<T, S> {
    fn bitor_assign(&mut self, rhs: R) {
        self.0 |= rhs.into().0;
    }
}

impl<T: ReprEnum, R: Into<Self>, const S: char> BitXorAssign<R> for ESet<T, S> {
    fn bitxor_assign(&mut self, rhs: R) {
        self.0 ^= rhs.into().0;
    }
}

impl<T: ReprEnum, R: Into<Self>, const S: char> AddAssign<R> for ESet<T, S> {
    fn add_assign(&mut self, rhs: R) {
        self.0 |= rhs.into().0;
    }
}

impl<T: ReprEnum, R: Into<Self>, const S: char> SubAssign<R> for ESet<T, S> {
    fn sub_assign(&mut self, rhs: R) {
        self.0 ^= self.0 & rhs.into().0 ;
    }
}

impl<T: ReprEnum, const S: char> PartialEq for ESet<T, S> {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
    }
}

impl<T: ReprEnum, const S: char> PartialOrd for ESet<T, S> {
    /// `==` mean equal `>` means contains, `<` means contained by, otherwise [`None`]
    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
        if self.0 == other.0 {
            Some(core::cmp::Ordering::Equal)
        } else if self.0 & other.0 == other.0 {
            Some(core::cmp::Ordering::Greater)
        } else if self.0 & other.0 == self.0 {
            Some(core::cmp::Ordering::Less)
        } else {
            None
        }
    }
}