glib: Add new object constructor for constructing an object with default property values

And also keep the `gio::Initable` / `gio::AsyncInitable` API in sync,
i.e. add a builder and the new contructors there too.

Author: sdroege

examples/gio_task/file_size/mod.rs

@@ -13,7 +13,7 @@ unsafe impl Sync for FileSize {}
 
 impl FileSize {
     pub fn new() -> Self {
-        glib::Object::new(&[])
+        glib::Object::new_default()
     }
 
     pub fn retrieved_size(&self) -> Option<i64> {

gio/src/async_initable.rs

@@ -1,23 +1,28 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use std::{boxed::Box as Box_, pin::Pin};
+use std::{boxed::Box as Box_, marker::PhantomData, pin::Pin};
 
 use futures_util::TryFutureExt;
 use glib::{object::IsClass, prelude::*, Object, Type};
 
 use crate::{prelude::*, AsyncInitable, Cancellable};
 
 impl AsyncInitable {
+    // rustdoc-stripper-ignore-next
+    /// Create a new instance of an async initable object with the given properties.
+    ///
+    /// Similar to [`Object::new`] but can fail because the object initialization in
+    /// `AsyncInitable::init` failed.
+    #[allow(clippy::new_ret_no_self)]
     #[doc(alias = "g_async_initable_new_async")]
     #[track_caller]
-    pub fn new_async<
-        O: Sized + IsClass + IsA<Object> + IsA<AsyncInitable>,
-        P: IsA<Cancellable>,
+    pub fn new<
+        O: IsClass + IsA<Object> + IsA<AsyncInitable>,
         Q: FnOnce(Result<O, glib::Error>) + 'static,
     >(
         properties: &[(&str, &dyn ToValue)],
         io_priority: glib::Priority,
-        cancellable: Option<&P>,
+        cancellable: Option<&impl IsA<Cancellable>>,
         callback: Q,
     ) {
         Self::with_type(
@@ -29,9 +34,14 @@ impl AsyncInitable {
         )
     }
 
+    // rustdoc-stripper-ignore-next
+    /// Create a new instance of an async initable object with the given properties as future.
+    ///
+    /// Similar to [`Object::new`] but can fail because the object initialization in
+    /// `AsyncInitable::init` failed.
     #[doc(alias = "g_async_initable_new_async")]
     #[track_caller]
-    pub fn new_future<O: Sized + IsClass + IsA<Object> + IsA<AsyncInitable>>(
+    pub fn new_future<O: IsClass + IsA<Object> + IsA<AsyncInitable>>(
         properties: &[(&str, &dyn ToValue)],
         io_priority: glib::Priority,
     ) -> Pin<Box_<dyn std::future::Future<Output = Result<O, glib::Error>> + 'static>> {
@@ -41,13 +51,18 @@ impl AsyncInitable {
         )
     }
 
+    // rustdoc-stripper-ignore-next
+    /// Create a new instance of an async initable object of the given type with the given properties.
+    ///
+    /// Similar to [`Object::with_type`] but can fail because the object initialization in
+    /// `AsyncInitable::init` failed.
     #[doc(alias = "g_async_initable_new_async")]
     #[track_caller]
-    pub fn with_type<P: IsA<Cancellable>, Q: FnOnce(Result<Object, glib::Error>) + 'static>(
+    pub fn with_type<Q: FnOnce(Result<Object, glib::Error>) + 'static>(
         type_: Type,
         properties: &[(&str, &dyn ToValue)],
         io_priority: glib::Priority,
-        cancellable: Option<&P>,
+        cancellable: Option<&impl IsA<Cancellable>>,
         callback: Q,
     ) {
         if !type_.is_a(AsyncInitable::static_type()) {
@@ -71,6 +86,11 @@ impl AsyncInitable {
         };
     }
 
+    // rustdoc-stripper-ignore-next
+    /// Create a new instance of an async initable object of the given type with the given properties as future.
+    ///
+    /// Similar to [`Object::with_type`] but can fail because the object initialization in
+    /// `AsyncInitable::init` failed.
     #[doc(alias = "g_async_initable_new_async")]
     #[track_caller]
     pub fn with_type_future(
@@ -105,13 +125,116 @@ impl AsyncInitable {
         }
     }
 
+    // rustdoc-stripper-ignore-next
+    /// Create a new instance of an async initable object with the default property values.
+    ///
+    /// Similar to [`Object::new_default`] but can fail because the object initialization in
+    /// `AsyncInitable::init` failed.
     #[doc(alias = "g_async_initable_new_async")]
     #[track_caller]
-    pub fn with_values<P: IsA<Cancellable>, Q: FnOnce(Result<Object, glib::Error>) + 'static>(
+    pub fn new_default<
+        O: IsClass + IsA<Object> + IsA<AsyncInitable>,
+        Q: FnOnce(Result<O, glib::Error>) + 'static,
+    >(
+        io_priority: glib::Priority,
+        cancellable: Option<&impl IsA<Cancellable>>,
+        callback: Q,
+    ) {
+        Self::new_default_with_type(O::static_type(), io_priority, cancellable, move |res| {
+            callback(res.map(|o| unsafe { o.unsafe_cast() }))
+        })
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Create a new instance of an async initable object with the default property values as future.
+    ///
+    /// Similar to [`Object::new_default`] but can fail because the object initialization in
+    /// `AsyncInitable::init` failed.
+    #[doc(alias = "g_async_initable_new_async")]
+    #[track_caller]
+    pub fn new_default_future<O: IsClass + IsA<Object> + IsA<AsyncInitable>>(
+        io_priority: glib::Priority,
+    ) -> Pin<Box_<dyn std::future::Future<Output = Result<O, glib::Error>> + 'static>> {
+        Box::pin(
+            Self::new_default_with_type_future(O::static_type(), io_priority)
+                .map_ok(|o| unsafe { o.unsafe_cast() }),
+        )
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Create a new instance of an async initable object of the given type with the default
+    /// property values.
+    ///
+    /// Similar to [`Object::new_default_with_type`] but can fail because the object initialization in
+    /// `AsyncInitable::init` failed.
+    #[doc(alias = "g_async_initable_new_async")]
+    #[track_caller]
+    pub fn new_default_with_type<Q: FnOnce(Result<Object, glib::Error>) + 'static>(
+        type_: Type,
+        io_priority: glib::Priority,
+        cancellable: Option<&impl IsA<Cancellable>>,
+        callback: Q,
+    ) {
+        if !type_.is_a(AsyncInitable::static_type()) {
+            panic!("Type '{type_}' is not async initable");
+        }
+
+        unsafe {
+            let obj = Object::new_internal(type_, &mut []);
+            obj.unsafe_cast_ref::<Self>().init_async(
+                io_priority,
+                cancellable,
+                glib::clone!(@strong obj => move |res| {
+                    callback(res.map(|_| obj));
+                }),
+            )
+        };
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Create a new instance of an async initable object of the given type with the default property values as future.
+    ///
+    /// Similar to [`Object::new_default_with_type`] but can fail because the object initialization in
+    /// `AsyncInitable::init` failed.
+    #[doc(alias = "g_async_initable_new_async")]
+    #[track_caller]
+    pub fn new_default_with_type_future(
+        type_: Type,
+        io_priority: glib::Priority,
+    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Object, glib::Error>> + 'static>> {
+        if !type_.is_a(AsyncInitable::static_type()) {
+            panic!("Type '{type_}' is not async initable");
+        }
+
+        unsafe {
+            Box_::pin(crate::GioFuture::new(
+                &(),
+                move |_obj, cancellable, send| {
+                    let obj = Object::new_internal(type_, &mut []);
+                    obj.unsafe_cast_ref::<Self>().init_async(
+                        io_priority,
+                        Some(cancellable),
+                        glib::clone!(@strong obj => move |res| {
+                            send.resolve(res.map(|_| obj));
+                        }),
+                    );
+                },
+            ))
+        }
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Create a new instance of an async initable object of the given type with the given properties.
+    ///
+    /// Similar to [`Object::with_values`] but can fail because the object initialization in
+    /// `AsyncInitable::init` failed.
+    #[doc(alias = "g_async_initable_new_async")]
+    #[track_caller]
+    pub fn with_values<Q: FnOnce(Result<Object, glib::Error>) + 'static>(
         type_: Type,
         properties: &[(&str, glib::Value)],
         io_priority: glib::Priority,
-        cancellable: Option<&P>,
+        cancellable: Option<&impl IsA<Cancellable>>,
         callback: Q,
     ) {
         if !type_.is_a(AsyncInitable::static_type()) {
@@ -135,6 +258,11 @@ impl AsyncInitable {
         };
     }
 
+    // rustdoc-stripper-ignore-next
+    /// Create a new instance of an async initable object of the given type with the given properties as a future.
+    ///
+    /// Similar to [`Object::with_values`] but can fail because the object initialization in
+    /// `AsyncInitable::init` failed.
     #[doc(alias = "g_async_initable_new_async")]
     #[track_caller]
     pub fn with_values_future(
@@ -168,4 +296,171 @@ impl AsyncInitable {
             ))
         }
     }
+
+    // rustdoc-stripper-ignore-next
+    /// Create a new instance of an async initable object of the given type with the given properties as mutable values.
+    ///
+    /// Similar to [`Object::with_mut_values`] but can fail because the object initialization in
+    /// `AsyncInitable::init` failed.
+    #[doc(alias = "g_async_initable_new_async")]
+    #[track_caller]
+    pub fn with_mut_values<Q: FnOnce(Result<Object, glib::Error>) + 'static>(
+        type_: Type,
+        properties: &mut [(&str, glib::Value)],
+        io_priority: glib::Priority,
+        cancellable: Option<&impl IsA<Cancellable>>,
+        callback: Q,
+    ) {
+        if !type_.is_a(AsyncInitable::static_type()) {
+            panic!("Type '{type_}' is not async initable");
+        }
+
+        unsafe {
+            let obj = Object::new_internal(type_, properties);
+            obj.unsafe_cast_ref::<Self>().init_async(
+                io_priority,
+                cancellable,
+                glib::clone!(@strong obj => move |res| {
+                    callback(res.map(|_| obj));
+                }),
+            )
+        };
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Create a new instance of an async initable object of the given type with the given properties as mutable values as a future.
+    ///
+    /// Similar to [`Object::with_mut_values`] but can fail because the object initialization in
+    /// `AsyncInitable::init` failed.
+    #[doc(alias = "g_async_initable_new_async")]
+    #[track_caller]
+    pub fn with_mut_values_future(
+        type_: Type,
+        properties: &mut [(&str, glib::Value)],
+        io_priority: glib::Priority,
+    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Object, glib::Error>> + 'static>> {
+        if !type_.is_a(AsyncInitable::static_type()) {
+            panic!("Type '{type_}' is not async initable");
+        }
+
+        unsafe {
+            // FIXME: object construction should ideally happen as part of the future
+            let obj = Object::new_internal(type_, properties);
+            Box_::pin(crate::GioFuture::new(
+                &obj,
+                move |obj, cancellable, send| {
+                    obj.unsafe_cast_ref::<Self>().init_async(
+                        io_priority,
+                        Some(cancellable),
+                        glib::clone!(@strong obj => move |res| {
+                            send.resolve(res.map(|_| obj));
+                        }),
+                    );
+                },
+            ))
+        }
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Create a new object builder for a specific type.
+    pub fn builder<'a, O: IsA<Object> + IsClass + IsA<AsyncInitable>>(
+    ) -> AsyncInitableBuilder<'a, O> {
+        AsyncInitableBuilder::new(O::static_type())
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Create a new object builder for a specific type.
+    pub fn builder_with_type<'a>(type_: Type) -> AsyncInitableBuilder<'a, Object> {
+        if !type_.is_a(AsyncInitable::static_type()) {
+            panic!("Type '{type_}' is not async initable");
+        }
+
+        AsyncInitableBuilder::new(type_)
+    }
+}
+
+#[must_use = "builder doesn't do anything unless built"]
+pub struct AsyncInitableBuilder<'a, O> {
+    type_: Type,
+    properties: smallvec::SmallVec<[(&'a str, glib::Value); 16]>,
+    phantom: PhantomData<O>,
+}
+
+impl<'a, O: IsA<Object> + IsClass> AsyncInitableBuilder<'a, O> {
+    #[inline]
+    fn new(type_: Type) -> Self {
+        AsyncInitableBuilder {
+            type_,
+            properties: smallvec::SmallVec::new(),
+            phantom: PhantomData,
+        }
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Gets the type of this builder.
+    #[inline]
+    pub fn type_(&self) -> Type {
+        self.type_
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Set property `name` to the given value `value`.
+    #[inline]
+    pub fn property(self, name: &'a str, value: impl Into<glib::Value>) -> Self {
+        let AsyncInitableBuilder {
+            type_,
+            mut properties,
+            ..
+        } = self;
+        properties.push((name, value.into()));
+
+        AsyncInitableBuilder {
+            type_,
+            properties,
+            phantom: PhantomData,
+        }
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Build the object with the provided properties.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the object is not instantiable, doesn't have all the given properties or
+    /// property values of the wrong type are provided.
+    #[track_caller]
+    #[inline]
+    pub fn build<Q: FnOnce(Result<O, glib::Error>) + 'static>(
+        mut self,
+        io_priority: glib::Priority,
+        cancellable: Option<&impl IsA<Cancellable>>,
+        callback: Q,
+    ) {
+        AsyncInitable::with_mut_values(
+            self.type_,
+            &mut self.properties,
+            io_priority,
+            cancellable,
+            move |res| callback(res.map(|o| unsafe { o.unsafe_cast() })),
+        );
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Build the object with the provided properties.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the object is not instantiable, doesn't have all the given properties or
+    /// property values of the wrong type are provided.
+    #[track_caller]
+    #[inline]
+    pub fn build_future(
+        mut self,
+        io_priority: glib::Priority,
+    ) -> Pin<Box_<dyn std::future::Future<Output = Result<O, glib::Error>> + 'static>> {
+        Box::pin(
+            AsyncInitable::with_mut_values_future(self.type_, &mut self.properties, io_priority)
+                .map_ok(|o| unsafe { o.unsafe_cast() }),
+        )
+    }
 }