Polyvoice

https://docs.rs/polyvoice/
Admin
Polyvoice is an ecosystem-agnostic speaker diarization library for Rust supporting both online...
Tokens:446,315
Snippets:3,114
Trust Score:9.1
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### entry method example

Source: https://docs.rs/polyvoice/latest/polyvoice/clusterer/assign/type.LocalGlobalDuration.html

Gets the given key's corresponding entry in the map for in-place manipulation. The example counts character occurrences in a string using entry and and_modify/or_insert.

```rust
use std::collections::HashMap;

let mut letters = HashMap::new();

for ch in "a short treatise on fungi".chars() {
    letters.entry(ch).and_modify(|counter| *counter += 1).or_insert(1);
}

assert_eq!(letters[&'s'], 2);
assert_eq!(letters[&'t'], 3);
assert_eq!(letters[&'u'], 1);
assert_eq!(letters.get(&'y'), None);
```

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

### StreamingPipeline with LatencyPreset example

Source: https://docs.rs/polyvoice/latest/polyvoice/streaming/index.html

Example of creating a `StreamingPipeline` with a `LatencyPreset::Balanced`, using `EnergyVad` and `DummyExtractor`. The pipeline feeds a 1-second chunk of audio and returns `SpeakerTurn`s. Note that `DummyExtractor` implements `Embedder` directly, and the example requires the `onnx` feature to be disabled for custom encoders.

```rust
use polyvoice::streaming::{LatencyPreset, StreamingPipeline};
use polyvoice::{DummyExtractor, EnergyVad, VadConfig};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let vad = EnergyVad::new(-40.0, 16000, 512);
    // DummyExtractor implements Embedder directly.
    let extractor = DummyExtractor::new(256);
    let mut pipeline = StreamingPipeline::with_latency_preset(
        vad,
        extractor,
        LatencyPreset::Balanced,
        VadConfig::default(),
    )?;
    let chunk = vec![0.0f32; 16000];
    let _turns = pipeline.feed(&chunk)?;
    Ok(())
}
```

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

### Initialize EnergyVad

Source: https://docs.rs/polyvoice/latest/polyvoice/vad/struct.EnergyVad.html

Example showing how to create a new EnergyVad instance and verify its sample rate.

```rust
use polyvoice::{EnergyVad, VoiceActivityDetector};
let vad = EnergyVad::new(-40.0, 16000, 512);
assert_eq!(vad.sample_rate(), 16000);
```

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

### get method example

Source: https://docs.rs/polyvoice/latest/polyvoice/clusterer/assign/type.LocalGlobalDuration.html

Returns a reference to the value corresponding to the key. The key may be any borrowed form of the map's key type, but Hash and Eq on the borrowed form must match those for the key type.

```rust
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);
```

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

### remove_entry example

Source: https://docs.rs/polyvoice/latest/polyvoice/clusterer/assign/type.LocalGlobalDuration.html

Demonstrates using remove_entry to remove a key and return the stored key and value. The example is incomplete in the source, showing only the beginning of the code.

```rust
use std::collections::HashMap;
```

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

### hasher method example

Source: https://docs.rs/polyvoice/latest/polyvoice/clusterer/assign/type.LocalGlobalDuration.html

Returns a reference to the map's BuildHasher. The example creates a HashMap with a RandomState hasher and retrieves a reference to it.

```rust
use std::collections::HashMap;
use std::hash::RandomState;

let hasher = RandomState::new();
let map: HashMap<i32, i32> = HashMap::with_hasher(hasher);
let hasher: &RandomState = map.hasher();
```

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

### HashMap remove_entry example

Source: https://docs.rs/polyvoice/latest/polyvoice/clusterer/assign/type.LocalGlobalDuration.html

Demonstrates removing an entry from a HashMap using remove_entry and remove. The example creates a HashMap, inserts a key-value pair, and asserts the removal behavior.

```rust
let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.remove_entry(&1), Some((1, "a")));
assert_eq!(map.remove(&1), None);
```

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

