Merge pull request #564 from arcnmx/variant-dictentry

Variant::from_dict_entry

Author: sdroege

glib/src/variant.rs

@@ -493,6 +493,20 @@ impl Variant {
         }
     }
 
+    // rustdoc-stripper-ignore-next
+    /// Creates a new dictionary entry Variant.
+    ///
+    /// [DictEntry] should be preferred over this when the types are known statically.
+    #[doc(alias = "g_variant_new_dict_entry")]
+    pub fn from_dict_entry(key: &Variant, value: &Variant) -> Self {
+        unsafe {
+            from_glib_none(ffi::g_variant_new_dict_entry(
+                key.to_glib_none().0,
+                value.to_glib_none().0,
+            ))
+        }
+    }
+
     // rustdoc-stripper-ignore-next
     /// Creates a new maybe Variant.
     #[doc(alias = "g_variant_new_maybe")]
@@ -1232,10 +1246,7 @@ impl ToVariant for std::ffi::OsStr {
 
 impl<T: StaticVariantType> StaticVariantType for Option<T> {
     fn static_variant_type() -> Cow<'static, VariantTy> {
-        unsafe {
-            let ptr = ffi::g_variant_type_new_maybe(T::static_variant_type().to_glib_none().0);
-            Cow::Owned(from_glib_full(ptr))
-        }
+        Cow::Owned(VariantType::new_maybe(&T::static_variant_type()))
     }
 }
 
@@ -1521,12 +1532,7 @@ where
     V: StaticVariantType + ToVariant,
 {
     fn to_variant(&self) -> Variant {
-        unsafe {
-            from_glib_none(ffi::g_variant_new_dict_entry(
-                self.key.to_variant().to_glib_none().0,
-                self.value.to_variant().to_glib_none().0,
-            ))
-        }
+        Variant::from_dict_entry(&self.key.to_variant(), &self.value.to_variant())
     }
 }
 
@@ -1544,13 +1550,10 @@ impl FromVariant for Variant {
 
 impl<K: StaticVariantType, V: StaticVariantType> StaticVariantType for DictEntry<K, V> {
     fn static_variant_type() -> Cow<'static, VariantTy> {
-        unsafe {
-            let ptr = ffi::g_variant_type_new_dict_entry(
-                K::static_variant_type().to_glib_none().0,
-                V::static_variant_type().to_glib_none().0,
-            );
-            Cow::Owned(from_glib_full(ptr))
-        }
+        Cow::Owned(VariantType::new_dict_entry(
+            &K::static_variant_type(),
+            &V::static_variant_type(),
+        ))
     }
 }
 
@@ -1609,16 +1612,11 @@ macro_rules! tuple_impls {
                 $($name: StaticVariantType,)+
             {
                 fn static_variant_type() -> Cow<'static, VariantTy> {
-                    let mut builder = crate::GStringBuilder::new("(");
-
-                    $(
-                        let t = $name::static_variant_type();
-                        builder.append(t.as_str());
-                    )+
-
-                    builder.append_c(')');
-
-                    Cow::Owned(VariantType::from_string(builder.into_string()).unwrap())
+                    Cow::Owned(VariantType::new_tuple(&[
+                        $(
+                            $name::static_variant_type(),
+                        )+
+                    ]))
                 }
             }
 

glib/src/variant_type.rs

@@ -38,6 +38,47 @@ impl VariantType {
         VariantTy::new(type_string).map(ToOwned::to_owned)
     }
 
+    // rustdoc-stripper-ignore-next
+    /// Creates a `VariantType` from a key and value type.
+    #[doc(alias = "g_variant_type_new_dict_entry")]
+    pub fn new_dict_entry(key_type: &VariantTy, value_type: &VariantTy) -> VariantType {
+        unsafe {
+            from_glib_full(ffi::g_variant_type_new_dict_entry(
+                key_type.to_glib_none().0,
+                value_type.to_glib_none().0,
+            ))
+        }
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Creates a `VariantType` from an array element type.
+    #[doc(alias = "g_variant_type_new_array")]
+    pub fn new_array(elem_type: &VariantTy) -> VariantType {
+        unsafe { from_glib_full(ffi::g_variant_type_new_array(elem_type.to_glib_none().0)) }
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Creates a `VariantType` from a maybe element type.
+    #[doc(alias = "g_variant_type_new_maybe")]
+    pub fn new_maybe(child_type: &VariantTy) -> VariantType {
+        unsafe { from_glib_full(ffi::g_variant_type_new_maybe(child_type.to_glib_none().0)) }
+    }
+
+    // rustdoc-stripper-ignore-next
+    /// Creates a `VariantType` from a maybe element type.
+    #[doc(alias = "g_variant_type_new_tuple")]
+    pub fn new_tuple<T: AsRef<VariantTy>, I: IntoIterator<Item = T>>(items: I) -> VariantType {
+        let mut builder = crate::GStringBuilder::new("(");
+
+        for ty in items {
+            builder.append(ty.as_ref().as_str());
+        }
+
+        builder.append_c(')');
+
+        VariantType::from_string(builder.into_string()).unwrap()
+    }
+
     // rustdoc-stripper-ignore-next
     /// Tries to create a `VariantType` from an owned string.
     ///
@@ -65,6 +106,12 @@ impl Drop for VariantType {
     }
 }
 
+impl AsRef<VariantTy> for VariantType {
+    fn as_ref(&self) -> &VariantTy {
+        self
+    }
+}
+
 impl Borrow<VariantTy> for VariantType {
     fn borrow(&self) -> &VariantTy {
         self
@@ -577,10 +624,7 @@ impl VariantTy {
         } else if self == VariantTy::DICT_ENTRY {
             Cow::Borrowed(VariantTy::DICTIONARY)
         } else {
-            unsafe {
-                let ptr = ffi::g_variant_type_new_array(self.to_glib_none().0);
-                Cow::Owned(VariantType::from_glib_full(ptr))
-            }
+            Cow::Owned(VariantType::new_array(self))
         }
     }
 }
@@ -608,6 +652,12 @@ impl<'a> From<&'a VariantTy> for Cow<'a, VariantTy> {
     }
 }
 
+impl AsRef<VariantTy> for VariantTy {
+    fn as_ref(&self) -> &Self {
+        self
+    }
+}
+
 impl ToOwned for VariantTy {
     type Owned = VariantType;