re-implemented Debug to show the bits field of the internal struct as… #9
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
… binary (8-bits wide)
|
Thanks! I think I'll remove the 10-character width limit for now (as it could be larger or smaller), but I'll do that locally. |
alexcrichton
added a commit
that referenced
this pull request
Jun 1, 2015
re-implemented Debug to show the bits field of the internal struct as…
|
This sucks a lot for my usecases at least, since a non-symbolic representation is impossible to decipher (I have 61 cases right now). I don't see a good way to do it in the macro though in the face of #8. |
| let out = format!("{} {{ bits: {:#010b} }}", | ||
| stringify!($BitFlags), | ||
| self.bits); | ||
| f.write_str(&out[..]) |
There was a problem hiding this comment.
General design note: there’s no need to create an intermediate string; you should use write! in here:
write!(f, "{} {{ bits: {:#010b} }}",
stringify!($BitFlags),
self.bits)
chris-morgan
added a commit
to chris-morgan/bitflags
that referenced
this pull request
Jun 26, 2015
`Debug` was implemented using the nice readable flag names in bitflags#7, but the flag names were removed in bitflags#9 because it used `$Flags` which broke trivial `#[cfg]`-based removal of flags. Changing `.contains($Flag)` to `.contains($BitFlags { bits: $value })` instead (akin to what `.all()` did) would have fixed that issue, allowing a friendly `Debug` again, but then I found a further improvement to make, because the `#[cfg]` behaviour was still off, as a flag’s value was still written out regardless of the `#[cfg]` attribute, so if *it* contained stuff that didn’t exist `bitflags!` would still blow up. This is inconsistent with how such things work in Rust proper, so I’ve fixed it. The fix is rather convoluted, involving a dummy module, a bunch of dummy constants, a nested function and glob imports, but it works, avoiding referring to `$value` successfully. This change causes this to work: ```rust bitflags! { flags Foo: u32 { #[cfg(a)] const A = 0b1, #[cfg(a)] const B = A.bits, // or anything else that is `#[cfg(a)]` } } ``` (Formerly `all()` was still trying to use `A.bits` when `cfg(not(a))` and thus `A` wasn’t defined.) This change allows `#[cfg]` on a flag to work like it should, allowing it to depend on things that don’t exist unless the conditions are met. Sure, that seems a pretty rare case for flags, but it’s real. Beyond the style of example above, my imagined scenario is a -sys crate having declared certain flag values, but only when certain features are enabled, and so when defining the bitflags in another crate (for the -sys crate doesn’t use bitflags) you can only use those values with the appropriate features.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
… binary (8-bits wide)
Fixes issue #8 by re-implementing Debug to a simpler representation:
$BitFlags { bits: 0bXXXXXXXX }If this isn't preferable, I would recommend dropping the general Debug impl and let everyone implement their own.