Implements a vector-based slab-like map with an interface similar to that of HashMap,
and also provides tools for generating lightweight identifiers that can be type-safely used as keys for this map.
Currently, this crate provides 3 ways to create new types based on usize that can be used as keys to BlazeMap.
They are represented by the following macros and provide different optimizations.
Creates a new type that acts as an usize-based replacement
for the old type that can be used as a key for blazemap collections.
use blazemap::prelude::{BlazeMap, define_key_wrapper};
define_key_wrapper! {
pub struct Key(&'static str);
Derive(as for Original Type): { // Optional section
Debug,
Display,
};
Derive(as for usize): { // Optional section
Ord,
}
}
let key_1 = Key::new("first");
let key_2 = Key::new("second");
let key_3 = Key::new("third");
let mut map = BlazeMap::new();
map.insert(key_2, "2");
map.insert(key_1, "1");
map.insert(key_3, "3");
assert_eq!(format!("{map:?}"), r#"{"first": "1", "second": "2", "third": "3"}"#)Creates a new type that acts as an usize-based replacement for the old
type that can be used as a key for blazemap collections.
Being an analogue of define_key_wrapper!
for the case when the user could statically guarantee
that the number of unique keys doesn't exceed MAX_CAP, it's optimized for
read operations so that they don't create any multi-thread contention.
use blazemap::prelude::{BlazeMap, define_key_wrapper_bounded};
define_key_wrapper_bounded! {
pub struct Key(&'static str);
MAX_CAP = 40_000;
Derive(as for Original Type): { // Optional section
Debug,
Display,
};
Derive(as for usize): { // Optional section
Ord,
}
}
let key_1 = Key::new("first");
let key_2 = Key::new("second");
let key_3 = Key::new("third");
let mut map = BlazeMap::new();
map.insert(key_2, "2");
map.insert(key_1, "1");
map.insert(key_3, "3");
assert_eq!(format!("{map:?}"), r#"{"first": "1", "second": "2", "third": "3"}"#)Creates a new type based on incrementally generated usize instances
that can be used as a key for blazemap collections. This is the most performant way to generate keys for BlazeMap.
use blazemap::prelude::{BlazeMap, define_plain_id};
define_plain_id! {
pub struct Id;
Derive: { // Optional section
Ord
};
}
let key_1 = Id::new();
let key_2 = Id::new();
let key_3 = Id::new();
let mut map = BlazeMap::new();
map.insert(key_2, "2");
map.insert(key_1, "1");
map.insert(key_3, "3");
assert_eq!(format!("{map:?}"), r#"{0: "1", 1: "2", 2: "3"}"#)