maikklein / enumflags Goto Github PK

Since it's defined directly on the type rather than a trait, the compiler will warn about it being unused. Can it be turned off?

Currently constants cannot be specified using bit shifts.
I personally find it much more readable in almost every case.

The following does not compile:

#[repr(u8)]
#[derive(Debug, Copy, Clone, Eq, PartialEq, EnumFlags)]
pub enum CtlCode {
    Banned        = 1 << 0,
    Administrator = 1 << 1,
    Common        = 1 << 2,
}

With the error:

At least one variant was not initialized explicity with a value.

Some C/C++ APIs have missing flags reserved for things like future expansion. It would be nice if could use enumflags to wrap these kind interfaces without translating from a continuous enum without missing flags to the actual API.

Example:

#[derive(EnumFlags, Copy, Clone, Debug)]
#[repr(u8)]
pub enum Test {
//  A = 0b0001, MISSING
    B = 0b0010,
    D = 0b0100,
    A = 0b1000,
}

I'm trying to represent ICMP Type field as an enum using EnumFlags. Type 0 is "Echo Reply".

If I try to represent this, however, it throws this compile time exception

 --> src/layer4/icmp.rs:6:10
  |
6 | #[derive(EnumFlags, Copy, Clone, Debug)]
  |          ^^^^^^^^^
  |
  = help: message: Null flag is not allowed

From this code:

#[derive(EnumFlags, Copy, Clone, Debug)]
#[repr(u8)]
pub enum IcmpType {
    EchoReply = 0,
    DestinationUnreachable = 3,
    SourceQuench = 4,
...

I'm trying to understand this logic, and whether it's strictly necessary. And what is the work-around when you're representing constants outside of your control (i.e. I can't just start at a value of 1 because if you cast back to the u8 value it will be incorrect)?

Repro:

extern crate enumflags;
#[macro_use]
extern crate enumflags_derive;

#[derive(EnumFlags, Copy, Clone, Debug)]
#[repr(u64)]
enum Bork {
    X = 0x40_0000_0000
}

Error:

error: proc-macro derive panicked
 --> src/lib.rs:5:10
  |
5 | #[derive(EnumFlags, Copy, Clone, Debug)]
  |          ^^^^^^^^^
error: proc-macro derive panicked
 --> src/lib.rs:5:10
  |
5 | #[derive(EnumFlags, Copy, Clone, Debug)]
  |          ^^^^^^^^^
  |
  |
  = help: message: assertion failed: index < std::u32::MAX as usize
  = help: message: assertion failed: index < std::u32::MAX as usize

#[derive(EnumFlags, Copy, Clone, Debug)]
#[repr(u8)]
pub enum GeneralStatus {
    INDICATOR_IDENTIFY    = 0b01000000,
    INDICATOR_MUTE        = 0b10000000,
    INDICATOR_NORMAL      = 0b11000000,

    PORT_AUTH_PANEL       = 0b00010000,
    PORT_AUTH_NETWORK     = 0b00100000,

    BOOT_ROM              = 0b00000100,
    RDM_CAPABLE           = 0b00000010,
    UBEA_PRESENT          = 0b00000001,
}

Gives the error:

The following flags are not unique: ["GeneralStatus::INDICATOR_IDENTIFY = 0b1000000", "GeneralStatus::INDICATOR_MUTE = 0b10000000", "GeneralStatus::IND
ICATOR_NORMAL = 0b11000000"]

Is this not possible? I can't change how these bits are laid out as they are part of an existing network protocol.

In the cloned repo, the enumflags crate is version "0.3.0" and the enumflags_derive crate is "0.4.0", but on crates.io they are both "0.4.1"

While using this crate, I found it rather useful to define a macro like this:

// public domain
macro_rules! flags {
    ( $($ns:ident::)* {} ) => (
        $($ns::)*empty_bitflag()
    );

    ( $($ns:ident::)* {$tail:ident} ) => (
        $crate::BitFlags::from($($ns::)*$tail)
    );

    // Use `{}` instead of `()` to avoid `unused_parens` warning
    ( $($ns:ident::)* {$head:ident | $($rest:tt)*} ) => ({
        flags![$($ns::)*{$head}] |
        flags![$($ns::)*{$($rest)*}]
    })
}

The usage is shown below:

#[derive(EnumFlags, Copy, Clone, PartialEq, Eq, Hash, Debug)]
#[repr(u8)]
pub enum Test { A = 0b0001, B = 0b0010 }

let flags0 = flags![Test::{}];
let flags1 = flags![Test::{A}];
let flags2 = flags![Test::{A | B}];

assert_eq!(flags0, enumflags::BitFlags::empty());
assert_eq!(flags1, Test::A.into());
assert_eq!(flags2, Test::A | Test::B);

Perhaps could you consider including this macro in enumflags?

Removing std would allow its usage in embedded programming, or in environments where it isn't available.

Is possible to implement support for const variants?

rust-lang/rust#10374

Because of that bug, we can't really use enumflags when we need to serialize to an architecture dependent size. For example: std::os::raw::c_ulong. We can either try to get it fixed in the compiler or we can try to work around it.