### strong_count_from_raw example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Shows how to get the strong count of an Arc from a raw pointer without consuming it. Requires the nightly feature arc_raw_get_strong. The pointer must point to a live Arc allocation with valid metadata. The example clones the Arc, converts to raw, and verifies the count is 2.

```rust
#![feature(arc_raw_get_strong)]
use std::sync::Arc;

let five = Arc::new(5);
let _also_five = Arc::clone(&five);
let ptr = Arc::into_raw(five);

unsafe {
    // This assertion is deterministic because we haven't shared
    // the `Arc` between threads.
    assert_eq!(2, Arc::strong_count_from_raw(ptr));

    // Convert back to an `Arc` to avoid leaking memory.
    let five = Arc::from_raw(ptr);
    assert_eq!(2, Arc::strong_count(&five));
}
```

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

### Confidence::get example

Source: https://docs.rs/polyvoice/latest/polyvoice/types/struct.Confidence.html

Returns the raw confidence value. The example unwraps the `Option` from `new` and asserts equality.

```rust
use polyvoice::Confidence;
let c = Confidence::new(0.9).unwrap();
assert_eq!(c.get(), 0.9);
```

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

### HashMap iteration example

Source: https://docs.rs/polyvoice/latest/polyvoice/clusterer/assign/type.LocalGlobalDuration.html

Shows how to create a HashMap from an array of key-value pairs and iterate over it using into_iter().

```rust
use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);
```

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

### pub fn set_next_start(&mut self, start: usize)

Source: https://docs.rs/polyvoice/latest/polyvoice/window/struct.WindowBuffer.html

Sets the next-start offset to a specific value.

```APIDOC
## set_next_start

### Description
Sets the next-start offset to a specific value.

### Method
set_next_start

### Signature
`pub fn set_next_start(&mut self, start: usize)`

### Parameters
- **start** (usize) - Required - The new value for the next-start offset.
```

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

### Arc::get_mut example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Shows how to get a mutable reference to the inner value when there are no other Arc or Weak pointers. Returns None otherwise. The example demonstrates mutation and the effect of cloning.

```rust
use std::sync::Arc;

let mut x = Arc::new(3);
*Arc::get_mut(&mut x).unwrap() = 4;
assert_eq!(*x, 4);

let _y = Arc::clone(&x);
assert!(Arc::get_mut(&mut x).is_none());
```

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

### segment_speech usage example

Source: https://docs.rs/polyvoice/latest/polyvoice/vad/fn.segment_speech.html

An example demonstrating how to initialize an EnergyVad detector and use segment_speech to identify speech segments in a vector of audio samples.

```rust
use polyvoice::{EnergyVad, segment_speech, DiarizationConfig, VadConfig};
let mut vad = EnergyVad::new(-40.0, 16000, 512);
let samples = vec![0.5f32; 16000]; // 1 second of "loud" audio
let config = DiarizationConfig::default();
let vad_config = VadConfig::default();
let segs = segment_speech(&mut vad, &samples, &config, &vad_config).unwrap();
assert!(!segs.is_empty());
assert!(segs.iter().all(|(s, e)| s < e));
```

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

### From<Box<T, A>> for Arc<T, A> example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Moves a boxed object into a new reference-counted allocation. The example converts a Box<str> to Arc<str> and asserts the content.

```rust
let unique: Box<str> = Box::from("eggplant");
let shared: Arc<str> = Arc::from(unique);
assert_eq!("eggplant", &shared[..]);
```

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

### get_mut example

Source: https://docs.rs/polyvoice/latest/polyvoice/clusterer/assign/type.LocalGlobalDuration.html

Demonstrates using get_mut to obtain a mutable reference to a value and modify it. The example inserts a key-value pair, modifies the value, and asserts the result.

```rust
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
if let Some(x) = map.get_mut(&1) {
    *x = "b";
}
assert_eq!(map[&1], "b");
```

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

