Struct Reusable 

pub struct Reusable<T: ObjectPool> { /* private fields */ }

A wrapper for an object that will return the object to the pool when it is dropped. This is useful for objects that are expensive to create, but are used frequently. This struct can be created using the Pool::remove_reusable function. However, it is highly recommended that you use the ObjectPool::new function instead, as it will reuse objects from the pool if possible.

The object implements Deref and DerefMut to allow you to access the object inside the wrapper. It also implements Borrow and BorrowMut to allow you to access the object inside the wrapper immutably or mutably. Finally, it implements AsRef and AsMut to allow you to access the object inside the wrapper immutably or mutably.

Example

use derivable_object_pool::prelude::*;

#[derive(Default, ObjectPool)]
struct Test(i32);

fn test(obj: &mut Test) {
    obj.0 += 1;
}

fn main() {
   let mut obj = Test::new();
   assert_eq!(obj.0, 0);
   test(&mut obj);
   assert_eq!(obj.0, 1);
}

Implementations

impl<T: ObjectPool> Reusable<T>

pub fn into_inner(self) -> T

Returns the owned object inside the wrapper. This will return the object without returning it to the pool. This is useful if you want to take ownership of the object.

Trait Implementations

impl<T: ObjectPool> AsMut<T> for Reusable<T>

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

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

impl<T: ObjectPool> AsRef<T> for Reusable<T>

fn as_ref(&self) -> &T

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

impl<T: ObjectPool> Borrow<T> for Reusable<T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T: ObjectPool> BorrowMut<T> for Reusable<T>

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

Mutably borrows from an owned value.

impl<T: ObjectPool> Deref for Reusable<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ObjectPool> DerefMut for Reusable<T>

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

Mutably dereferences the value.

impl<T: ObjectPool> Drop for Reusable<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: ObjectPool> From<T> for Reusable<T>

fn from(item: T) -> Self

Converts to this type from the input type.