Struct RcPool 

pub struct RcPool<T: Sized>(/* private fields */);

A single thread, interior mutable memory Pool backed by a reference count. This allows objects to hold references back to the pool to keep it alive without carrying a lifetime.

Implementations

impl<T> RcPool<T>

pub fn new() -> Self

Creates a new RcPool for objects of type T.

Trait Implementations

impl<T> AsRef<RcPool<RcInner<T>>> for Rc<T>

Get a reference to the pool this Rc was constructed from.

fn as_ref(&self) -> &RcPool<RcInner<T>>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> AsRef<RcPool<ScInner<T>>> for Sc<T>

Get a reference to the pool this Sc was constructed from.

fn as_ref(&self) -> &RcPool<ScInner<T>>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> AsRef<RcPool<T>> for Box<T>

Get a reference to the pool this Box was constructed from.

fn as_ref(&self) -> &RcPool<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> AsRef<RcPool<T>> for RcPool<T>

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Clone for RcPool<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Default for RcPool<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> PoolApi<T> for RcPool<T>

fn with_min_entries(&self, min_entries: usize)

Configures the minimum of entries the first block will hold. Must be called before the first allocation is made. Can be used when the number of entries that will be used is roughly guessable and or the size of entries is small. Setting this improves cache locality. Since blocks are allocated with exponentially growing size this should be still small enough, approx 1/4 of the average number of entries to be expected. The implementation will generously round this up to the next power of two. When not set it defaults to 64 entries.

fn leak(self)

Destroys a Pool while leaking its allocated blocks. The fast way out when one knows that allocations still exist and will never be returned to to the Pool. Either because the program exits or because the allocations are meant to stay.

fn alloc_entry(&self) -> NonNull<Entry<T>>

Allocates a new entry, either from the freelist or by extending the pool. Returns Entry pointer tagged as UNINITIALIZED.

fn alloc(&self, t: T) -> Slot<T, Initialized>

Allocates a new slot from the pool, initializes it with the supplied object and returns a slot handle. Freeing the object should be done manually with pool.free(), pool::forget() or pool.take(). The user must take care that the slot/references obtained from it are not used after free as this may panic or return another object.

unsafe fn free_by_ref<S: DropPolicy>(&self, slot: &mut Slot<T, S>)

Non consuming variant of pool.free(), allows freeing slots that are part of other structures while keeping Slot non-Copy. The slot must not be used after this. See slot.free() for details.

unsafe fn take_by_ref<S: CanTakeValue>(&self, slot: &mut Slot<T, S>) -> T

Non consuming variant of pool.take(), allows taking slots that are part of other structures while keeping Slot non-Copy. The slot must not be used after this. See slot.take() for details.

fn alloc_uninit(&self) -> Slot<T, Uninitialized>

Allocates a new slot from the pool, keeps the content uninitialized returns a Slot handle to it. Freeing the object should be done manually with pool.free() or pool.forget(). The user must take care that the provided handle or references obtained from is are used after free as this may panic or return another object.

unsafe fn free<S: DropPolicy>(&self, slot: Slot<T, S>)

Frees slot by calling its destructor when it contains an initialized object, uninitialized objects become forgotten as with Pool::forget(). Puts the given slot back into the freelist.

unsafe fn forget<S: Policy>(&self, slot: Slot<T, S>)

Puts the given slot back into the freelist. Will not call the the destructor.

unsafe fn forget_by_ref<S: Policy>(&self, slot: &mut Slot<T, S>)

Non consuming variant of pool.forget(), allows forgetting slots that are part of other structures while keeping Slot non-Copy. The slot must not be used after this. See slot.forget() for details.

unsafe fn take<S: CanTakeValue>(&self, slot: Slot<T, S>) -> T

Takes an object out of the Pool and returns it. The slot at slot is put back to the freelist. This operation violates the Pin guarantees, thus in presence of pinned operation it must not be used.