Struct LocalBlindPooledMut 

pub struct LocalBlindPooledMut<T: ?Sized> { /* private fields */ }

A unique single-threaded reference-counting handle for a pooled object.

Implications of reference counted handles

The handle can be used to access the pooled object.

This is a reference-counted handle that automatically removes the object when the handle is dropped. Dropping the handle is the only way to remove the object from the pool. This is a unique handle, guaranteeing that no other handles to the same object exist. You may create both shared and exclusive references to the object through this handle. The handle may also be converted to a shared handle via .into_shared().

Thread safety

This type is single-threaded.

Implementations

impl<T: ?Sized> LocalBlindPooledMut<T>

pub fn ptr(&self) -> NonNull<T>

Get a pointer to the target object.

All pooled objects are guaranteed to be pinned for their entire lifetime, so this pointer remains valid for as long as the object remains in the pool.

The object pool implementation does not keep any references to the pooled objects, so you have the option of using this pointer to create Rust references directly without fear of any conflicting references created by the pool.

pub fn into_shared(self) -> LocalBlindPooled<T>

Transforms the unique handle into a shared handle that can be cloned as needed.

A shared handle does not support the creation of exclusive references to the target object.

Thread Safety

The resulting shared handle will only be Send if T: Send + Sync. This is a stronger requirement than for unique handles, which only require T: Send.

pub fn as_pin(&self) -> Pin<&T>

Borrows the target object as a pinned shared reference.

All pooled objects are guaranteed to be pinned for their entire lifetime.

pub fn as_pin_mut(&mut self) -> Pin<&mut T>

Borrows the target object as a pinned exclusive reference.

All pooled objects are guaranteed to be pinned for their entire lifetime.

pub fn erase(self) -> LocalBlindPooledMut<()>

Erase the type information from this handle, converting it to LocalBlindPooledMut<()>.

This is useful for extending the lifetime of an object in the pool without retaining type information. The type-erased handle prevents access to the object but ensures it remains in the pool.

impl<T> LocalBlindPooledMut<T>

where T: Unpin,

pub fn into_inner(self) -> T

Removes the item from the pool and returns it to the caller.

Trait Implementations

impl<T> AsMut<T> for LocalBlindPooledMut<T>

where T: ?Sized + Unpin,

fn as_mut(&mut self) -> &mut T

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T: ?Sized> AsRef<T> for LocalBlindPooledMut<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

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

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T> BorrowMut<T> for LocalBlindPooledMut<T>

where T: ?Sized + Unpin,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value.

impl<T: ?Sized> Debug for LocalBlindPooledMut<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: ?Sized> Deref for LocalBlindPooledMut<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for LocalBlindPooledMut<T>

where T: ?Sized + Unpin,

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

Mutably dereferences the value.

impl<T: ?Sized> Drop for LocalBlindPooledMut<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: ?Sized> From<LocalBlindPooledMut<T>> for LocalBlindPooled<T>

fn from(value: LocalBlindPooledMut<T>) -> Self

Converts to this type from the input type.