Struct Pool 

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

A bounded pool where one thread acquires and any thread can return.

Only one Pool exists per pool. It cannot be cloned or shared across threads (it is Send but not Sync or Clone).

When the Pool is dropped, outstanding Pooled guards will drop their values directly instead of returning them to the pool.

Example

use nexus_pool::sync::Pool;

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

// Acquirer thread
let mut buf = acquirer.try_acquire().unwrap();
buf.extend_from_slice(b"hello");

// Can send buf to another thread
std::thread::spawn(move || {
    println!("{:?}", &*buf);
    // buf returns to pool on drop
}).join().unwrap();

Implementations

impl<T> Pool<T>

pub fn new<I, R>(capacity: usize, init: I, reset: R) -> Self

where I: FnMut() -> T, R: Fn(&mut T) + Send + Sync + 'static,

Creates a pool with capacity pre-initialized objects.

Arguments

• capacity - Number of objects to pre-allocate
• init - Factory function to create each object
• reset - Called when object returns to pool (e.g., Vec::clear)

Panics

Panics if capacity is zero or exceeds u32::MAX - 1.

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

Attempts to acquire an object from the pool.

Returns None if all objects are currently in use.

pub fn available(&self) -> usize

Returns the number of available objects.

Note: This is a snapshot and may be immediately outdated if other threads are returning objects concurrently.

Trait Implementations

impl<T: Send> Send for Pool<T>