Struct Pool 

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

Growable object pool with LIFO reuse.

Objects are created on demand via the factory function when the pool is empty. Use try_acquire() for the fast path that only returns pooled objects, or acquire() which may create new objects.

Example

use nexus_pool::local::Pool;

let pool = Pool::new(
    || Vec::<u8>::with_capacity(1024),
    |v| v.clear(),
);

let mut buf = pool.acquire(); // Creates new object
buf.extend_from_slice(b"hello");
drop(buf); // Returns to pool, clear() is called

let buf2 = pool.acquire(); // Reuses existing (now empty) object

Implementations

impl<T> Pool<T>

pub fn new<F, R>(factory: F, reset: R) -> Self

where F: FnMut() -> T + 'static, R: FnMut(&mut T) + 'static,

Creates an empty pool with the given factory and reset functions.

Arguments

• factory - Creates new objects when pool is empty
• reset - Called when object returns to pool (e.g., Vec::clear)

pub fn with_capacity<F, R>(capacity: usize, factory: F, reset: R) -> Self

where F: FnMut() -> T + 'static, R: FnMut(&mut T) + 'static,

Creates a pool pre-populated with capacity objects.

pub fn acquire(&self) -> Pooled<T>

Acquires an object from the pool, creating one if necessary.

This always succeeds but may allocate if the pool is empty.

pub fn try_acquire(&self) -> Option<Pooled<T>>

Attempts to acquire an object from the pool without creating.

Returns None if the pool is empty. This is the fast path.

pub fn available(&self) -> usize

Returns the number of available objects.

Trait Implementations

impl<T> Drop for Pool<T>

fn drop(&mut self)

Executes the destructor for this type.