Struct ConcurrentHandleAllocator 

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

A thread-safe handle allocator using parking_lot primitives.

This allocator allows concurrent read access and synchronized write access. Use this when handles need to be shared across threads.

Performance Characteristics

• Reads (get): Uses RwLock, multiple concurrent readers allowed
• Writes (allocate, deallocate): Briefly locks a mutex for the free list

Example

use std::sync::Arc;

let allocator = Arc::new(ConcurrentHandleAllocator::new());

// Clone for another thread
let alloc_clone = Arc::clone(&allocator);
std::thread::spawn(move || {
    let handle = alloc_clone.allocate(42);
    // ...
});

Implementations

impl<T> ConcurrentHandleAllocator<T>

pub fn new() -> Self

Creates a new empty concurrent allocator.

pub fn with_capacity(capacity: usize) -> Self

Creates a concurrent allocator with pre-allocated capacity.

pub fn allocate(&self, value: T) -> Handle<T>

Allocates a handle for the given value.

This operation briefly locks the free list and entries for writing.

pub fn deallocate(&self, handle: Handle<T>) -> Option<T>

Deallocates a handle, returning the value if the handle was valid.

pub fn get(&self, handle: Handle<T>) -> Option<ValueRef<'_, T>>

Gets a reference to the value, if the handle is valid.

This operation takes a read lock and returns a guard.

pub fn is_valid(&self, handle: Handle<T>) -> bool

Checks if a handle is valid.

pub fn len(&self) -> usize

Returns the number of allocated handles.

pub fn is_empty(&self) -> bool

Returns true if no handles are allocated.

pub fn clear(&self)

Clears all entries, deallocating all handles.

Trait Implementations

impl<T: Debug> Debug for ConcurrentHandleAllocator<T>

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

Formats the value using the given formatter.

impl<T> Default for ConcurrentHandleAllocator<T>

fn default() -> Self

Returns the “default value” for a type.