PipeWire Native SPA

https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/
Admin
PipeWire Native SPA is a Rust library providing native bindings for PipeWire's SPA (Simple Plugin...
Tokens:529,691
Snippets:3,063
Trust Score:9.7
Update:10 months ago
Show doc for...
Tokens:
Raw
### pipewire_native_spa::interface::plugin::Handle Trait

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/plugin/trait.Handle_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Documentation for the Handle trait, including its required methods and an example implementor.

```APIDOC
## Trait pipewire_native_spa::interface::plugin::Handle

### Description

The `Handle` trait defines the core interface for interacting with PipeWire plugins.

### Methods

#### `version(&self) -> u32`

Returns the version of the plugin interface.

#### `get_interface(&self, type_: &str) -> Option<Box<dyn Interface>>`

Retrieves a specific interface implementation by its type string.

### Implementors

*   `PluginHandle`
```

--------------------------------

### Get TypeId of an Object

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/pod/parser/struct.ObjectParser

Gets the `TypeId` of `self`, which can be used for runtime type checks. This is part of the `Any` trait implementation.

```rust
fn type_id(&self) -> TypeId;
```

--------------------------------

### Box Initialization Methods in Rust

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/thread/type.ThreadReturn_search=

Demonstrates various methods for creating and initializing `Box` instances in Rust. Includes methods for allocating on the heap, handling uninitialized memory, zeroed memory, and experimental allocator API support. These methods are crucial for managing heap-allocated data.

```rust
let five = Box::new(5);

```

```rust
let mut five = Box::<u32>::new_uninit();
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5)

```

```rust
#![feature(new_zeroed_alloc)]

let zero = Box::<u32>::new_zeroed();
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0)

```

```rust
#![feature(allocator_api)]

let five = Box::try_new(5)?;

```

```rust
#![feature(allocator_api)]

let mut five = Box::<u32>::try_new_uninit()?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);

```

```rust
#![feature(allocator_api)]

let zero = Box::<u32>::try_new_zeroed()?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);

```

--------------------------------

### Plugin Initialization and Factory Methods in Rust

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/support/plugin/struct.Plugin_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates the creation of a new 'Plugin' instance and its implementation of the 'HandleFactory' trait. This includes methods for retrieving the plugin's version, name, information, and initialization logic.

```rust
impl Plugin {
    pub fn new() -> Self
}

impl HandleFactory for Plugin {
    fn version(&self) -> u32
    fn name(&self) -> &str
    fn info(&self) -> Option<&Dict>
    fn init( &self, _: Option<Dict>, _: &Support, ) -> Result<Box<dyn Handle + Send + Sync>>
}

```

--------------------------------

### bits() -> u32

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/param/struct.ParamInfoFlags_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the underlying bits value.

```APIDOC
## fn bits(&self) -> u32

### Description
Get the underlying bits value.

### Method
Function

### Response
#### Success Response
- **u32** (u32) - The underlying bits value.

```

--------------------------------

### Box Creation and Initialization

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/thread/type.ThreadReturn

Methods for creating and initializing Box instances with specific allocators and memory filling options.

```APIDOC
## POST /box/try_new_zeroed_in

### Description
Constructs a new `Box` with uninitialized contents, filling the memory with `0` bytes using the provided allocator. Returns an error if allocation fails. This is a nightly-only experimental API.

### Method
POST

### Endpoint
`/box/try_new_zeroed_in`

### Parameters
#### Query Parameters
- **alloc** (Allocator) - Required - The allocator to use for memory allocation.

#### Request Body
- **T** (type) - Required - The type of the value to be boxed.

### Request Example
```json
{
  "alloc": "System",
  "value_type": "u32"
}
```

### Response
#### Success Response (200)
- **Box<MaybeUninit<T>, A>** (Box) - A Box with zeroed, uninitialized memory.

#### Response Example
```json
{
  "value": "0x00000000"
}
```
```

```APIDOC
## POST /box/pin_in

### Description
Constructs a new `Pin<Box<T, A>>`. If `T` does not implement `Unpin`, the value `x` will be pinned in memory and unable to be moved. This is a nightly-only experimental API.

### Method
POST

### Endpoint
`/box/pin_in`

### Parameters
#### Query Parameters
- **alloc** (Allocator) - Required - The allocator to use.

#### Request Body
- **x** (T) - Required - The value to be pinned and boxed.

### Request Example
```json
{
  "alloc": "System",
  "x": 10
}
```

### Response
#### Success Response (200)
- **Pin<Box<T, A>>** (Pin<Box>) - A pinned Box containing the value.

#### Response Example
```json
{
  "pinned_box": "0x12345678"
}
```
```

