cxx-qt-lib: add binding for QVariant::typeName()

Author: yuknig

crates/cxx-qt-lib/include/core/qvariant.h

@@ -85,6 +85,9 @@ qvariantValueOrDefault(const QVariant& variant) noexcept
   return variant.value<T>();
 }
 
+::rust::Slice<const ::std::uint8_t>
+qvariantTypeName(const QVariant& variant) noexcept;
+
 // Need to use a macro here as we can't template because the types
 // are always QVariant and bool. So then CXX can't decide which to use.
 #define CXX_QT_QVARIANT_CAN_CONVERT(name)                                      \

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

@@ -58,6 +58,13 @@ mod ffi {
         #[rust_name = "qvariant_to_debug_qstring"]
         fn toDebugQString(variant: &QVariant) -> QString;
     }
+
+    #[namespace = "rust::cxxqtlib1::qvariant"]
+    unsafe extern "C++" {
+        #[doc(hidden)]
+        #[rust_name = "qvariant_type_name"]
+        fn qvariantTypeName(variant: &QVariant) -> &[u8];
+    }
 }
 
 /// The `QVariant` class acts like a union for the most common Qt data types.
@@ -119,6 +126,16 @@ impl QVariant {
         self.user_type().into()
     }
 
+    /// Returns the name of the type stored in the variant.
+    ///
+    /// The returned string describes the C++ datatype used to store the data.
+    /// An invalid variant returns an empty string.
+    pub fn type_name(&self) -> &str {
+        // The slice is empty when the variant has no type name.
+        let slice = ffi::qvariant_type_name(self);
+        std::str::from_utf8(slice).expect("QVariant type name is not valid UTF-8")
+    }
+
     /// Returns the stored value converted to the template type `T`, or `None` if the type cannot be converted to `T`.
     ///
     /// Note that this first calls [`can_convert`](QVariantValue::can_convert).

crates/cxx-qt-lib/src/core/qvariant/qvariant.cpp

@@ -11,6 +11,8 @@
 
 #include <cxx-qt-lib/assertion_utils.h>
 
+#include <cstring>
+
 // The layout has changed between Qt 5 and Qt 6
 //
 // Qt6 QVariant has one member, which contains three pointers and a union
@@ -56,6 +58,17 @@ namespace rust {
 namespace cxxqtlib1 {
 namespace qvariant {
 
+::rust::Slice<const ::std::uint8_t>
+qvariantTypeName(const QVariant& variant) noexcept
+{
+  if (const char* name = variant.typeName()) {
+    const ::std::size_t len = ::std::strlen(name);
+    return ::rust::Slice{ reinterpret_cast<const ::std::uint8_t*>(name), len };
+  }
+
+  return {};
+}
+
 CXX_QT_QVARIANT_CAN_CONVERT_IMPL(bool, Bool)
 CXX_QT_QVARIANT_CAN_CONVERT_IMPL(float, F32)
 CXX_QT_QVARIANT_CAN_CONVERT_IMPL(double, F64)