add to_owned() methods to Proplist and format::Info

this has proven necessary for adding a lifetime annotation to the
`Proplist` struct and consequently also to `format::Info`. (to follow if
worthwhile).

previously the `to_owned()` methods on introspection structs were creating
owned copies of these two types via their `Clone` implementations (which
always return owned copies). when experimenting with adding the mentioned
lifetime annotations (including changing the output of the `Clone`
implementations to `Foo<'static>`), i ran into confusing compiler errors
complaining that the lifetime of the objects created (in the introspection
`to_owned()` methods) might not live for the `'static` output lifetime.
there was no error to suggest that my modified `Clone` implementations were
invalid, so i couldn't understand what the problem was. i ended up creating
`to_owned()` methods on the `Proplist` and `format::Info` structs,
containing identical code to their `Clone` implementations, and tried using
these methods instead. this fixed the errors. so it seems that for some
reason the `Clone` implementations were not actually honouring the`'static`
output lifetime I'd expressed.

why? the `Clone` trait itself has no lifetime constraints, and does not
provide an associated type for specifying the output of `clone()` which
explicitly specifies `Self` as the output. so either you're not actually
allowed to override the `Self` output like I did, in which case the compiler
let me down by not pointing to the true source of the error; or the compiler
mistakenly derived the lifetime from the `Self` expressed in the trait,
rather the output expression in my implementation. interestingly (since
lifetimes are somewhat poorly explained in rust documentation), from
experimentation i've discovered that `Self` does not take lifetime(s) from
function inputs, but rather from the `impl` line. thus in my commit where
I'd added the lifetime to `Proplist`, if the compiler was indeed using the
`Self` output expressed in the trait definition, then that `Self` would
have taken the lifetime associated with the `Proplist` instance refered to
in `&self`, which would then make sense why the lifetime would not have
been long enough. but still, the compiler either has a bug picking the
correct lifetime, or a deficiency in pointing out the true source of the
error.

additionally, the fact that my `Clone` implementations for these structs
always output owned instances is not necessarily inline with proper
expectations of cloning. note that `std::borrow::Cow` can hold both
borrowed and owned types, and its clone behaviour is such that it creates a
duplicate that matches the original, thus borrowed if the original is
borrowed, or owned if the original is owned. mine should probably have the
same behaviour. if i do change mine accordingly, I'd need such `to_owned()`
methods as added here to provide a means of forcing the creation of an
owned instance from a borrowed one.

note that the return type of `Self` here is fine since the types do not
currently have a lifetime annotation, so effectively the return instances
are owned/static.

Author: jnqnfe

pulse-binding/src/context/ext_device_restore.rs

@@ -56,7 +56,7 @@ impl Info {
     /// Creates a copy with owned data.
     pub fn to_owned(&self) -> Self {
         Info {
-            formats: self.formats.clone(), //Our implementation makes an owned copy!
+            formats: self.formats.iter().map(format::Info::to_owned).collect(),
             ..*self
         }
     }

pulse-binding/src/context/introspect.rs

@@ -471,10 +471,10 @@ impl SinkInfo<'_> {
             description: self.description.clone().map(|o| Cow::Owned(o.into_owned())),
             monitor_source_name: self.monitor_source_name.clone().map(|o| Cow::Owned(o.into_owned())),
             driver: self.driver.clone().map(|o| Cow::Owned(o.into_owned())),
-            proplist: self.proplist.clone(), //Our implementation makes an owned copy!
+            proplist: self.proplist.to_owned(),
             ports: self.ports.iter().map(SinkPortInfo::to_owned).collect(),
             active_port: self.active_port.as_ref().map(|ap| Box::new(ap.as_ref().to_owned())),
-            formats: self.formats.clone(), //Our implementation makes an owned copy!
+            formats: self.formats.iter().map(format::Info::to_owned).collect(),
             ..*self
         }
     }
@@ -901,10 +901,10 @@ impl SourceInfo<'_> {
             description: self.description.clone().map(|o| Cow::Owned(o.into_owned())),
             monitor_of_sink_name: self.monitor_of_sink_name.clone().map(|o| Cow::Owned(o.into_owned())),
             driver: self.driver.clone().map(|o| Cow::Owned(o.into_owned())),
-            proplist: self.proplist.clone(), //Our implementation makes an owned copy!
+            proplist: self.proplist.to_owned(),
             ports: self.ports.iter().map(SourcePortInfo::to_owned).collect(),
             active_port: self.active_port.as_ref().map(|ap| Box::new(ap.as_ref().to_owned())),
-            formats: self.formats.clone(), //Our implementation makes an owned copy!
+            formats: self.formats.iter().map(format::Info::to_owned).collect(),
             ..*self
         }
     }
@@ -1271,7 +1271,7 @@ impl ModuleInfo<'_> {
         ModuleInfo {
             name: self.name.clone().map(|o| Cow::Owned(o.into_owned())),
             argument: self.argument.clone().map(|o| Cow::Owned(o.into_owned())),
-            proplist: self.proplist.clone(), //Our implementation makes an owned copy!
+            proplist: self.proplist.to_owned(),
             ..*self
         }
     }
@@ -1469,7 +1469,7 @@ impl ClientInfo<'_> {
         ClientInfo {
             name: self.name.clone().map(|o| Cow::Owned(o.into_owned())),
             driver: self.driver.clone().map(|o| Cow::Owned(o.into_owned())),
-            proplist: self.proplist.clone(), //Our implementation makes an owned copy!
+            proplist: self.proplist.to_owned(),
             ..*self
         }
     }
