Struct TypeMapV 

pub struct TypeMapV<K, V>
where
    K: Clone + Eq + Hash + Debug,
    V: Send + Sync,
{ /* private fields */ }

A thread-safe map that stores values of a specific type

TypeMapV allows you to create a type-safe, thread-safe map where all values must be of the same type (or implement the same trait). This is particularly useful for storing collections of trait objects or other homogeneous values.

Examples

use sovran_typemap::{TypeMapV, MapError};

// Store trait objects
trait Handler: Send + Sync {
    fn handle(&self) -> Result<(), MapError>;
}

let store = TypeMapV::<String, Box<dyn Handler>>::new();

// Apply an operation to all handlers
let result = store.apply(|key, handler| {
    println!("Running handler {}", key);
    handler.handle()
});

Implementations

impl<K, V> TypeMapV<K, V>

where K: Clone + Eq + Hash + Debug, V: Send + Sync,

pub fn new() -> Self

Creates a new, empty TypeMapV

Examples

use sovran_typemap::TypeMapV;

// Create a map storing strings
let string_store = TypeMapV::<String, String>::new();

// Create a map storing trait objects
trait MyTrait: Send + Sync {}
let trait_store = TypeMapV::<u32, Box<dyn MyTrait>>::new();

pub fn set(&self, key: K, value: V) -> Result<(), MapError>

Stores a value in the map

Errors

Returns MapError::LockError if the internal lock cannot be acquired.

pub fn get(&self, key: &K) -> Result<V, MapError>

where V: Clone,

Retrieves a clone of a value from the map

Errors

• Returns MapError::LockError if the internal lock cannot be acquired
• Returns MapError::KeyNotFound if the key doesn’t exist

pub fn remove(&self, key: &K) -> Result<bool, MapError>

Removes a value from the map

Errors

Returns MapError::LockError if the internal lock cannot be acquired.

Returns

Returns Ok(true) if the key was present and removed, Ok(false) if not present.

pub fn apply<F>(&self, f: F) -> Result<(), MapError>

where F: FnMut(&K, &V) -> Result<(), MapError>,

Applies a function to all key-value pairs in the map

This method allows you to perform operations on all stored values while maintaining thread safety. The function is called with a reference to both the key and value for each entry.

Examples

trait Handler: Send + Sync {
    fn handle(&self) -> Result<(), MapError>;
}

let store = TypeMapV::<String, Box<dyn Handler>>::new();

// Apply to all handlers
let result = store.apply(|key, handler| {
    handler.handle().map_err(|_| MapError::LockError)
});

Errors

Returns MapError::LockError if the internal lock cannot be acquired, or any error returned by the provided function.

pub fn len(&self) -> Result<usize, MapError>

Returns the number of entries in the map

Errors

Returns MapError::LockError if the internal lock cannot be acquired.

pub fn is_empty(&self) -> Result<bool, MapError>

Returns true if the map contains no entries

Errors

Returns MapError::LockError if the internal lock cannot be acquired.

pub fn contains_key(&self, key: &K) -> Result<bool, MapError>

Returns true if the map contains the specified key

Errors

Returns MapError::LockError if the internal lock cannot be acquired.

pub fn keys(&self) -> Result<Vec<K>, MapError>

where K: Clone,

Returns a vector of all keys in the map

Errors

Returns MapError::LockError if the internal lock cannot be acquired.

pub fn values(&self) -> Result<Vec<V>, MapError>

where V: Clone,

Returns a vector of all values in the map

Errors

Returns MapError::LockError if the internal lock cannot be acquired.

Trait Implementations

impl<K, V> Clone for TypeMapV<K, V>

where K: Clone + Eq + Hash + Debug + Clone, V: Send + Sync + Clone,

fn clone(&self) -> TypeMapV<K, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V> Debug for TypeMapV<K, V>

where K: Clone + Eq + Hash + Debug + Debug, V: Send + Sync + Debug,

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

Formats the value using the given formatter.

impl<K, V> Default for TypeMapV<K, V>

where K: Clone + Eq + Hash + Debug, V: Send + Sync,

fn default() -> Self

Returns the “default value” for a type.