Struct ScatteredMap 

pub struct ScatteredMap<K: 'static, V: 'static> { /* private fields */ }

A swiss-table-style lookup table initialized with link-time data. Each item in the map must have a unique hash.

For a flat list in arbitrary link order, use crate::ScatteredSlice. For a sorted list without per-item handles, use crate::ScatteredSortedSlice. For static handles at scatter sites, use crate::ScatteredReferencedSlice; when sorted order is required as well, use crate::ScatteredSortedReferencedSlice.

Performance notes

The map’s metadata section is only ever written to once, and then becomes read-only. This means that we can avoid tombstone logic.

Metadata is arranged in 16-slot SIMD groups for optimal performance.

//! Example for `ScatteredMap`.
use scattered_collect::{gather, map::ScatteredMap, scatter};

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]
struct MyId(u32);

#[gather]
static MAP: ScatteredMap<&'static str, MyId>;

#[scatter(MAP)]
static APPLE: (&'static str, MyId) = ("apple", MyId(1));

#[scatter(MAP)]
static BANANA: (&'static str, MyId) = ("banana", MyId(2));

#[scatter(MAP)]
static ORANGE: (&'static str, MyId) = ("orange", MyId(3));

fn main() {
    println!("APPLE: {:?}", APPLE);
    println!("BANANA: {:?}", BANANA);
    println!("ORANGE: {:?}", ORANGE);

    println!("Entries:");
    for (key, value) in &MAP {
        println!(" - {}: {:?}", key, value);
    }
}

Implementations

impl<K: ConstHash + PartialEq + 'static, V: 'static> ScatteredMap<K, V>

pub fn find(&self, key: &K) -> Option<&V>

Lookup a value by key.

pub fn entries(&self) -> impl Iterator<Item = (&K, &V)>

Iterate over the entries in the map.

pub fn keys(&self) -> impl Iterator<Item = &K>

Iterate over the keys in the map.

pub fn values(&self) -> impl Iterator<Item = &V>

Iterate over the values in the map.

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

True when a key is present in the map.

pub fn len(&self) -> usize

The number of records in the map.

pub fn is_empty(&self) -> bool

True if the map has no records.

Trait Implementations

impl<K: 'static, V: 'static> IntoIterator for &'static ScatteredMap<K, V>

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

The type of the elements being iterated over.

type IntoIter = Map<Iter<'static, MapRecord<K, V>>, fn(&MapRecord<K, V>) -> (&K, &V)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.