Struct PoolGuard 

pub struct PoolGuard<T: PoolItem, P: PoolProvider<T>> { /* private fields */ }

Exclusive, address-stable guard returned by a PoolProvider.

Address stability

The provider entry implements StableDeref, keeping the value at the same address for the complete lifetime of the guard, even when the guard moves.

References into the value cannot outlive the guard:

use rylv_pool::{FixedThreadLocalPool, FixedThreadLocalPoolGuard, PoolItem};
let mut guard = FixedThreadLocalPoolGuard::acquire(&POOL).unwrap();
let borrowed = &mut guard.0;
drop(guard);
borrowed.push(1);

A guard cannot provide two simultaneously used mutable references:

use rylv_pool::{FixedThreadLocalPool, FixedThreadLocalPoolGuard, PoolItem};
let mut guard = FixedThreadLocalPoolGuard::acquire(&POOL).unwrap();
let first = &mut guard.0;
let second = &mut guard.0;
first.push(1);
second.push(2);

A guard cannot be cloned to create a second owner:

use rylv_pool::{FixedThreadLocalPool, FixedThreadLocalPoolGuard, PoolItem};
let guard = FixedThreadLocalPoolGuard::acquire(&POOL).unwrap();
let duplicate = guard.clone();

Implementations

impl<T: PoolItem, P: PoolProvider<T>> PoolGuard<T, P>

pub fn acquire(provider: P) -> Result<Self, PoolError<Infallible>>

where T: Default,

Acquire a value through the supplied provider.

Errors

Returns a captured panic if acquisition or the default factory unwinds.

pub fn acquire_with<F>( provider: P, create: F, ) -> Result<Self, PoolError<Infallible>>

where F: FnOnce() -> T,

Acquire a value, using create only when the provider misses.

Errors

Returns a captured panic if acquisition or the factory unwinds.

pub fn try_acquire_with<F, E>( provider: P, create: F, ) -> Result<Self, PoolError<E>>

where F: FnOnce() -> Result<T, E>,

Acquire a value using a fallible factory only when the provider misses.

Errors

Returns the factory error or a captured panic without creating a guard.

Trait Implementations

impl<T: PoolItem, P: PoolProvider<T>> Deref for PoolGuard<T, P>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: PoolItem, P: PoolProvider<T>> DerefMut for PoolGuard<T, P>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: PoolItem, P: PoolProvider<T>> Drop for PoolGuard<T, P>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T: PoolItem, P: PoolProvider<T>> StableDeref for PoolGuard<T, P>