--------------------------------

### all() -> Self

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/param/struct.ParamInfoFlags_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets a flags value with all known bits set.

```APIDOC
## fn all() -> Self

### Description
Get a flags value with all known bits set.

### Method
Function

### Response
#### Success Response
- **Self** (ParamInfoFlags) - A flags value with all known bits set.

```

--------------------------------

### Loop Struct and Initialization

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/support/loop/struct.Loop_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Documentation for the Loop struct and its constructor `new_impl`.

```APIDOC
## Loop Struct

### Description
Represents a loop mechanism within the pipewire-native-spa library. Internal fields are private.

### Source Code
```rust
pub struct Loop { /* private fields */ }
```

## Implementations

### `impl Loop`

#### `pub fn new_impl(support: &Support) -> Result<LoopImpl>`

##### Description
Creates a new instance of `LoopImpl` using the provided `Support` object. Returns a `Result` which can be `Ok(LoopImpl)` on success or an error.

##### Method
`new_impl`

##### Parameters
- **support** (`&Support`) - Required - A reference to the `Support` object required for loop creation.

##### Response
#### Success Response (200)
- **LoopImpl** - An instance of `LoopImpl`.

#### Response Example
```json
{
  "LoopImpl": "<instance_of_loop_impl>"
}
```
```

--------------------------------

### empty() -> Self

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/param/struct.ParamInfoFlags_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets a flags value with all bits unset.

```APIDOC
## fn empty() -> Self

### Description
Get a flags value with all bits unset.

### Method
Function

### Response
#### Success Response
- **Self** (ParamInfoFlags) - A flags value with all bits unset.

```

--------------------------------

### ArmCpuFlags Bit Manipulation

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/cpu/struct.ArmCpuFlags_search=u32+-%3E+bool

Methods for getting, setting, and converting underlying bit representations.

```APIDOC
## POST /armcpufalgs/bits

### Description
Gets the underlying bits value of an ArmCpuFlags.

### Method
POST

### Endpoint
/armcpufalgs/bits

### Parameters
#### Request Body
- **self** (ArmCpuFlags) - Required - The flags value.

### Request Example
```json
{
  "self": "0b1010"
}
```

### Response
#### Success Response (200)
- **bits** (u32) - The underlying bits value.

#### Response Example
```json
{
  "bits": 10
}
```

## POST /armcpufalgs/from_bits_retain

### Description
Converts from a bits value exactly, keeping all bits.

### Method
POST

### Endpoint
/armcpufalgs/from_bits_retain

### Parameters
#### Request Body
- **bits** (u32) - Required - The bits value to convert from.

### Request Example
```json
{
  "bits": 10
}
```

### Response
#### Success Response (200)
- **result** (ArmCpuFlags) - The ArmCpuFlags value.

#### Response Example
```json
{
  "result": "0b1010"
}
```

## POST /armcpufalgs/from_bits

### Description
Converts from a bits value, returning `None` if unknown bits are present.

### Method
POST

### Endpoint
/armcpufalgs/from_bits

### Parameters
#### Request Body
- **bits** (Self::Bits) - Required - The bits value to convert from.

### Request Example
```json
{
  "bits": 10
}
```

### Response
#### Success Response (200)
- **result** (Option<ArmCpuFlags>) - The ArmCpuFlags value if conversion is successful, otherwise None.

#### Response Example
```json
{
  "result": "0b1010"
}
```

## POST /armcpufalgs/from_bits_truncate

### Description
Converts from a bits value, unsetting any unknown bits.

### Method
POST

### Endpoint
/armcpufalgs/from_bits_truncate

### Parameters
#### Request Body
- **bits** (Self::Bits) - Required - The bits value to convert from.

### Request Example
```json
{
  "bits": 10
}
```

### Response
#### Success Response (200)
- **result** (ArmCpuFlags) - The ArmCpuFlags value with unknown bits truncated.

#### Response Example
```json
{
  "result": "0b1010"
}
```
```

--------------------------------

### Create SystemImpl Instance with pipewire-native-spa

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/support/system/fn.new_search=std%3A%3Avec

This function, `new`, is part of the `pipewire_native_spa::support::system` module. It is used to create a new instance of `SystemImpl`. This is a fundamental operation for interacting with the system's PipeWire support.

```rust
pub fn new() -> SystemImpl
```

--------------------------------

### Consume Box to Get Inner Value

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/thread/type.ThreadReturn_search=

