Struct SingletonMap 

pub struct SingletonMap<V>(/* private fields */);

A map that uses types as keys and stores values of a single type V.

This data structure allows you to associate values with types as keys. For example, you could map u8 to a String description, i8 to another String description, etc., all within the same SingletonMap<String>.

Examples

use singletons::SingletonMap;

let mut map: SingletonMap<String> = SingletonMap::new();
map.insert::<u8>("An unsigned 8-bit integer".to_string());
map.insert::<i8>("A signed 8-bit integer".to_string());

assert_eq!(map.get::<u8>(), Some(&"An unsigned 8-bit integer".to_string()));
assert_eq!(map.get::<i8>(), Some(&"A signed 8-bit integer".to_string()));

Implementations

impl<V> SingletonMap<V>

pub fn new() -> Self

Creates an empty SingletonMap.

The map is initially created with a capacity of 0, so it will not allocate until an element is inserted.

Examples

use singletons::SingletonMap;
let mut map: SingletonMap<String> = SingletonMap::new();

Examples found in repository

examples/map_overview.rs (line 5)

fn main() {
    // Create a map that stores String descriptions for different types
    let mut type_descriptions: SingletonMap<String> = SingletonMap::new();

    // Insert descriptions for various types
    type_descriptions.insert::<u8>("An unsigned 8-bit integer (0 to 255)".to_string());
    type_descriptions.insert::<i8>("A signed 8-bit integer (-128 to 127)".to_string());
    type_descriptions.insert::<u16>("An unsigned 16-bit integer".to_string());
    type_descriptions.insert::<String>("A heap-allocated string".to_string());
    type_descriptions.insert::<Vec<u32>>("A vector of 32-bit integers".to_string());

    // Retrieve descriptions
    println!("u8: {}", type_descriptions.get::<u8>().unwrap());
    println!("i8: {}", type_descriptions.get::<i8>().unwrap());
    println!("String: {}", type_descriptions.get::<String>().unwrap());

    // Modify a description
    if let Some(desc) = type_descriptions.get_mut::<u16>() {
        desc.push_str(" (0 to 65,535)");
    }
    println!("u16: {}", type_descriptions.get::<u16>().unwrap());

    // Use entry API
    type_descriptions
        .entry::<f64>()
        .or_insert("A 64-bit floating-point number".to_string());

    // Update existing entry
    type_descriptions
        .entry::<u8>()
        .and_modify(|desc| desc.push_str(" - commonly used for bytes"))
        .or_insert("Should not be inserted".to_string());

    println!("\nAll type descriptions:");
    for (type_key, description) in type_descriptions.iter() {
        println!("  {}: {}", type_key.as_name(), description);
    }

    println!("\nTotal types documented: {}", type_descriptions.len());

    // Example with default values
    let mut counters: SingletonMap<i32> = SingletonMap::new();
    *counters.get_or_insert_default::<u8>() += 5;
    *counters.get_or_insert_default::<i8>() -= 3;

    println!("\nCounters:");
    println!("  u8 counter: {}", counters.get::<u8>().unwrap());
    println!("  i8 counter: {}", counters.get::<i8>().unwrap());
}

pub fn with_capacity(capacity: usize) -> Self

Creates an empty SingletonMap with at least the specified capacity.

The map will be able to hold at least capacity elements without reallocating.

Examples

use singletons::SingletonMap;
let mut map: SingletonMap<String> = SingletonMap::with_capacity(10);

pub fn capacity(&self) -> usize

Returns the number of elements the map can hold without reallocating.

pub fn len(&self) -> usize

Returns the number of elements currently in the map.

Examples found in repository

examples/map_overview.rs (line 41)

