pipewire 0.10.0

Rust bindings for PipeWire
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

// Copyright The pipewire-rs Contributors.
// SPDX-License-Identifier: MIT

use std::{marker::PhantomData, ops::Deref, ptr};

use crate::core::Core;

use super::Registry;

/// Smart pointer providing unique ownership of a PipeWire [registry](super).
///
/// For shared ownership, see [`RegistryRc`](super::RegistryRc).
///
/// For an explanation of these, see [Smart pointers to PipeWire objects](crate#smart-pointers-to-pipewire-objects).
#[derive(Debug)]
pub struct RegistryBox<'c> {
    ptr: ptr::NonNull<pw_sys::pw_registry>,
    core: PhantomData<&'c Core>,
}

impl<'c> RegistryBox<'c> {
    /// Create a `RegistryBox` by taking ownership of a raw `pw_registry`.
    ///
    /// # Safety
    /// The provided pointer must point to a valid, well aligned [`pw_registry`](`pw_sys::pw_registry`).
    ///
    /// The raw registry must not be manually destroyed or moved, as the new [`RegistryBox`] takes
    /// ownership of it.
    ///
    /// The lifetime of the returned box is unbounded. The caller is responsible to make sure
    /// that the core used with this registry outlives the registry.
    pub unsafe fn from_raw(ptr: ptr::NonNull<pw_sys::pw_registry>) -> Self {
        Self {
            ptr,
            core: PhantomData,
        }
    }
}

impl<'c> std::ops::Deref for RegistryBox<'c> {
    type Target = Registry;

    fn deref(&self) -> &Self::Target {
        unsafe { self.ptr.cast::<Registry>().as_ref() }
    }
}

impl<'c> AsRef<Registry> for RegistryBox<'c> {
    fn as_ref(&self) -> &Registry {
        self.deref()
    }
}

impl<'c> Drop for RegistryBox<'c> {
    fn drop(&mut self) {
        unsafe {
            pw_sys::pw_proxy_destroy(self.as_raw_ptr().cast());
        }
    }
}