@@ -1688,7 +1688,7 @@ impl CardPortInfo<'_> {
         CardPortInfo {
             name: self.name.clone().map(|o| Cow::Owned(o.into_owned())),
             description: self.description.clone().map(|o| Cow::Owned(o.into_owned())),
-            proplist: self.proplist.clone(), //Our implementation makes an owned copy!
+            proplist: self.proplist.to_owned(),
             profiles: self.profiles.iter().map(CardProfileInfo::to_owned).collect(),
             #[cfg(any(doc, feature = "pa_v14"))]
             availability_group: self.availability_group.clone().map(|o| Cow::Owned(o.into_owned())),
@@ -1776,7 +1776,7 @@ impl CardInfo<'_> {
         CardInfo {
             name: self.name.clone().map(|o| Cow::Owned(o.into_owned())),
             driver: self.driver.clone().map(|o| Cow::Owned(o.into_owned())),
-            proplist: self.proplist.clone(), //Our implementation makes an owned copy!
+            proplist: self.proplist.to_owned(),
             ports: self.ports.iter().map(CardPortInfo::to_owned).collect(),
             profiles: self.profiles.iter().map(CardProfileInfo::to_owned).collect(),
             active_profile: self.active_profile.as_ref().map(|ap| Box::new(ap.as_ref().to_owned())),
@@ -2014,8 +2014,8 @@ impl SinkInputInfo<'_> {
             name: self.name.clone().map(|o| Cow::Owned(o.into_owned())),
             resample_method: self.resample_method.clone().map(|o| Cow::Owned(o.into_owned())),
             driver: self.driver.clone().map(|o| Cow::Owned(o.into_owned())),
-            proplist: self.proplist.clone(), //Our implementation makes an owned copy!
-            format: self.format.clone(), //Our implementation makes an owned copy!
+            proplist: self.proplist.to_owned(),
+            format: self.format.to_owned(),
             ..*self
         }
     }
@@ -2255,8 +2255,8 @@ impl SourceOutputInfo<'_> {
             name: self.name.clone().map(|o| Cow::Owned(o.into_owned())),
             resample_method: self.resample_method.clone().map(|o| Cow::Owned(o.into_owned())),
             driver: self.driver.clone().map(|o| Cow::Owned(o.into_owned())),
-            proplist: self.proplist.clone(), //Our implementation makes an owned copy!
-            format: self.format.clone(), //Our implementation makes an owned copy!
+            proplist: self.proplist.to_owned(),
+            format: self.format.to_owned(),
             ..*self
         }
     }
@@ -2479,7 +2479,7 @@ impl SampleInfo<'_> {
         SampleInfo {
             name: self.name.clone().map(|o| Cow::Owned(o.into_owned())),
             filename: self.filename.clone().map(|o| Cow::Owned(o.into_owned())),
-            proplist: self.proplist.clone(), //Our implementation makes an owned copy!
+            proplist: self.proplist.to_owned(),
             ..*self
         }
     }

pulse-binding/src/format.rs

@@ -224,6 +224,15 @@ impl Info {
         unsafe { Self { ptr: ptr, properties: Proplist::from_raw_weak((*ptr).list), weak: true } }
     }
 
+    /// Returns a new `Info` struct representing the same format.
+    ///
+    /// If this is called on a ‘weak’ instance, a non-weak object is returned.
+    #[inline]
+    pub(crate) fn to_owned(&self) -> Self {
+        let ptr = unsafe { capi::pa_format_info_copy(self.ptr as *const capi::pa_format_info) };
+        Self::from_raw(ptr as *mut InfoInternal)
+    }
+
     /// Checks whether the `Info` structure is valid.
     #[inline]
     pub fn is_valid(&self) -> bool {
@@ -592,8 +601,6 @@ impl Clone for Info {
     ///
     /// If this is called on a ‘weak’ instance, a non-weak object is returned.
     fn clone(&self) -> Self {
-        let ptr = unsafe { capi::pa_format_info_copy(self.ptr as *const capi::pa_format_info) };
-        assert_eq!(false, ptr.is_null());
-        Self::from_raw(ptr as *mut InfoInternal)
+        self.to_owned()
     }
 }

pulse-binding/src/proplist.rs

@@ -251,6 +251,14 @@ impl Proplist {
         Proplist(ProplistInner { ptr: ptr, weak: true })
     }
 
+    /// Allocates a new property list and copies over every single entry from the specified list.
+    ///
+    /// If this is called on a ‘weak’ instance, a non-weak object is returned.
+    #[inline]
+    pub(crate) fn to_owned(&self) -> Self {
+        Self::from_raw(unsafe { capi::pa_proplist_copy(self.0.ptr) })
+    }
+
     /// Checks if the key is valid.
     pub fn key_is_valid(key: &str) -> bool {
         // Warning: New CStrings will be immediately freed if not bound to a variable, leading to
@@ -499,7 +507,7 @@ impl Clone for Proplist {
     /// If this is called on a ‘weak’ instance, a non-weak object is returned.
     #[inline]
     fn clone(&self) -> Self {
-        Self::from_raw(unsafe { capi::pa_proplist_copy(self.0.ptr) })
+        self.to_owned()
     }
 }