Struct object_lib::collections::pmap::PHashMap

#[repr(C)]
pub struct PHashMap<K: Persistable, V: Persistable> {
    num_elements: usize,
    capacity: usize,
    num_buckets: usize,
    table: PhantomData<Bucket<K, V>>,
    table_offset: usize,
    /* private fields */
}

A persistable hash map, which is safely movable between runtime instances.

This implementation leverages the PVec implementation to provide key/value pair backing storage for a collection of Buckets. Note that because of how resizing is currently performed, and the use of a stateless bump allocator to manage allocations, we end up leaking the space for all the Bucket tables we had allocated for all past capacities.

Fields

num_elements: usize

capacity: usize

num_buckets: usize

table: PhantomData<Bucket<K, V>>

table_offset: usize

Implementations

impl<K, V> PHashMap<K, V>where K: Eq + Default + Hash + Persistable + PersistentlyAllocatable, V: Persistable,

pub fn new() -> Self

Instantiates a new empty hashmap. No allocations are made as a result of this call.

pub fn len(&self) -> usize

Returns the number of elements in the map.

pub fn with_capacity(&mut self, capacity: usize)

Allocates space for the PHashMap to hold at least capacity elements before a reallocation is needed.

pub fn insert<T>(&mut self, k: T, v: V) -> Option<V>where T: Hash, K: CopyFrom<From = T> + PartialEq<T>,

Inserts a key-value pair into the PHashMap, resizing if necessary.

If the element was already in the PHashMap, the entry for the key is updated, and the old value is returned. Otherwise, None is returned.

pub fn clear(&mut self)

pub fn get<T>(&self, k: &T) -> Option<&V>where T: Hash, K: CopyFrom<From = T> + PartialEq<T>,

Returns a reference to the value corresponding to the key.

fn get_pkey(&self, k: &K) -> Option<&V>

pub fn get_mut(&self, k: &K) -> Option<&mut V>

Returns a mutable reference to the value corresponding to the (persistable) key.

pub fn get_mut_non_persistent_key<T>(&self, k: &T) -> Option<&mut V>where T: Hash, K: CopyFrom<From = T> + PartialEq<T>,

Returns a mutable reference to the value corresponding to the key.

pub fn contains(&self, k: &K) -> bool

Returns true if the map contains a value for the specified key.

pub fn contains_key<T>(&self, k: &T) -> boolwhere T: Hash, K: CopyFrom<From = T> + PartialEq<T>,

Returns true if the map contains a value for the specified key. Note that this supports keys that can be converted into the native key type (unlike [contains]).

fn get_hash_for_other_key<T>(&self, key: &T) -> usizewhere T: Hash, K: CopyFrom<From = T>,

unsafe fn get_bucket_at_index_ptr(&self, idx: usize) -> *mut Bucket<K, V>

pub fn iter(&self) -> PHashMapIter<'_, K, V>

pub fn group_buckets(&self, num_groups: usize) -> Vec<Range<usize>>

pub fn iter_for_bucket_range( &self, start_bucket: usize, end_bucket: usize ) -> PHashMapRangeIter<'_, K, V>

pub fn union_as_map<'a, F>( &'a self, other: &'a HashMap<K, V>, value_tiebreak_fn: F ) -> HashMap<K, V>where K: Copy, V: Copy, F: Fn((&'a K, &'a V), (&'a K, &'a V)) -> (&'a K, &'a V),

Trait Implementations

impl<K: Debug + Persistable, V: Debug + Persistable> Debug for PHashMap<K, V>

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

Formats the value using the given formatter.

impl<K, V> Into<HashMap<K, V>> for &PHashMap<K, V>where K: Eq + Default + Hash + Persistable + PersistentlyAllocatable + Copy, V: Persistable + Copy,

fn into(self) -> HashMap<K, V>

Converts this type into the (usually inferred) input type.

impl<'a, K, V> IntoIterator for &'a PHashMap<K, V>where K: Persistable, V: Persistable,

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

type IntoIter = PHashMapIter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V> Persistable for PHashMap<K, V>where K: Persistable, V: Persistable,

fn as_bytes(&self) -> &[u8] where Self: Sized,

fn from_bytes(src: *mut [u8]) -> *mut Selfwhere Self: Sized,

fn from_bytes_ref(src: *const [u8]) -> &'static Selfwhere Self: Sized,

fn adjust_from(&mut self, _other: &Self)

Used for object moves.

impl<K, V> PersistentlyAllocatable for PHashMap<K, V>where K: Eq + Default + Hash + Persistable + PersistentlyAllocatable, V: Persistable,

fn set_allocator(&mut self, allocator: Arc<RwLock<BumpAllocator>>)

Sets the allocator that is going to be used by the PHashMap instance whenever it needs to extend its internal capacity.

NOTE This needs to be set before any subsequent calls are made that would trigger an allocation.

fn get_allocator(&self) -> Option<Arc<RwLock<BumpAllocator>>>