Consumes the Box and returns the wrapped value. This is a nightly-only experimental API.

```rust
#![feature(box_into_inner)]

let c = Box::new(5);

assert_eq!(Box::into_inner(c), 5);

```

--------------------------------

### Rust: Initialize and Use POD Parser

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/pod/parser/struct.Parser_search=

Demonstrates how to create a `Parser` instance with byte data and utilize its methods to extract various POD data types. The parser consumes data as it's read, and available methods handle different primitive and complex types.

```rust
use pipewire_native_spa::pod::parser::{Parser, Pod, Error, Primitive, Type, Choice, Pointer, Fd, Rectangle, Fraction};
use std::convert::Infallible;

// Assuming 'data' is a byte slice representing PipeWire POD data
let data: &[u8] = b"..."; // Replace with actual POD data
let mut parser = Parser::new(data);

// Example: Pop an integer
match parser.pop_int() {
    Ok(value) => println!("Parsed integer: {}", value),
    Err(e) => eprintln!("Error parsing integer: {:?}", e),
}

// Example: Pop a string
match parser.pop_string() {
    Ok(value) => println!("Parsed string: {}", value),
    Err(e) => eprintln!("Error parsing string: {:?}", e),
}

// Example: Pop an array of primitives (e.g., u32)
match parser.pop_array::<u32>() {
    Ok(values) => println!("Parsed u32 array: {:?}", values),
    Err(e) => eprintln!("Error parsing u32 array: {:?}", e),
}

// Example: Pop a raw POD structure
match parser.pop_raw_pod() {
    Ok(raw_pod) => println!("Parsed raw POD: {:?}", raw_pod),
    Err(e) => eprintln!("Error parsing raw POD: {:?}", e),
}

```

--------------------------------

### from_name(name: &str) -> Option<Self>

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/param/struct.ParamInfoFlags_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets a flags value with the bits of a flag with the given name set.

```APIDOC
## fn from_name(name: &str) -> Option<Self>

### Description
Get a flags value with the bits of a flag with the given name set.

### Method
Function

### Parameters
#### Path Parameters
- **name** (&str) - Required - The name of the flag.

### Response
#### Success Response
- **Option<Self>** (Option<Self>) - The resulting ParamInfoFlags value, or None if the name is not found.

```

--------------------------------

### System Support - New System Implementation

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/support/system/fn.new_search=std%3A%3Avec

Provides a way to create a new instance of the SystemImpl, which is likely used for interacting with the PipeWire system.

```APIDOC
## POST /pipewire_native_spa/support/system

### Description
Creates a new instance of the `SystemImpl`.

### Method
POST

### Endpoint
/pipewire_native_spa/support/system

### Parameters
None

### Request Body
None

### Request Example
```json
{
  "message": "Initiate new SystemImpl"
}
```

### Response
#### Success Response (200)
- **system_impl** (object) - An object representing the newly created SystemImpl instance.

#### Response Example
```json
{
  "system_impl": {
    "status": "initialized",
    "version": "0.1.3"
  }
}
```
```

--------------------------------

### AsRef Implementation

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/thread/type.ThreadReturn_search=std%3A%3Avec

Provides the `as_ref` method to get a shared reference to the inner type T within a Box<T, A>.

```APIDOC
## impl<T, A> AsRef<T> for Box<T, A>

where A: Allocator, T: ?Sized

### Description
Provides the `as_ref` method to get a shared reference to the inner type T within a Box<T, A>.

### Method
`as_ref`

### Endpoint
N/A (Trait Method)

### Parameters
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **&T** (type) - A shared reference to the inner type T.

### Response Example
```json
{
  "shared_reference": "<shared_reference_representation>"
}
```
```

--------------------------------

### Box<T> Implementations

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/thread/type.ThreadReturn

Documentation for various implementations of `Box<T>`, including methods for allocation, initialization, and raw pointer conversion.

```APIDOC
## Implementations for Box<T>

### `impl<T> Box<T>` (1.0.0 and later)

#### `pub fn new(x: T) -> Box<T>`

Allocates memory on the heap and then places `x` into it. This doesn’t actually allocate if `T` is zero-sized.

##### Examples
```rust
let five = Box::new(5);
```

#### `pub fn new_uninit() -> Box<MaybeUninit<T>>`

Constructs a new box with uninitialized contents.

##### Examples
```rust
let mut five = Box::<u32>::new_uninit();
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5)
```

#### `pub fn new_zeroed() -> Box<MaybeUninit<T>>`

**(Nightly-only experimental API)** Constructs a new `Box` with uninitialized contents, with the memory being filled with `0` bytes.

##### Examples
```rust
#![feature(new_zeroed_alloc)]

