Skip to content

Commit

Permalink
Merge pull request #570 from sdroege/0.15-backports
Browse files Browse the repository at this point in the history 
0.15 backports
  • Loading branch information
@sdroege
sdroege committed Feb 20, 2022
2 parents ce140d7 + d4f17e4 commit 1e230dd
Show file tree
Hide file tree
Showing 3 changed files with 91 additions and 35 deletions.
3 changes: 2 additions & 1 deletion glib-macros/src/variant_derive.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -35,6 +35,7 @@ pub fn derive_variant_for_struct(
.collect::<Vec<_>>();

let idents = (0..types.len()).map(syn::Index::from).collect::<Vec<_>>();
let idents_len = idents.len();

let static_variant_type = quote! {
impl #generics #glib::StaticVariantType for #ident #generics {
Expand Down Expand Up @@ -62,7 +63,7 @@ pub fn derive_variant_for_struct(
let to_variant = quote! {
impl #generics #glib::ToVariant for #ident #generics {
fn to_variant(&self) -> #glib::Variant {
#glib::Variant::tuple_from_iter(::std::array::IntoIter::new([
#glib::Variant::tuple_from_iter(::std::array::IntoIter::<#glib::Variant, #idents_len>::new([
#(
#glib::ToVariant::to_variant(&self.#idents)
),*
Expand Down
65 changes: 35 additions & 30 deletions glib/src/variant.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -439,7 +439,7 @@ impl Variant {
///
/// 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>>(
pub fn array_from_iter_with_type<T: AsRef<Variant>, I: IntoIterator<Item = T>>(
type_: &VariantTy,
children: I,
) -> Self {
Expand All @@ -448,6 +448,7 @@ impl Variant {
ffi::g_variant_builder_init(builder.as_mut_ptr(), type_.as_array().to_glib_none().0);
let mut builder = builder.assume_init();
for value in children.into_iter() {
let value = value.as_ref();
if ffi::g_variant_is_of_type(value.to_glib_none().0, type_.to_glib_none().0)
== ffi::GFALSE
{
Expand Down Expand Up @@ -480,18 +481,32 @@ impl Variant {
// rustdoc-stripper-ignore-next
/// Creates a new Variant tuple from children.
#[doc(alias = "g_variant_new_tuple")]
pub fn tuple_from_iter(children: impl IntoIterator<Item = Variant>) -> Self {
pub fn tuple_from_iter(children: impl IntoIterator<Item = impl AsRef<Variant>>) -> Self {
unsafe {
let mut builder = mem::MaybeUninit::uninit();
ffi::g_variant_builder_init(builder.as_mut_ptr(), VariantTy::TUPLE.to_glib_none().0);
let mut builder = builder.assume_init();
for value in children.into_iter() {
ffi::g_variant_builder_add_value(&mut builder, value.to_glib_none().0);
ffi::g_variant_builder_add_value(&mut builder, value.as_ref().to_glib_none().0);
}
from_glib_none(ffi::g_variant_builder_end(&mut builder))
}
}

// 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")]
Expand Down Expand Up @@ -881,6 +896,12 @@ impl Hash for Variant {
}
}

impl AsRef<Variant> for Variant {
fn as_ref(&self) -> &Self {
self
}
}

// rustdoc-stripper-ignore-next
/// Converts to `Variant`.
pub trait ToVariant {
Expand Down Expand Up @@ -1225,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()))
}
}

Expand Down Expand Up @@ -1514,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())
}
}

Expand All @@ -1537,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(),
))
}
}

Expand Down Expand Up @@ -1602,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(),
)+
]))
}
}

Expand Down
58 changes: 54 additions & 4 deletions glib/src/variant_type.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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.
///
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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))
}
}
}
Expand Down Expand Up @@ -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;

Expand Down

0 comments on commit 1e230dd

Please sign in to comment.