### Arc::try_unwrap example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Shows how to use Arc::try_unwrap to get the inner value when there is exactly one strong reference, and how to handle the Err case when there are multiple references.

```rust
use std::sync::Arc;

let x = Arc::new(3);
assert_eq!(Arc::try_unwrap(x), Ok(3));

let x = Arc::new(4);
let _y = Arc::clone(&x);
assert_eq!(*Arc::try_unwrap(x).unwrap_err(), 4);
```

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

### Arc::new_in example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Constructs a new Arc in a provided allocator. Requires the nightly feature allocator_api. The example uses the System allocator.

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

use std::sync::Arc;
use std::alloc::System;

let five = Arc::new_in(5, System);
```

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

### From<Cow<'a, B>> for Arc<B> example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Creates an atomically reference-counted pointer from a clone-on-write pointer by copying its content. The example converts a borrowed Cow to Arc<str>.

```rust
let cow: Cow<'_, str> = Cow::Borrowed("eggplant");
let shared: Arc<str> = Arc::from(cow);
assert_eq!("eggplant", &shared[..]);
```

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

### From<T> for Arc<T> example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Converts a T into an Arc<T> by moving the value into a newly allocated Arc, equivalent to Arc::new(t). The example compares the result of Arc::from(x) with Arc::new(5).

```rust
let x = 5;
let arc = Arc::new(5);

assert_eq!(Arc::from(x), arc);
```

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

### Drop implementation example for Arc

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Shows that dropping an Arc only prints when the strong reference count reaches zero. The example creates two clones and drops one without output, then drops the last one printing "dropped!".

```rust
use std::sync::Arc;

struct Foo;

impl Drop for Foo {
    fn drop(&mut self) {
        println!("dropped!");
    }
}

let foo  = Arc::new(Foo);
let foo2 = Arc::clone(&foo);

drop(foo);    // Doesn't print anything
drop(foo2);   // Prints "dropped!"
```

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

### Ord implementation example for Arc

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Compares two Arcs by calling cmp() on their inner values. The example asserts that Arc::new(5) is less than Arc::new(6).

```rust
use std::sync::Arc;
use std::cmp::Ordering;

let five = Arc::new(5);

assert_eq!(Ordering::Less, five.cmp(&Arc::new(6)));
```

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

### new_uninit_in example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Constructs an Arc with uninitialized contents in the provided allocator. Requires nightly features allocator_api and get_mut_unchecked. Uses deferred initialization via get_mut_unchecked and assume_init.

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

use std::sync::Arc;
use std::alloc::System;

let mut five = Arc::<u32, _>::new_uninit_in(System);

let five = unsafe {
    // Deferred initialization:
    Arc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);

    five.assume_init()
};

assert_eq!(*five, 5)
```

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

### Arc::default example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Creates a new Arc<T> with the Default value for T. Available on non-no_global_oom_handling only.

```rust
use std::sync::Arc;

let x: Arc<i32> = Default::default();
assert_eq!(*x, 0);
```

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

### segment_speech usage example

Source: https://docs.rs/polyvoice/latest/src/polyvoice/vad/mod.rs.html

Example usage of segment_speech with an EnergyVad. Creates a 1-second loud audio buffer and asserts that the returned segments are non-empty and each start is less than its end.

```rust
use polyvoice::{EnergyVad, segment_speech, DiarizationConfig, VadConfig};
let mut vad = EnergyVad::new(-40.0, 16000, 512);
let samples = vec![0.5f32; 16000]; // 1 second of "loud" audio
let config = DiarizationConfig::default();
let vad_config = VadConfig::default();
let segs = segment_speech(&mut vad, &samples, &config, &vad_config).unwrap();
assert!(!segs.is_empty());
assert!(segs.iter().all(|(s, e)| s < e));
```

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

### EnergyVad::new example

Source: https://docs.rs/polyvoice/latest/src/polyvoice/vad/mod.rs.html