fn main() {
    // Create a map that stores String descriptions for different types
    let mut type_descriptions: SingletonMap<String> = SingletonMap::new();

    // Insert descriptions for various types
    type_descriptions.insert::<u8>("An unsigned 8-bit integer (0 to 255)".to_string());
    type_descriptions.insert::<i8>("A signed 8-bit integer (-128 to 127)".to_string());
    type_descriptions.insert::<u16>("An unsigned 16-bit integer".to_string());
    type_descriptions.insert::<String>("A heap-allocated string".to_string());
    type_descriptions.insert::<Vec<u32>>("A vector of 32-bit integers".to_string());

    // Retrieve descriptions
    println!("u8: {}", type_descriptions.get::<u8>().unwrap());
    println!("i8: {}", type_descriptions.get::<i8>().unwrap());
    println!("String: {}", type_descriptions.get::<String>().unwrap());

    // Modify a description
    if let Some(desc) = type_descriptions.get_mut::<u16>() {
        desc.push_str(" (0 to 65,535)");
    }
    println!("u16: {}", type_descriptions.get::<u16>().unwrap());

    // Use entry API
    type_descriptions
        .entry::<f64>()
        .or_insert("A 64-bit floating-point number".to_string());

    // Update existing entry
    type_descriptions
        .entry::<u8>()
        .and_modify(|desc| desc.push_str(" - commonly used for bytes"))
        .or_insert("Should not be inserted".to_string());

    println!("\nAll type descriptions:");
    for (type_key, description) in type_descriptions.iter() {
        println!("  {}: {}", type_key.as_name(), description);
    }

    println!("\nTotal types documented: {}", type_descriptions.len());

    // Example with default values
    let mut counters: SingletonMap<i32> = SingletonMap::new();
    *counters.get_or_insert_default::<u8>() += 5;
    *counters.get_or_insert_default::<i8>() -= 3;

    println!("\nCounters:");
    println!("  u8 counter: {}", counters.get::<u8>().unwrap());
    println!("  i8 counter: {}", counters.get::<i8>().unwrap());
}

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

pub fn clear(&mut self)

Clears the map, removing all key-value pairs.

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements.

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

Tries to reserve capacity for at least additional more elements.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the map as much as possible.

pub fn shrink_to(&mut self, min_capacity: usize)

Shrinks the capacity of the map as much as possible, but not less than min_capacity.

pub fn insert<K: 'static>(&mut self, value: V) -> Option<V>

Inserts a value into the map with the type K as the key.

If the map did not have this type as a key, None is returned. If the map did have this type as a key, the value is updated and the old value is returned.

Examples

use singletons::SingletonMap;

let mut map = SingletonMap::new();
assert_eq!(map.insert::<u8>("first".to_string()), None);
assert_eq!(map.insert::<u8>("second".to_string()), Some("first".to_string()));

Examples found in repository

examples/map_overview.rs (line 8)

fn main() {
    // Create a map that stores String descriptions for different types
    let mut type_descriptions: SingletonMap<String> = SingletonMap::new();

    // Insert descriptions for various types
    type_descriptions.insert::<u8>("An unsigned 8-bit integer (0 to 255)".to_string());
    type_descriptions.insert::<i8>("A signed 8-bit integer (-128 to 127)".to_string());
    type_descriptions.insert::<u16>("An unsigned 16-bit integer".to_string());
    type_descriptions.insert::<String>("A heap-allocated string".to_string());
    type_descriptions.insert::<Vec<u32>>("A vector of 32-bit integers".to_string());

    // Retrieve descriptions
    println!("u8: {}", type_descriptions.get::<u8>().unwrap());
    println!("i8: {}", type_descriptions.get::<i8>().unwrap());
    println!("String: {}", type_descriptions.get::<String>().unwrap());

    // Modify a description
    if let Some(desc) = type_descriptions.get_mut::<u16>() {
        desc.push_str(" (0 to 65,535)");
    }
    println!("u16: {}", type_descriptions.get::<u16>().unwrap());

    // Use entry API
    type_descriptions
        .entry::<f64>()
        .or_insert("A 64-bit floating-point number".to_string());

    // Update existing entry
    type_descriptions
        .entry::<u8>()
        .and_modify(|desc| desc.push_str(" - commonly used for bytes"))
        .or_insert("Should not be inserted".to_string());

    println!("\nAll type descriptions:");
    for (type_key, description) in type_descriptions.iter() {
        println!("  {}: {}", type_key.as_name(), description);
    }

    println!("\nTotal types documented: {}", type_descriptions.len());

    // Example with default values
    let mut counters: SingletonMap<i32> = SingletonMap::new();
    *counters.get_or_insert_default::<u8>() += 5;
    *counters.get_or_insert_default::<i8>() -= 3;

    println!("\nCounters:");
    println!("  u8 counter: {}", counters.get::<u8>().unwrap());
    println!("  i8 counter: {}", counters.get::<i8>().unwrap());
}

pub fn get<K: 'static>(&self) -> Option<&V>

Returns a reference to the value corresponding to the type key K.

Examples

use singletons::SingletonMap;

let mut map = SingletonMap::new();
map.insert::<u8>("value".to_string());
assert_eq!(map.get::<u8>(), Some(&"value".to_string()));
assert_eq!(map.get::<i8>(), None);

