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
|
//! An example of implementing the `BitFlags` trait manually for a flags type.
//!
//! This example doesn't use any macros.
use std::{fmt, str};
use bitflags::{Flag, Flags};
// First: Define your flags type. It just needs to be `Sized + 'static`.
pub struct ManualFlags(u32);
// Not required: Define some constants for valid flags
impl ManualFlags {
pub const A: ManualFlags = ManualFlags(0b00000001);
pub const B: ManualFlags = ManualFlags(0b00000010);
pub const C: ManualFlags = ManualFlags(0b00000100);
pub const ABC: ManualFlags = ManualFlags(0b00000111);
}
// Next: Implement the `BitFlags` trait, specifying your set of valid flags
// and iterators
impl Flags for ManualFlags {
const FLAGS: &'static [Flag<Self>] = &[
Flag::new("A", Self::A),
Flag::new("B", Self::B),
Flag::new("C", Self::C),
];
type Bits = u32;
fn bits(&self) -> u32 {
self.0
}
fn from_bits_retain(bits: u32) -> Self {
Self(bits)
}
}
// Not required: Add parsing support
impl str::FromStr for ManualFlags {
type Err = bitflags::parser::ParseError;
fn from_str(input: &str) -> Result<Self, Self::Err> {
bitflags::parser::from_str(input)
}
}
// Not required: Add formatting support
impl fmt::Display for ManualFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
bitflags::parser::to_writer(self, f)
}
}
fn main() {
println!(
"{}",
ManualFlags::A.union(ManualFlags::B).union(ManualFlags::C)
);
}
|
