Name Description Size
arbitrary.rs 2131
equivalent.rs 735
lib.rs [`IndexMap`] is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. [`IndexSet`] is a corresponding hash set using the same implementation and with similar properties. [`IndexMap`]: map/struct.IndexMap.html [`IndexSet`]: set/struct.IndexSet.html ### Feature Highlights [`IndexMap`] and [`IndexSet`] are drop-in compatible with the std `HashMap` and `HashSet`, but they also have some features of note: - The ordering semantics (see their documentation for details) - Sorting methods and the [`.pop()`][IndexMap::pop] methods. - The [`Equivalent`] trait, which offers more flexible equality definitions between borrowed and owned versions of keys. - The [`MutableKeys`][map::MutableKeys] trait, which gives opt-in mutable access to hash map keys. ### Alternate Hashers [`IndexMap`] and [`IndexSet`] have a default hasher type `S = RandomState`, just like the standard `HashMap` and `HashSet`, which is resistant to HashDoS attacks but not the most performant. Type aliases can make it easier to use alternate hashers: ``` use fnv::FnvBuildHasher; use fxhash::FxBuildHasher; use indexmap::{IndexMap, IndexSet}; type FnvIndexMap<K, V> = IndexMap<K, V, FnvBuildHasher>; type FnvIndexSet<T> = IndexSet<T, FnvBuildHasher>; type FxIndexMap<K, V> = IndexMap<K, V, FxBuildHasher>; type FxIndexSet<T> = IndexSet<T, FxBuildHasher>; let std: IndexSet<i32> = (0..100).collect(); let fnv: FnvIndexSet<i32> = (0..100).collect(); let fx: FxIndexSet<i32> = (0..100).collect(); assert_eq!(std, fnv); assert_eq!(std, fx); ``` ### Rust Version This version of indexmap requires Rust 1.56 or later. The indexmap 1.x release series will use a carefully considered version upgrade policy, where in a later 1.x version, we will raise the minimum required Rust version. ## No Standard Library Targets This crate supports being built without `std`, requiring `alloc` instead. This is enabled automatically when it is detected that `std` is not available. There is no crate feature to enable/disable to trigger this. It can be tested by building for a std-less target. - Creating maps and sets using [`new`][IndexMap::new] and [`with_capacity`][IndexMap::with_capacity] is unavailable without `std`. Use methods [`IndexMap::default`][def], [`with_hasher`][IndexMap::with_hasher], [`with_capacity_and_hasher`][IndexMap::with_capacity_and_hasher] instead. A no-std compatible hasher will be needed as well, for example from the crate `twox-hash`. - Macros [`indexmap!`] and [`indexset!`] are unavailable without `std`. [def]: map/struct.IndexMap.html#impl-Default 5475
macros.rs 5147
map
map.rs `IndexMap` is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. 56962
mutable_keys.rs 2192
rayon
rustc.rs Minimal support for `rustc-rayon`, not intended for general use. 3894
serde.rs 3905
serde_seq.rs Functions to serialize and deserialize an `IndexMap` as an ordered sequence. The default `serde` implementation serializes `IndexMap` as a normal map, but there is no guarantee that serialization formats will preserve the order of the key-value pairs. This module serializes `IndexMap` as a sequence of `(key, value)` elements instead, in order. This module may be used in a field attribute for derived implementations: ``` # use indexmap::IndexMap; # use serde_derive::{Deserialize, Serialize}; #[derive(Deserialize, Serialize)] struct Data { #[serde(with = "indexmap::serde_seq")] map: IndexMap<i32, u64>, // ... } ``` Requires crate feature `"serde"` or `"serde-1"` 3200
set.rs A hash set implemented using `IndexMap` 54372
util.rs 915