Skip to contentSkip to conversation

rust: impl_flags: add method to return underlying integer

PATCH New Andreas Hindborg 1 participant 1 message Nov 4 Rust

lore
Share & tools
lore

Andreas Hindborg

author reviewer
#0 lore raw

PATCH v3 1/1 rust: impl_flags: add method to return underlying integer

Add a bits method to return a copy of the underlying integer used to represent the flags. This is useful when passing flag values to C APIs.

The macro already generates a public From<$flags> for $ty conversion, so this does not expose anything that was not already reachable by users of the generated types.

---
Changes in v3:
- Make bits() unconditionally public and drop the inner-field visibility specifier from v2. The bit pattern is already reachable through the generated From implementation, so gating the accessor hid
nothing (Gary, Miguel).
- Leave the bitmask struct declaration in the doctest unchanged and only add a line exercising bits() (Miguel).
- Rebase on v7.4-rc1.
- Link to v2: https://msgid.link/[email protected]

Changes in v2:
- Rename the accessor from into_inner to bits, matching the
name used by the bitflags crate (Gary).
- Tie the visibility of bits to the visibility of the inner
field of the bitmask struct, so callers must explicitly write
pub to expose the bit pattern outside the defining module (Gary).
- Extend the macro's doctest to declare the inner field pub
and exercise the bits accessor.
- Link to v1: https://msgid.link/[email protected]

---
 rust/kernel/impl_flags.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)
rust/kernel/impl_flags.rs +11 -0
index fdf44d5eea9c..6051487f6e28 100644
@@ -68,6 +68,11 @@
 /// let negated = !read_only;
 /// assert!(negated.contains(Permission::Write));
 /// assert!(!negated.contains(Permission::Read));
+///
+/// // Obtain the raw integer representation with `bits()`, which is
+/// // useful for passing the value to a C API.
+/// let raw: u32 = read_only.bits();
+/// assert_eq!(raw, Permission::Read as u32);
 /// ```
 #[macro_export]
 macro_rules! impl_flags {
@@ -270,6 +275,12 @@ pub fn contains_any(self, flags: $flags) -> bool {
             pub fn contains_all(self, flags: $flags) -> bool {
                 (self.0 & flags.0) == flags.0
             }
+
+            /// Return a copy of the inner representation of the flags.
+            #[inline]
+            pub fn bits(self) -> $ty {
+                self.0
+            }
         }
     };
 }

---
base-commit: 6628e7d4c6b25c8d18f1345e3a20d21829aae7e4
change-id: 20260212-impl-flags-inner-c61974b27b18

Best regards,

Signature · 1 line
Andreas Hindborg <[email protected]>