Macro define_static_map

macro_rules! define_static_map {
    (const // Default constructor
        $NAME:ident, KEY:$KEY:ty $(,)?
    ) => { ... };
    (const // Custom Empty/Tomb, Default Hasher
        $NAME:ident, KEY:$KEY:ty, EMPTY:$EMPTY:expr, TOMB:$TOMB:expr $(,)?
    ) => { ... };
    (const // Custom Hasher, Default Empty/Tomb
        $NAME:ident, KEY:$KEY:ty, HASHER: | $HASH_ARG:ident | $HASH_EXPR:expr $(,)?
    ) => { ... };
    (const // Fully customizable
        $NAME:ident, KEY:$KEY:ty, EMPTY:$EMPTY:expr, TOMB:$TOMB:expr,
        HASHER: | $HASH_ARG:ident | $HASH_EXPR:expr $(,)?
    ) => { ... };
    ( // Default constructor
        $NAME:ident, KEY:$KEY:ty $(,)?
    ) => { ... };
    ( // Custom Empty/Tomb, Default Hasher
        $NAME:ident, KEY:$KEY:ty, EMPTY:$EMPTY:expr, TOMB:$TOMB:expr $(,)?
    ) => { ... };
    ( // Custom Hasher, Default Empty/Tomb
        $NAME:ident, KEY:$KEY:ty, HASHER: | $HASH_ARG:ident | $HASH_EXPR:expr $(,)?
    ) => { ... };
    ( // Fully customizable
        $NAME:ident, KEY:$KEY:ty, EMPTY:$EMPTY:expr, TOMB:$TOMB:expr,
        HASHER: | $HASH_ARG:ident | $HASH_EXPR:expr $(,)?
    ) => { ... };
    (typeid // uses 64-bit hashes of `TypeId`s for the keys
     $NAME:ident $(,)?) => { ... };
    (@shared $NAME:ident, KEY:$KEY:ty, HASHER: | $HASH_ARG:ident | $HASH_EXPR:expr $(,)?) => { ... };
}

Build a custom static hashmap.

Arguments

• $NAME: the name of the new hashmap.
• $KEY: the integer primitive type for the keys.

optional:

• $EMPTY: the $KEY value for empty entries.
• $TOMB: the $KEY value for deleted entries.
• $HASH_ARG: the argument representing the byte slice.
• $HASH_EXPR: the const hasher expression using $HASH_ARG.

Notes

• values V have to be Copy + ConstDefault.
• keys $KEY can be any primitive integers, floats or char.
• Two specific $KEY values are reserved to indicate empty deleted keys. They default to MIN and MAX, respectively, but can be customized.
• The default hasher is HasherFx.

There are two variants, one prefixed with const that supports const methods, but the empty and tomb values have to be known at compile time. The other variant has not const methods,

Examples

See the example type: ExampleStaticMapU16.

Basic usage

// Define a static hashmap with `u16` keys and default hasher
define_static_map![const ExampleMap, KEY: u16];

let mut map = ExampleMap::<u16, u32, 8>::new();

// Insert key-value pairs
map.insert(1, 100).unwrap();
map.insert(2, 200).unwrap();

// Retrieve values
assert_eq!(map.get(1), Some(100));
assert_eq!(map.get(2), Some(200));
assert_eq!(map.get(3), None); // Key not found

// Delete a key
assert!(map.remove(1));
assert_eq!(map.get(1), None);

// Check introspection methods
assert_eq!(map.len(), 1);
assert!(!map.is_empty());
assert!(!map.is_full());

// Rebuild after deletions to optimize probing
if map.should_rebuild() {
    map.rebuild();
}

Custom hashers

// Define a static hashmap using `HasherFx` with a custom seed
define_static_map![const ExampleMapFxSeeded, KEY: u16,
    HASHER: |b| HasherFx::<usize>::hash_bytes_with_seed(123, b)
];
let mut map = ExampleMapFxSeeded::<u16, u32, 8>::new();
map.insert(1, 100).unwrap();
assert_eq!(map.get(1), Some(100));

// Define a static hashmap using a stateful pengy hasher
define_static_map![const ExampleMapPengy, KEY: u16,
    HASHER: |b| {
        let mut p = HasherPengy::new();
        p.process(b);
        p.digest() as usize
    }
];
let mut map = ExampleMapPengy::<u16, u32, 8>::new();
map.insert(1, 100).unwrap();
assert_eq!(map.get(1), Some(100));