Creates an EnergyVad with a -40 dB threshold, 16 kHz sample rate, and 512-sample frame size, then verifies the sample rate. The frame_size must be a positive multiple of the expected chunk size; passing 0 panics.

```rust
use polyvoice::{EnergyVad, VoiceActivityDetector};
let vad = EnergyVad::new(-40.0, 16000, 512);
assert_eq!(vad.sample_rate(), 16000);
```

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

### new_zeroed_in example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Constructs an Arc with uninitialized contents filled with 0 bytes in the provided allocator. Requires nightly feature allocator_api. Uses assume_init to complete initialization.

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

use std::sync::Arc;
use std::alloc::System;

let zero = Arc::<u32, _>::new_zeroed_in(System);
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0)
```

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

### WindowIter::new

Source: https://docs.rs/polyvoice/latest/src/polyvoice/window/mod.rs.html

Creates a new WindowIter with the given total samples, window size, and hop size. Panics if win == 0, hop == 0, or hop > win.

```APIDOC
## WindowIter::new

### Description
Creates a new iterator over (start, end) sample ranges. Panics if win == 0, hop == 0, or hop > win. Use try_new for a fallible alternative.

### Method
pub fn new(total: usize, win: usize, hop: usize) -> Self

### Parameters
- **total** (usize) - Required - Total number of samples in the audio region.
- **win** (usize) - Required - Window size in samples.
- **hop** (usize) - Required - Hop size in samples.

### Panics
Panics if win == 0, hop == 0, or hop > win.

### Returns
Self - A new WindowIter instance.
```

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

### Arc::map example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Shows how to use Arc::map to apply a function to the value inside an Arc, reusing the allocation if possible.

```rust
use std::sync::Arc;

let r = Arc::new(7);
let new = Arc::map(r, |i| i + 7);
assert_eq!(*new, 14);
```

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

### Arc partial comparison with partial_cmp

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Example for PartialOrd::partial_cmp on Arc. Compares by calling partial_cmp() on inner values.

```rust
use std::sync::Arc;
use std::cmp::Ordering;

let five = Arc::new(5);

assert_eq!(Some(Ordering::Less), five.partial_cmp(&Arc::new(6)));
```

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

### get_disjoint_unchecked_mut example

Source: https://docs.rs/polyvoice/latest/polyvoice/clusterer/assign/type.LocalGlobalDuration.html

Shows the unsafe usage of get_disjoint_unchecked_mut to get mutable references to multiple values without checking for overlapping keys. The example uses a SAFETY comment to assert that the keys are unique, and demonstrates retrieving two values.

```rust
use std::collections::HashMap;

let mut libraries = HashMap::new();
libraries.insert("Bodleian Library".to_string(), 1602);
libraries.insert("Athenæum".to_string(), 1807);
libraries.insert("Herzogin-Anna-Amalia-Bibliothek".to_string(), 1691);
libraries.insert("Library of Congress".to_string(), 1800);

// SAFETY: The keys do not overlap.
let [Some(a), Some(b)] = (unsafe { libraries.get_disjoint_unchecked_mut([
    "Athenæum",
    "Bodleian Library",
]) }) else { panic!() };

// SAFETY: The keys do not overlap.
let got = unsafe { libraries.get_disjoint_unchecked_mut([
    "Athenæum",
    "Library of Congress",
]) };
assert_eq!(
    got,
    [
        Some(&mut 1807),
        Some(&mut 1800),
    ],
);

```

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

### pub fn new(win: usize, hop: usize) -> Self

Source: https://docs.rs/polyvoice/latest/polyvoice/window/struct.WindowBuffer.html

Creates a new WindowBuffer with the given window size and hop size. Panics if win is 0, hop is 0, or hop > win.

```APIDOC
## new

### Description
Creates a new streaming buffer that accumulates samples and yields full windows.

### Method
new

### Signature
`pub fn new(win: usize, hop: usize) -> Self`

