| arbitrary.rs |
|
2238 |
| borsh.rs |
|
3142 |
| 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.
### 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 map keys, and [`MutableValues`][set::MutableValues] for sets.
### Feature Flags
To reduce the amount of compiled code in the crate by default, certain
features are gated behind [feature flags]. These allow you to opt in to (or
out of) functionality. Below is a list of the features available in this
crate.
* `std`: Enables features which require the Rust standard library. For more
information see the section on [`no_std`].
* `rayon`: Enables parallel iteration and other parallel methods.
* `serde`: Adds implementations for [`Serialize`] and [`Deserialize`]
to [`IndexMap`] and [`IndexSet`]. Alternative implementations for
(de)serializing [`IndexMap`] as an ordered sequence are available in the
[`map::serde_seq`] module.
* `borsh`: Adds implementations for [`BorshSerialize`] and [`BorshDeserialize`]
to [`IndexMap`] and [`IndexSet`].
* `arbitrary`: Adds implementations for the [`arbitrary::Arbitrary`] trait
to [`IndexMap`] and [`IndexSet`].
* `quickcheck`: Adds implementations for the [`quickcheck::Arbitrary`] trait
to [`IndexMap`] and [`IndexSet`].
_Note: only the `std` feature is enabled by default._
[feature flags]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-section
[`no_std`]: #no-standard-library-targets
[`Serialize`]: `::serde::Serialize`
[`Deserialize`]: `::serde::Deserialize`
[`BorshSerialize`]: `::borsh::BorshSerialize`
[`BorshDeserialize`]: `::borsh::BorshDeserialize`
[`arbitrary::Arbitrary`]: `::arbitrary::Arbitrary`
[`quickcheck::Arbitrary`]: `::quickcheck::Arbitrary`
### Alternate Hashers
[`IndexMap`] and [`IndexSet`] have a default hasher type
[`S = RandomState`][std::collections::hash_map::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.63 or later.
The indexmap 2.x release series will use a carefully considered version
upgrade policy, where in a later 2.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 chosen by disabling the default "std" cargo feature, by adding
`default-features = false` to your dependency specification.
- Creating maps and sets using [`new`][IndexMap::new] and
[`with_capacity`][IndexMap::with_capacity] is unavailable without `std`.
Use methods [`IndexMap::default`], [`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`. |
8773 |
| macros.rs |
|
5395 |
| 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. |
46720 |
| rayon |
|
|
| rustc.rs |
Minimal support for `rustc-rayon`, not intended for general use. |
3894 |
| serde.rs |
|
4453 |
| set |
|
|
| set.rs |
A hash set implemented using [`IndexMap`] |
37713 |
| util.rs |
|
1508 |