Enum Entry 

pub enum Entry<'a, K, V, const N: usize> {
    Occupied(OccupiedEntry<'a, K, V, N>),
    Vacant(VacantEntry<'a, K, V, N>),
}

A view into an entry in the map

Variants

Occupied(OccupiedEntry<'a, K, V, N>)

The entry corresponding to the key K exists in the map

Vacant(VacantEntry<'a, K, V, N>)

The entry corresponding to the key K does not exist in the map

Implementations

impl<'a, K, V, const N: usize> Entry<'a, K, V, N>

where K: Eq + Hash,

pub fn or_insert(self, default: V) -> Result<&'a mut V, V>

Ensures a value is in the entry by inserting the default if empty, and returns a mutable reference to the value in the entry.

Examples

use heapless::index_map::FnvIndexMap;

// A hash map with a capacity of 16 key-value pairs allocated on the stack
let mut book_reviews = FnvIndexMap::<_, _, 16>::new();
let result = book_reviews
    .entry("Adventures of Huckleberry Finn")
    .or_insert("My favorite book.");

assert_eq!(result, Ok(&mut "My favorite book."));
assert_eq!(
    book_reviews["Adventures of Huckleberry Finn"],
    "My favorite book."
);

pub fn or_insert_with<F: FnOnce() -> V>( self, default: F, ) -> Result<&'a mut V, V>

Ensures a value is in the entry by inserting the result of the default function if empty, and returns a mutable reference to the value in the entry.

Examples

use heapless::index_map::FnvIndexMap;

// A hash map with a capacity of 16 key-value pairs allocated on the stack
let mut book_reviews = FnvIndexMap::<_, _, 16>::new();
let s = "Masterpiece.".to_string();

book_reviews
    .entry("Grimms' Fairy Tales")
    .or_insert_with(|| s);

assert_eq!(
    book_reviews["Grimms' Fairy Tales"],
    "Masterpiece.".to_string()
);

pub fn or_insert_with_key<F: FnOnce(&K) -> V>( self, default: F, ) -> Result<&'a mut V, V>

Ensures a value is in the entry by inserting, if empty, the result of the default function. This method allows for generating key-derived values for insertion by providing the default function a reference to the key that was moved during the .entry(key) method call.

The reference to the moved key is provided so that cloning or copying the key is unnecessary, unlike with .or_insert_with(|| ... ).

Examples

use heapless::index_map::FnvIndexMap;

// A hash map with a capacity of 16 key-value pairs allocated on the stack
let mut book_reviews = FnvIndexMap::<_, _, 16>::new();

book_reviews
    .entry("Pride and Prejudice")
    .or_insert_with_key(|key| key.chars().count());

assert_eq!(book_reviews["Pride and Prejudice"], 19);

pub fn key(&self) -> &K

Returns a reference to this entry’s key.

Examples

use heapless::index_map::FnvIndexMap;

// A hash map with a capacity of 16 key-value pairs allocated on the stack
let mut book_reviews = FnvIndexMap::<&str, &str, 16>::new();
assert_eq!(
    book_reviews
        .entry("The Adventures of Sherlock Holmes")
        .key(),
    &"The Adventures of Sherlock Holmes"
);

pub fn and_modify<F>(self, f: F) -> Self

where F: FnOnce(&mut V),

Provides in-place mutable access to an occupied entry before any potential inserts into the map.

Examples

use heapless::index_map::FnvIndexMap;

// A hash map with a capacity of 16 key-value pairs allocated on the stack
let mut book_reviews = FnvIndexMap::<_, _, 16>::new();

book_reviews
    .entry("Grimms' Fairy Tales")
    .and_modify(|e| *e = "Masterpiece.")
    .or_insert("Very enjoyable.");
assert_eq!(book_reviews["Grimms' Fairy Tales"], "Very enjoyable.");

impl<'a, K, V, const N: usize> Entry<'a, K, V, N>

where K: Eq + Hash, V: Default,

pub fn or_default(self) -> Result<&'a mut V, V>

Ensures a value is in the entry by inserting the default value if empty, and returns a mutable reference to the value in the entry.

Examples

use heapless::index_map::FnvIndexMap;

let mut book_reviews = FnvIndexMap::<&str, Option<&str>, 16>::new();

book_reviews.entry("Pride and Prejudice").or_default();

assert_eq!(book_reviews["Pride and Prejudice"], None);