### Parameters
- **win** (usize) - Required - Window size in samples. Must be greater than 0.
- **hop** (usize) - Required - Hop size in samples. Must be greater than 0 and less than or equal to win.

### Panics
Panics if `win == 0`, `hop == 0`, or `hop > win`. Use `try_new` for a fallible alternative.
```

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

### try_new_zeroed_in example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Constructs an Arc with uninitialized contents filled with 0 bytes in the provided allocator, returning an error if allocation fails. Requires nightly feature allocator_api. Uses assume_init to complete initialization.

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

use std::sync::Arc;
use std::alloc::System;

let zero = Arc::<u32, _>::try_new_zeroed_in(System)?;
let zero = unsafe { zero.assume_init() };

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

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

### Arc::clone example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Creates another pointer to the same allocation, increasing the strong reference count.

```rust
use std::sync::Arc;

let five = Arc::new(5);

let _ = Arc::clone(&five);
```

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

### Arc::clone_from_ref Example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Constructs a new Arc<T> with a clone of the value. Requires the nightly-only clone_from_ref feature.

```rust
#![feature(clone_from_ref)]
use std::sync::Arc;

let hello: Arc<str> = Arc::clone_from_ref("hello");
```

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

### with_capacity_and_hasher_in example

Source: https://docs.rs/polyvoice/latest/polyvoice/clusterer/assign/type.LocalGlobalDuration.html

Creates an empty HashMap with at least the specified capacity, using a custom hasher and allocator. Requires nightly feature allocator_api. Warning: manually setting the hasher can expose a DoS attack vector.

```rust
#![feature(allocator_api)]
use std::alloc::Global;
use std::collections::HashMap;
use std::hash::RandomState;

let s = RandomState::new();
let map: HashMap<i32, i32> = HashMap::with_capacity_and_hasher_in(10, s, Global);
```

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

### Arc less-than-or-equal comparison with le

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Example for PartialOrd::le on Arc. Compares by calling <= on inner values.

```rust
use std::sync::Arc;

let five = Arc::new(5);

assert!(five <= Arc::new(5));
```

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

### try_new_uninit_in example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Constructs an Arc with uninitialized contents in the provided allocator, returning an error if allocation fails. Requires nightly features allocator_api and get_mut_unchecked. Uses deferred initialization and assume_init.

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

use std::sync::Arc;
use std::alloc::System;

let mut five = Arc::<u32, _>::try_new_uninit_in(System)?;

let five = unsafe {
    // Deferred initialization:
    Arc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);

    five.assume_init()
};

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

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

### Arc::into_inner practical example with LinkedList

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Shows a manual Drop implementation for a linked list using Arc::into_inner to avoid stack overflow when dropping long lists, and demonstrates parallel dropping of clones.

```rust
use std::sync::Arc;

// Definition of a simple singly linked list using `Arc`:
#[derive(Clone)]
struct LinkedList<T>(Option<Arc<Node<T>>>);
struct Node<T>(T, Option<Arc<Node<T>>>);

// Dropping a long `LinkedList<T>` relying on the destructor of `Arc`
// can cause a stack overflow. To prevent this, we can provide a
// manual `Drop` implementation that does the destruction in a loop:
impl<T> Drop for LinkedList<T> {
    fn drop(&mut self) {
        let mut link = self.0.take();
        while let Some(arc_node) = link.take() {
            if let Some(Node(_value, next)) = Arc::into_inner(arc_node) {
                link = next;
            }
        }
    }
}

// Implementation of `new` and `push` omitted
impl<T> LinkedList<T> {
    /* ... */
}

// The following code could have still caused a stack overflow
// despite the manual `Drop` impl if that `Drop` impl had used
// `Arc::try_unwrap(arc).ok()` instead of `Arc::into_inner(arc)`.

// Create a long list and clone it
let mut x = LinkedList::new();
let size = 100000;
for i in 0..size {
    x.push(i); // Adds i to the front of x
}
let y = x.clone();