let zero = Box::<u32>::new_zeroed();
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0)
```

#### `pub fn pin(x: T) -> Pin<Box<T>>`

Constructs a new `Pin<Box<T>>`. If `T` does not implement `Unpin`, then `x` will be pinned in memory and unable to be moved.

#### `pub fn try_new(x: T) -> Result<Box<T>, AllocError>`

**(Nightly-only experimental API)** Allocates memory on the heap then places `x` into it, returning an error if the allocation fails.

##### Examples
```rust
#![feature(allocator_api)]

let five = Box::try_new(5)?;
```

#### `pub fn try_new_uninit() -> Result<Box<MaybeUninit<T>>, AllocError>`

**(Nightly-only experimental API)** Constructs a new box with uninitialized contents on the heap, returning an error if the allocation fails.

##### Examples
```rust
#![feature(allocator_api)]

let mut five = Box::<u32>::try_new_uninit()?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);
```

#### `pub fn try_new_zeroed() -> Result<Box<MaybeUninit<T>>, AllocError>`

**(Nightly-only experimental API)** Constructs a new `Box` with uninitialized contents, with the memory being filled with `0` bytes on the heap.

##### Examples
```rust
#![feature(allocator_api)]

let zero = Box::<u32>::try_new_zeroed()?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);
```

### `impl<T> Box<T> where T: ?Sized` (1.4.0 and later)

#### `pub unsafe fn from_raw(raw: *mut T) -> Box<T>`

Constructs a box from a raw pointer. After calling this function, the raw pointer is owned by the resulting `Box`. The `Box` destructor will call the destructor of `T` and free the allocated memory. For this to be safe, the memory must have been allocated in accordance with the memory layout used by `Box`.

##### Safety
This function is unsafe because improper use may lead to memory problems. The raw pointer must point to a block of memory allocated by the global allocator.

##### Examples
```rust
let x = Box::new(5);
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };
```

```rust
use std::alloc::{alloc, Layout};

unsafe {
    let ptr = alloc(Layout::new::<i32>()) as *mut i32;
    ptr.write(5);
    let x = Box::from_raw(ptr);
}
```

#### `pub unsafe fn from_non_null(ptr: NonNull<T>) -> Box<T>`

**(Nightly-only experimental API)** Constructs a box from a `NonNull` pointer. After calling this function, the `NonNull` pointer is owned by the resulting `Box`. The `Box` destructor will call the destructor of `T` and free the allocated memory. For this to be safe, the memory must have been allocated in accordance with the memory layout used by `Box`.
```

--------------------------------

### pipewire_native_spa::support::ffi::system::new_impl

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/support/ffi/system/fn.new_impl_search=

Creates a new SystemImpl instance from a CInterface pointer.

```APIDOC
## pipewire_native_spa::support::ffi::system::new_impl

### Description
This function creates a new `SystemImpl` from a raw C interface pointer.

### Method
Rust Function

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// Assuming 'interface' is a *mut CInterface
let system_impl = pipewire_native_spa::support::ffi::system::new_impl(interface);
```

### Response
#### Success Response (SystemImpl)
- **SystemImpl** - A new instance of SystemImpl.

#### Response Example
```rust
// Representation of SystemImpl would depend on its definition
// For example purposes:
{
  "some_field": "value"
}
```
```

--------------------------------

### AsMut Implementation

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/thread/type.ThreadReturn_search=std%3A%3Avec

Provides the `as_mut` method to get a mutable reference to the inner type T within a Box<T, A>.

```APIDOC
## impl<T, A> AsMut<T> for Box<T, A>

where A: Allocator, T: ?Sized

### Description
Provides the `as_mut` method to get a mutable reference to the inner type T within a Box<T, A>.

### Method
`as_mut`

### Endpoint
N/A (Trait Method)

### Parameters
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **&mut T** (type) - A mutable reference to the inner type T.

### Response Example
```json
{
  "mutable_reference": "<mutable_reference_representation>"
}
```
```

--------------------------------

### RiscvCpuFlags Static Methods

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/cpu/struct.RiscvCpuFlags

Documentation for static methods to create RiscvCpuFlags instances.

```APIDOC
## RiscvCpuFlags Static Methods

### `empty()`

#### `fn empty() -> Self`

Get a flags value with all bits unset.

### `all()`

#### `fn all() -> Self`

