| arbitrary.rs |
|
2238 |
- |
| borsh.rs |
|
3860 |
- |
| inner |
|
|
88 % |
| inner.rs |
This is the core implementation that doesn't depend on the hasher at all.
The methods of `Core` don't use any Hash properties of K.
It's cleaner to separate them out, then the compiler checks that we are not
using Hash at all in these methods.
However, we should probably not let this show in the public API or docs. |
25052 |
84 % |
| 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.
* `arbitrary`: Adds implementations for the [`arbitrary::Arbitrary`] trait
to [`IndexMap`] and [`IndexSet`].
* `quickcheck`: Adds implementations for the [`quickcheck::Arbitrary`] trait
to [`IndexMap`] and [`IndexSet`].
* `borsh` (**deprecated**): Adds implementations for [`BorshSerialize`] and
[`BorshDeserialize`] to [`IndexMap`] and [`IndexSet`]. Due to a cyclic
dependency that arose between [`borsh`] and `indexmap`, `borsh v1.5.6`
added an `indexmap` feature that should be used instead of enabling the
feature here.
_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_core::Serialize`
[`Deserialize`]: `::serde_core::Deserialize`
[`BorshSerialize`]: `::borsh::BorshSerialize`
[`BorshDeserialize`]: `::borsh::BorshDeserialize`
[`borsh`]: `::borsh`
[`arbitrary::Arbitrary`]: `::arbitrary::Arbitrary`
[`quickcheck::Arbitrary`]: `::quickcheck::Arbitrary`
### Alternate Hashers
[`IndexMap`] and [`IndexSet`] have a default hasher type
[`S = RandomState`][std::hash::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 indexmap::{IndexMap, IndexSet};
type FnvIndexMap<K, V> = IndexMap<K, V, FnvBuildHasher>;
type FnvIndexSet<T> = IndexSet<T, FnvBuildHasher>;
let std: IndexSet<i32> = (0..100).collect();
let fnv: FnvIndexSet<i32> = (0..100).collect();
assert_eq!(std, fnv);
```
### Rust Version
This version of indexmap requires Rust 1.85 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`. Use
the macros [`indexmap_with_default!`] and [`indexset_with_default!`] instead. |
9430 |
58 % |
| macros.rs |
|
7619 |
100 % |
| map |
|
|
100 % |
| 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. |
64208 |
93 % |
| rayon |
|
|
- |
| serde.rs |
|
4441 |
0 % |
| set |
|
|
50 % |
| set.rs |
A hash set implemented using [`IndexMap`] |
49482 |
100 % |
| sval.rs |
|
965 |
- |
| util.rs |
|
2734 |
48 % |