enum-flags 0.4.0

EnumFlags is a csharp like enum flags implementation.
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

[![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE-MIT)
[![Documentation](https://docs.rs/enum-flags/badge.svg)](https://docs.rs/enum-flags)
[![Crates.io Version](https://img.shields.io/crates/v/enum-flags.svg)](https://crates.io/crates/enum-flags)
# EnumFlags

> EnumFlags is a [csharp](https://docs.microsoft.com/en-us/dotnet/api/system.flagsattribute?view=net-5.0) like enum flags implementation.

The generated code is `no_std` compatible.


## Example

Since use the feature `arbitrary_enum_discriminant`, **nightly channel** is required.

```rust
#![feature(arbitrary_enum_discriminant)]
use enum_flags::enum_flags;

#[repr(u8)]  // default: #[repr(usize)]
#[enum_flags]
#[derive(Copy, Clone, PartialEq)] // can be omitted
enum Flags{
    None = 0,
    A = 1,
    B, // 2
    C = 4
}
fn main() {
    let e1: Flags = Flags::A | Flags::C;
    let e2 = Flags::B | Flags::C;

    assert_eq!(e1 | e2, Flags::A | Flags::B | Flags::C); // union
    assert_eq!(e1 & e2, Flags::C); // intersection
    assert_eq!(e1 ^ e2, Flags::A | Flags::B); // toggle
    assert_eq!(e1 & (!Flags::C), Flags::A); // deletion
    assert_eq!(e1 - Flags::C, Flags::A); // deletion

    assert_eq!(format!("{:?}", e1).as_str(), "(Flags::A | Flags::C)");
    assert!(e1.has_a());
    assert!(!e1.has_b());
    assert!(e1.has_flag(Flags::C));
    assert!(e1.contains(Flags::C));
    assert_eq!(match Flags::A | Flags::C {
        Flags::None => "None",
        Flags::A => "A",
        Flags::B => "B",
        Flags::C => "C",
        Flags::__Composed__(v) if v == Flags::A | Flags::B => "A and B",
        Flags::__Composed__(v) if v == Flags::A | Flags::C => "A and C",
        _ => "Others"
    }, "A and C")
}
```



## Breaking Changes

- before version 0.18
  ```rust
  #[derive(Copy, EnumFlags, Clone, PartialEq)]
  enum Flags {
      None = 0,
      A = 1,
      B = 2,
      C = 4
  }
  ```
- version 0.30 later
  ```rust
  #[enum_flags] 
  #[derive(Copy, Clone, PartialEq)]
  enum Flags {
      None = 0,
      A = 1,
      B = 2,
      C = 4
  }
  ```