Get a flags value with all known bits set.
```

--------------------------------

### Io Enum Definition

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/param/buffers/enum.Io_search=

Defines the Io enum with its possible values: Start, Id, and Size, each associated with a `u32` value.

```APIDOC
## Enum Io

### Description
Represents input/output parameters for PipeWire SPA.

### Source Code
```rust
#[repr(u32)]
pub enum Io {
    Start = 0,
    Id = 1,
    Size = 2,
}
```

### Variants
*   **Start** (0): Represents the start of an operation or stream.
*   **Id** (1): Represents an identifier for a resource or stream.
*   **Size** (2): Represents the size of a buffer or data.

### Trait Implementations
*   **`Clone`**: Allows creating a copy of an `Io` variant.
*   **`Debug`**: Enables debugging output for `Io` variants.
*   **`From<Io> for u32`**: Converts an `Io` variant into its corresponding `u32` value.
*   **`ParamObject`**: Implements the `ParamObject` trait with `TYPE` set to `ObjectType::ParamIo`.
*   **`PartialEq`**: Enables comparison between `Io` variants.
*   **`TryFrom<u32> for Io`**: Attempts to convert a `u32` value into an `Io` variant, returning an error if the value is invalid.
*   **`Copy`**: Indicates that `Io` is a copyable type.
*   **`Eq`**: Marks `Io` as having a total equivalence relation.
*   **`StructuralPartialEq`**: Enables structural comparison for `Io`.
```

--------------------------------

### Initialize and Use Pipewire-Native-SPA Parser

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/pod/parser/struct.Parser

Demonstrates how to create a new `Parser` instance from a byte slice and use its methods to extract various data types. The parser supports primitive types, arrays, and more complex structures.

```rust
use pipewire_native_spa::pod::parser::Parser;

// Assuming 'data' is a byte slice containing PipeWire data
let data: &[u8] = b"..."; 
let mut parser = Parser::new(data);

// Example: Pop an integer
match parser.pop_int() {
    Ok(value) => println!("Parsed integer: {}", value),
    Err(e) => eprintln!("Error parsing integer: {:?}", e),
}

// Example: Pop a string
match parser.pop_string() {
    Ok(value) => println!("Parsed string: {}", value),
    Err(e) => eprintln!("Error parsing string: {:?}", e),
}

// Example: Pop a rectangle
match parser.pop_rectangle() {
    Ok(rect) => println!("Parsed rectangle: w={}, h={}, x={}, y={}", rect.width, rect.height, rect.x, rect.y),
    Err(e) => eprintln!("Error parsing rectangle: {:?}", e),
}

// Example: Pop an array of primitives (e.g., f32)
match parser.pop_array::<f32>() {
    Ok(arr) => println!("Parsed array of floats: {:?}", arr),
    Err(e) => eprintln!("Error parsing float array: {:?}", e),
}

// Example: Pop raw POD data
match parser.pop_raw_pod() {
    Ok(raw_pod) => println!("Parsed raw POD: {:?}", raw_pod),
    Err(e) => eprintln!("Error parsing raw POD: {:?}", e),
}

```

--------------------------------

### Fold Iterator into Accumulator in Rust

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/thread/type.ThreadReturn

Reduces an iterator to a single value by repeatedly applying a closure. Starts with an initial value and updates it with each element.

```rust
fn fold<B, F>(self, init: B, f: F) -> B
where
    Self: Sized,
    F: FnMut(B, Self::Item) -> B,
```

--------------------------------

### SystemImpl Implementations

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/system/struct.SystemImpl

This section details the implementations of the methods available on the SystemImpl struct.

```APIDOC
## impl SystemImpl

### pub fn read(&self, fd: RawFd, buf: &mut [u8]) -> Result<isize>
Reads data from the given file descriptor into the buffer.

### pub fn write(&self, fd: RawFd, buf: &[u8]) -> Result<isize>
Writes data from the buffer to the given file descriptor.

### pub fn close(&self, fd: RawFd) -> Result<i32>
Closes the specified file descriptor.

### pub fn clock_gettime(&self, clockid: clockid_t, value: &mut timespec) -> Result<i32>
Retrieves the current time from the specified clock.

### pub fn clock_getres(&self, clockid: clockid_t, res: &mut timespec) -> Result<i32>
Retrieves the resolution of the specified clock.

### pub fn pollfd_create(&self, flags: Fd) -> Result<i32>
Creates a new poll file descriptor with the given flags.

### pub fn pollfd_add(&self, pfd: RawFd, fd: RawFd, events: Io, data: u64) -> Result<i32>
Adds a file descriptor to the poll set, specifying events to monitor and associated data.

