Struct Pool

pub struct Pool<T> { /* private fields */ }

A pool of objects that can be reused. This is useful for objects that are expensive to create, but are used frequently. This struct can be created using the Pool::new function. However, it is highly recommended that you use the ObjectPool trait instead, as it is much easier to use.

Example

Example without deriving ObjectPool:

use derivable_object_pool::prelude::*;

#[derive(Default)]
struct Test;

static POOL: Pool<Test> = Pool::new(Test::default);

impl ObjectPool for Test {
    fn pool<'a>() -> &'a Pool<Self> {
        &POOL
    }
}

fn main() {
   let obj = Test::new();
   drop(obj); // obj is returned to the pool
   assert_eq!(POOL.len(), 1);
}

Implementations

impl<T> Pool<T>

pub const fn new(generator: fn() -> T) -> Self

Creates a new pool of objects. The pool will use the specified generator function to create new objects.

pub fn len(&self) -> usize

Returns the number of objects in the pool.

pub fn is_empty(&self) -> bool

Returns true if the pool is empty.

pub fn insert(&self, item: T)

Inserts an object into the pool while taking ownership of it.

pub fn clear(&self)

Removes all objects from the pool.

pub fn remove(&self) -> Option<T>

Removes an object from the pool and returns the object while taking ownership of it.

impl<T: ObjectPool> Pool<T>

pub fn remove_reusable(&self) -> Option<Reusable<T>>

Removes an object from the pool and returns a resuable wrapper for it, which will return the object to the pool when it is dropped.