Examples found in repository

examples/map_overview.rs (line 15)

fn main() {
    // Create a map that stores String descriptions for different types
    let mut type_descriptions: SingletonMap<String> = SingletonMap::new();

    // Insert descriptions for various types
    type_descriptions.insert::<u8>("An unsigned 8-bit integer (0 to 255)".to_string());
    type_descriptions.insert::<i8>("A signed 8-bit integer (-128 to 127)".to_string());
    type_descriptions.insert::<u16>("An unsigned 16-bit integer".to_string());
    type_descriptions.insert::<String>("A heap-allocated string".to_string());
    type_descriptions.insert::<Vec<u32>>("A vector of 32-bit integers".to_string());

    // Retrieve descriptions
    println!("u8: {}", type_descriptions.get::<u8>().unwrap());
    println!("i8: {}", type_descriptions.get::<i8>().unwrap());
    println!("String: {}", type_descriptions.get::<String>().unwrap());

    // Modify a description
    if let Some(desc) = type_descriptions.get_mut::<u16>() {
        desc.push_str(" (0 to 65,535)");
    }
    println!("u16: {}", type_descriptions.get::<u16>().unwrap());

    // Use entry API
    type_descriptions
        .entry::<f64>()
        .or_insert("A 64-bit floating-point number".to_string());

    // Update existing entry
    type_descriptions
        .entry::<u8>()
        .and_modify(|desc| desc.push_str(" - commonly used for bytes"))
        .or_insert("Should not be inserted".to_string());

    println!("\nAll type descriptions:");
    for (type_key, description) in type_descriptions.iter() {
        println!("  {}: {}", type_key.as_name(), description);
    }

    println!("\nTotal types documented: {}", type_descriptions.len());

    // Example with default values
    let mut counters: SingletonMap<i32> = SingletonMap::new();
    *counters.get_or_insert_default::<u8>() += 5;
    *counters.get_or_insert_default::<i8>() -= 3;

    println!("\nCounters:");
    println!("  u8 counter: {}", counters.get::<u8>().unwrap());
    println!("  i8 counter: {}", counters.get::<i8>().unwrap());
}

pub fn get_mut<K: 'static>(&mut self) -> Option<&mut V>

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

Examples

use singletons::SingletonMap;

let mut map = SingletonMap::new();
map.insert::<u8>("value".to_string());
if let Some(v) = map.get_mut::<u8>() {
    v.push_str(" modified");
}
assert_eq!(map.get::<u8>(), Some(&"value modified".to_string()));

Examples found in repository

examples/map_overview.rs (line 20)

fn main() {
    // Create a map that stores String descriptions for different types
    let mut type_descriptions: SingletonMap<String> = SingletonMap::new();

    // Insert descriptions for various types
    type_descriptions.insert::<u8>("An unsigned 8-bit integer (0 to 255)".to_string());
    type_descriptions.insert::<i8>("A signed 8-bit integer (-128 to 127)".to_string());
    type_descriptions.insert::<u16>("An unsigned 16-bit integer".to_string());
    type_descriptions.insert::<String>("A heap-allocated string".to_string());
    type_descriptions.insert::<Vec<u32>>("A vector of 32-bit integers".to_string());

    // Retrieve descriptions
    println!("u8: {}", type_descriptions.get::<u8>().unwrap());
    println!("i8: {}", type_descriptions.get::<i8>().unwrap());
    println!("String: {}", type_descriptions.get::<String>().unwrap());

    // Modify a description
    if let Some(desc) = type_descriptions.get_mut::<u16>() {
        desc.push_str(" (0 to 65,535)");
    }
    println!("u16: {}", type_descriptions.get::<u16>().unwrap());

    // Use entry API
    type_descriptions
        .entry::<f64>()
        .or_insert("A 64-bit floating-point number".to_string());

    // Update existing entry
    type_descriptions
        .entry::<u8>()
        .and_modify(|desc| desc.push_str(" - commonly used for bytes"))
        .or_insert("Should not be inserted".to_string());

    println!("\nAll type descriptions:");
    for (type_key, description) in type_descriptions.iter() {
        println!("  {}: {}", type_key.as_name(), description);
    }

    println!("\nTotal types documented: {}", type_descriptions.len());

    // Example with default values
    let mut counters: SingletonMap<i32> = SingletonMap::new();
    *counters.get_or_insert_default::<u8>() += 5;
    *counters.get_or_insert_default::<i8>() -= 3;

    println!("\nCounters:");
    println!("  u8 counter: {}", counters.get::<u8>().unwrap());
    println!("  i8 counter: {}", counters.get::<i8>().unwrap());
}

