Struct branchless::core::task::ResourcePool

pub struct ResourcePool<R: Resource> { /* private fields */ }

An unbounded pool of on-demand generated resources. This is useful when distributing work across threads which needs access to an expensive-to-build context.

A new resource is created when there isn’t one available in the pool. When it’s dropped, it’s returned to the pool. Old resources remain in the pool until the pool itself is dropped.

struct MyResource {
    num_instantiations: RefCell<usize>,
}

impl Resource for MyResource {
    type Output = String;
    type Error = std::convert::Infallible;
    fn try_create(&self) -> Result<Self::Output, Self::Error> {
        let mut r = self.num_instantiations.borrow_mut();
        *r += 1;
        Ok(format!("This is resource #{}", *r))
    }
}

let resource = MyResource { num_instantiations: Default::default() };
let pool = ResourcePool::new(resource);

// Any number of the resource can be created.
let r1: ResourceHandle<'_, MyResource> = pool.try_create().unwrap();
assert_eq!(&*r1, "This is resource #1");
let r2 = pool.try_create().unwrap();
assert_eq!(&*r2, "This is resource #2");
drop(r2);
drop(r1);

// After releasing a resource, an attempt to get a resource returns an
// existing one from the pool.
let r1_again = pool.try_create().unwrap();
assert_eq!(&*r1_again, "This is resource #1");

Implementations

impl<R: Resource> ResourcePool<R>

pub fn new(factory: R) -> Self

Constructor.

pub fn try_create(&self) -> Result<ResourceHandle<'_, R>, R::Error>

If there are any resources available in the pool, return an arbitrary one. Otherwise, invoke the constructor function of the associated Resource and return a ResourceHandle for it.

Trait Implementations

impl<R: Resource> Debug for ResourcePool<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.