Struct lazy_pool::Pool

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

Implementations

impl<T: Send + 'static> Pool<T>

pub async fn new<F>(size: usize, factory: F) -> Result<Self>where SyncFactory<T>: From<F>,

Default constructor for the Pool object:

let pool = block_on(async { Pool::new(10, Box::new(|| AnyObject)).await.unwrap() });

The pool requires an object factory in order to be able to provide lazy initialization for objects. Any synchronous closure can be used to create a SyncFactory.

pub async fn new_with_factory<F>(size: usize, factory: F) -> Result<Self>where F: Factory<T> + 'static,

Creating a Pool instance with a Factory Check Factory docs for an example of creating an async factory.

pub async fn get(&self) -> Pooled<T>

To get an object out of the pool use get. This will return a future so you either need to await on it or to use it in an async manner

let object = block_on(async {
    let pool = Pool::new(10, Box::new(|| AnyObject)).await.unwrap();
    get!(object = pool => {
        // Object was retrieved and assigned to `object`. It will be put back at
        // the end of this block, unless it's marked as tainted.
        Pooled::tainted(&mut object);
    });
});