pub fn remove<K: 'static>(&mut self) -> Option<V>

Removes a key-value pair from the map, returning the value if the type key K was present.

Examples

use singletons::SingletonMap;

let mut map = SingletonMap::new();
map.insert::<u8>("value".to_string());
assert_eq!(map.remove::<u8>(), Some("value".to_string()));
assert_eq!(map.remove::<u8>(), None);

pub fn contains_key<K: 'static>(&self) -> bool

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

Examples

use singletons::SingletonMap;

let mut map = SingletonMap::new();
map.insert::<u8>("value".to_string());
assert!(map.contains_key::<u8>());
assert!(!map.contains_key::<i8>());

pub fn keys(&self) -> Keys<'_, V>

Returns an iterator visiting all type keys in insertion order.

pub fn values(&self) -> Values<'_, V>

Returns an iterator visiting all values in insertion order.

pub fn values_mut(&mut self) -> ValuesMut<'_, V>

Returns an iterator visiting all values mutably in insertion order.

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

Returns an iterator visiting all key-value pairs in insertion order.

Examples found in repository

examples/map_overview.rs (line 37)

fn main() {
    // Create a map that stores String descriptions for different types
    let mut type_descriptions: SingletonMap<String> = SingletonMap::new();

    // Insert descriptions for various types
    type_descriptions.insert::<u8>("An unsigned 8-bit integer (0 to 255)".to_string());
    type_descriptions.insert::<i8>("A signed 8-bit integer (-128 to 127)".to_string());
    type_descriptions.insert::<u16>("An unsigned 16-bit integer".to_string());
    type_descriptions.insert::<String>("A heap-allocated string".to_string());
    type_descriptions.insert::<Vec<u32>>("A vector of 32-bit integers".to_string());

    // Retrieve descriptions
    println!("u8: {}", type_descriptions.get::<u8>().unwrap());
    println!("i8: {}", type_descriptions.get::<i8>().unwrap());
    println!("String: {}", type_descriptions.get::<String>().unwrap());

    // Modify a description
    if let Some(desc) = type_descriptions.get_mut::<u16>() {
        desc.push_str(" (0 to 65,535)");
    }
    println!("u16: {}", type_descriptions.get::<u16>().unwrap());

    // Use entry API
    type_descriptions
        .entry::<f64>()
        .or_insert("A 64-bit floating-point number".to_string());

    // Update existing entry
    type_descriptions
        .entry::<u8>()
        .and_modify(|desc| desc.push_str(" - commonly used for bytes"))
        .or_insert("Should not be inserted".to_string());

    println!("\nAll type descriptions:");
    for (type_key, description) in type_descriptions.iter() {
        println!("  {}: {}", type_key.as_name(), description);
    }

    println!("\nTotal types documented: {}", type_descriptions.len());

    // Example with default values
    let mut counters: SingletonMap<i32> = SingletonMap::new();
    *counters.get_or_insert_default::<u8>() += 5;
    *counters.get_or_insert_default::<i8>() -= 3;

    println!("\nCounters:");
    println!("  u8 counter: {}", counters.get::<u8>().unwrap());
    println!("  i8 counter: {}", counters.get::<i8>().unwrap());
}

pub fn iter_mut(&mut self) -> IterMut<'_, V>

Returns an iterator visiting all key-value pairs mutably in insertion order.

pub fn entry<K: 'static>(&mut self) -> Entry<'_, V>

Gets the given type key’s corresponding entry in the map for in-place manipulation.

Examples

use singletons::SingletonMap;

let mut map = SingletonMap::new();
map.entry::<u8>().or_insert("default".to_string());
assert_eq!(map.get::<u8>(), Some(&"default".to_string()));

Examples found in repository

examples/map_overview.rs (line 27)