### pub fn pollfd_mod(&self, pfd: RawFd, fd: RawFd, events: Io, data: u64) -> Result<i32>
Modifies the monitored events and associated data for a file descriptor in the poll set.

### pub fn pollfd_del(&self, pfd: RawFd, fd: RawFd) -> Result<i32>
Removes a file descriptor from the poll set.

### pub fn pollfd_wait(&self, pfd: RawFd, events: &mut [PollEvent], timeout: i32) -> Result<i32>
Waits for events on the poll set, with a specified timeout. Returns the number of file descriptors with events.

### pub fn timerfd_create(&self, clockid: i32, flags: Fd) -> Result<i32>
Creates a new timer file descriptor associated with the specified clock ID and flags.

### pub fn timerfd_settime(&self, fd: RawFd, flags: Fd, new_value: &itimerspec, old_value: Option<&mut itimerspec>) -> Result<i32>
Sets the expiration time and interval for the timer file descriptor.

### pub fn timerfd_gettime(&self, fd: RawFd, curr_value: &mut itimerspec) -> Result<i32>
Retrieves the remaining time until the next expiration of the timer file descriptor.

### pub fn timerfd_read(&self, fd: RawFd) -> Result<u64>
Reads the timer expiration count from the timer file descriptor.

### pub fn eventfd_create(&self, flags: Fd) -> Result<i32>
Creates a new event file descriptor with the specified flags.

### pub fn eventfd_write(&self, fd: RawFd, count: u64) -> Result<i32>
Writes a value to the event file descriptor.

### pub fn eventfd_read(&self, fd: RawFd) -> Result<u64>
Reads a value from the event file descriptor.

### pub fn signalfd_create(&self, signal: u32, flags: Fd) -> Result<i32>
Creates a signal file descriptor to receive notifications for specified signals.

### pub fn signalfd_read(&self, fd: RawFd) -> Result<u32>
Reads signal information from the signal file descriptor.
```

--------------------------------

### Get Type of RawPodOwned (Rust)

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/pod/struct.RawPodOwned_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the type information associated with the RawPodOwned data. The 'Type' enum likely defines the structure or format of the data.

```rust
pub fn type_(&self) -> Type
```

--------------------------------

### Read Timer File Descriptor

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/system/struct.SystemImpl_search=

Reads from a timer file descriptor. This is used to get the expiration count from a timer created with timerfd_create.

```rust
pub fn timerfd_read(&self, fd: RawFd) -> Result<u64>
```

--------------------------------

### Box Allocation and Initialization

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/thread/type.ThreadReturn_search=u32+-%3E+bool

APIs for creating and initializing Box instances with specific allocators and memory zeroing.

```APIDOC
## POST /box/try_new_zeroed_in

### Description
Constructs a new `Box` with uninitialized contents, with the memory being filled with `0` bytes in the provided allocator. Returns an error if the allocation fails. This is a nightly-only experimental API.

### Method
POST

### Endpoint
/box/try_new_zeroed_in

### Parameters
#### Query Parameters
- **alloc** (Allocator) - Required - The allocator to use for memory allocation.

### Request Body
```json
{
  "alloc": "Allocator Type"
}
```

### Response
#### Success Response (200)
- **Box<MaybeUninit<T>, A>** - A Box with uninitialized contents, zeroed in memory.

#### Response Example
```json
{
  "boxed_value": "Boxed MaybeUninit Value"
}
```
```

```APIDOC
## POST /box/pin_in

### Description
Constructs a new `Pin<Box<T, A>>`. If `T` does not implement `Unpin`, then `x` will be pinned in memory and unable to be moved. This is a nightly-only experimental API.

### Method
POST

### Endpoint
/box/pin_in

### Parameters
#### Query Parameters
- **alloc** (Allocator) - Required - The allocator to use for memory allocation.

#### Request Body
- **x** (T) - Required - The value to be pinned and boxed.

### Request Example
```json
{
  "x": "Value to be pinned and boxed",
  "alloc": "Allocator Type"
}
```

### Response
#### Success Response (200)
- **Pin<Box<T, A>>** - A pinned Box containing the provided value.

#### Response Example
```json
{
  "pinned_boxed_value": "Pinned Boxed Value"
}
```
```

--------------------------------

### Implement Clone and Copy for Fraction (Rust)

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/pod/types/struct.Fraction

Demonstrates the implementation of `Clone` and `Copy` traits for the `Fraction` struct. These implementations allow `Fraction` instances to be duplicated efficiently, either by explicit cloning or by implicit copying, which is vital for performance in data-intensive operations.

```Rust
impl Clone for Fraction {
    fn clone(&self) -> Fraction
    fn clone_from(&mut self, source: &Self)
}

