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

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

* cxx-qt-lib: add some tests for QVariant::type_name()

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).
@@ -277,3 +294,37 @@ unsafe impl ExternType for QVariant {
     type Id = type_id!("QVariant");
     type Kind = cxx::kind::Trivial;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{QList, QString};
+
+    #[test]
+    fn test_type_name() {
+        let variant = QVariant::from(&true);
+        assert_eq!(variant.type_name(), "bool");
+
+        let variant = QVariant::from(&123_i32);
+        assert_eq!(variant.type_name(), "int");
+
+        let variant = QVariant::from(&0.25f32);
+        assert_eq!(variant.type_name(), "float");
+
+        let variant = QVariant::from(&0.75f64);
+        assert_eq!(variant.type_name(), "double");
+
+        let variant = QVariant::from(&QList::<i32>::from_iter(&[1, 2, 3]));
+        assert_eq!(variant.type_name(), "QList<int>");
+
+        let variant = QVariant::from(&QString::from("ABC"));
+        assert_eq!(variant.type_name(), "QString");
+    }
+
+    #[test]
+    fn qvariant_type_name_invalid() {
+        let variant = QVariant::default();
+        assert!(!variant.is_valid());
+        assert_eq!(variant.type_name(), "");
+    }
+}

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)