fn main() {
    // Create a map that stores String descriptions for different types
    let mut type_descriptions: SingletonMap<String> = SingletonMap::new();

    // Insert descriptions for various types
    type_descriptions.insert::<u8>("An unsigned 8-bit integer (0 to 255)".to_string());
    type_descriptions.insert::<i8>("A signed 8-bit integer (-128 to 127)".to_string());
    type_descriptions.insert::<u16>("An unsigned 16-bit integer".to_string());
    type_descriptions.insert::<String>("A heap-allocated string".to_string());
    type_descriptions.insert::<Vec<u32>>("A vector of 32-bit integers".to_string());

    // Retrieve descriptions
    println!("u8: {}", type_descriptions.get::<u8>().unwrap());
    println!("i8: {}", type_descriptions.get::<i8>().unwrap());
    println!("String: {}", type_descriptions.get::<String>().unwrap());

    // Modify a description
    if let Some(desc) = type_descriptions.get_mut::<u16>() {
        desc.push_str(" (0 to 65,535)");
    }
    println!("u16: {}", type_descriptions.get::<u16>().unwrap());

    // Use entry API
    type_descriptions
        .entry::<f64>()
        .or_insert("A 64-bit floating-point number".to_string());

    // Update existing entry
    type_descriptions
        .entry::<u8>()
        .and_modify(|desc| desc.push_str(" - commonly used for bytes"))
        .or_insert("Should not be inserted".to_string());

    println!("\nAll type descriptions:");
    for (type_key, description) in type_descriptions.iter() {
        println!("  {}: {}", type_key.as_name(), description);
    }

    println!("\nTotal types documented: {}", type_descriptions.len());

    // Example with default values
    let mut counters: SingletonMap<i32> = SingletonMap::new();
    *counters.get_or_insert_default::<u8>() += 5;
    *counters.get_or_insert_default::<i8>() -= 3;

    println!("\nCounters:");
    println!("  u8 counter: {}", counters.get::<u8>().unwrap());
    println!("  i8 counter: {}", counters.get::<i8>().unwrap());
}

impl<V: Default> SingletonMap<V>

pub fn get_or_insert_default<K: 'static>(&mut self) -> &mut V

Returns a mutable reference to the value for type key K, inserting a default value if the key is not present.

Examples

use singletons::SingletonMap;

let mut map: SingletonMap<String> = SingletonMap::new();
let value = map.get_or_insert_default::<u8>();
assert_eq!(value, &String::new());

Examples found in repository

examples/map_overview.rs (line 45)

fn main() {
    // Create a map that stores String descriptions for different types
    let mut type_descriptions: SingletonMap<String> = SingletonMap::new();

    // Insert descriptions for various types
    type_descriptions.insert::<u8>("An unsigned 8-bit integer (0 to 255)".to_string());
    type_descriptions.insert::<i8>("A signed 8-bit integer (-128 to 127)".to_string());
    type_descriptions.insert::<u16>("An unsigned 16-bit integer".to_string());
    type_descriptions.insert::<String>("A heap-allocated string".to_string());
    type_descriptions.insert::<Vec<u32>>("A vector of 32-bit integers".to_string());

    // Retrieve descriptions
    println!("u8: {}", type_descriptions.get::<u8>().unwrap());
    println!("i8: {}", type_descriptions.get::<i8>().unwrap());
    println!("String: {}", type_descriptions.get::<String>().unwrap());

    // Modify a description
    if let Some(desc) = type_descriptions.get_mut::<u16>() {
        desc.push_str(" (0 to 65,535)");
    }
    println!("u16: {}", type_descriptions.get::<u16>().unwrap());

    // Use entry API
    type_descriptions
        .entry::<f64>()
        .or_insert("A 64-bit floating-point number".to_string());

    // Update existing entry
    type_descriptions
        .entry::<u8>()
        .and_modify(|desc| desc.push_str(" - commonly used for bytes"))
        .or_insert("Should not be inserted".to_string());

    println!("\nAll type descriptions:");
    for (type_key, description) in type_descriptions.iter() {
        println!("  {}: {}", type_key.as_name(), description);
    }

    println!("\nTotal types documented: {}", type_descriptions.len());

    // Example with default values
    let mut counters: SingletonMap<i32> = SingletonMap::new();
    *counters.get_or_insert_default::<u8>() += 5;
    *counters.get_or_insert_default::<i8>() -= 3;

    println!("\nCounters:");
    println!("  u8 counter: {}", counters.get::<u8>().unwrap());
    println!("  i8 counter: {}", counters.get::<i8>().unwrap());
}

Trait Implementations

impl<V: Clone> Clone for SingletonMap<V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug> Debug for SingletonMap<V>

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

Formats the value using the given formatter.

impl<V: Default> Default for SingletonMap<V>

fn default() -> Self

Returns the “default value” for a type.