impl Copy for Fraction
```

--------------------------------

### Generic `Any` Trait Implementation

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/cpu/struct.X86CpuFlags_search=std%3A%3Avec

This snippet shows the blanket implementation of the `Any` trait for any type `T` that is `'static` and sized. It includes the `type_id` method to get the `TypeId` of the type.

```rust
use std::any::TypeId;

fn type_id(&self) -> TypeId;
// Gets the `TypeId` of `self`.
```

--------------------------------

### Blanket Implementations for T in Rust

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/pod/types/struct.Id

Demonstrates various blanket implementations available for any type `T`. These include `Any`, `Borrow`, `BorrowMut`, `CloneToUninit`, `From<T>` for `T`, `Into<U>` where `U: From<T>`, `Pod` where `T: Primitive`, `ToOwned`, `TryFrom<U>` where `U: Into<T>`, and `TryInto<U>` where `U: TryFrom<T>`. These highlight the versatility and integration of types within the Rust ecosystem.

```rust
impl<T> Any for T where T: 'static + ?Sized

impl<T> Borrow<T> for T where T: ?Sized

impl<T> BorrowMut<T> for T where T: ?Sized

impl<T> CloneToUninit for T where T: Clone

impl<T> From<T> for T

impl<T, U> Into<U> for T where U: From<T>

impl<T> Pod for T where T: Primitive

impl<T> ToOwned for T where T: Clone

impl<T, U> TryFrom<U> for T where U: Into<T>

impl<T, U> TryInto<U> for T where U: TryFrom<T>

```

--------------------------------

### CHandle Structure

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/support/ffi/plugin/struct.CHandle_search=u32+-%3E+bool

Documentation for the CHandle structure, which represents a handle for interacting with C interfaces. It includes fields for version and function pointers to get and clear interfaces.

```APIDOC
## Struct CHandle

### Description
Represents a handle for interacting with C interfaces. It contains the version of the handle and function pointers for retrieving and clearing interfaces.

### Fields
- **version** (u32) - The version of the CHandle.
- **get_interface** (fn(*const CHandle, *const c_char, *mut *mut CInterface) -> c_int) - A function pointer to retrieve a C interface based on its type.
- **clear** (fn(*mut CHandle) -> c_int) - A function pointer to clear or release the CHandle.

### Auto Trait Implementations
- **Freeze**
- **RefUnwindSafe**
- **Send**
- **Sync**
- **Unpin**
- **UnwindSafe**

### Blanket Implementations
This structure also implements several blanket implementations provided by the Rust standard library, such as `Any`, `Borrow`, `BorrowMut`, `From`, `Into`, `TryFrom`, and `TryInto`.
```

--------------------------------

### Get Total Size of RawPodOwned (Rust)

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/pod/struct.RawPodOwned_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the total size in bytes of the RawPodOwned data. This method is useful for pre-allocating buffers or understanding memory usage.

```rust
pub fn total_size(&self) -> usize
```

--------------------------------

### Blanket Implementations

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/cpu/enum.CpuVm_search=

Details blanket implementations available for generic types, including `Any`, `Borrow`, `CloneToUninit`, `From`, `Into`, `ToOwned`, `ToString`, `TryFrom`, and `TryInto`.

```APIDOC
## Blanket Implementations

### impl<T> Any for T

#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.

### impl<T> Borrow<T> for T

#### fn borrow(&self) -> &T
Immutably borrows from an owned value.

### impl<T> BorrowMut<T> for T

#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value.

### impl<T> CloneToUninit for T

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)
Performs copy-assignment from `self` to `dest`.

### impl<T> From<T> for T

#### fn from(t: T) -> T
Returns the argument unchanged.

### impl<T, U> Into<U> for T

#### fn into(self) -> U
Calls `U::from(self)`.

### impl<T> ToOwned for T

#### type Owned = T

#### fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning.

#### fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning.

### impl<T> ToString for T

#### fn to_string(&self) -> String
Converts the given value to a `String`.

### impl<T, U> TryFrom<U> for T

#### type Error = Infallible

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.

### impl<T, U> TryInto<U> for T

#### type Error = <U as TryFrom<T>>::Error

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
```

--------------------------------

