examples: use Result in qml_features and test_inputs

And add a test to ensure we can catch a thrown exception.

Related to #404

Author: ahayzen-kdab

crates/cxx-qt-gen/test_inputs/invokables.rs

@@ -35,6 +35,12 @@ mod ffi {
 
         #[qinvokable(cxx_virtual)]
         fn invokable_virtual(self: &MyObject);
+
+        #[qinvokable]
+        fn invokable_result_tuple(self: &MyObject) -> Result<()>;
+
+        #[qinvokable]
+        fn invokable_result_type(self: &MyObject) -> Result<String>;
     }
 
     impl cxx_qt::Threading for MyObject {}

crates/cxx-qt-gen/test_outputs/invokables.cpp

@@ -78,6 +78,20 @@ MyObject::invokableVirtual() const
   invokableVirtualWrapper();
 }
 
+void
+MyObject::invokableResultTuple() const
+{
+  const ::std::lock_guard<::std::recursive_mutex> guard(*m_rustObjMutex);
+  invokableResultTupleWrapper();
+}
+
+::rust::String
+MyObject::invokableResultType() const
+{
+  const ::std::lock_guard<::std::recursive_mutex> guard(*m_rustObjMutex);
+  return invokableResultTypeWrapper();
+}
+
 static_assert(alignof(MyObjectCxxQtThread) <= alignof(::std::size_t),
               "unexpected aligment");
 static_assert(sizeof(MyObjectCxxQtThread) == sizeof(::std::size_t[4]),

crates/cxx-qt-gen/test_outputs/invokables.h

@@ -36,6 +36,8 @@ class MyObject : public QObject
   Q_INVOKABLE void invokableFinal() const final;
   Q_INVOKABLE void invokableOverride() const override;
   Q_INVOKABLE virtual void invokableVirtual() const;
+  Q_INVOKABLE void invokableResultTuple() const;
+  Q_INVOKABLE ::rust::String invokableResultType() const;
   MyObjectCxxQtThread qtThread() const;
   explicit MyObject(::std::int32_t arg0, QObject* arg1);
 
@@ -50,6 +52,8 @@ class MyObject : public QObject
   void invokableFinalWrapper() const noexcept;
   void invokableOverrideWrapper() const noexcept;
   void invokableVirtualWrapper() const noexcept;
+  void invokableResultTupleWrapper() const;
+  ::rust::String invokableResultTypeWrapper() const;
   explicit MyObject(
     cxx_qt::my_object::cxx_qt_my_object::CxxQtConstructorArguments0&& args);
 

crates/cxx-qt-gen/test_outputs/invokables.rs

@@ -75,6 +75,16 @@ mod ffi {
         #[cxx_name = "invokableVirtualWrapper"]
         fn invokable_virtual(self: &MyObject);
     }
+    extern "Rust" {
+        #[doc(hidden)]
+        #[cxx_name = "invokableResultTupleWrapper"]
+        fn invokable_result_tuple(self: &MyObject) -> Result<()>;
+    }
+    extern "Rust" {
+        #[doc(hidden)]
+        #[cxx_name = "invokableResultTypeWrapper"]
+        fn invokable_result_type(self: &MyObject) -> Result<String>;
+    }
     unsafe extern "C++" {
         #[doc(hidden)]
         type MyObjectCxxQtThread = cxx_qt::CxxQtThread<MyObject>;

examples/qml_features/rust/src/invokables.rs

@@ -24,7 +24,7 @@ pub mod qobject {
     unsafe extern "RustQt" {
         /// Immutable invokable method that returns the QColor
         #[qinvokable]
-        fn load_color(self: &RustInvokables) -> QColor;
+        fn load_color(self: &RustInvokables) -> Result<QColor>;
 
         /// Mutable invokable method that stores a color
         #[qinvokable]
@@ -61,8 +61,8 @@ impl Default for RustInvokablesRust {
 // ANCHOR: book_invokable_impl
 impl qobject::RustInvokables {
     /// Immutable invokable method that returns the QColor
-    fn load_color(&self) -> QColor {
-        self.as_qcolor()
+    fn load_color(&self) -> Result<QColor, i32> {
+        Ok(self.as_qcolor())
     }
 
     /// Mutable invokable method that stores a color

tests/basic_cxx_qt/cpp/main.cpp

@@ -260,6 +260,21 @@ private Q_SLOTS:
 
   // Tests that we can build an empty QObject end to end
   void testEmpty() { Empty empty; }
+
+  void testThrowException()
+  {
+    cxx_qt::my_object::MyObject obj;
+    bool thrown = false;
+    try {
+      obj.throwException();
+      Q_UNREACHABLE();
+    } catch (const rust::Error& e) {
+      QCOMPARE(e.what(), "RustException");
+      thrown = true;
+    }
+
+    QCOMPARE(thrown, true);
+  }
 };
 
 QTEST_MAIN(CxxQtTest)

tests/basic_cxx_qt/rust/src/lib.rs

@@ -45,6 +45,9 @@ mod qobject {
 
         #[qinvokable]
         fn fetch_update_call_count(self: &MyObject) -> i32;
+
+        #[qinvokable]
+        fn throw_exception(self: &MyObject) -> Result<i32>;
     }
 }
 
@@ -124,4 +127,8 @@ impl qobject::MyObject {
     fn fetch_update_call_count(&self) -> i32 {
         self.update_call_count
     }
+
+    fn throw_exception(&self) -> Result<i32, String> {
+        Err("RustException".to_string())
+    }
 }