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
|
bitflags
========
[](https://github.com/bitflags/bitflags/actions)
[](https://crates.io/crates/bitflags)
[](https://docs.rs/bitflags)
`bitflags` generates flags enums with well-defined semantics and ergonomic end-user APIs.
You can use `bitflags` to:
- provide more user-friendly bindings to C APIs where flags may or may not be fully known in advance.
- generate efficient options types with string parsing and formatting support.
You can't use `bitflags` to:
- guarantee only bits corresponding to defined flags will ever be set. `bitflags` allows access to the underlying bits type so arbitrary bits may be set.
- define bitfields. `bitflags` only generates types where set bits denote the presence of some combination of flags.
- [Documentation](https://docs.rs/bitflags)
- [Specification](https://github.com/bitflags/bitflags/blob/main/spec.md)
- [Release notes](https://github.com/bitflags/bitflags/releases)
## Usage
Add this to your `Cargo.toml`:
```toml
[dependencies]
bitflags = "2.9.1"
```
and this to your source code:
```rust
use bitflags::bitflags;
```
## Example
Generate a flags structure:
```rust
use bitflags::bitflags;
// The `bitflags!` macro generates `struct`s that manage a set of flags.
bitflags! {
/// Represents a set of flags.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
struct Flags: u32 {
/// The value `A`, at bit position `0`.
const A = 0b00000001;
/// The value `B`, at bit position `1`.
const B = 0b00000010;
/// The value `C`, at bit position `2`.
const C = 0b00000100;
/// The combination of `A`, `B`, and `C`.
const ABC = Self::A.bits() | Self::B.bits() | Self::C.bits();
}
}
fn main() {
let e1 = Flags::A | Flags::C;
let e2 = Flags::B | Flags::C;
assert_eq!((e1 | e2), Flags::ABC); // union
assert_eq!((e1 & e2), Flags::C); // intersection
assert_eq!((e1 - e2), Flags::A); // set difference
assert_eq!(!e2, Flags::A); // set complement
}
```
## Rust Version Support
The minimum supported Rust version is documented in the `Cargo.toml` file.
This may be bumped in minor releases as necessary.
|