// Drop the clones in parallel
let x_thread = std::thread::spawn(|| drop(x));
let y_thread = std::thread::spawn(|| drop(y));
x_thread.join().unwrap();
y_thread.join().unwrap();
```

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

### Arc::strong_count example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Shows how to use Arc::strong_count to get the number of strong Arc pointers to an allocation. The assertion is deterministic only when the Arc is not shared between threads.

```rust
use std::sync::Arc;

let five = Arc::new(5);
let _also_five = Arc::clone(&five);

// This assertion is deterministic because we haven't shared
// the `Arc` between threads.
assert_eq!(2, Arc::strong_count(&five));
```

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

### insert example

Source: https://docs.rs/polyvoice/latest/polyvoice/clusterer/assign/type.LocalGlobalDuration.html

Shows how to insert a key-value pair into a HashMap. It demonstrates that insert returns None for a new key and Some(old_value) when updating an existing key.

```rust
use std::collections::HashMap;

let mut map = HashMap::new();
assert_eq!(map.insert(37, "a"), None);
assert_eq!(map.is_empty(), false);

map.insert(37, "b");
assert_eq!(map.insert(37, "c"), Some("b"));
assert_eq!(map[&37], "c");
```

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

### Arc::weak_count example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Shows how to use Arc::weak_count to get the number of Weak pointers to an allocation. The assertion is deterministic only when the Arc and Weak are not shared between threads.

```rust
use std::sync::Arc;

let five = Arc::new(5);
let _weak_five = Arc::downgrade(&five);

// This assertion is deterministic because we haven't shared
// the `Arc` or `Weak` between threads.
assert_eq!(1, Arc::weak_count(&five));
```

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

### try_new_in example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Constructs a new Arc in the provided allocator, returning an error if allocation fails. Requires nightly feature allocator_api. Uses the ? operator to propagate allocation errors.

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

use std::sync::Arc;
use std::alloc::System;

let five = Arc::try_new_in(5, System)?;
```

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

### Arc::try_clone_from_ref Example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Constructs a new Arc<T> with a clone of the value, returning an error if allocation fails. Requires nightly features clone_from_ref and allocator_api.

```rust
#![feature(clone_from_ref)]
#![feature(allocator_api)]
use std::sync::Arc;

let hello: Arc<str> = Arc::try_clone_from_ref("hello")?;
```

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

### Arc greater-than-or-equal comparison with ge

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Example for PartialOrd::ge on Arc. Compares by calling >= on inner values.

```rust
use std::sync::Arc;

let five = Arc::new(5);

assert!(five >= Arc::new(5));
```

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

### Arc equality with eq

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Example for PartialEq::eq on Arc. Two Arcs are equal if their inner values are equal, even if stored in different allocations.

```rust
use std::sync::Arc;

let five = Arc::new(5);

assert!(five == Arc::new(5));
```

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

### Get the raw sample rate value with SampleRate::get

Source: https://docs.rs/polyvoice/latest/polyvoice/types/struct.SampleRate.html

Example of using `SampleRate::get` to retrieve the raw sample rate value in Hz. The `unwrap` will panic if the rate is invalid.

```rust
use polyvoice::SampleRate;
let sr = SampleRate::new(44100).unwrap();
assert_eq!(sr.get(), 44100);
```

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

### Arc::from_raw Example

Source: https://docs.rs/polyvoice/latest/polyvoice/models/adapter/type.AdapterFactory.html

Converts a raw pointer back into an Arc. The pointer must have been obtained from Arc::into_raw or Arc::into_raw_with_allocator. Unsafe due to potential memory unsafety.

```rust
use std::sync::Arc;

let x = Arc::new("hello".to_owned());
let x_ptr = Arc::into_raw(x);

unsafe {
    // Convert back to an `Arc` to prevent leak.
    let x = Arc::from_raw(x_ptr);
    assert_eq!(&*x, "hello");

    // Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe.
}

// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!
```
Tokens:
Raw