glib: VariantType::new_tuple

Also impl AsRef for VariantTy{pe,}

Author: arcnmx

glib/src/variant.rs

@@ -1605,16 +1605,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

@@ -64,6 +64,21 @@ impl 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.
     ///
@@ -91,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
@@ -631,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;