cxx-qt-lib: seal QFlagRepr trait

Author: jnbooth

crates/cxx-qt-lib/src/core/mod.rs

@@ -18,7 +18,7 @@ mod qdatetime;
 pub use qdatetime::QDateTime;
 
 mod qflags;
-pub use qflags::{QFlag, QFlags};
+pub use qflags::{QFlag, QFlagRepr, QFlags};
 
 mod qhash;
 pub use qhash::{QHash, QHashPair, QHashPair_QString_QVariant, QHashPair_i32_QByteArray};

crates/cxx-qt-lib/src/core/qflags/mod.rs

@@ -10,18 +10,19 @@ use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, N
 
 mod qflag;
 pub use qflag::QFlag;
-use qflag::{QFlagExt, QFlagRepr};
+use qflag::QFlagExt;
 
-mod util;
+mod repr;
+pub use repr::QFlagRepr;
 
-type QFlagInt<T> = <T as QFlagExt>::Int;
+mod util;
 
 /// The `QFlags<T>` class is a template class, where T is an enum type.
-/// QFlags is used throughout Qt for storing combinations of enum values.
+/// QFlags are used throughout Qt for storing combinations of enum values.
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(transparent)]
 pub struct QFlags<T: QFlag> {
-    repr: QFlagInt<T>,
+    repr: <T::Repr as QFlagRepr>::Int,
 }
 
 impl<T: QFlag> Copy for QFlags<T> {}
@@ -55,12 +56,12 @@ impl<T: QFlag> QFlags<T> {
     }
 
     /// Constructs a QFlags object representing the integer value *i*.
-    pub const fn from_int(i: QFlagInt<T>) -> Self {
+    pub const fn from_int(i: <T::Repr as QFlagRepr>::Int) -> Self {
         Self { repr: i }
     }
 
     /// Returns the value stored in the QFlags object as an integer.
-    pub const fn to_int(self) -> QFlagInt<T> {
+    pub const fn to_int(self) -> <T::Repr as QFlagRepr>::Int {
         self.repr
     }
 

crates/cxx-qt-lib/src/core/qflags/qflag.rs

@@ -3,59 +3,10 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use std::fmt::Debug;
-use std::hash::Hash;
-use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not};
+use super::QFlagRepr;
 
 use cxx::ExternType;
 
-pub trait QFlagRepr: Sized {
-    /// Qt chooses the integer representation for a `QFlags<T>` as follows:
-    ///
-    /// - If `T` is signed, use a signed integer. Otherwise, use an unsigned integer.
-    /// - If `T` is 32 bits or less, use a 32-bit integer.
-    /// - If `T` is 64 bits and the Qt version is at least 6.9, use a 64-bit integer.
-    type Int: From<Self>
-        + Copy
-        + Debug
-        + Default
-        + Eq
-        + Ord
-        + Hash
-        + BitAnd<Output = Self::Int>
-        + BitAndAssign
-        + BitOr<Output = Self::Int>
-        + BitOrAssign
-        + BitXor<Output = Self::Int>
-        + BitXorAssign
-        + Not<Output = Self::Int>
-        + ExternType<Kind = cxx::kind::Trivial>;
-
-    const ZERO: Self::Int;
-}
-
-macro_rules! impl_repr {
-    ($t:ty, $i:ty) => {
-        impl QFlagRepr for $t {
-            type Int = $i;
-
-            const ZERO: Self::Int = 0;
-        }
-    };
-}
-
-impl_repr!(i8, i32);
-impl_repr!(i16, i32);
-impl_repr!(i32, i32);
-impl_repr!(u8, u32);
-impl_repr!(u16, u32);
-impl_repr!(u32, u32);
-
-#[cfg(cxxqt_qt_version_at_least_6_9)]
-impl_repr!(i64, i64);
-#[cfg(cxxqt_qt_version_at_least_6_9)]
-impl_repr!(u64, u64);
-
 /// # Safety
 ///
 /// By writing the unsafe `QFlag` impl, the programmer asserts that the C++ namespace and type name
@@ -90,17 +41,13 @@ pub unsafe trait QFlag: Sized {
 }
 
 /// Internal utility trait for converting `T` in a `QFlag<T>` to the corresponding integer type.
-pub trait QFlagExt: QFlag {
-    type Int;
-
-    fn to_int(self) -> Self::Int;
+pub(super) trait QFlagExt: QFlag {
+    fn to_int(self) -> <Self::Repr as QFlagRepr>::Int;
 }
 
 impl<T: QFlag> QFlagExt for T {
-    type Int = <<T as QFlag>::Repr as QFlagRepr>::Int;
-
     #[inline(always)]
-    fn to_int(self) -> Self::Int {
+    fn to_int(self) -> <Self::Repr as QFlagRepr>::Int {
         self.to_repr().into()
     }
 }

crates/cxx-qt-lib/src/core/qflags/repr.rs

@@ -0,0 +1,58 @@
+use std::fmt::Debug;
+use std::hash::Hash;
+use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not};
+
+use cxx::ExternType;
+
+mod private {
+    pub trait Sealed {}
+}
+
+pub trait QFlagRepr: Sized + private::Sealed {
+    /// Qt chooses the integer representation for a `QFlags<T>` as follows:
+    ///
+    /// - If `T` is signed, use a signed integer. Otherwise, use an unsigned integer.
+    /// - If `T` is 32 bits or less, use a 32-bit integer.
+    /// - If `T` is 64 bits and the Qt version is at least 6.9, use a 64-bit integer.
+    type Int: From<Self>
+        + Copy
+        + Debug
+        + Default
+        + Eq
+        + Ord
+        + Hash
+        + BitAnd<Output = Self::Int>
+        + BitAndAssign
+        + BitOr<Output = Self::Int>
+        + BitOrAssign
+        + BitXor<Output = Self::Int>
+        + BitXorAssign
+        + Not<Output = Self::Int>
+        + ExternType<Kind = cxx::kind::Trivial>;
+
+    const ZERO: Self::Int;
+}
+
+macro_rules! impl_repr {
+    ($t:ty, $i:ty) => {
+        impl private::Sealed for $t {}
+
+        impl QFlagRepr for $t {
+            type Int = $i;
+
+            const ZERO: Self::Int = 0;
+        }
+    };
+}
+
+impl_repr!(i8, i32);
+impl_repr!(i16, i32);
+impl_repr!(i32, i32);
+impl_repr!(u8, u32);
+impl_repr!(u16, u32);
+impl_repr!(u32, u32);
+
+#[cfg(cxxqt_qt_version_at_least_6_9)]
+impl_repr!(i64, i64);
+#[cfg(cxxqt_qt_version_at_least_6_9)]
+impl_repr!(u64, u64);