Merge pull request #519 from arcnmx/variant-types

dynamic type function variants for Variants and Values

Author: sdroege

glib/src/value.rs

@@ -450,7 +450,15 @@ impl Value {
     /// or is a sub-type of `T`.
     #[inline]
     pub fn is<T: StaticType>(&self) -> bool {
-        self.type_().is_a(T::static_type())
+        self.is_type(T::static_type())
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Returns `true` if the type of the value corresponds to `type_`
+    /// or is a sub-type of `type_`.
+    #[inline]
+    pub fn is_type(&self, type_: Type) -> bool {
+        self.type_().is_a(type_)
     }
 
     // rustdoc-stripper-ignore-next
@@ -475,8 +483,15 @@ impl Value {
     /// Tries to transform the value into a value of the target type
     #[doc(alias = "g_value_transform")]
     pub fn transform<T: ValueType>(&self) -> Result<Value, crate::BoolError> {
+        self.transform_with_type(T::Type::static_type())
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Tries to transform the value into a value of the target type
+    #[doc(alias = "g_value_transform")]
+    pub fn transform_with_type(&self, type_: Type) -> Result<Value, crate::BoolError> {
         unsafe {
-            let mut dest = Value::for_value_type::<T>();
+            let mut dest = Value::from_type(type_);
             if from_glib(gobject_ffi::g_value_transform(
                 self.to_glib_none().0,
                 dest.to_glib_none_mut().0,
@@ -486,7 +501,7 @@ impl Value {
                 Err(crate::bool_error!(
                     "Can't transform value of type '{}' into '{}'",
                     self.type_(),
-                    T::Type::static_type()
+                    type_
                 ))
             }
         }

glib/src/variant.rs

@@ -236,10 +236,20 @@ impl Variant {
     #[inline]
     #[doc(alias = "g_variant_is_of_type")]
     pub fn is<T: StaticVariantType>(&self) -> bool {
+        self.is_type(&T::static_variant_type())
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Returns `true` if the type of the value corresponds to `type_`.
+    ///
+    /// This is equivalent to [`self.type_().is_subtype_of(type_)`](VariantTy::is_subtype_of).
+    #[inline]
+    #[doc(alias = "g_variant_is_of_type")]
+    pub fn is_type(&self, type_: &VariantTy) -> bool {
         unsafe {
             from_glib(ffi::g_variant_is_of_type(
                 self.to_glib_none().0,
-                T::static_variant_type().to_glib_none().0,
+                type_.to_glib_none().0,
             ))
         }
     }
@@ -415,8 +425,20 @@ impl Variant {
     pub fn array_from_iter<T: StaticVariantType, I: IntoIterator<Item = Variant>>(
         children: I,
     ) -> Self {
-        let type_ = T::static_variant_type();
+        Self::array_from_iter_with_type(&T::static_variant_type(), children)
+    }
 
+    // rustdoc-stripper-ignore-next
+    /// Creates a new Variant array from children with the specified type.
+    ///
+    /// # Panics
+    ///
+    /// This function panics if not all variants are of type `type_`.
+    #[doc(alias = "g_variant_new_array")]
+    pub fn array_from_iter_with_type<I: IntoIterator<Item = Variant>>(
+        type_: &VariantTy,
+        children: I,
+    ) -> Self {
         unsafe {
             let mut builder = mem::MaybeUninit::uninit();
             ffi::g_variant_builder_init(builder.as_mut_ptr(), type_.as_array().to_glib_none().0);
@@ -426,7 +448,7 @@ impl Variant {
                     == ffi::GFALSE
                 {
                     ffi::g_variant_builder_clear(&mut builder);
-                    assert!(value.is::<T>());
+                    assert!(value.is_type(type_));
                 }
 
                 ffi::g_variant_builder_add_value(&mut builder, value.to_glib_none().0);
@@ -471,22 +493,55 @@ impl Variant {
     #[doc(alias = "g_variant_new_maybe")]
     pub fn from_maybe<T: StaticVariantType>(child: Option<&Variant>) -> Self {
         let type_ = T::static_variant_type();
-        let ptr = match child {
+        match child {
             Some(child) => {
                 assert_eq!(type_, child.type_());
 
-                child.to_glib_none().0
+                Self::from_some(child)
             }
-            None => std::ptr::null(),
-        };
+            None => Self::from_none(&type_),
+        }
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Creates a new maybe Variant from a child.
+    #[doc(alias = "g_variant_new_maybe")]
+    pub fn from_some(child: &Variant) -> Self {
         unsafe {
             from_glib_none(ffi::g_variant_new_maybe(
-                type_.as_ptr() as *const _,
-                ptr as *mut ffi::GVariant,
+                ptr::null(),
+                child.to_glib_none().0,
             ))
         }
     }
 
+    // rustdoc-stripper-ignore-next
+    /// Creates a new maybe Variant with Nothing.
+    #[doc(alias = "g_variant_new_maybe")]
+    pub fn from_none(type_: &VariantTy) -> Self {
+        unsafe {
+            from_glib_none(ffi::g_variant_new_maybe(
+                type_.to_glib_none().0,
+                ptr::null_mut(),
+            ))
+        }
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Extract the value of a maybe Variant.
+    ///
+    /// Returns the child value, or `None` if the value is Nothing.
+    ///
+    /// # Panics
+    ///
+    /// Panics if compiled with `debug_assertions` and the variant is not maybe-typed.
+    #[inline]
+    pub fn as_maybe(&self) -> Option<Variant> {
+        debug_assert!(self.type_().is_maybe());
+
+        unsafe { from_glib_full(ffi::g_variant_get_maybe(self.to_glib_none().0)) }
+    }
+
     // rustdoc-stripper-ignore-next
     /// Constructs a new serialized-mode GVariant instance.
     #[doc(alias = "g_variant_new_from_bytes")]
@@ -1923,6 +1978,19 @@ mod tests {
         assert_eq!(a.get::<()>(), Some(()));
     }
 
+    #[test]
+    fn test_maybe() {
+        assert!(<Option<()>>::static_variant_type().is_maybe());
+        let m1 = Some(()).to_variant();
+        assert_eq!(m1.type_().as_str(), "m()");
+
+        assert_eq!(m1.get::<Option<()>>(), Some(Some(())));
+        assert!(m1.as_maybe().is_some());
+
+        let m2 = None::<()>.to_variant();
+        assert!(m2.as_maybe().is_none());
+    }
+
     #[test]
     fn test_btreemap() {
         assert_eq!(