### Box::new_uninit_in

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/thread/type.ThreadReturn_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Constructs a new Box with uninitialized contents in the provided allocator. This is a nightly-only experimental API.

```APIDOC
## POST /box/new_uninit_in

### Description
Constructs a new box with uninitialized contents in the provided allocator. This is a nightly-only experimental API.

### Method
POST

### Endpoint
/box/new_uninit_in

### Parameters
#### Request Body
- **alloc** (A) - Required - The allocator to use.

### Request Example
```json
{
  "alloc": "// Represents an Allocator"
}
```

### Response
#### Success Response (200)
- **uninit_box** (Box<MaybeUninit<T>, A>) - The newly created Box with uninitialized contents.

#### Response Example
```json
{
  "uninit_box": "// Represents a Box<MaybeUninit<T>, A>"
}
```
```

--------------------------------

### Meta Enum

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/param/buffers/enum.Meta_search=

The Meta enum represents metadata types within the pipewire-native-spa library. It includes variants for Start, Type, and Size, each associated with a `u32` value.

```APIDOC
## Enum Meta

### Description
Represents metadata types with variants for Start, Type, and Size.

### Variants
- **Start** (u32 = 0)
- **Type** (u32 = 1)
- **Size** (u32 = 2)

### Source Code
```rust
#[repr(u32)]
pub enum Meta {
    Start = 0,
    Type = 1,
    Size = 2,
}
```
```

--------------------------------

### Support Struct and Methods

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/struct.Support_search=std%3A%3Avec

Documentation for the 'Support' struct, including its constructor, methods for managing interfaces, and retrieving C support information.

```APIDOC
## Struct Support

Source
```rust
pub struct Support { /* private fields */ }
```

### Implementations

#### `impl Support`

##### `pub fn new() -> Support`
Creates a new instance of the Support struct.

##### `pub fn c_support(&self) -> &Vec<CSupport>`
Returns a reference to the vector of CSupport.

##### `pub fn add_interface(&mut self, name: &'static str, iface: Box<dyn Interface>)`
Adds an interface to the Support struct.

##### `pub fn get_interface<T>(&self, name: &str) -> Option<Arc<Pin<Box<T>>>>`
Retrieves an interface by name. Type T must implement the Interface trait.
```

--------------------------------

### Get Interface Type ID (Rust)

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/plugin/trait.Interface_search=

The `type_id` method returns the unique `TypeId` of the implementing type. This method is provided and requires the implementer to be `'static`.

```rust
fn type_id(&self) -> TypeId
where Self: 'static {
```

--------------------------------

### Generic Implementations for LoopUtilsImpl in Rust

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/interface/loop/struct.LoopUtilsImpl_search=u32+-%3E+bool

Demonstrates blanket implementations for standard Rust traits like `Any`, `Send`, `Sync`, `Freeze`, `Borrow`, `BorrowMut`, `From`, and `Into` for `LoopUtilsImpl`. These implementations enable `LoopUtilsImpl` to be used seamlessly within the broader Rust ecosystem.

```rust
impl<T> Any for T where T: 'static + ?Sized,
fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,
fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,
fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T
fn from(t: T) -> T

impl<T, U> Into<U> for T where U: From<T>,

```

--------------------------------

### Rust TryInto Usage Example

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/param/format/enum.MediaSubtype_search=

Shows how to use the `TryInto` trait, which is automatically implemented when `TryFrom` is implemented. It provides a more idiomatic way to perform fallible conversions.

```rust
use std::convert::TryInto;

struct MyInt(i32);

impl TryFrom<i32> for MyInt {
    type Error = &'static str;

    fn try_from(value: i32) -> Result<Self, Self::Error> {
        if value >= 0 {
            Ok(MyInt(value))
        } else {
            Err("Cannot convert negative number")
        }
    }
}

fn main() {
    let positive_num = 20;
    let negative_num = -15;

    let my_int_positive: Result<MyInt, _> = positive_num.try_into();
    let my_int_negative: Result<MyInt, _> = negative_num.try_into();

    println!("{:?}", my_int_positive);
    println!("{:?}", my_int_negative);
}
```

--------------------------------

### Rust Iterator: Get Minimum Element

Source: https://docs.rs/pipewire-native-spa/0.1.3/pipewire_native_spa/pod/parser/struct.ObjectParserRaw_search=std%3A%3Avec

Returns the minimum element of an iterator. Requires the item type to implement the `Ord` trait. Returns `None` if the iterator is empty.

```rust
fn min(self) -> Option<Self::Item>
where Self: Sized,
    Self::Item: Ord,
```
Tokens:
Raw