tidy up hex flag parsing and formatting

KodrAus · KodrAus · commit 3dfe0b2310e0 · 2023-05-17T09:12:48.000+10:00
diff --git a/examples/fmt.rs b/examples/fmt.rs
@@ -2,40 +2,40 @@
 
 use core::{fmt, str};
 
-fn main() -> Result<(), bitflags::parser::ParseError> {
-    bitflags::bitflags! {
-        // You can `#[derive]` the `Debug` trait, but implementing it manually
-        // can produce output like `A | B` instead of `Flags(A | B)`.
-        // #[derive(Debug)]
-        #[derive(PartialEq, Eq)]
-        pub struct Flags: u32 {
-            const A = 1;
-            const B = 2;
-            const C = 4;
-            const D = 8;
-        }
+bitflags::bitflags! {
+    // You can `#[derive]` the `Debug` trait, but implementing it manually
+    // can produce output like `A | B` instead of `Flags(A | B)`.
+    // #[derive(Debug)]
+    #[derive(PartialEq, Eq)]
+    pub struct Flags: u32 {
+        const A = 1;
+        const B = 2;
+        const C = 4;
+        const D = 8;
     }
+}
 
-    impl fmt::Debug for Flags {
-        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            fmt::Debug::fmt(&self.0, f)
-        }
+impl fmt::Debug for Flags {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        bitflags::parser::to_writer(self, f)
     }
+}
 
-    impl fmt::Display for Flags {
-        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            fmt::Display::fmt(&self.0, f)
-        }
+impl fmt::Display for Flags {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        bitflags::parser::to_writer(self, f)
     }
+}
 
-    impl str::FromStr for Flags {
-        type Err = bitflags::parser::ParseError;
+impl str::FromStr for Flags {
+    type Err = bitflags::parser::ParseError;
 
-        fn from_str(flags: &str) -> Result<Self, Self::Err> {
-            Ok(Self(flags.parse()?))
-        }
+    fn from_str(flags: &str) -> Result<Self, Self::Err> {
+        bitflags::parser::from_str(flags)
     }
+}
 
+fn main() -> Result<(), bitflags::parser::ParseError> {
     let flags = Flags::A | Flags::B;
 
     println!("{}", flags);
diff --git a/src/external/arbitrary.rs b/src/external/arbitrary.rs
@@ -2,6 +2,7 @@
 
 use crate::Flags;
 
+/// Get a random known flags value.
 pub fn arbitrary<'a, B: Flags>(
     u: &mut arbitrary::Unstructured<'a>,
 ) -> arbitrary::Result<B>
diff --git a/src/lib.rs b/src/lib.rs
@@ -660,9 +660,6 @@ macro_rules! bitflags {
             non_upper_case_globals
         )]
         const _: () = {
-            // NOTE: We don't need to check `__is_primitive` here because we don't derive
-            // traits on the user's behalf
-
             __impl_public_bitflags! {
                 $BitFlags: $T {
                     $(
diff --git a/src/parser.rs b/src/parser.rs
@@ -28,7 +28,7 @@
 
 #![allow(clippy::let_unit_value)]
 
-use core::fmt::{self, Write, LowerHex};
+use core::fmt::{self, Write};
 
 use crate::{Flags, Bits};
 
@@ -38,7 +38,7 @@ use crate::{Flags, Bits};
 /// as a hex number.
 pub fn to_writer<B: Flags>(flags: &B, mut writer: impl Write) -> Result<(), fmt::Error>
 where
-    B::Bits: LowerHex,
+    B::Bits: WriteHex,
 {
     // A formatter for bitflags that produces text output like:
     //
@@ -67,7 +67,8 @@ where
             writer.write_str(" | ")?;
         }
 
-        write!(writer, "{:#x}", remaining)?;
+        writer.write_str("0x")?;
+        remaining.write_hex(writer)?;
     }
 
     fmt::Result::Ok(())
@@ -77,7 +78,7 @@ pub(crate) struct AsDisplay<'a, B>(pub(crate) &'a B);
 
 impl<'a, B: Flags> fmt::Display for AsDisplay<'a, B>
 where
-    B::Bits: LowerHex,
+    B::Bits: WriteHex,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         to_writer(self.0, f)
@@ -89,14 +90,12 @@ where
 /// This function will fail on unknown flags rather than ignore them.
 pub fn from_str<B: Flags>(input: &str) -> Result<B, ParseError>
 where
-    B::Bits: FromHex,
+    B::Bits: ParseHex,
 {
-    let input = input.trim();
-
     let mut parsed_flags = B::empty();
 
     // If the input is empty then return an empty set of flags
-    if input.is_empty() {
+    if input.trim().is_empty() {
         return Ok(parsed_flags);
     }
 
@@ -111,7 +110,7 @@ where
         // If the flag starts with `0x` then it's a hex number
         // Parse it directly to the underlying bits type
         let parsed_flag = if let Some(flag) = flag.strip_prefix("0x") {
-            let bits = <B::Bits>::from_hex(flag).map_err(|_| ParseError::invalid_hex_flag(flag))?;
+            let bits = <B::Bits>::parse_hex(flag).map_err(|_| ParseError::invalid_hex_flag(flag))?;
 
             B::from_bits_retain(bits)
         }
@@ -128,10 +127,16 @@ where
     Ok(parsed_flags)
 }
 
+/// Encode a value as a hex string.
+pub trait WriteHex {
+    /// Write the value as hex.
+    fn write_hex<W: fmt::Write>(&self, writer: W) -> fmt::Result;
+}
+
 /// Parse a value from a number encoded as a hex string.
-pub trait FromHex {
-    /// Perform the conversion.
-    fn from_hex(input: &str) -> Result<Self, ParseError>
+pub trait ParseHex {
+    /// Parse the value from hex.
+    fn parse_hex(input: &str) -> Result<Self, ParseError>
     where
         Self: Sized;
 }
diff --git a/src/traits.rs b/src/traits.rs
@@ -1,6 +1,6 @@
-use core::ops::{BitAnd, BitOr, BitXor, Not};
+use core::{fmt, ops::{BitAnd, BitOr, BitXor, Not}};
 
-use crate::{parser::{ParseError, FromHex}, iter};
+use crate::{parser::{ParseError, ParseHex, WriteHex}, iter};
 
 /// Metadata for an individual flag.
 pub struct Flag<B> {
@@ -271,18 +271,30 @@ macro_rules! impl_bits {
                 const ALL: $i = <$u>::MAX as $i;
             }
 
-            impl FromHex for $u {
-                fn from_hex(input: &str) -> Result<Self, ParseError> {
+            impl ParseHex for $u {
+                fn parse_hex(input: &str) -> Result<Self, ParseError> {
                     <$u>::from_str_radix(input, 16).map_err(|_| ParseError::invalid_hex_flag(input))
                 }
             }
 
-            impl FromHex for $i {
-                fn from_hex(input: &str) -> Result<Self, ParseError> {
+            impl ParseHex for $i {
+                fn parse_hex(input: &str) -> Result<Self, ParseError> {
                     <$i>::from_str_radix(input, 16).map_err(|_| ParseError::invalid_hex_flag(input))
                 }
             }
 
+            impl WriteHex for $u {
+                fn write_hex<W: fmt::Write>(&self, mut writer: W) -> fmt::Result {
+                    write!(writer, "{:x}", self)
+                }
+            }
+
+            impl WriteHex for $i {
+                fn write_hex<W: fmt::Write>(&self, mut writer: W) -> fmt::Result {
+                    write!(writer, "{:x}", self)
+                }
+            }
+
             impl Primitive for $i {}
             impl Primitive for $u {}
         )*
