Add convenience function to return a result

Author: swsnr

examples/gio_dbus_register_object/main.rs

@@ -28,13 +28,16 @@ fn on_startup(app: &gio::Application, tx: &Sender<gio::RegistrationId>) {
             move |_, _, _, _, method, params, invocation| {
                 match method {
                     "Hello" => {
-                        if let Some((name,)) = <(String,)>::from_variant(&params) {
-                            let greet = format!("Hello {name}!");
-                            println!("{greet}");
-                            invocation.return_value(Some(&(greet,).to_variant()));
-                        } else {
-                            invocation.return_error(gio::IOErrorEnum::Failed, "Invalid parameters");
-                        }
+                        let result = <(String,)>::from_variant(&params)
+                            .ok_or_else(|| {
+                                glib::Error::new(gio::IOErrorEnum::Failed, "Invalid parameters")
+                            })
+                            .map(|(name,)| {
+                                let greet = format!("Hello {name}!");
+                                println!("{greet}");
+                                Some(greet.to_variant())
+                            });
+                        invocation.return_result(result);
                     }
                     _ => unreachable!(),
                 }

gio/src/dbus_method_invocation.rs

@@ -1,6 +1,6 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use glib::{prelude::*, translate::*};
+use glib::{prelude::*, translate::*, VariantTy};
 
 use crate::{ffi, DBusMethodInvocation};
 
@@ -26,4 +26,23 @@ impl DBusMethodInvocation {
             );
         }
     }
+
+    // rustdoc-stripper-ignore-next
+    /// Return a result for this invocation.
+    ///
+    /// If `Ok` return the contained value with [`return_value`].  If the return
+    /// value is not a tuple, automatically convert it to a one-element tuple, as
+    /// DBus return values must be tuples.
+    ///
+    /// If `Err` return the contained error with [`return_gerror`].
+    pub fn return_result(self, result: Result<Option<glib::Variant>, glib::Error>) {
+        match result {
+            Ok(Some(value)) if !value.is_type(VariantTy::TUPLE) => {
+                let tupled = glib::Variant::tuple_from_iter(std::iter::once(value));
+                self.return_value(Some(&tupled));
+            }
+            Ok(value) => self.return_value(value.as_ref()),
+            Err(error) => self.return_gerror(error),
+        }
+    }
 }