summaryrefslogtreecommitdiffstats
path: root/third_party/rust/indexmap
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-06-12 05:43:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-06-12 05:43:14 +0000
commit8dd16259287f58f9273002717ec4d27e97127719 (patch)
tree3863e62a53829a84037444beab3abd4ed9dfc7d0 /third_party/rust/indexmap
parentReleasing progress-linux version 126.0.1-1~progress7.99u1. (diff)
downloadfirefox-8dd16259287f58f9273002717ec4d27e97127719.tar.xz
firefox-8dd16259287f58f9273002717ec4d27e97127719.zip
Merging upstream version 127.0.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/rust/indexmap')
-rw-r--r--third_party/rust/indexmap/.cargo-checksum.json2
-rw-r--r--third_party/rust/indexmap/Cargo.toml47
-rw-r--r--third_party/rust/indexmap/README.md10
-rw-r--r--third_party/rust/indexmap/RELEASES.md618
-rw-r--r--third_party/rust/indexmap/build.rs8
-rw-r--r--third_party/rust/indexmap/src/arbitrary.rs2
-rw-r--r--third_party/rust/indexmap/src/borsh.rs122
-rw-r--r--third_party/rust/indexmap/src/equivalent.rs27
-rw-r--r--third_party/rust/indexmap/src/lib.rs132
-rw-r--r--third_party/rust/indexmap/src/macros.rs36
-rw-r--r--third_party/rust/indexmap/src/map.rs1410
-rw-r--r--third_party/rust/indexmap/src/map/core.rs460
-rw-r--r--third_party/rust/indexmap/src/map/core/entry.rs481
-rw-r--r--third_party/rust/indexmap/src/map/core/raw.rs174
-rw-r--r--third_party/rust/indexmap/src/map/core/raw_entry_v1.rs652
-rw-r--r--third_party/rust/indexmap/src/map/iter.rs713
-rw-r--r--third_party/rust/indexmap/src/map/mutable.rs87
-rw-r--r--third_party/rust/indexmap/src/map/serde_seq.rs (renamed from third_party/rust/indexmap/src/serde_seq.rs)60
-rw-r--r--third_party/rust/indexmap/src/map/slice.rs539
-rw-r--r--third_party/rust/indexmap/src/map/tests.rs727
-rw-r--r--third_party/rust/indexmap/src/mutable_keys.rs75
-rw-r--r--third_party/rust/indexmap/src/rayon/map.rs184
-rw-r--r--third_party/rust/indexmap/src/rayon/mod.rs2
-rw-r--r--third_party/rust/indexmap/src/rayon/set.rs111
-rw-r--r--third_party/rust/indexmap/src/serde.rs43
-rw-r--r--third_party/rust/indexmap/src/set.rs1457
-rw-r--r--third_party/rust/indexmap/src/set/iter.rs626
-rw-r--r--third_party/rust/indexmap/src/set/mutable.rs86
-rw-r--r--third_party/rust/indexmap/src/set/slice.rs340
-rw-r--r--third_party/rust/indexmap/src/set/tests.rs723
-rw-r--r--third_party/rust/indexmap/src/util.rs22
-rw-r--r--third_party/rust/indexmap/tests/quick.rs198
32 files changed, 7175 insertions, 2999 deletions
diff --git a/third_party/rust/indexmap/.cargo-checksum.json b/third_party/rust/indexmap/.cargo-checksum.json
index 0f44683d7f..50a4338741 100644
--- a/third_party/rust/indexmap/.cargo-checksum.json
+++ b/third_party/rust/indexmap/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"1290d383adfdcd24f158a4619afb5547d633c83c0a1ab3b5c1ee0dabe4fb1f36","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"ecc269ef87fd38a1d98e30bfac9ba964a9dbd9315c3770fed98d4d7cb5882055","README.md":"f8b02aa7c20fc0f5bc13de9e9e78899ec8cdbc16c2db880a1d0bc14c25b07542","RELEASES.md":"85d9d9bc78e94df7ce90300bb94099b9ab2696d1b3f6b815c22761522878e679","benches/bench.rs":"3b2900abbc9e8a60af78b0395222ee75e86bc68519a0f38477387d1572eed397","benches/faststring.rs":"5fdd6cdb19d0557ed58f241e809a240cf8939d9e5b87a72d5f127f81ab98380b","build.rs":"558b4d0b9e9b3a44f7e1a2b69f7a7567ea721cd45cb54f4e458e850bf702f35c","src/arbitrary.rs":"bb8bda10f686abe57eef1446d3fc3fc6fb251f95629b28c20e620a4838c43db8","src/equivalent.rs":"2e6ae24ef09a09b917f4e2b0f6288f901878e42f5080f61b1bd1afdcc90aba87","src/lib.rs":"ea2cbe4f6cc2c4a75f42c9fc936503e6bee0f136c60f6811a2a9907ed8886443","src/macros.rs":"80c22f630e7f81e6fa663ca4c9e50cf5f332c8905d72d1338bd16f24eb353c2a","src/map.rs":"2e9cbfa240865cfd6b6b972bdbdb39283e6302dd2d0d72b3c2bfce4414bf5729","src/map/core.rs":"8422cd774c5db7d83cdeb0c5836c10f29caa1bee8d95b0d674b01b32e7ce80d8","src/map/core/raw.rs":"4e5fac4fecccc352268351d8b1f82b345067b5c029bba7e6ab88e8f8bc799c6a","src/mutable_keys.rs":"a919065b59000286eb11c7d46f6896bf0a1d484c9dac5e61d80bb8990c9fbedb","src/rayon/map.rs":"1a508c7c95c5d56113b851f7ce140d62ad541f1c6129352a7ec62d5bea7af4a1","src/rayon/mod.rs":"019e9379ccab57a299ab5b5a2c0efc7561b77a715a5afe8f797c7e8330c6206c","src/rayon/set.rs":"ba00e88e90fb7ab803589f99f24b595d60309e541aae3d01fdde21bff3840194","src/rustc.rs":"fe7a348c5a10a66880cb6c737593fe79d3b6de40f44ba0d7b89204aa95e14a3a","src/serde.rs":"d45ec8fb9c02594ca6f2e9b20764778b2b4193a24a52f1e233160a33efc6e683","src/serde_seq.rs":"c54a52fa607b6ccddda1e76e829778ca304c49b5f434edc5e582a5386c35d662","src/set.rs":"0a57affb623fa6b28df18cc14841e4f076cbd1da5c809635d202f865640af1ee","src/util.rs":"ab712bce71b54cf2763e6010e64bb5944d1d59ce15e2f2beffa7ceed204d6a68","tests/equivalent_trait.rs":"efe9393069e3cfc893d2c9c0343679979578e437fdb98a10baefeced027ba310","tests/macros_full_path.rs":"c33c86d7341581fdd08e2e6375a4afca507fa603540c54a3b9e51c4cd011cd71","tests/quick.rs":"1addbc6cbcb1aae5b8bde0fb0e18197d947e8f13244e4ae7ebf97bdda00eafea","tests/tests.rs":"f6dbeeb0e2950402b0e66ac52bf74c9e4197d3c5d9c0dde64a7998a2ef74d327"},"package":"bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"} \ No newline at end of file
+{"files":{"Cargo.toml":"34db4bcb2f85a5e3980eb06d3ec4aac3fa0ef6ff48b57ef28aba6dfc1fbeedbb","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"ecc269ef87fd38a1d98e30bfac9ba964a9dbd9315c3770fed98d4d7cb5882055","README.md":"98781168dcaf64ed3eecbf7146311045433773486259a372b985c9ae28545017","RELEASES.md":"0f8b4d3a352bddda55384f2ffa804b39e7d73aefa27364c56378d0043756e491","benches/bench.rs":"3b2900abbc9e8a60af78b0395222ee75e86bc68519a0f38477387d1572eed397","benches/faststring.rs":"5fdd6cdb19d0557ed58f241e809a240cf8939d9e5b87a72d5f127f81ab98380b","src/arbitrary.rs":"068713b1e8e762dbe9e4d19d555e77c17e59408335a40f4777d6100340605655","src/borsh.rs":"74121b426379d4f7365757ffd4f3dd469543fa1635193460fe268799a78a0706","src/lib.rs":"57ca834c31a7bb70821f476de916486ab58b9ad3922761153972b5f3923fe078","src/macros.rs":"1493afee2db2c9744be99e5fc32d0cd3742b8a3dbb31fa786ebbe28f1387e7d6","src/map.rs":"d1422353531e6114778033e901b30c8138da048075582fb396d299211958044c","src/map/core.rs":"eb291748598e1aa9112ee068a9a5fea7b1190114c4007de179528408f7439faa","src/map/core/entry.rs":"7d987cc5099099e0c9020afa7b3c23d20f11812dce9d684db03ff390f4068691","src/map/core/raw.rs":"30cc048f7c7f0deb2eb1c699a15e6b18dff1187404228c55e404c0d5bfe11f3e","src/map/core/raw_entry_v1.rs":"0942938c167aca6c892bd78e431d2b7366443e1d6f4f0d930b0bf72ca3ab8054","src/map/iter.rs":"ae0023c1ccc78ac765dc43fe51f233f2fca1ebba132490db8429941183d2c497","src/map/mutable.rs":"9d8dded5a95a21fba2d97ef64610627fae97dffc096e872b0c378ae8b63de53b","src/map/serde_seq.rs":"ce06b5bb816c15ea8fe3d2c358baa90fe6f45ecb585623a69592d6de69319194","src/map/slice.rs":"c0d770a6ce47fa4f3d9c82b468504c567dc4031d8f3694603e2b5bcc295cf3e1","src/map/tests.rs":"714674a55103dc57c16d9fe2916d462a655dc217e079a7e0ed5a62ab0f9749f1","src/rayon/map.rs":"0fad36851fdf6894695e526c684c9b3afeac82e29016e6a523eea68cc3b2d19d","src/rayon/mod.rs":"1c9c13b5cf6974f652ded53b014774944c761f079a77a61b3bc52eaa3d4b972b","src/rayon/set.rs":"4b076dbfd9a7eb2fd65783f1c8a5acabe075403f3d05e30c337676acec25d8ee","src/rustc.rs":"fe7a348c5a10a66880cb6c737593fe79d3b6de40f44ba0d7b89204aa95e14a3a","src/serde.rs":"23fd6b5e8f6795e4121693ac16dab61e76c4d8c83e6da1b3ef26d081fae28e79","src/set.rs":"fe9ca3fea8c1156a13ffccdf49d8acb9c79433586c1dfc71ef21ecfcebfd8b14","src/set/iter.rs":"a387c48eff0338b5c8f4e2059403bd665a9c8037634cc5860f80b72a4fbbed30","src/set/mutable.rs":"83ac1719a5eb5bdefac0e9eaa87b80ed98e39c5f2bb4cb69143e3fbff4302e6d","src/set/slice.rs":"9b5aa57e3510d5e17a91a6eaa2ee66a3d79d40b171beb86f7dd9208277135900","src/set/tests.rs":"d9c182cd776ca9182b5284f06eacc70c5f33a66aff3021c35134ffd1d7630c05","src/util.rs":"dbd57cfdac2a72db8c5ce83bf288bcaf33b5ae59adddcd088792a624c4c0e909","tests/equivalent_trait.rs":"efe9393069e3cfc893d2c9c0343679979578e437fdb98a10baefeced027ba310","tests/macros_full_path.rs":"c33c86d7341581fdd08e2e6375a4afca507fa603540c54a3b9e51c4cd011cd71","tests/quick.rs":"9759dcc34d86d9635d9d18be6358f5f3e3c0f995874b64b5a7ca4b582f4acedb","tests/tests.rs":"f6dbeeb0e2950402b0e66ac52bf74c9e4197d3c5d9c0dde64a7998a2ef74d327"},"package":"168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"} \ No newline at end of file
diff --git a/third_party/rust/indexmap/Cargo.toml b/third_party/rust/indexmap/Cargo.toml
index 28f3618f01..51d6e6e97c 100644
--- a/third_party/rust/indexmap/Cargo.toml
+++ b/third_party/rust/indexmap/Cargo.toml
@@ -11,9 +11,9 @@
[package]
edition = "2021"
-rust-version = "1.56"
+rust-version = "1.63"
name = "indexmap"
-version = "1.9.3"
+version = "2.2.6"
description = "A hash table with consistent order and fast iteration."
documentation = "https://docs.rs/indexmap/"
readme = "README.md"
@@ -26,22 +26,27 @@ categories = [
"no-std",
]
license = "Apache-2.0 OR MIT"
-repository = "https://github.com/bluss/indexmap"
-
-[package.metadata.release]
-no-dev-version = true
-tag-name = "{{version}}"
+repository = "https://github.com/indexmap-rs/indexmap"
[package.metadata.docs.rs]
features = [
"arbitrary",
"quickcheck",
- "serde-1",
+ "serde",
+ "borsh",
"rayon",
]
+rustdoc-args = [
+ "--cfg",
+ "docsrs",
+]
+
+[package.metadata.release]
+no-dev-version = true
+tag-name = "{{version}}"
[profile.bench]
-debug = true
+debug = 2
[lib]
bench = false
@@ -51,8 +56,17 @@ version = "1.0"
optional = true
default-features = false
+[dependencies.borsh]
+version = "1.2"
+optional = true
+default-features = false
+
+[dependencies.equivalent]
+version = "1.0"
+default-features = false
+
[dependencies.hashbrown]
-version = "0.12"
+version = "0.14.1"
features = ["raw"]
default-features = false
@@ -62,7 +76,7 @@ optional = true
default-features = false
[dependencies.rayon]
-version = "1.4.1"
+version = "1.5.3"
optional = true
[dependencies.rustc-rayon]
@@ -82,7 +96,7 @@ version = "1.0"
version = "0.2.1"
[dev-dependencies.itertools]
-version = "0.10"
+version = "0.12"
[dev-dependencies.lazy_static]
version = "1.3"
@@ -98,11 +112,10 @@ features = ["small_rng"]
[dev-dependencies.serde_derive]
version = "1.0"
-[build-dependencies.autocfg]
-version = "1"
-
[features]
-serde-1 = ["serde"]
+default = ["std"]
std = []
test_debug = []
-test_low_transition_point = []
+
+[lints.clippy]
+style = "allow"
diff --git a/third_party/rust/indexmap/README.md b/third_party/rust/indexmap/README.md
index d80b7099ce..9112d52893 100644
--- a/third_party/rust/indexmap/README.md
+++ b/third_party/rust/indexmap/README.md
@@ -1,9 +1,9 @@
# indexmap
-[![build status](https://github.com/bluss/indexmap/workflows/Continuous%20integration/badge.svg?branch=master)](https://github.com/bluss/indexmap/actions)
+[![build status](https://github.com/indexmap-rs/indexmap/workflows/Continuous%20integration/badge.svg?branch=master)](https://github.com/indexmap-rs/indexmap/actions)
[![crates.io](https://img.shields.io/crates/v/indexmap.svg)](https://crates.io/crates/indexmap)
[![docs](https://docs.rs/indexmap/badge.svg)](https://docs.rs/indexmap)
-[![rustc](https://img.shields.io/badge/rust-1.56%2B-orange.svg)](https://img.shields.io/badge/rust-1.56%2B-orange.svg)
+[![rustc](https://img.shields.io/badge/rust-1.63%2B-orange.svg)](https://img.shields.io/badge/rust-1.63%2B-orange.svg)
A pure-Rust hash table which preserves (in a limited sense) insertion order.
@@ -26,7 +26,9 @@ was indexmap, a hash table that has following properties:
- Order is **independent of hash function** and hash values of keys.
- Fast to iterate.
- Indexed in compact space.
-- Preserves insertion order **as long** as you don't call `.remove()`.
+- Preserves insertion order **as long** as you don't call `.remove()`,
+ `.swap_remove()`, or other methods that explicitly change order.
+ The alternate `.shift_remove()` does preserve relative order.
- Uses hashbrown for the inner table, just like Rust's libstd `HashMap` does.
## Performance
@@ -52,4 +54,4 @@ which is roughly:
# Recent Changes
-See [RELEASES.md](https://github.com/bluss/indexmap/blob/master/RELEASES.md).
+See [RELEASES.md](https://github.com/indexmap-rs/indexmap/blob/master/RELEASES.md).
diff --git a/third_party/rust/indexmap/RELEASES.md b/third_party/rust/indexmap/RELEASES.md
index 7ea8b702e0..8c033db042 100644
--- a/third_party/rust/indexmap/RELEASES.md
+++ b/third_party/rust/indexmap/RELEASES.md
@@ -1,388 +1,508 @@
-- 1.9.3
+# Releases
- - Bump the `rustc-rayon` dependency, for compiler use only.
+## 2.2.6
-- 1.9.2
+- Added trait `MutableValues` for opt-in mutable access to set values.
- - `IndexMap` and `IndexSet` both implement `arbitrary::Arbitrary<'_>` and
- `quickcheck::Arbitrary` if those optional dependency features are enabled.
+## 2.2.5
-- 1.9.1
+- Added optional `borsh` serialization support.
- - The MSRV now allows Rust 1.56.0 as well. However, currently `hashbrown`
- 0.12.1 requires 1.56.1, so users on 1.56.0 should downgrade that to 0.12.0
- until there is a later published version relaxing its requirement.
+## 2.2.4
-- 1.9.0
+- Added an `insert_sorted` method on `IndexMap`, `IndexSet`, and `VacantEntry`.
+- Avoid hashing for lookups in single-entry maps.
+- Limit preallocated memory in `serde` deserializers.
- - **MSRV**: Rust 1.56.1 or later is now required.
+## 2.2.3
- - The `hashbrown` dependency has been updated to version 0.12.
+- Added `move_index` and `swap_indices` methods to `IndexedEntry`,
+ `OccupiedEntry`, and `RawOccupiedEntryMut`, functioning like the existing
+ methods on `IndexMap`.
+- Added `shift_insert` methods on `VacantEntry` and `RawVacantEntryMut`, as
+ well as `shift_insert_hashed_nocheck` on the latter, to insert the new entry
+ at a particular index.
+- Added `shift_insert` methods on `IndexMap` and `IndexSet` to insert a new
+ entry at a particular index, or else move an existing entry there.
- - `IterMut` and `ValuesMut` now implement `Debug`.
+## 2.2.2
- - The new `IndexMap::shrink_to` and `IndexSet::shrink_to` methods shrink
- the capacity with a lower bound.
+- Added indexing methods to raw entries: `RawEntryBuilder::from_hash_full`,
+ `RawEntryBuilder::index_from_hash`, and `RawEntryMut::index`.
- - The new `IndexMap::move_index` and `IndexSet::move_index` methods change
- the position of an item from one index to another, shifting the items
- between to accommodate the move.
+## 2.2.1
-- 1.8.2
+- Corrected the signature of `RawOccupiedEntryMut::into_key(self) -> &'a mut K`,
+ This a breaking change from 2.2.0, but that version was published for less
+ than a day and has now been yanked.
- - Bump the `rustc-rayon` dependency, for compiler use only.
+## 2.2.0
-- 1.8.1
+- The new `IndexMap::get_index_entry` method finds an entry by its index for
+ in-place manipulation.
- - The new `IndexSet::replace_full` will return the index of the item along
- with the replaced value, if any, by @zakcutner in PR [222].
+- The `Keys` iterator now implements `Index<usize>` for quick access to the
+ entry's key, compared to indexing the map to get the value.
-[222]: https://github.com/bluss/indexmap/pull/222
+- The new `IndexMap::splice` and `IndexSet::splice` methods will drain the
+ given range as an iterator, and then replace that range with entries from
+ an input iterator.
-- 1.8.0
+- The new trait `RawEntryApiV1` offers opt-in access to a raw entry API for
+ `IndexMap`, corresponding to the unstable API on `HashSet` as of Rust 1.75.
- - The new `IndexMap::into_keys` and `IndexMap::into_values` will consume
- the map into keys or values, respectively, matching Rust 1.54's `HashMap`
- methods, by @taiki-e in PR [195].
+- Many `IndexMap` and `IndexSet` methods have relaxed their type constraints,
+ e.g. removing `K: Hash` on methods that don't actually need to hash.
- - More of the iterator types implement `Debug`, `ExactSizeIterator`, and
- `FusedIterator`, by @cuviper in PR [196].
+- Removal methods `remove`, `remove_entry`, and `take` are now deprecated
+ in favor of their `shift_` or `swap_` prefixed variants, which are more
+ explicit about their effect on the index and order of remaining items.
+ The deprecated methods will remain to guide drop-in replacements from
+ `HashMap` and `HashSet` toward the prefixed methods.
- - `IndexMap` and `IndexSet` now implement rayon's `ParallelDrainRange`,
- by @cuviper in PR [197].
+## 2.1.0
- - `IndexMap::with_hasher` and `IndexSet::with_hasher` are now `const`
- functions, allowing static maps and sets, by @mwillsey in PR [203].
+- Empty slices can now be created with `map::Slice::{new, new_mut}` and
+ `set::Slice::new`. In addition, `Slice::new`, `len`, and `is_empty` are
+ now `const` functions on both types.
- - `IndexMap` and `IndexSet` now implement `From` for arrays, matching
- Rust 1.56's implementation for `HashMap`, by @rouge8 in PR [205].
+- `IndexMap`, `IndexSet`, and their respective `Slice`s all have binary
+ search methods for sorted data: map `binary_search_keys` and set
+ `binary_search` for plain comparison, `binary_search_by` for custom
+ comparators, `binary_search_by_key` for key extraction, and
+ `partition_point` for boolean conditions.
- - `IndexMap` and `IndexSet` now have methods `sort_unstable_keys`,
- `sort_unstable_by`, `sorted_unstable_by`, and `par_*` equivalents,
- which sort in-place without preserving the order of equal items, by
- @bhgomes in PR [211].
+## 2.0.2
-[195]: https://github.com/bluss/indexmap/pull/195
-[196]: https://github.com/bluss/indexmap/pull/196
-[197]: https://github.com/bluss/indexmap/pull/197
-[203]: https://github.com/bluss/indexmap/pull/203
-[205]: https://github.com/bluss/indexmap/pull/205
-[211]: https://github.com/bluss/indexmap/pull/211
+- The `hashbrown` dependency has been updated to version 0.14.1 to
+ complete the support for Rust 1.63.
-- 1.7.0
+## 2.0.1
- - **MSRV**: Rust 1.49 or later is now required.
+- **MSRV**: Rust 1.63.0 is now supported as well, pending publication of
+ `hashbrown`'s relaxed MSRV (or use cargo `--ignore-rust-version`).
- - The `hashbrown` dependency has been updated to version 0.11.
+## 2.0.0
-- 1.6.2
+- **MSRV**: Rust 1.64.0 or later is now required.
- - Fixed to match `std` behavior, `OccupiedEntry::key` now references the
- existing key in the map instead of the lookup key, by @cuviper in PR [170].
+- The `"std"` feature is no longer auto-detected. It is included in the
+ default feature set, or else can be enabled like any other Cargo feature.
- - The new `Entry::or_insert_with_key` matches Rust 1.50's `Entry` method,
- passing `&K` to the callback to create a value, by @cuviper in PR [175].
+- The `"serde-1"` feature has been removed, leaving just the optional
+ `"serde"` dependency to be enabled like a feature itself.
-[170]: https://github.com/bluss/indexmap/pull/170
-[175]: https://github.com/bluss/indexmap/pull/175
+- `IndexMap::get_index_mut` now returns `Option<(&K, &mut V)>`, changing
+ the key part from `&mut K` to `&K`. There is also a new alternative
+ `MutableKeys::get_index_mut2` to access the former behavior.
-- 1.6.1
+- The new `map::Slice<K, V>` and `set::Slice<T>` offer a linear view of maps
+ and sets, behaving a lot like normal `[(K, V)]` and `[T]` slices. Notably,
+ comparison traits like `Eq` only consider items in order, rather than hash
+ lookups, and slices even implement `Hash`.
- - The new `serde_seq` module implements `IndexMap` serialization as a
- sequence to ensure order is preserved, by @cuviper in PR [158].
+- `IndexMap` and `IndexSet` now have `sort_by_cached_key` and
+ `par_sort_by_cached_key` methods which perform stable sorts in place
+ using a key extraction function.
- - New methods on maps and sets work like the `Vec`/slice methods by the same name:
- `truncate`, `split_off`, `first`, `first_mut`, `last`, `last_mut`, and
- `swap_indices`, by @cuviper in PR [160].
+- `IndexMap` and `IndexSet` now have `reserve_exact`, `try_reserve`, and
+ `try_reserve_exact` methods that correspond to the same methods on `Vec`.
+ However, exactness only applies to the direct capacity for items, while the
+ raw hash table still follows its own rules for capacity and load factor.
-[158]: https://github.com/bluss/indexmap/pull/158
-[160]: https://github.com/bluss/indexmap/pull/160
+- The `Equivalent` trait is now re-exported from the `equivalent` crate,
+ intended as a common base to allow types to work with multiple map types.
-- 1.6.0
+- The `hashbrown` dependency has been updated to version 0.14.
- - **MSRV**: Rust 1.36 or later is now required.
+- The `serde_seq` module has been moved from the crate root to below the
+ `map` module.
- - The `hashbrown` dependency has been updated to version 0.9.
+## 1.9.3
-- 1.5.2
+- Bump the `rustc-rayon` dependency, for compiler use only.
- - The new "std" feature will force the use of `std` for users that explicitly
- want the default `S = RandomState`, bypassing the autodetection added in 1.3.0,
- by @cuviper in PR [145].
+## 1.9.2
-[145]: https://github.com/bluss/indexmap/pull/145
+- `IndexMap` and `IndexSet` both implement `arbitrary::Arbitrary<'_>` and
+ `quickcheck::Arbitrary` if those optional dependency features are enabled.
-- 1.5.1
+## 1.9.1
- - Values can now be indexed by their `usize` position by @cuviper in PR [132].
+- The MSRV now allows Rust 1.56.0 as well. However, currently `hashbrown`
+ 0.12.1 requires 1.56.1, so users on 1.56.0 should downgrade that to 0.12.0
+ until there is a later published version relaxing its requirement.
- - Some of the generic bounds have been relaxed to match `std` by @cuviper in PR [141].
+## 1.9.0
- - `drain` now accepts any `R: RangeBounds<usize>` by @cuviper in PR [142].
+- **MSRV**: Rust 1.56.1 or later is now required.
-[132]: https://github.com/bluss/indexmap/pull/132
-[141]: https://github.com/bluss/indexmap/pull/141
-[142]: https://github.com/bluss/indexmap/pull/142
+- The `hashbrown` dependency has been updated to version 0.12.
-- 1.5.0
+- `IterMut` and `ValuesMut` now implement `Debug`.
- - **MSRV**: Rust 1.32 or later is now required.
+- The new `IndexMap::shrink_to` and `IndexSet::shrink_to` methods shrink
+ the capacity with a lower bound.
- - The inner hash table is now based on `hashbrown` by @cuviper in PR [131].
- This also completes the method `reserve` and adds `shrink_to_fit`.
+- The new `IndexMap::move_index` and `IndexSet::move_index` methods change
+ the position of an item from one index to another, shifting the items
+ between to accommodate the move.
- - Add new methods `get_key_value`, `remove_entry`, `swap_remove_entry`,
- and `shift_remove_entry`, by @cuviper in PR [136]
+## 1.8.2
- - `Clone::clone_from` reuses allocations by @cuviper in PR [125]
+- Bump the `rustc-rayon` dependency, for compiler use only.
- - Add new method `reverse` by @linclelinkpart5 in PR [128]
+## 1.8.1
-[125]: https://github.com/bluss/indexmap/pull/125
-[128]: https://github.com/bluss/indexmap/pull/128
-[131]: https://github.com/bluss/indexmap/pull/131
-[136]: https://github.com/bluss/indexmap/pull/136
+- The new `IndexSet::replace_full` will return the index of the item along
+ with the replaced value, if any, by @zakcutner in PR [222].
-- 1.4.0
+[222]: https://github.com/indexmap-rs/indexmap/pull/222
- - Add new method `get_index_of` by @Thermatrix in PR [115] and [120]
+## 1.8.0
- - Fix build script rebuild-if-changed configuration to use "build.rs";
- fixes issue [123]. Fix by @cuviper.
+- The new `IndexMap::into_keys` and `IndexMap::into_values` will consume
+ the map into keys or values, respectively, matching Rust 1.54's `HashMap`
+ methods, by @taiki-e in PR [195].
- - Dev-dependencies (rand and quickcheck) have been updated. The crate's tests
- now run using Rust 1.32 or later (MSRV for building the crate has not changed).
- by @kjeremy and @bluss
+- More of the iterator types implement `Debug`, `ExactSizeIterator`, and
+ `FusedIterator`, by @cuviper in PR [196].
-[123]: https://github.com/bluss/indexmap/issues/123
-[115]: https://github.com/bluss/indexmap/pull/115
-[120]: https://github.com/bluss/indexmap/pull/120
+- `IndexMap` and `IndexSet` now implement rayon's `ParallelDrainRange`,
+ by @cuviper in PR [197].
-- 1.3.2
+- `IndexMap::with_hasher` and `IndexSet::with_hasher` are now `const`
+ functions, allowing static maps and sets, by @mwillsey in PR [203].
- - Maintenance update to regenerate the published `Cargo.toml`.
+- `IndexMap` and `IndexSet` now implement `From` for arrays, matching
+ Rust 1.56's implementation for `HashMap`, by @rouge8 in PR [205].
-- 1.3.1
+- `IndexMap` and `IndexSet` now have methods `sort_unstable_keys`,
+ `sort_unstable_by`, `sorted_unstable_by`, and `par_*` equivalents,
+ which sort in-place without preserving the order of equal items, by
+ @bhgomes in PR [211].
- - Maintenance update for formatting and `autocfg` 1.0.
+[195]: https://github.com/indexmap-rs/indexmap/pull/195
+[196]: https://github.com/indexmap-rs/indexmap/pull/196
+[197]: https://github.com/indexmap-rs/indexmap/pull/197
+[203]: https://github.com/indexmap-rs/indexmap/pull/203
+[205]: https://github.com/indexmap-rs/indexmap/pull/205
+[211]: https://github.com/indexmap-rs/indexmap/pull/211
-- 1.3.0
+## 1.7.0
- - The deprecation messages in the previous version have been removed.
- (The methods have not otherwise changed.) Docs for removal methods have been
- improved.
- - From Rust 1.36, 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. The new build-dep `autocfg` enables this.
+- **MSRV**: Rust 1.49 or later is now required.
-- 1.2.0
+- The `hashbrown` dependency has been updated to version 0.11.
- - Plain `.remove()` now has a deprecation message, it informs the user
- about picking one of the removal functions `swap_remove` and `shift_remove`
- which have different performance and order semantics.
- Plain `.remove()` will not be removed, the warning message and method
- will remain until further.
+## 1.6.2
- - Add new method `shift_remove` for order preserving removal on the map,
- and `shift_take` for the corresponding operation on the set.
+- Fixed to match `std` behavior, `OccupiedEntry::key` now references the
+ existing key in the map instead of the lookup key, by @cuviper in PR [170].
- - Add methods `swap_remove`, `swap_remove_entry` to `Entry`.
+- The new `Entry::or_insert_with_key` matches Rust 1.50's `Entry` method,
+ passing `&K` to the callback to create a value, by @cuviper in PR [175].
- - Fix indexset/indexmap to support full paths, like `indexmap::indexmap!()`
+[170]: https://github.com/indexmap-rs/indexmap/pull/170
+[175]: https://github.com/indexmap-rs/indexmap/pull/175
- - Internal improvements: fix warnings, deprecations and style lints
+## 1.6.1
-- 1.1.0
+- The new `serde_seq` module implements `IndexMap` serialization as a
+ sequence to ensure order is preserved, by @cuviper in PR [158].
- - Added optional feature `"rayon"` that adds parallel iterator support
- to `IndexMap` and `IndexSet` using Rayon. This includes all the regular
- iterators in parallel versions, and parallel sort.
+- New methods on maps and sets work like the `Vec`/slice methods by the same name:
+ `truncate`, `split_off`, `first`, `first_mut`, `last`, `last_mut`, and
+ `swap_indices`, by @cuviper in PR [160].
- - Implemented `Clone` for `map::{Iter, Keys, Values}` and
- `set::{Difference, Intersection, Iter, SymmetricDifference, Union}`
+[158]: https://github.com/indexmap-rs/indexmap/pull/158
+[160]: https://github.com/indexmap-rs/indexmap/pull/160
- - Implemented `Debug` for `map::{Entry, IntoIter, Iter, Keys, Values}` and
- `set::{Difference, Intersection, IntoIter, Iter, SymmetricDifference, Union}`
+## 1.6.0
- - Serde trait `IntoDeserializer` are implemented for `IndexMap` and `IndexSet`.
+- **MSRV**: Rust 1.36 or later is now required.
- - Minimum Rust version requirement increased to Rust 1.30 for development builds.
+- The `hashbrown` dependency has been updated to version 0.9.
-- 1.0.2
+## 1.5.2
- - The new methods `IndexMap::insert_full` and `IndexSet::insert_full` are
- both like `insert` with the index included in the return value.
+- The new "std" feature will force the use of `std` for users that explicitly
+ want the default `S = RandomState`, bypassing the autodetection added in 1.3.0,
+ by @cuviper in PR [145].
- - The new method `Entry::and_modify` can be used to modify occupied
- entries, matching the new methods of `std` maps in Rust 1.26.
+[145]: https://github.com/indexmap-rs/indexmap/pull/145
- - The new method `Entry::or_default` inserts a default value in unoccupied
- entries, matching the new methods of `std` maps in Rust 1.28.
+## 1.5.1
-- 1.0.1
+- Values can now be indexed by their `usize` position by @cuviper in PR [132].
- - Document Rust version policy for the crate (see rustdoc)
+- Some of the generic bounds have been relaxed to match `std` by @cuviper in PR [141].
-- 1.0.0
+- `drain` now accepts any `R: RangeBounds<usize>` by @cuviper in PR [142].
- - This is the 1.0 release for `indexmap`! (the crate and datastructure
- formerly known as “ordermap”)
- - `OccupiedEntry::insert` changed its signature, to use `&mut self` for
- the method receiver, matching the equivalent method for a standard
- `HashMap`. Thanks to @dtolnay for finding this bug.
- - The deprecated old names from ordermap were removed: `OrderMap`,
- `OrderSet`, `ordermap!{}`, `orderset!{}`. Use the new `IndexMap`
- etc names instead.
+[132]: https://github.com/indexmap-rs/indexmap/pull/132
+[141]: https://github.com/indexmap-rs/indexmap/pull/141
+[142]: https://github.com/indexmap-rs/indexmap/pull/142
-- 0.4.1
+## 1.5.0
- - Renamed crate to `indexmap`; the `ordermap` crate is now deprecated
- and the types `OrderMap/Set` now have a deprecation notice.
+- **MSRV**: Rust 1.32 or later is now required.
-- 0.4.0
+- The inner hash table is now based on `hashbrown` by @cuviper in PR [131].
+ This also completes the method `reserve` and adds `shrink_to_fit`.
- - This is the last release series for this `ordermap` under that name,
- because the crate is **going to be renamed** to `indexmap` (with types
- `IndexMap`, `IndexSet`) and no change in functionality!
- - The map and its associated structs moved into the `map` submodule of the
- crate, so that the map and set are symmetric
+- Add new methods `get_key_value`, `remove_entry`, `swap_remove_entry`,
+ and `shift_remove_entry`, by @cuviper in PR [136]
+
+- `Clone::clone_from` reuses allocations by @cuviper in PR [125]
+
+- Add new method `reverse` by @linclelinkpart5 in PR [128]
+
+[125]: https://github.com/indexmap-rs/indexmap/pull/125
+[128]: https://github.com/indexmap-rs/indexmap/pull/128
+[131]: https://github.com/indexmap-rs/indexmap/pull/131
+[136]: https://github.com/indexmap-rs/indexmap/pull/136
+
+## 1.4.0
+
+- Add new method `get_index_of` by @Thermatrix in PR [115] and [120]
+
+- Fix build script rebuild-if-changed configuration to use "build.rs";
+ fixes issue [123]. Fix by @cuviper.
+
+- Dev-dependencies (rand and quickcheck) have been updated. The crate's tests
+ now run using Rust 1.32 or later (MSRV for building the crate has not changed).
+ by @kjeremy and @bluss
+
+[123]: https://github.com/indexmap-rs/indexmap/issues/123
+[115]: https://github.com/indexmap-rs/indexmap/pull/115
+[120]: https://github.com/indexmap-rs/indexmap/pull/120
+
+## 1.3.2
+
+- Maintenance update to regenerate the published `Cargo.toml`.
+
+## 1.3.1
+
+- Maintenance update for formatting and `autocfg` 1.0.
+
+## 1.3.0
+
+- The deprecation messages in the previous version have been removed.
+ (The methods have not otherwise changed.) Docs for removal methods have been
+ improved.
+- From Rust 1.36, 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. The new build-dep `autocfg` enables this.
+
+## 1.2.0
+
+- Plain `.remove()` now has a deprecation message, it informs the user
+ about picking one of the removal functions `swap_remove` and `shift_remove`
+ which have different performance and order semantics.
+ Plain `.remove()` will not be removed, the warning message and method
+ will remain until further.
+
+- Add new method `shift_remove` for order preserving removal on the map,
+ and `shift_take` for the corresponding operation on the set.
+
+- Add methods `swap_remove`, `swap_remove_entry` to `Entry`.
+
+- Fix indexset/indexmap to support full paths, like `indexmap::indexmap!()`
+
+- Internal improvements: fix warnings, deprecations and style lints
+
+## 1.1.0
+
+- Added optional feature `"rayon"` that adds parallel iterator support
+ to `IndexMap` and `IndexSet` using Rayon. This includes all the regular
+ iterators in parallel versions, and parallel sort.
+
+- Implemented `Clone` for `map::{Iter, Keys, Values}` and
+ `set::{Difference, Intersection, Iter, SymmetricDifference, Union}`
+
+- Implemented `Debug` for `map::{Entry, IntoIter, Iter, Keys, Values}` and
+ `set::{Difference, Intersection, IntoIter, Iter, SymmetricDifference, Union}`
+
+- Serde trait `IntoDeserializer` are implemented for `IndexMap` and `IndexSet`.
+
+- Minimum Rust version requirement increased to Rust 1.30 for development builds.
+
+## 1.0.2
+
+- The new methods `IndexMap::insert_full` and `IndexSet::insert_full` are
+ both like `insert` with the index included in the return value.
+
+- The new method `Entry::and_modify` can be used to modify occupied
+ entries, matching the new methods of `std` maps in Rust 1.26.
+
+- The new method `Entry::or_default` inserts a default value in unoccupied
+ entries, matching the new methods of `std` maps in Rust 1.28.
+
+## 1.0.1
+
+- Document Rust version policy for the crate (see rustdoc)
+
+## 1.0.0
+
+- This is the 1.0 release for `indexmap`! (the crate and datastructure
+ formerly known as “ordermap”)
+- `OccupiedEntry::insert` changed its signature, to use `&mut self` for
+ the method receiver, matching the equivalent method for a standard
+ `HashMap`. Thanks to @dtolnay for finding this bug.
+- The deprecated old names from ordermap were removed: `OrderMap`,
+ `OrderSet`, `ordermap!{}`, `orderset!{}`. Use the new `IndexMap`
+ etc names instead.
+
+## 0.4.1
+
+- Renamed crate to `indexmap`; the `ordermap` crate is now deprecated
+ and the types `OrderMap/Set` now have a deprecation notice.
+
+## 0.4.0
+
+- This is the last release series for this `ordermap` under that name,
+ because the crate is **going to be renamed** to `indexmap` (with types
+ `IndexMap`, `IndexSet`) and no change in functionality!
+- The map and its associated structs moved into the `map` submodule of the
+ crate, so that the map and set are symmetric
+ The iterators, `Entry` and other structs are now under `ordermap::map::`
- - Internally refactored `OrderMap<K, V, S>` so that all the main algorithms
- (insertion, lookup, removal etc) that don't use the `S` parameter (the
- hasher) are compiled without depending on `S`, which reduces generics bloat.
+- Internally refactored `OrderMap<K, V, S>` so that all the main algorithms
+ (insertion, lookup, removal etc) that don't use the `S` parameter (the
+ hasher) are compiled without depending on `S`, which reduces generics bloat.
- - `Entry<K, V>` no longer has a type parameter `S`, which is just like
- the standard `HashMap`'s entry.
+- `Entry<K, V>` no longer has a type parameter `S`, which is just like
+ the standard `HashMap`'s entry.
- - Minimum Rust version requirement increased to Rust 1.18
+- Minimum Rust version requirement increased to Rust 1.18
-- 0.3.5
+## 0.3.5
- - Documentation improvements
+- Documentation improvements
-- 0.3.4
+## 0.3.4
- - The `.retain()` methods for `OrderMap` and `OrderSet` now
- traverse the elements in order, and the retained elements **keep their order**
- - Added new methods `.sort_by()`, `.sort_keys()` to `OrderMap` and
- `.sort_by()`, `.sort()` to `OrderSet`. These methods allow you to
- sort the maps in place efficiently.
+- The `.retain()` methods for `OrderMap` and `OrderSet` now
+ traverse the elements in order, and the retained elements **keep their order**
+- Added new methods `.sort_by()`, `.sort_keys()` to `OrderMap` and
+ `.sort_by()`, `.sort()` to `OrderSet`. These methods allow you to
+ sort the maps in place efficiently.
-- 0.3.3
+## 0.3.3
- - Document insertion behaviour better by @lucab
- - Updated dependences (no feature changes) by @ignatenkobrain
+- Document insertion behaviour better by @lucab
+- Updated dependences (no feature changes) by @ignatenkobrain
-- 0.3.2
+## 0.3.2
- - Add `OrderSet` by @cuviper!
- - `OrderMap::drain` is now (too) a double ended iterator.
+- Add `OrderSet` by @cuviper!
+- `OrderMap::drain` is now (too) a double ended iterator.
-- 0.3.1
+## 0.3.1
- - In all ordermap iterators, forward the `collect` method to the underlying
- iterator as well.
- - Add crates.io categories.
+- In all ordermap iterators, forward the `collect` method to the underlying
+ iterator as well.
+- Add crates.io categories.
-- 0.3.0
+## 0.3.0
- - The methods `get_pair`, `get_pair_index` were both replaced by
- `get_full` (and the same for the mutable case).
- - Method `swap_remove_pair` replaced by `swap_remove_full`.
- - Add trait `MutableKeys` for opt-in mutable key access. Mutable key access
- is only possible through the methods of this extension trait.
- - Add new trait `Equivalent` for key equivalence. This extends the
- `Borrow` trait mechanism for `OrderMap::get` in a backwards compatible
- way, just some minor type inference related issues may become apparent.
- See [#10] for more information.
- - Implement `Extend<(&K, &V)>` by @xfix.
+- The methods `get_pair`, `get_pair_index` were both replaced by
+ `get_full` (and the same for the mutable case).
+- Method `swap_remove_pair` replaced by `swap_remove_full`.
+- Add trait `MutableKeys` for opt-in mutable key access. Mutable key access
+ is only possible through the methods of this extension trait.
+- Add new trait `Equivalent` for key equivalence. This extends the
+ `Borrow` trait mechanism for `OrderMap::get` in a backwards compatible
+ way, just some minor type inference related issues may become apparent.
+ See [#10] for more information.
+- Implement `Extend<(&K, &V)>` by @xfix.
-[#10]: https://github.com/bluss/ordermap/pull/10
+[#10]: https://github.com/indexmap-rs/indexmap/pull/10
-- 0.2.13
+## 0.2.13
- - Fix deserialization to support custom hashers by @Techcable.
- - Add methods `.index()` on the entry types by @garro95.
+- Fix deserialization to support custom hashers by @Techcable.
+- Add methods `.index()` on the entry types by @garro95.
-- 0.2.12
+## 0.2.12
- - Add methods `.with_hasher()`, `.hasher()`.
+- Add methods `.with_hasher()`, `.hasher()`.
-- 0.2.11
+## 0.2.11
- - Support `ExactSizeIterator` for the iterators. By @Binero.
- - Use `Box<[Pos]>` internally, saving a word in the `OrderMap` struct.
- - Serde support, with crate feature `"serde-1"`. By @xfix.
+- Support `ExactSizeIterator` for the iterators. By @Binero.
+- Use `Box<[Pos]>` internally, saving a word in the `OrderMap` struct.
+- Serde support, with crate feature `"serde-1"`. By @xfix.
-- 0.2.10
+## 0.2.10
- - Add iterator `.drain(..)` by @stevej.
+- Add iterator `.drain(..)` by @stevej.
-- 0.2.9
+## 0.2.9
- - Add method `.is_empty()` by @overvenus.
- - Implement `PartialEq, Eq` by @overvenus.
- - Add method `.sorted_by()`.
+- Add method `.is_empty()` by @overvenus.
+- Implement `PartialEq, Eq` by @overvenus.
+- Add method `.sorted_by()`.
-- 0.2.8
+## 0.2.8
- - Add iterators `.values()` and `.values_mut()`.
- - Fix compatibility with 32-bit platforms.
+- Add iterators `.values()` and `.values_mut()`.
+- Fix compatibility with 32-bit platforms.
-- 0.2.7
+## 0.2.7
- - Add `.retain()`.
+- Add `.retain()`.
-- 0.2.6
+## 0.2.6
- - Add `OccupiedEntry::remove_entry` and other minor entry methods,
- so that it now has all the features of `HashMap`'s entries.
+- Add `OccupiedEntry::remove_entry` and other minor entry methods,
+ so that it now has all the features of `HashMap`'s entries.
-- 0.2.5
+## 0.2.5
- - Improved `.pop()` slightly.
+- Improved `.pop()` slightly.
-- 0.2.4
+## 0.2.4
- - Improved performance of `.insert()` ([#3]) by @pczarn.
+- Improved performance of `.insert()` ([#3]) by @pczarn.
-[#3]: https://github.com/bluss/ordermap/pull/3
+[#3]: https://github.com/indexmap-rs/indexmap/pull/3
-- 0.2.3
+## 0.2.3
- - Generalize `Entry` for now, so that it works on hashmaps with non-default
- hasher. However, there's a lingering compat issue since libstd `HashMap`
- does not parameterize its entries by the hasher (`S` typarm).
- - Special case some iterator methods like `.nth()`.
+- Generalize `Entry` for now, so that it works on hashmaps with non-default
+ hasher. However, there's a lingering compat issue since libstd `HashMap`
+ does not parameterize its entries by the hasher (`S` typarm).
+- Special case some iterator methods like `.nth()`.
-- 0.2.2
+## 0.2.2
- - Disable the verbose `Debug` impl by default.
+- Disable the verbose `Debug` impl by default.
-- 0.2.1
+## 0.2.1
- - Fix doc links and clarify docs.
+- Fix doc links and clarify docs.
-- 0.2.0
+## 0.2.0
- - Add more `HashMap` methods & compat with its API.
- - Experimental support for `.entry()` (the simplest parts of the API).
- - Add `.reserve()` (placeholder impl).
- - Add `.remove()` as synonym for `.swap_remove()`.
- - Changed `.insert()` to swap value if the entry already exists, and
- return `Option`.
- - Experimental support as an *indexed* hash map! Added methods
- `.get_index()`, `.get_index_mut()`, `.swap_remove_index()`,
- `.get_pair_index()`, `.get_pair_index_mut()`.
+- Add more `HashMap` methods & compat with its API.
+- Experimental support for `.entry()` (the simplest parts of the API).
+- Add `.reserve()` (placeholder impl).
+- Add `.remove()` as synonym for `.swap_remove()`.
+- Changed `.insert()` to swap value if the entry already exists, and
+ return `Option`.
+- Experimental support as an *indexed* hash map! Added methods
+ `.get_index()`, `.get_index_mut()`, `.swap_remove_index()`,
+ `.get_pair_index()`, `.get_pair_index_mut()`.
-- 0.1.2
+## 0.1.2
- - Implement the 32/32 split idea for `Pos` which improves cache utilization
- and lookup performance.
+- Implement the 32/32 split idea for `Pos` which improves cache utilization
+ and lookup performance.
-- 0.1.1
+## 0.1.1
- - Initial release.
+- Initial release.
diff --git a/third_party/rust/indexmap/build.rs b/third_party/rust/indexmap/build.rs
deleted file mode 100644
index 9f9fa054f8..0000000000
--- a/third_party/rust/indexmap/build.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-fn main() {
- // If "std" is explicitly requested, don't bother probing the target for it.
- match std::env::var_os("CARGO_FEATURE_STD") {
- Some(_) => autocfg::emit("has_std"),
- None => autocfg::new().emit_sysroot_crate("std"),
- }
- autocfg::rerun_path("build.rs");
-}
diff --git a/third_party/rust/indexmap/src/arbitrary.rs b/third_party/rust/indexmap/src/arbitrary.rs
index 1347c8b54f..7798438c15 100644
--- a/third_party/rust/indexmap/src/arbitrary.rs
+++ b/third_party/rust/indexmap/src/arbitrary.rs
@@ -1,4 +1,5 @@
#[cfg(feature = "arbitrary")]
+#[cfg_attr(docsrs, doc(cfg(feature = "arbitrary")))]
mod impl_arbitrary {
use crate::{IndexMap, IndexSet};
use arbitrary::{Arbitrary, Result, Unstructured};
@@ -35,6 +36,7 @@ mod impl_arbitrary {
}
#[cfg(feature = "quickcheck")]
+#[cfg_attr(docsrs, doc(cfg(feature = "quickcheck")))]
mod impl_quickcheck {
use crate::{IndexMap, IndexSet};
use alloc::boxed::Box;
diff --git a/third_party/rust/indexmap/src/borsh.rs b/third_party/rust/indexmap/src/borsh.rs
new file mode 100644
index 0000000000..c485bd5222
--- /dev/null
+++ b/third_party/rust/indexmap/src/borsh.rs
@@ -0,0 +1,122 @@
+#![cfg_attr(docsrs, doc(cfg(feature = "borsh")))]
+
+use alloc::vec::Vec;
+use core::hash::BuildHasher;
+use core::hash::Hash;
+use core::mem::size_of;
+
+use borsh::error::ERROR_ZST_FORBIDDEN;
+use borsh::io::{Error, ErrorKind, Read, Result, Write};
+use borsh::{BorshDeserialize, BorshSerialize};
+
+use crate::map::IndexMap;
+use crate::set::IndexSet;
+
+impl<K, V, S> BorshSerialize for IndexMap<K, V, S>
+where
+ K: BorshSerialize,
+ V: BorshSerialize,
+{
+ #[inline]
+ fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+ check_zst::<K>()?;
+
+ let iterator = self.iter();
+
+ u32::try_from(iterator.len())
+ .map_err(|_| ErrorKind::InvalidData)?
+ .serialize(writer)?;
+
+ for (key, value) in iterator {
+ key.serialize(writer)?;
+ value.serialize(writer)?;
+ }
+
+ Ok(())
+ }
+}
+
+impl<K, V, S> BorshDeserialize for IndexMap<K, V, S>
+where
+ K: BorshDeserialize + Eq + Hash,
+ V: BorshDeserialize,
+ S: BuildHasher + Default,
+{
+ #[inline]
+ fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+ check_zst::<K>()?;
+ let vec = <Vec<(K, V)>>::deserialize_reader(reader)?;
+ Ok(vec.into_iter().collect::<IndexMap<K, V, S>>())
+ }
+}
+
+impl<T, S> BorshSerialize for IndexSet<T, S>
+where
+ T: BorshSerialize,
+{
+ #[inline]
+ fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+ check_zst::<T>()?;
+
+ let iterator = self.iter();
+
+ u32::try_from(iterator.len())
+ .map_err(|_| ErrorKind::InvalidData)?
+ .serialize(writer)?;
+
+ for item in iterator {
+ item.serialize(writer)?;
+ }
+
+ Ok(())
+ }
+}
+
+impl<T, S> BorshDeserialize for IndexSet<T, S>
+where
+ T: BorshDeserialize + Eq + Hash,
+ S: BuildHasher + Default,
+{
+ #[inline]
+ fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+ check_zst::<T>()?;
+ let vec = <Vec<T>>::deserialize_reader(reader)?;
+ Ok(vec.into_iter().collect::<IndexSet<T, S>>())
+ }
+}
+
+fn check_zst<T>() -> Result<()> {
+ if size_of::<T>() == 0 {
+ return Err(Error::new(ErrorKind::InvalidData, ERROR_ZST_FORBIDDEN));
+ }
+ Ok(())
+}
+
+#[cfg(test)]
+mod borsh_tests {
+ use super::*;
+
+ #[test]
+ fn map_borsh_roundtrip() {
+ let original_map: IndexMap<i32, i32> = {
+ let mut map = IndexMap::new();
+ map.insert(1, 2);
+ map.insert(3, 4);
+ map.insert(5, 6);
+ map
+ };
+ let serialized_map = borsh::to_vec(&original_map).unwrap();
+ let deserialized_map: IndexMap<i32, i32> =
+ BorshDeserialize::try_from_slice(&serialized_map).unwrap();
+ assert_eq!(original_map, deserialized_map);
+ }
+
+ #[test]
+ fn set_borsh_roundtrip() {
+ let original_map: IndexSet<i32> = [1, 2, 3, 4, 5, 6].into_iter().collect();
+ let serialized_map = borsh::to_vec(&original_map).unwrap();
+ let deserialized_map: IndexSet<i32> =
+ BorshDeserialize::try_from_slice(&serialized_map).unwrap();
+ assert_eq!(original_map, deserialized_map);
+ }
+}
diff --git a/third_party/rust/indexmap/src/equivalent.rs b/third_party/rust/indexmap/src/equivalent.rs
deleted file mode 100644
index ad6635ffac..0000000000
--- a/third_party/rust/indexmap/src/equivalent.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use core::borrow::Borrow;
-
-/// Key equivalence trait.
-///
-/// This trait allows hash table lookup to be customized.
-/// It has one blanket implementation that uses the regular `Borrow` solution,
-/// just like `HashMap` and `BTreeMap` do, so that you can pass `&str` to lookup
-/// into a map with `String` keys and so on.
-///
-/// # Contract
-///
-/// The implementor **must** hash like `K`, if it is hashable.
-pub trait Equivalent<K: ?Sized> {
- /// Compare self to `key` and return `true` if they are equal.
- fn equivalent(&self, key: &K) -> bool;
-}
-
-impl<Q: ?Sized, K: ?Sized> Equivalent<K> for Q
-where
- Q: Eq,
- K: Borrow<Q>,
-{
- #[inline]
- fn equivalent(&self, key: &K) -> bool {
- *self == *key.borrow()
- }
-}
diff --git a/third_party/rust/indexmap/src/lib.rs b/third_party/rust/indexmap/src/lib.rs
index 6e94936124..7d88ffef08 100644
--- a/third_party/rust/indexmap/src/lib.rs
+++ b/third_party/rust/indexmap/src/lib.rs
@@ -1,7 +1,6 @@
// We *mostly* avoid unsafe code, but `map::core::raw` allows it to use `RawTable` buckets.
#![deny(unsafe_code)]
#![warn(rust_2018_idioms)]
-#![doc(html_root_url = "https://docs.rs/indexmap/1/")]
#![no_std]
//! [`IndexMap`] is a hash table where the iteration order of the key-value
@@ -10,11 +9,7 @@
//! [`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
+//! ### Highlights
//!
//! [`IndexMap`] and [`IndexSet`] are drop-in compatible with the std `HashMap`
//! and `HashSet`, but they also have some features of note:
@@ -24,11 +19,44 @@
//! - 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.
+//! 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`,
+//! [`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:
@@ -53,33 +81,31 @@
//!
//! ### Rust Version
//!
-//! This version of indexmap requires Rust 1.56 or later.
+//! This version of indexmap requires Rust 1.63 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
+//! 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 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.
+//! 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`][def],
-//! [`with_hasher`][IndexMap::with_hasher],
+//! [`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`.
-//!
-//! [def]: map/struct.IndexMap.html#impl-Default
+
+#![cfg_attr(docsrs, feature(doc_cfg))]
extern crate alloc;
-#[cfg(has_std)]
+#[cfg(feature = "std")]
#[macro_use]
extern crate std;
@@ -88,12 +114,10 @@ use alloc::vec::{self, Vec};
mod arbitrary;
#[macro_use]
mod macros;
-mod equivalent;
-mod mutable_keys;
+#[cfg(feature = "borsh")]
+mod borsh;
#[cfg(feature = "serde")]
mod serde;
-#[cfg(feature = "serde")]
-pub mod serde_seq;
mod util;
pub mod map;
@@ -107,9 +131,9 @@ mod rayon;
#[cfg(feature = "rustc-rayon")]
mod rustc;
-pub use crate::equivalent::Equivalent;
pub use crate::map::IndexMap;
pub use crate::set::IndexSet;
+pub use equivalent::Equivalent;
// shared private items
@@ -192,3 +216,59 @@ trait Entries {
where
F: FnOnce(&mut [Self::Entry]);
}
+
+/// The error type for [`try_reserve`][IndexMap::try_reserve] methods.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct TryReserveError {
+ kind: TryReserveErrorKind,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+enum TryReserveErrorKind {
+ // The standard library's kind is currently opaque to us, otherwise we could unify this.
+ Std(alloc::collections::TryReserveError),
+ CapacityOverflow,
+ AllocError { layout: alloc::alloc::Layout },
+}
+
+// These are not `From` so we don't expose them in our public API.
+impl TryReserveError {
+ fn from_alloc(error: alloc::collections::TryReserveError) -> Self {
+ Self {
+ kind: TryReserveErrorKind::Std(error),
+ }
+ }
+
+ fn from_hashbrown(error: hashbrown::TryReserveError) -> Self {
+ Self {
+ kind: match error {
+ hashbrown::TryReserveError::CapacityOverflow => {
+ TryReserveErrorKind::CapacityOverflow
+ }
+ hashbrown::TryReserveError::AllocError { layout } => {
+ TryReserveErrorKind::AllocError { layout }
+ }
+ },
+ }
+ }
+}
+
+impl core::fmt::Display for TryReserveError {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ let reason = match &self.kind {
+ TryReserveErrorKind::Std(e) => return core::fmt::Display::fmt(e, f),
+ TryReserveErrorKind::CapacityOverflow => {
+ " because the computed capacity exceeded the collection's maximum"
+ }
+ TryReserveErrorKind::AllocError { .. } => {
+ " because the memory allocator returned an error"
+ }
+ };
+ f.write_str("memory allocation failed")?;
+ f.write_str(reason)
+ }
+}
+
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+impl std::error::Error for TryReserveError {}
diff --git a/third_party/rust/indexmap/src/macros.rs b/third_party/rust/indexmap/src/macros.rs
index ca26287be9..b347de22dd 100644
--- a/third_party/rust/indexmap/src/macros.rs
+++ b/third_party/rust/indexmap/src/macros.rs
@@ -1,6 +1,7 @@
-#[cfg(has_std)]
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
#[macro_export]
-/// Create an `IndexMap` from a list of key-value pairs
+/// Create an [`IndexMap`][crate::IndexMap] from a list of key-value pairs
///
/// ## Example
///
@@ -19,25 +20,25 @@
/// assert_eq!(map.keys().next(), Some(&"a"));
/// ```
macro_rules! indexmap {
- (@single $($x:tt)*) => (());
- (@count $($rest:expr),*) => (<[()]>::len(&[$($crate::indexmap!(@single $rest)),*]));
-
($($key:expr => $value:expr,)+) => { $crate::indexmap!($($key => $value),+) };
($($key:expr => $value:expr),*) => {
{
- let _cap = $crate::indexmap!(@count $($key),*);
- let mut _map = $crate::IndexMap::with_capacity(_cap);
+ // Note: `stringify!($key)` is just here to consume the repetition,
+ // but we throw away that string literal during constant evaluation.
+ const CAP: usize = <[()]>::len(&[$({ stringify!($key); }),*]);
+ let mut map = $crate::IndexMap::with_capacity(CAP);
$(
- _map.insert($key, $value);
+ map.insert($key, $value);
)*
- _map
+ map
}
};
}
-#[cfg(has_std)]
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
#[macro_export]
-/// Create an `IndexSet` from a list of values
+/// Create an [`IndexSet`][crate::IndexSet] from a list of values
///
/// ## Example
///
@@ -56,18 +57,17 @@ macro_rules! indexmap {
/// assert_eq!(set.iter().next(), Some(&"a"));
/// ```
macro_rules! indexset {
- (@single $($x:tt)*) => (());
- (@count $($rest:expr),*) => (<[()]>::len(&[$($crate::indexset!(@single $rest)),*]));
-
($($value:expr,)+) => { $crate::indexset!($($value),+) };
($($value:expr),*) => {
{
- let _cap = $crate::indexset!(@count $($value),*);
- let mut _set = $crate::IndexSet::with_capacity(_cap);
+ // Note: `stringify!($value)` is just here to consume the repetition,
+ // but we throw away that string literal during constant evaluation.
+ const CAP: usize = <[()]>::len(&[$({ stringify!($value); }),*]);
+ let mut set = $crate::IndexSet::with_capacity(CAP);
$(
- _set.insert($value);
+ set.insert($value);
)*
- _set
+ set
}
};
}
diff --git a/third_party/rust/indexmap/src/map.rs b/third_party/rust/indexmap/src/map.rs
index d39448d06d..82824c9002 100644
--- a/third_party/rust/indexmap/src/map.rs
+++ b/third_party/rust/indexmap/src/map.rs
@@ -1,36 +1,50 @@
-//! `IndexMap` is a hash table where the iteration order of the key-value
+//! [`IndexMap`] is a hash table where the iteration order of the key-value
//! pairs is independent of the hash values of the keys.
mod core;
+mod iter;
+mod mutable;
+mod slice;
-pub use crate::mutable_keys::MutableKeys;
+#[cfg(feature = "serde")]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+pub mod serde_seq;
+
+#[cfg(test)]
+mod tests;
+
+pub use self::core::raw_entry_v1::{self, RawEntryApiV1};
+pub use self::core::{Entry, IndexedEntry, OccupiedEntry, VacantEntry};
+pub use self::iter::{
+ Drain, IntoIter, IntoKeys, IntoValues, Iter, IterMut, Keys, Splice, Values, ValuesMut,
+};
+pub use self::mutable::MutableKeys;
+pub use self::slice::Slice;
#[cfg(feature = "rayon")]
pub use crate::rayon::map as rayon;
-use crate::vec::{self, Vec};
use ::core::cmp::Ordering;
use ::core::fmt;
use ::core::hash::{BuildHasher, Hash, Hasher};
-use ::core::iter::FusedIterator;
+use ::core::mem;
use ::core::ops::{Index, IndexMut, RangeBounds};
-use ::core::slice::{Iter as SliceIter, IterMut as SliceIterMut};
+use alloc::boxed::Box;
+use alloc::vec::Vec;
-#[cfg(has_std)]
+#[cfg(feature = "std")]
use std::collections::hash_map::RandomState;
use self::core::IndexMapCore;
-use crate::equivalent::Equivalent;
-use crate::util::third;
-use crate::{Bucket, Entries, HashValue};
-
-pub use self::core::{Entry, OccupiedEntry, VacantEntry};
+use crate::util::{third, try_simplify_range};
+use crate::{Bucket, Entries, Equivalent, HashValue, TryReserveError};
/// A hash table where the iteration order of the key-value pairs is independent
/// of the hash values of the keys.
///
-/// The interface is closely compatible with the standard `HashMap`, but also
-/// has additional features.
+/// The interface is closely compatible with the standard
+/// [`HashMap`][std::collections::HashMap],
+/// but also has additional features.
///
/// # Order
///
@@ -41,7 +55,8 @@ pub use self::core::{Entry, OccupiedEntry, VacantEntry};
/// All iterators traverse the map in *the order*.
///
/// The insertion order is preserved, with **notable exceptions** like the
-/// `.remove()` or `.swap_remove()` methods. Methods such as `.sort_by()` of
+/// [`.remove()`][Self::remove] or [`.swap_remove()`][Self::swap_remove] methods.
+/// Methods such as [`.sort_by()`][Self::sort_by] of
/// course result in a new order, depending on the sorting order.
///
/// # Indices
@@ -67,12 +82,12 @@ pub use self::core::{Entry, OccupiedEntry, VacantEntry};
/// assert_eq!(letters[&'u'], 1);
/// assert_eq!(letters.get(&'y'), None);
/// ```
-#[cfg(has_std)]
+#[cfg(feature = "std")]
pub struct IndexMap<K, V, S = RandomState> {
pub(crate) core: IndexMapCore<K, V>,
hash_builder: S,
}
-#[cfg(not(has_std))]
+#[cfg(not(feature = "std"))]
pub struct IndexMap<K, V, S> {
pub(crate) core: IndexMapCore<K, V>,
hash_builder: S,
@@ -128,19 +143,22 @@ where
K: fmt::Debug,
V: fmt::Debug,
{
+ #[cfg(not(feature = "test_debug"))]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- if cfg!(not(feature = "test_debug")) {
- f.debug_map().entries(self.iter()).finish()
- } else {
- // Let the inner `IndexMapCore` print all of its details
- f.debug_struct("IndexMap")
- .field("core", &self.core)
- .finish()
- }
+ f.debug_map().entries(self.iter()).finish()
+ }
+
+ #[cfg(feature = "test_debug")]
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ // Let the inner `IndexMapCore` print all of its details
+ f.debug_struct("IndexMap")
+ .field("core", &self.core)
+ .finish()
}
}
-#[cfg(has_std)]
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl<K, V> IndexMap<K, V> {
/// Create a new map. (Does not allocate.)
#[inline]
@@ -186,6 +204,11 @@ impl<K, V, S> IndexMap<K, V, S> {
}
}
+ /// Return the number of elements the map can hold without reallocating.
+ ///
+ /// This number is a lower bound; the map might be able to hold more,
+ /// but is guaranteed to be able to hold at least this many.
+ ///
/// Computes in **O(1)** time.
pub fn capacity(&self) -> usize {
self.core.capacity()
@@ -214,52 +237,38 @@ impl<K, V, S> IndexMap<K, V, S> {
/// Return an iterator over the key-value pairs of the map, in their order
pub fn iter(&self) -> Iter<'_, K, V> {
- Iter {
- iter: self.as_entries().iter(),
- }
+ Iter::new(self.as_entries())
}
/// Return an iterator over the key-value pairs of the map, in their order
pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
- IterMut {
- iter: self.as_entries_mut().iter_mut(),
- }
+ IterMut::new(self.as_entries_mut())
}
/// Return an iterator over the keys of the map, in their order
pub fn keys(&self) -> Keys<'_, K, V> {
- Keys {
- iter: self.as_entries().iter(),
- }
+ Keys::new(self.as_entries())
}
/// Return an owning iterator over the keys of the map, in their order
pub fn into_keys(self) -> IntoKeys<K, V> {
- IntoKeys {
- iter: self.into_entries().into_iter(),
- }
+ IntoKeys::new(self.into_entries())
}
/// Return an iterator over the values of the map, in their order
pub fn values(&self) -> Values<'_, K, V> {
- Values {
- iter: self.as_entries().iter(),
- }
+ Values::new(self.as_entries())
}
/// Return an iterator over mutable references to the values of the map,
/// in their order
pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> {
- ValuesMut {
- iter: self.as_entries_mut().iter_mut(),
- }
+ ValuesMut::new(self.as_entries_mut())
}
/// Return an owning iterator over the values of the map, in their order
pub fn into_values(self) -> IntoValues<K, V> {
- IntoValues {
- iter: self.into_entries().into_iter(),
- }
+ IntoValues::new(self.into_entries())
}
/// Remove all key-value pairs in the map, while preserving its capacity.
@@ -279,7 +288,7 @@ impl<K, V, S> IndexMap<K, V, S> {
/// Clears the `IndexMap` in the given index range, returning those
/// key-value pairs as a drain iterator.
///
- /// The range may be any type that implements `RangeBounds<usize>`,
+ /// The range may be any type that implements [`RangeBounds<usize>`],
/// including all of the `std::ops::Range*` types, or even a tuple pair of
/// `Bound` start and end values. To drain the map entirely, use `RangeFull`
/// like `map.drain(..)`.
@@ -293,9 +302,7 @@ impl<K, V, S> IndexMap<K, V, S> {
where
R: RangeBounds<usize>,
{
- Drain {
- iter: self.core.drain(range),
- }
+ Drain::new(self.core.drain(range))
}
/// Splits the collection into two at the given index.
@@ -314,13 +321,7 @@ impl<K, V, S> IndexMap<K, V, S> {
hash_builder: self.hash_builder.clone(),
}
}
-}
-impl<K, V, S> IndexMap<K, V, S>
-where
- K: Hash + Eq,
- S: BuildHasher,
-{
/// Reserve capacity for `additional` more key-value pairs.
///
/// Computes in **O(n)** time.
@@ -328,6 +329,37 @@ where
self.core.reserve(additional);
}
+ /// Reserve capacity for `additional` more key-value pairs, without over-allocating.
+ ///
+ /// Unlike `reserve`, this does not deliberately over-allocate the entry capacity to avoid
+ /// frequent re-allocations. However, the underlying data structures may still have internal
+ /// capacity requirements, and the allocator itself may give more space than requested, so this
+ /// cannot be relied upon to be precisely minimal.
+ ///
+ /// Computes in **O(n)** time.
+ pub fn reserve_exact(&mut self, additional: usize) {
+ self.core.reserve_exact(additional);
+ }
+
+ /// Try to reserve capacity for `additional` more key-value pairs.
+ ///
+ /// Computes in **O(n)** time.
+ pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> {
+ self.core.try_reserve(additional)
+ }
+
+ /// Try to reserve capacity for `additional` more key-value pairs, without over-allocating.
+ ///
+ /// Unlike `try_reserve`, this does not deliberately over-allocate the entry capacity to avoid
+ /// frequent re-allocations. However, the underlying data structures may still have internal
+ /// capacity requirements, and the allocator itself may give more space than requested, so this
+ /// cannot be relied upon to be precisely minimal.
+ ///
+ /// Computes in **O(n)** time.
+ pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> {
+ self.core.try_reserve_exact(additional)
+ }
+
/// Shrink the capacity of the map as much as possible.
///
/// Computes in **O(n)** time.
@@ -341,26 +373,27 @@ where
pub fn shrink_to(&mut self, min_capacity: usize) {
self.core.shrink_to(min_capacity);
}
+}
- fn hash<Q: ?Sized + Hash>(&self, key: &Q) -> HashValue {
- let mut h = self.hash_builder.build_hasher();
- key.hash(&mut h);
- HashValue(h.finish() as usize)
- }
-
+impl<K, V, S> IndexMap<K, V, S>
+where
+ K: Hash + Eq,
+ S: BuildHasher,
+{
/// Insert a key-value pair in the map.
///
/// If an equivalent key already exists in the map: the key remains and
/// retains in its place in the order, its corresponding value is updated
- /// with `value` and the older value is returned inside `Some(_)`.
+ /// with `value`, and the older value is returned inside `Some(_)`.
///
/// If no equivalent key existed in the map: the new key-value pair is
/// inserted, last in order, and `None` is returned.
///
/// Computes in **O(1)** time (amortized average).
///
- /// See also [`entry`](#method.entry) if you you want to insert *or* modify
- /// or if you need to get the index of the corresponding key-value pair.
+ /// See also [`entry`][Self::entry] if you want to insert *or* modify,
+ /// or [`insert_full`][Self::insert_full] if you need to get the index of
+ /// the corresponding key-value pair.
pub fn insert(&mut self, key: K, value: V) -> Option<V> {
self.insert_full(key, value).1
}
@@ -369,20 +402,77 @@ where
///
/// If an equivalent key already exists in the map: the key remains and
/// retains in its place in the order, its corresponding value is updated
- /// with `value` and the older value is returned inside `(index, Some(_))`.
+ /// with `value`, and the older value is returned inside `(index, Some(_))`.
///
/// If no equivalent key existed in the map: the new key-value pair is
/// inserted, last in order, and `(index, None)` is returned.
///
/// Computes in **O(1)** time (amortized average).
///
- /// See also [`entry`](#method.entry) if you you want to insert *or* modify
- /// or if you need to get the index of the corresponding key-value pair.
+ /// See also [`entry`][Self::entry] if you want to insert *or* modify.
pub fn insert_full(&mut self, key: K, value: V) -> (usize, Option<V>) {
let hash = self.hash(&key);
self.core.insert_full(hash, key, value)
}
+ /// Insert a key-value pair in the map at its ordered position among sorted keys.
+ ///
+ /// This is equivalent to finding the position with
+ /// [`binary_search_keys`][Self::binary_search_keys], then either updating
+ /// it or calling [`shift_insert`][Self::shift_insert] for a new key.
+ ///
+ /// If the sorted key is found in the map, its corresponding value is
+ /// updated with `value`, and the older value is returned inside
+ /// `(index, Some(_))`. Otherwise, the new key-value pair is inserted at
+ /// the sorted position, and `(index, None)` is returned.
+ ///
+ /// If the existing keys are **not** already sorted, then the insertion
+ /// index is unspecified (like [`slice::binary_search`]), but the key-value
+ /// pair is moved to or inserted at that position regardless.
+ ///
+ /// Computes in **O(n)** time (average). Instead of repeating calls to
+ /// `insert_sorted`, it may be faster to call batched [`insert`][Self::insert]
+ /// or [`extend`][Self::extend] and only call [`sort_keys`][Self::sort_keys]
+ /// or [`sort_unstable_keys`][Self::sort_unstable_keys] once.
+ pub fn insert_sorted(&mut self, key: K, value: V) -> (usize, Option<V>)
+ where
+ K: Ord,
+ {
+ match self.binary_search_keys(&key) {
+ Ok(i) => (i, Some(mem::replace(&mut self[i], value))),
+ Err(i) => (i, self.shift_insert(i, key, value)),
+ }
+ }
+
+ /// Insert a key-value pair in the map at the given index.
+ ///
+ /// If an equivalent key already exists in the map: the key remains and
+ /// is moved to the new position in the map, its corresponding value is updated
+ /// with `value`, and the older value is returned inside `Some(_)`.
+ ///
+ /// If no equivalent key existed in the map: the new key-value pair is
+ /// inserted at the given index, and `None` is returned.
+ ///
+ /// ***Panics*** if `index` is out of bounds.
+ ///
+ /// Computes in **O(n)** time (average).
+ ///
+ /// See also [`entry`][Self::entry] if you want to insert *or* modify,
+ /// perhaps only using the index for new entries with [`VacantEntry::shift_insert`].
+ pub fn shift_insert(&mut self, index: usize, key: K, value: V) -> Option<V> {
+ match self.entry(key) {
+ Entry::Occupied(mut entry) => {
+ let old = mem::replace(entry.get_mut(), value);
+ entry.move_index(index);
+ Some(old)
+ }
+ Entry::Vacant(entry) => {
+ entry.shift_insert(index, value);
+ None
+ }
+ }
+ }
+
/// Get the given key’s corresponding entry in the map for insertion and/or
/// in-place manipulation.
///
@@ -392,12 +482,61 @@ where
self.core.entry(hash, key)
}
+ /// Creates a splicing iterator that replaces the specified range in the map
+ /// with the given `replace_with` key-value iterator and yields the removed
+ /// items. `replace_with` does not need to be the same length as `range`.
+ ///
+ /// The `range` is removed even if the iterator is not consumed until the
+ /// end. It is unspecified how many elements are removed from the map if the
+ /// `Splice` value is leaked.
+ ///
+ /// The input iterator `replace_with` is only consumed when the `Splice`
+ /// value is dropped. If a key from the iterator matches an existing entry
+ /// in the map (outside of `range`), then the value will be updated in that
+ /// position. Otherwise, the new key-value pair will be inserted in the
+ /// replaced `range`.
+ ///
+ /// ***Panics*** if the starting point is greater than the end point or if
+ /// the end point is greater than the length of the map.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use indexmap::IndexMap;
+ ///
+ /// let mut map = IndexMap::from([(0, '_'), (1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]);
+ /// let new = [(5, 'E'), (4, 'D'), (3, 'C'), (2, 'B'), (1, 'A')];
+ /// let removed: Vec<_> = map.splice(2..4, new).collect();
+ ///
+ /// // 1 and 4 got new values, while 5, 3, and 2 were newly inserted.
+ /// assert!(map.into_iter().eq([(0, '_'), (1, 'A'), (5, 'E'), (3, 'C'), (2, 'B'), (4, 'D')]));
+ /// assert_eq!(removed, &[(2, 'b'), (3, 'c')]);
+ /// ```
+ pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter, K, V, S>
+ where
+ R: RangeBounds<usize>,
+ I: IntoIterator<Item = (K, V)>,
+ {
+ Splice::new(self, range, replace_with.into_iter())
+ }
+}
+
+impl<K, V, S> IndexMap<K, V, S>
+where
+ S: BuildHasher,
+{
+ pub(crate) fn hash<Q: ?Sized + Hash>(&self, key: &Q) -> HashValue {
+ let mut h = self.hash_builder.build_hasher();
+ key.hash(&mut h);
+ HashValue(h.finish() as usize)
+ }
+
/// Return `true` if an equivalent to `key` exists in the map.
///
/// Computes in **O(1)** time (average).
- pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool
+ pub fn contains_key<Q>(&self, key: &Q) -> bool
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
self.get_index_of(key).is_some()
}
@@ -406,9 +545,9 @@ where
/// else `None`.
///
/// Computes in **O(1)** time (average).
- pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V>
+ pub fn get<Q>(&self, key: &Q) -> Option<&V>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
if let Some(i) = self.get_index_of(key) {
let entry = &self.as_entries()[i];
@@ -422,9 +561,9 @@ where
/// if it is present, else `None`.
///
/// Computes in **O(1)** time (average).
- pub fn get_key_value<Q: ?Sized>(&self, key: &Q) -> Option<(&K, &V)>
+ pub fn get_key_value<Q>(&self, key: &Q) -> Option<(&K, &V)>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
if let Some(i) = self.get_index_of(key) {
let entry = &self.as_entries()[i];
@@ -435,9 +574,9 @@ where
}
/// Return item index, key and value
- pub fn get_full<Q: ?Sized>(&self, key: &Q) -> Option<(usize, &K, &V)>
+ pub fn get_full<Q>(&self, key: &Q) -> Option<(usize, &K, &V)>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
if let Some(i) = self.get_index_of(key) {
let entry = &self.as_entries()[i];
@@ -450,21 +589,23 @@ where
/// Return item index, if it exists in the map
///
/// Computes in **O(1)** time (average).
- pub fn get_index_of<Q: ?Sized>(&self, key: &Q) -> Option<usize>
+ pub fn get_index_of<Q>(&self, key: &Q) -> Option<usize>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
- if self.is_empty() {
- None
- } else {
- let hash = self.hash(key);
- self.core.get_index_of(hash, key)
+ match self.as_entries() {
+ [] => None,
+ [x] => key.equivalent(&x.key).then_some(0),
+ _ => {
+ let hash = self.hash(key);
+ self.core.get_index_of(hash, key)
+ }
}
}
- pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut V>
+ pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
if let Some(i) = self.get_index_of(key) {
let entry = &mut self.as_entries_mut()[i];
@@ -474,9 +615,9 @@ where
}
}
- pub fn get_full_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<(usize, &K, &mut V)>
+ pub fn get_full_mut<Q>(&mut self, key: &Q) -> Option<(usize, &K, &mut V)>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
if let Some(i) = self.get_index_of(key) {
let entry = &mut self.as_entries_mut()[i];
@@ -486,46 +627,33 @@ where
}
}
- pub(crate) fn get_full_mut2_impl<Q: ?Sized>(
- &mut self,
- key: &Q,
- ) -> Option<(usize, &mut K, &mut V)>
- where
- Q: Hash + Equivalent<K>,
- {
- if let Some(i) = self.get_index_of(key) {
- let entry = &mut self.as_entries_mut()[i];
- Some((i, &mut entry.key, &mut entry.value))
- } else {
- None
- }
- }
-
/// Remove the key-value pair equivalent to `key` and return
/// its value.
///
- /// **NOTE:** This is equivalent to `.swap_remove(key)`, if you need to
- /// preserve the order of the keys in the map, use `.shift_remove(key)`
- /// instead.
- ///
- /// Computes in **O(1)** time (average).
- pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V>
+ /// **NOTE:** This is equivalent to [`.swap_remove(key)`][Self::swap_remove], replacing this
+ /// entry's position with the last element, and it is deprecated in favor of calling that
+ /// explicitly. If you need to preserve the relative order of the keys in the map, use
+ /// [`.shift_remove(key)`][Self::shift_remove] instead.
+ #[deprecated(note = "`remove` disrupts the map order -- \
+ use `swap_remove` or `shift_remove` for explicit behavior.")]
+ pub fn remove<Q>(&mut self, key: &Q) -> Option<V>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
self.swap_remove(key)
}
/// Remove and return the key-value pair equivalent to `key`.
///
- /// **NOTE:** This is equivalent to `.swap_remove_entry(key)`, if you need to
- /// preserve the order of the keys in the map, use `.shift_remove_entry(key)`
- /// instead.
- ///
- /// Computes in **O(1)** time (average).
- pub fn remove_entry<Q: ?Sized>(&mut self, key: &Q) -> Option<(K, V)>
+ /// **NOTE:** This is equivalent to [`.swap_remove_entry(key)`][Self::swap_remove_entry],
+ /// replacing this entry's position with the last element, and it is deprecated in favor of
+ /// calling that explicitly. If you need to preserve the relative order of the keys in the map,
+ /// use [`.shift_remove_entry(key)`][Self::shift_remove_entry] instead.
+ #[deprecated(note = "`remove_entry` disrupts the map order -- \
+ use `swap_remove_entry` or `shift_remove_entry` for explicit behavior.")]
+ pub fn remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
self.swap_remove_entry(key)
}
@@ -533,32 +661,32 @@ where
/// Remove the key-value pair equivalent to `key` and return
/// its value.
///
- /// Like `Vec::swap_remove`, the pair is removed by swapping it with the
+ /// Like [`Vec::swap_remove`], the pair is removed by swapping it with the
/// last element of the map and popping it off. **This perturbs
/// the position of what used to be the last element!**
///
/// Return `None` if `key` is not in map.
///
/// Computes in **O(1)** time (average).
- pub fn swap_remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V>
+ pub fn swap_remove<Q>(&mut self, key: &Q) -> Option<V>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
self.swap_remove_full(key).map(third)
}
/// Remove and return the key-value pair equivalent to `key`.
///
- /// Like `Vec::swap_remove`, the pair is removed by swapping it with the
+ /// Like [`Vec::swap_remove`], the pair is removed by swapping it with the
/// last element of the map and popping it off. **This perturbs
/// the position of what used to be the last element!**
///
/// Return `None` if `key` is not in map.
///
/// Computes in **O(1)** time (average).
- pub fn swap_remove_entry<Q: ?Sized>(&mut self, key: &Q) -> Option<(K, V)>
+ pub fn swap_remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
match self.swap_remove_full(key) {
Some((_, key, value)) => Some((key, value)),
@@ -569,53 +697,59 @@ where
/// Remove the key-value pair equivalent to `key` and return it and
/// the index it had.
///
- /// Like `Vec::swap_remove`, the pair is removed by swapping it with the
+ /// Like [`Vec::swap_remove`], the pair is removed by swapping it with the
/// last element of the map and popping it off. **This perturbs
/// the position of what used to be the last element!**
///
/// Return `None` if `key` is not in map.
///
/// Computes in **O(1)** time (average).
- pub fn swap_remove_full<Q: ?Sized>(&mut self, key: &Q) -> Option<(usize, K, V)>
+ pub fn swap_remove_full<Q>(&mut self, key: &Q) -> Option<(usize, K, V)>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
- if self.is_empty() {
- return None;
+ match self.as_entries() {
+ [x] if key.equivalent(&x.key) => {
+ let (k, v) = self.core.pop()?;
+ Some((0, k, v))
+ }
+ [_] | [] => None,
+ _ => {
+ let hash = self.hash(key);
+ self.core.swap_remove_full(hash, key)
+ }
}
- let hash = self.hash(key);
- self.core.swap_remove_full(hash, key)
}
/// Remove the key-value pair equivalent to `key` and return
/// its value.
///
- /// Like `Vec::remove`, the pair is removed by shifting all of the
+ /// Like [`Vec::remove`], the pair is removed by shifting all of the
/// elements that follow it, preserving their relative order.
/// **This perturbs the index of all of those elements!**
///
/// Return `None` if `key` is not in map.
///
/// Computes in **O(n)** time (average).
- pub fn shift_remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V>
+ pub fn shift_remove<Q>(&mut self, key: &Q) -> Option<V>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
self.shift_remove_full(key).map(third)
}
/// Remove and return the key-value pair equivalent to `key`.
///
- /// Like `Vec::remove`, the pair is removed by shifting all of the
+ /// Like [`Vec::remove`], the pair is removed by shifting all of the
/// elements that follow it, preserving their relative order.
/// **This perturbs the index of all of those elements!**
///
/// Return `None` if `key` is not in map.
///
/// Computes in **O(n)** time (average).
- pub fn shift_remove_entry<Q: ?Sized>(&mut self, key: &Q) -> Option<(K, V)>
+ pub fn shift_remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
match self.shift_remove_full(key) {
Some((_, key, value)) => Some((key, value)),
@@ -626,24 +760,32 @@ where
/// Remove the key-value pair equivalent to `key` and return it and
/// the index it had.
///
- /// Like `Vec::remove`, the pair is removed by shifting all of the
+ /// Like [`Vec::remove`], the pair is removed by shifting all of the
/// elements that follow it, preserving their relative order.
/// **This perturbs the index of all of those elements!**
///
/// Return `None` if `key` is not in map.
///
/// Computes in **O(n)** time (average).
- pub fn shift_remove_full<Q: ?Sized>(&mut self, key: &Q) -> Option<(usize, K, V)>
+ pub fn shift_remove_full<Q>(&mut self, key: &Q) -> Option<(usize, K, V)>
where
- Q: Hash + Equivalent<K>,
+ Q: ?Sized + Hash + Equivalent<K>,
{
- if self.is_empty() {
- return None;
+ match self.as_entries() {
+ [x] if key.equivalent(&x.key) => {
+ let (k, v) = self.core.pop()?;
+ Some((0, k, v))
+ }
+ [_] | [] => None,
+ _ => {
+ let hash = self.hash(key);
+ self.core.shift_remove_full(hash, key)
+ }
}
- let hash = self.hash(key);
- self.core.shift_remove_full(hash, key)
}
+}
+impl<K, V, S> IndexMap<K, V, S> {
/// Remove the last key-value pair
///
/// This preserves the order of the remaining elements.
@@ -667,15 +809,12 @@ where
self.core.retain_in_order(move |k, v| keep(k, v));
}
- pub(crate) fn retain_mut<F>(&mut self, keep: F)
- where
- F: FnMut(&mut K, &mut V) -> bool,
- {
- self.core.retain_in_order(keep);
- }
-
/// Sort the map’s key-value pairs by the default ordering of the keys.
///
+ /// This is a stable sort -- but equivalent keys should not normally coexist in
+ /// a map at all, so [`sort_unstable_keys`][Self::sort_unstable_keys] is preferred
+ /// because it is generally faster and doesn't allocate auxiliary memory.
+ ///
/// See [`sort_by`](Self::sort_by) for details.
pub fn sort_keys(&mut self)
where
@@ -713,9 +852,7 @@ where
{
let mut entries = self.into_entries();
entries.sort_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
- IntoIter {
- iter: entries.into_iter(),
- }
+ IntoIter::new(entries)
}
/// Sort the map's key-value pairs by the default ordering of the keys, but
@@ -759,9 +896,82 @@ where
{
let mut entries = self.into_entries();
entries.sort_unstable_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
- IntoIter {
- iter: entries.into_iter(),
- }
+ IntoIter::new(entries)
+ }
+
+ /// Sort the map’s key-value pairs in place using a sort-key extraction function.
+ ///
+ /// During sorting, the function is called at most once per entry, by using temporary storage
+ /// to remember the results of its evaluation. The order of calls to the function is
+ /// unspecified and may change between versions of `indexmap` or the standard library.
+ ///
+ /// Computes in **O(m n + n log n + c)** time () and **O(n)** space, where the function is
+ /// **O(m)**, *n* is the length of the map, and *c* the capacity. The sort is stable.
+ pub fn sort_by_cached_key<T, F>(&mut self, mut sort_key: F)
+ where
+ T: Ord,
+ F: FnMut(&K, &V) -> T,
+ {
+ self.with_entries(move |entries| {
+ entries.sort_by_cached_key(move |a| sort_key(&a.key, &a.value));
+ });
+ }
+
+ /// Search over a sorted map for a key.
+ ///
+ /// Returns the position where that key is present, or the position where it can be inserted to
+ /// maintain the sort. See [`slice::binary_search`] for more details.
+ ///
+ /// Computes in **O(log(n))** time, which is notably less scalable than looking the key up
+ /// using [`get_index_of`][IndexMap::get_index_of], but this can also position missing keys.
+ pub fn binary_search_keys(&self, x: &K) -> Result<usize, usize>
+ where
+ K: Ord,
+ {
+ self.as_slice().binary_search_keys(x)
+ }
+
+ /// Search over a sorted map with a comparator function.
+ ///
+ /// Returns the position where that value is present, or the position where it can be inserted
+ /// to maintain the sort. See [`slice::binary_search_by`] for more details.
+ ///
+ /// Computes in **O(log(n))** time.
+ #[inline]
+ pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
+ where
+ F: FnMut(&'a K, &'a V) -> Ordering,
+ {
+ self.as_slice().binary_search_by(f)
+ }
+
+ /// Search over a sorted map with an extraction function.
+ ///
+ /// Returns the position where that value is present, or the position where it can be inserted
+ /// to maintain the sort. See [`slice::binary_search_by_key`] for more details.
+ ///
+ /// Computes in **O(log(n))** time.
+ #[inline]
+ pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<usize, usize>
+ where
+ F: FnMut(&'a K, &'a V) -> B,
+ B: Ord,
+ {
+ self.as_slice().binary_search_by_key(b, f)
+ }
+
+ /// Returns the index of the partition point of a sorted map according to the given predicate
+ /// (the index of the first element of the second partition).
+ ///
+ /// See [`slice::partition_point`] for more details.
+ ///
+ /// Computes in **O(log(n))** time.
+ #[must_use]
+ pub fn partition_point<P>(&self, pred: P) -> usize
+ where
+ P: FnMut(&K, &V) -> bool,
+ {
+ self.as_slice().partition_point(pred)
}
/// Reverses the order of the map’s key-value pairs in place.
@@ -770,9 +980,28 @@ where
pub fn reverse(&mut self) {
self.core.reverse()
}
-}
-impl<K, V, S> IndexMap<K, V, S> {
+ /// Returns a slice of all the key-value pairs in the map.
+ ///
+ /// Computes in **O(1)** time.
+ pub fn as_slice(&self) -> &Slice<K, V> {
+ Slice::from_slice(self.as_entries())
+ }
+
+ /// Returns a mutable slice of all the key-value pairs in the map.
+ ///
+ /// Computes in **O(1)** time.
+ pub fn as_mut_slice(&mut self) -> &mut Slice<K, V> {
+ Slice::from_mut_slice(self.as_entries_mut())
+ }
+
+ /// Converts into a boxed slice of all the key-value pairs in the map.
+ ///
+ /// Note that this will drop the inner hash table and any excess capacity.
+ pub fn into_boxed_slice(self) -> Box<Slice<K, V>> {
+ Slice::from_boxed(self.into_entries().into_boxed_slice())
+ }
+
/// Get a key-value pair by index
///
/// Valid indices are *0 <= index < self.len()*
@@ -787,8 +1016,42 @@ impl<K, V, S> IndexMap<K, V, S> {
/// Valid indices are *0 <= index < self.len()*
///
/// Computes in **O(1)** time.
- pub fn get_index_mut(&mut self, index: usize) -> Option<(&mut K, &mut V)> {
- self.as_entries_mut().get_mut(index).map(Bucket::muts)
+ pub fn get_index_mut(&mut self, index: usize) -> Option<(&K, &mut V)> {
+ self.as_entries_mut().get_mut(index).map(Bucket::ref_mut)
+ }
+
+ /// Get an entry in the map by index for in-place manipulation.
+ ///
+ /// Valid indices are *0 <= index < self.len()*
+ ///
+ /// Computes in **O(1)** time.
+ pub fn get_index_entry(&mut self, index: usize) -> Option<IndexedEntry<'_, K, V>> {
+ if index >= self.len() {
+ return None;
+ }
+ Some(IndexedEntry::new(&mut self.core, index))
+ }
+
+ /// Returns a slice of key-value pairs in the given range of indices.
+ ///
+ /// Valid indices are *0 <= index < self.len()*
+ ///
+ /// Computes in **O(1)** time.
+ pub fn get_range<R: RangeBounds<usize>>(&self, range: R) -> Option<&Slice<K, V>> {
+ let entries = self.as_entries();
+ let range = try_simplify_range(range, entries.len())?;
+ entries.get(range).map(Slice::from_slice)
+ }
+
+ /// Returns a mutable slice of key-value pairs in the given range of indices.
+ ///
+ /// Valid indices are *0 <= index < self.len()*
+ ///
+ /// Computes in **O(1)** time.
+ pub fn get_range_mut<R: RangeBounds<usize>>(&mut self, range: R) -> Option<&mut Slice<K, V>> {
+ let entries = self.as_entries_mut();
+ let range = try_simplify_range(range, entries.len())?;
+ entries.get_mut(range).map(Slice::from_mut_slice)
}
/// Get the first key-value pair
@@ -823,7 +1086,7 @@ impl<K, V, S> IndexMap<K, V, S> {
///
/// Valid indices are *0 <= index < self.len()*
///
- /// Like `Vec::swap_remove`, the pair is removed by swapping it with the
+ /// Like [`Vec::swap_remove`], the pair is removed by swapping it with the
/// last element of the map and popping it off. **This perturbs
/// the position of what used to be the last element!**
///
@@ -836,7 +1099,7 @@ impl<K, V, S> IndexMap<K, V, S> {
///
/// Valid indices are *0 <= index < self.len()*
///
- /// Like `Vec::remove`, the pair is removed by shifting all of the
+ /// Like [`Vec::remove`], the pair is removed by shifting all of the
/// elements that follow it, preserving their relative order.
/// **This perturbs the index of all of those elements!**
///
@@ -861,386 +1124,14 @@ impl<K, V, S> IndexMap<K, V, S> {
/// Swaps the position of two key-value pairs in the map.
///
/// ***Panics*** if `a` or `b` are out of bounds.
+ ///
+ /// Computes in **O(1)** time (average).
pub fn swap_indices(&mut self, a: usize, b: usize) {
self.core.swap_indices(a, b)
}
}
-/// An iterator over the keys of a `IndexMap`.
-///
-/// This `struct` is created by the [`keys`] method on [`IndexMap`]. See its
-/// documentation for more.
-///
-/// [`keys`]: struct.IndexMap.html#method.keys
-/// [`IndexMap`]: struct.IndexMap.html
-pub struct Keys<'a, K, V> {
- iter: SliceIter<'a, Bucket<K, V>>,
-}
-
-impl<'a, K, V> Iterator for Keys<'a, K, V> {
- type Item = &'a K;
-
- iterator_methods!(Bucket::key_ref);
-}
-
-impl<K, V> DoubleEndedIterator for Keys<'_, K, V> {
- double_ended_iterator_methods!(Bucket::key_ref);
-}
-
-impl<K, V> ExactSizeIterator for Keys<'_, K, V> {
- fn len(&self) -> usize {
- self.iter.len()
- }
-}
-
-impl<K, V> FusedIterator for Keys<'_, K, V> {}
-
-// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
-impl<K, V> Clone for Keys<'_, K, V> {
- fn clone(&self) -> Self {
- Keys {
- iter: self.iter.clone(),
- }
- }
-}
-
-impl<K: fmt::Debug, V> fmt::Debug for Keys<'_, K, V> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_list().entries(self.clone()).finish()
- }
-}
-
-/// An owning iterator over the keys of a `IndexMap`.
-///
-/// This `struct` is created by the [`into_keys`] method on [`IndexMap`].
-/// See its documentation for more.
-///
-/// [`IndexMap`]: struct.IndexMap.html
-/// [`into_keys`]: struct.IndexMap.html#method.into_keys
-pub struct IntoKeys<K, V> {
- iter: vec::IntoIter<Bucket<K, V>>,
-}
-
-impl<K, V> Iterator for IntoKeys<K, V> {
- type Item = K;
-
- iterator_methods!(Bucket::key);
-}
-
-impl<K, V> DoubleEndedIterator for IntoKeys<K, V> {
- double_ended_iterator_methods!(Bucket::key);
-}
-
-impl<K, V> ExactSizeIterator for IntoKeys<K, V> {
- fn len(&self) -> usize {
- self.iter.len()
- }
-}
-
-impl<K, V> FusedIterator for IntoKeys<K, V> {}
-
-impl<K: fmt::Debug, V> fmt::Debug for IntoKeys<K, V> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- let iter = self.iter.as_slice().iter().map(Bucket::key_ref);
- f.debug_list().entries(iter).finish()
- }
-}
-
-/// An iterator over the values of a `IndexMap`.
-///
-/// This `struct` is created by the [`values`] method on [`IndexMap`]. See its
-/// documentation for more.
-///
-/// [`values`]: struct.IndexMap.html#method.values
-/// [`IndexMap`]: struct.IndexMap.html
-pub struct Values<'a, K, V> {
- iter: SliceIter<'a, Bucket<K, V>>,
-}
-
-impl<'a, K, V> Iterator for Values<'a, K, V> {
- type Item = &'a V;
-
- iterator_methods!(Bucket::value_ref);
-}
-
-impl<K, V> DoubleEndedIterator for Values<'_, K, V> {
- double_ended_iterator_methods!(Bucket::value_ref);
-}
-
-impl<K, V> ExactSizeIterator for Values<'_, K, V> {
- fn len(&self) -> usize {
- self.iter.len()
- }
-}
-
-impl<K, V> FusedIterator for Values<'_, K, V> {}
-
-// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
-impl<K, V> Clone for Values<'_, K, V> {
- fn clone(&self) -> Self {
- Values {
- iter: self.iter.clone(),
- }
- }
-}
-
-impl<K, V: fmt::Debug> fmt::Debug for Values<'_, K, V> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_list().entries(self.clone()).finish()
- }
-}
-
-/// A mutable iterator over the values of a `IndexMap`.
-///
-/// This `struct` is created by the [`values_mut`] method on [`IndexMap`]. See its
-/// documentation for more.
-///
-/// [`values_mut`]: struct.IndexMap.html#method.values_mut
-/// [`IndexMap`]: struct.IndexMap.html
-pub struct ValuesMut<'a, K, V> {
- iter: SliceIterMut<'a, Bucket<K, V>>,
-}
-
-impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {
- type Item = &'a mut V;
-
- iterator_methods!(Bucket::value_mut);
-}
-
-impl<K, V> DoubleEndedIterator for ValuesMut<'_, K, V> {
- double_ended_iterator_methods!(Bucket::value_mut);
-}
-
-impl<K, V> ExactSizeIterator for ValuesMut<'_, K, V> {
- fn len(&self) -> usize {
- self.iter.len()
- }
-}
-
-impl<K, V> FusedIterator for ValuesMut<'_, K, V> {}
-
-impl<K, V: fmt::Debug> fmt::Debug for ValuesMut<'_, K, V> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- let iter = self.iter.as_slice().iter().map(Bucket::value_ref);
- f.debug_list().entries(iter).finish()
- }
-}
-
-/// An owning iterator over the values of a `IndexMap`.
-///
-/// This `struct` is created by the [`into_values`] method on [`IndexMap`].
-/// See its documentation for more.
-///
-/// [`IndexMap`]: struct.IndexMap.html
-/// [`into_values`]: struct.IndexMap.html#method.into_values
-pub struct IntoValues<K, V> {
- iter: vec::IntoIter<Bucket<K, V>>,
-}
-
-impl<K, V> Iterator for IntoValues<K, V> {
- type Item = V;
-
- iterator_methods!(Bucket::value);
-}
-
-impl<K, V> DoubleEndedIterator for IntoValues<K, V> {
- double_ended_iterator_methods!(Bucket::value);
-}
-
-impl<K, V> ExactSizeIterator for IntoValues<K, V> {
- fn len(&self) -> usize {
- self.iter.len()
- }
-}
-
-impl<K, V> FusedIterator for IntoValues<K, V> {}
-
-impl<K, V: fmt::Debug> fmt::Debug for IntoValues<K, V> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- let iter = self.iter.as_slice().iter().map(Bucket::value_ref);
- f.debug_list().entries(iter).finish()
- }
-}
-
-/// An iterator over the entries of a `IndexMap`.
-///
-/// This `struct` is created by the [`iter`] method on [`IndexMap`]. See its
-/// documentation for more.
-///
-/// [`iter`]: struct.IndexMap.html#method.iter
-/// [`IndexMap`]: struct.IndexMap.html
-pub struct Iter<'a, K, V> {
- iter: SliceIter<'a, Bucket<K, V>>,
-}
-
-impl<'a, K, V> Iterator for Iter<'a, K, V> {
- type Item = (&'a K, &'a V);
-
- iterator_methods!(Bucket::refs);
-}
-
-impl<K, V> DoubleEndedIterator for Iter<'_, K, V> {
- double_ended_iterator_methods!(Bucket::refs);
-}
-
-impl<K, V> ExactSizeIterator for Iter<'_, K, V> {
- fn len(&self) -> usize {
- self.iter.len()
- }
-}
-
-impl<K, V> FusedIterator for Iter<'_, K, V> {}
-
-// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
-impl<K, V> Clone for Iter<'_, K, V> {
- fn clone(&self) -> Self {
- Iter {
- iter: self.iter.clone(),
- }
- }
-}
-
-impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Iter<'_, K, V> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_list().entries(self.clone()).finish()
- }
-}
-
-/// A mutable iterator over the entries of a `IndexMap`.
-///
-/// This `struct` is created by the [`iter_mut`] method on [`IndexMap`]. See its
-/// documentation for more.
-///
-/// [`iter_mut`]: struct.IndexMap.html#method.iter_mut
-/// [`IndexMap`]: struct.IndexMap.html
-pub struct IterMut<'a, K, V> {
- iter: SliceIterMut<'a, Bucket<K, V>>,
-}
-
-impl<'a, K, V> Iterator for IterMut<'a, K, V> {
- type Item = (&'a K, &'a mut V);
-
- iterator_methods!(Bucket::ref_mut);
-}
-
-impl<K, V> DoubleEndedIterator for IterMut<'_, K, V> {
- double_ended_iterator_methods!(Bucket::ref_mut);
-}
-
-impl<K, V> ExactSizeIterator for IterMut<'_, K, V> {
- fn len(&self) -> usize {
- self.iter.len()
- }
-}
-
-impl<K, V> FusedIterator for IterMut<'_, K, V> {}
-
-impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IterMut<'_, K, V> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- let iter = self.iter.as_slice().iter().map(Bucket::refs);
- f.debug_list().entries(iter).finish()
- }
-}
-
-/// An owning iterator over the entries of a `IndexMap`.
-///
-/// This `struct` is created by the [`into_iter`] method on [`IndexMap`]
-/// (provided by the `IntoIterator` trait). See its documentation for more.
-///
-/// [`into_iter`]: struct.IndexMap.html#method.into_iter
-/// [`IndexMap`]: struct.IndexMap.html
-pub struct IntoIter<K, V> {
- iter: vec::IntoIter<Bucket<K, V>>,
-}
-
-impl<K, V> Iterator for IntoIter<K, V> {
- type Item = (K, V);
-
- iterator_methods!(Bucket::key_value);
-}
-
-impl<K, V> DoubleEndedIterator for IntoIter<K, V> {
- double_ended_iterator_methods!(Bucket::key_value);
-}
-
-impl<K, V> ExactSizeIterator for IntoIter<K, V> {
- fn len(&self) -> usize {
- self.iter.len()
- }
-}
-
-impl<K, V> FusedIterator for IntoIter<K, V> {}
-
-impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IntoIter<K, V> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- let iter = self.iter.as_slice().iter().map(Bucket::refs);
- f.debug_list().entries(iter).finish()
- }
-}
-
-/// A draining iterator over the entries of a `IndexMap`.
-///
-/// This `struct` is created by the [`drain`] method on [`IndexMap`]. See its
-/// documentation for more.
-///
-/// [`drain`]: struct.IndexMap.html#method.drain
-/// [`IndexMap`]: struct.IndexMap.html
-pub struct Drain<'a, K, V> {
- pub(crate) iter: vec::Drain<'a, Bucket<K, V>>,
-}
-
-impl<K, V> Iterator for Drain<'_, K, V> {
- type Item = (K, V);
-
- iterator_methods!(Bucket::key_value);
-}
-
-impl<K, V> DoubleEndedIterator for Drain<'_, K, V> {
- double_ended_iterator_methods!(Bucket::key_value);
-}
-
-impl<K, V> ExactSizeIterator for Drain<'_, K, V> {
- fn len(&self) -> usize {
- self.iter.len()
- }
-}
-
-impl<K, V> FusedIterator for Drain<'_, K, V> {}
-
-impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Drain<'_, K, V> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- let iter = self.iter.as_slice().iter().map(Bucket::refs);
- f.debug_list().entries(iter).finish()
- }
-}
-
-impl<'a, K, V, S> IntoIterator for &'a IndexMap<K, V, S> {
- type Item = (&'a K, &'a V);
- type IntoIter = Iter<'a, K, V>;
- fn into_iter(self) -> Self::IntoIter {
- self.iter()
- }
-}
-
-impl<'a, K, V, S> IntoIterator for &'a mut IndexMap<K, V, S> {
- type Item = (&'a K, &'a mut V);
- type IntoIter = IterMut<'a, K, V>;
- fn into_iter(self) -> Self::IntoIter {
- self.iter_mut()
- }
-}
-
-impl<K, V, S> IntoIterator for IndexMap<K, V, S> {
- type Item = (K, V);
- type IntoIter = IntoIter<K, V>;
- fn into_iter(self) -> Self::IntoIter {
- IntoIter {
- iter: self.into_entries().into_iter(),
- }
- }
-}
-
-/// Access `IndexMap` values corresponding to a key.
+/// Access [`IndexMap`] values corresponding to a key.
///
/// # Examples
///
@@ -1265,7 +1156,6 @@ impl<K, V, S> IntoIterator for IndexMap<K, V, S> {
impl<K, V, Q: ?Sized, S> Index<&Q> for IndexMap<K, V, S>
where
Q: Hash + Equivalent<K>,
- K: Hash + Eq,
S: BuildHasher,
{
type Output = V;
@@ -1278,7 +1168,7 @@ where
}
}
-/// Access `IndexMap` values corresponding to a key.
+/// Access [`IndexMap`] values corresponding to a key.
///
/// Mutable indexing allows changing / updating values of key-value
/// pairs that are already present.
@@ -1310,7 +1200,6 @@ where
impl<K, V, Q: ?Sized, S> IndexMut<&Q> for IndexMap<K, V, S>
where
Q: Hash + Equivalent<K>,
- K: Hash + Eq,
S: BuildHasher,
{
/// Returns a mutable reference to the value corresponding to the supplied `key`.
@@ -1321,7 +1210,11 @@ where
}
}
-/// Access `IndexMap` values at indexed positions.
+/// Access [`IndexMap`] values at indexed positions.
+///
+/// See [`Index<usize> for Keys`][keys] to access a map's keys instead.
+///
+/// [keys]: Keys#impl-Index<usize>-for-Keys<'a,+K,+V>
///
/// # Examples
///
@@ -1362,12 +1255,12 @@ impl<K, V, S> Index<usize> for IndexMap<K, V, S> {
}
}
-/// Access `IndexMap` values at indexed positions.
+/// Access [`IndexMap`] values at indexed positions.
///
/// Mutable indexing allows changing / updating indexed values
/// that are already present.
///
-/// You can **not** insert new values with index syntax, use `.insert()`.
+/// You can **not** insert new values with index syntax -- use [`.insert()`][IndexMap::insert].
///
/// # Examples
///
@@ -1411,7 +1304,7 @@ where
/// iterable.
///
/// `from_iter` uses the same logic as `extend`. See
- /// [`extend`](#method.extend) for more details.
+ /// [`extend`][IndexMap::extend] for more details.
fn from_iter<I: IntoIterator<Item = (K, V)>>(iterable: I) -> Self {
let iter = iterable.into_iter();
let (low, _) = iter.size_hint();
@@ -1421,7 +1314,8 @@ where
}
}
-#[cfg(has_std)]
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl<K, V, const N: usize> From<[(K, V); N]> for IndexMap<K, V, RandomState>
where
K: Hash + Eq,
@@ -1447,7 +1341,7 @@ where
{
/// Extend the map with all key-value pairs in the iterable.
///
- /// This is equivalent to calling [`insert`](#method.insert) for each of
+ /// This is equivalent to calling [`insert`][IndexMap::insert] for each of
/// them in order, which means that for keys that already existed
/// in the map, their value is updated but it keeps the existing order.
///
@@ -1491,7 +1385,7 @@ impl<K, V, S> Default for IndexMap<K, V, S>
where
S: Default,
{
- /// Return an empty `IndexMap`
+ /// Return an empty [`IndexMap`]
fn default() -> Self {
Self::with_capacity_and_hasher(0, S::default())
}
@@ -1521,427 +1415,3 @@ where
S: BuildHasher,
{
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use std::string::String;
-
- #[test]
- fn it_works() {
- let mut map = IndexMap::new();
- assert_eq!(map.is_empty(), true);
- map.insert(1, ());
- map.insert(1, ());
- assert_eq!(map.len(), 1);
- assert!(map.get(&1).is_some());
- assert_eq!(map.is_empty(), false);
- }
-
- #[test]
- fn new() {
- let map = IndexMap::<String, String>::new();
- println!("{:?}", map);
- assert_eq!(map.capacity(), 0);
- assert_eq!(map.len(), 0);
- assert_eq!(map.is_empty(), true);
- }
-
- #[test]
- fn insert() {
- let insert = [0, 4, 2, 12, 8, 7, 11, 5];
- let not_present = [1, 3, 6, 9, 10];
- let mut map = IndexMap::with_capacity(insert.len());
-
- for (i, &elt) in insert.iter().enumerate() {
- assert_eq!(map.len(), i);
- map.insert(elt, elt);
- assert_eq!(map.len(), i + 1);
- assert_eq!(map.get(&elt), Some(&elt));
- assert_eq!(map[&elt], elt);
- }
- println!("{:?}", map);
-
- for &elt in &not_present {
- assert!(map.get(&elt).is_none());
- }
- }
-
- #[test]
- fn insert_full() {
- let insert = vec![9, 2, 7, 1, 4, 6, 13];
- let present = vec![1, 6, 2];
- let mut map = IndexMap::with_capacity(insert.len());
-
- for (i, &elt) in insert.iter().enumerate() {
- assert_eq!(map.len(), i);
- let (index, existing) = map.insert_full(elt, elt);
- assert_eq!(existing, None);
- assert_eq!(Some(index), map.get_full(&elt).map(|x| x.0));
- assert_eq!(map.len(), i + 1);
- }
-
- let len = map.len();
- for &elt in &present {
- let (index, existing) = map.insert_full(elt, elt);
- assert_eq!(existing, Some(elt));
- assert_eq!(Some(index), map.get_full(&elt).map(|x| x.0));
- assert_eq!(map.len(), len);
- }
- }
-
- #[test]
- fn insert_2() {
- let mut map = IndexMap::with_capacity(16);
-
- let mut keys = vec![];
- keys.extend(0..16);
- keys.extend(if cfg!(miri) { 32..64 } else { 128..267 });
-
- for &i in &keys {
- let old_map = map.clone();
- map.insert(i, ());
- for key in old_map.keys() {
- if map.get(key).is_none() {
- println!("old_map: {:?}", old_map);
- println!("map: {:?}", map);
- panic!("did not find {} in map", key);
- }
- }
- }
-
- for &i in &keys {
- assert!(map.get(&i).is_some(), "did not find {}", i);
- }
- }
-
- #[test]
- fn insert_order() {
- let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
- let mut map = IndexMap::new();
-
- for &elt in &insert {
- map.insert(elt, ());
- }
-
- assert_eq!(map.keys().count(), map.len());
- assert_eq!(map.keys().count(), insert.len());
- for (a, b) in insert.iter().zip(map.keys()) {
- assert_eq!(a, b);
- }
- for (i, k) in (0..insert.len()).zip(map.keys()) {
- assert_eq!(map.get_index(i).unwrap().0, k);
- }
- }
-
- #[test]
- fn grow() {
- let insert = [0, 4, 2, 12, 8, 7, 11];
- let not_present = [1, 3, 6, 9, 10];
- let mut map = IndexMap::with_capacity(insert.len());
-
- for (i, &elt) in insert.iter().enumerate() {
- assert_eq!(map.len(), i);
- map.insert(elt, elt);
- assert_eq!(map.len(), i + 1);
- assert_eq!(map.get(&elt), Some(&elt));
- assert_eq!(map[&elt], elt);
- }
-
- println!("{:?}", map);
- for &elt in &insert {
- map.insert(elt * 10, elt);
- }
- for &elt in &insert {
- map.insert(elt * 100, elt);
- }
- for (i, &elt) in insert.iter().cycle().enumerate().take(100) {
- map.insert(elt * 100 + i as i32, elt);
- }
- println!("{:?}", map);
- for &elt in &not_present {
- assert!(map.get(&elt).is_none());
- }
- }
-
- #[test]
- fn reserve() {
- let mut map = IndexMap::<usize, usize>::new();
- assert_eq!(map.capacity(), 0);
- map.reserve(100);
- let capacity = map.capacity();
- assert!(capacity >= 100);
- for i in 0..capacity {
- assert_eq!(map.len(), i);
- map.insert(i, i * i);
- assert_eq!(map.len(), i + 1);
- assert_eq!(map.capacity(), capacity);
- assert_eq!(map.get(&i), Some(&(i * i)));
- }
- map.insert(capacity, std::usize::MAX);
- assert_eq!(map.len(), capacity + 1);
- assert!(map.capacity() > capacity);
- assert_eq!(map.get(&capacity), Some(&std::usize::MAX));
- }
-
- #[test]
- fn shrink_to_fit() {
- let mut map = IndexMap::<usize, usize>::new();
- assert_eq!(map.capacity(), 0);
- for i in 0..100 {
- assert_eq!(map.len(), i);
- map.insert(i, i * i);
- assert_eq!(map.len(), i + 1);
- assert!(map.capacity() >= i + 1);
- assert_eq!(map.get(&i), Some(&(i * i)));
- map.shrink_to_fit();
- assert_eq!(map.len(), i + 1);
- assert_eq!(map.capacity(), i + 1);
- assert_eq!(map.get(&i), Some(&(i * i)));
- }
- }
-
- #[test]
- fn remove() {
- let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
- let mut map = IndexMap::new();
-
- for &elt in &insert {
- map.insert(elt, elt);
- }
-
- assert_eq!(map.keys().count(), map.len());
- assert_eq!(map.keys().count(), insert.len());
- for (a, b) in insert.iter().zip(map.keys()) {
- assert_eq!(a, b);
- }
-
- let remove_fail = [99, 77];
- let remove = [4, 12, 8, 7];
-
- for &key in &remove_fail {
- assert!(map.swap_remove_full(&key).is_none());
- }
- println!("{:?}", map);
- for &key in &remove {
- //println!("{:?}", map);
- let index = map.get_full(&key).unwrap().0;
- assert_eq!(map.swap_remove_full(&key), Some((index, key, key)));
- }
- println!("{:?}", map);
-
- for key in &insert {
- assert_eq!(map.get(key).is_some(), !remove.contains(key));
- }
- assert_eq!(map.len(), insert.len() - remove.len());
- assert_eq!(map.keys().count(), insert.len() - remove.len());
- }
-
- #[test]
- fn remove_to_empty() {
- let mut map = indexmap! { 0 => 0, 4 => 4, 5 => 5 };
- map.swap_remove(&5).unwrap();
- map.swap_remove(&4).unwrap();
- map.swap_remove(&0).unwrap();
- assert!(map.is_empty());
- }
-
- #[test]
- fn swap_remove_index() {
- let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
- let mut map = IndexMap::new();
-
- for &elt in &insert {
- map.insert(elt, elt * 2);
- }
-
- let mut vector = insert.to_vec();
- let remove_sequence = &[3, 3, 10, 4, 5, 4, 3, 0, 1];
-
- // check that the same swap remove sequence on vec and map
- // have the same result.
- for &rm in remove_sequence {
- let out_vec = vector.swap_remove(rm);
- let (out_map, _) = map.swap_remove_index(rm).unwrap();
- assert_eq!(out_vec, out_map);
- }
- assert_eq!(vector.len(), map.len());
- for (a, b) in vector.iter().zip(map.keys()) {
- assert_eq!(a, b);
- }
- }
-
- #[test]
- fn partial_eq_and_eq() {
- let mut map_a = IndexMap::new();
- map_a.insert(1, "1");
- map_a.insert(2, "2");
- let mut map_b = map_a.clone();
- assert_eq!(map_a, map_b);
- map_b.swap_remove(&1);
- assert_ne!(map_a, map_b);
-
- let map_c: IndexMap<_, String> = map_b.into_iter().map(|(k, v)| (k, v.into())).collect();
- assert_ne!(map_a, map_c);
- assert_ne!(map_c, map_a);
- }
-
- #[test]
- fn extend() {
- let mut map = IndexMap::new();
- map.extend(vec![(&1, &2), (&3, &4)]);
- map.extend(vec![(5, 6)]);
- assert_eq!(
- map.into_iter().collect::<Vec<_>>(),
- vec![(1, 2), (3, 4), (5, 6)]
- );
- }
-
- #[test]
- fn entry() {
- let mut map = IndexMap::new();
-
- map.insert(1, "1");
- map.insert(2, "2");
- {
- let e = map.entry(3);
- assert_eq!(e.index(), 2);
- let e = e.or_insert("3");
- assert_eq!(e, &"3");
- }
-
- let e = map.entry(2);
- assert_eq!(e.index(), 1);
- assert_eq!(e.key(), &2);
- match e {
- Entry::Occupied(ref e) => assert_eq!(e.get(), &"2"),
- Entry::Vacant(_) => panic!(),
- }
- assert_eq!(e.or_insert("4"), &"2");
- }
-
- #[test]
- fn entry_and_modify() {
- let mut map = IndexMap::new();
-
- map.insert(1, "1");
- map.entry(1).and_modify(|x| *x = "2");
- assert_eq!(Some(&"2"), map.get(&1));
-
- map.entry(2).and_modify(|x| *x = "doesn't exist");
- assert_eq!(None, map.get(&2));
- }
-
- #[test]
- fn entry_or_default() {
- let mut map = IndexMap::new();
-
- #[derive(Debug, PartialEq)]
- enum TestEnum {
- DefaultValue,
- NonDefaultValue,
- }
-
- impl Default for TestEnum {
- fn default() -> Self {
- TestEnum::DefaultValue
- }
- }
-
- map.insert(1, TestEnum::NonDefaultValue);
- assert_eq!(&mut TestEnum::NonDefaultValue, map.entry(1).or_default());
-
- assert_eq!(&mut TestEnum::DefaultValue, map.entry(2).or_default());
- }
-
- #[test]
- fn occupied_entry_key() {
- // These keys match hash and equality, but their addresses are distinct.
- let (k1, k2) = (&mut 1, &mut 1);
- let k1_ptr = k1 as *const i32;
- let k2_ptr = k2 as *const i32;
- assert_ne!(k1_ptr, k2_ptr);
-
- let mut map = IndexMap::new();
- map.insert(k1, "value");
- match map.entry(k2) {
- Entry::Occupied(ref e) => {
- // `OccupiedEntry::key` should reference the key in the map,
- // not the key that was used to find the entry.
- let ptr = *e.key() as *const i32;
- assert_eq!(ptr, k1_ptr);
- assert_ne!(ptr, k2_ptr);
- }
- Entry::Vacant(_) => panic!(),
- }
- }
-
- #[test]
- fn keys() {
- let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
- let map: IndexMap<_, _> = vec.into_iter().collect();
- let keys: Vec<_> = map.keys().copied().collect();
- assert_eq!(keys.len(), 3);
- assert!(keys.contains(&1));
- assert!(keys.contains(&2));
- assert!(keys.contains(&3));
- }
-
- #[test]
- fn into_keys() {
- let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
- let map: IndexMap<_, _> = vec.into_iter().collect();
- let keys: Vec<i32> = map.into_keys().collect();
- assert_eq!(keys.len(), 3);
- assert!(keys.contains(&1));
- assert!(keys.contains(&2));
- assert!(keys.contains(&3));
- }
-
- #[test]
- fn values() {
- let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
- let map: IndexMap<_, _> = vec.into_iter().collect();
- let values: Vec<_> = map.values().copied().collect();
- assert_eq!(values.len(), 3);
- assert!(values.contains(&'a'));
- assert!(values.contains(&'b'));
- assert!(values.contains(&'c'));
- }
-
- #[test]
- fn values_mut() {
- let vec = vec![(1, 1), (2, 2), (3, 3)];
- let mut map: IndexMap<_, _> = vec.into_iter().collect();
- for value in map.values_mut() {
- *value *= 2
- }
- let values: Vec<_> = map.values().copied().collect();
- assert_eq!(values.len(), 3);
- assert!(values.contains(&2));
- assert!(values.contains(&4));
- assert!(values.contains(&6));
- }
-
- #[test]
- fn into_values() {
- let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
- let map: IndexMap<_, _> = vec.into_iter().collect();
- let values: Vec<char> = map.into_values().collect();
- assert_eq!(values.len(), 3);
- assert!(values.contains(&'a'));
- assert!(values.contains(&'b'));
- assert!(values.contains(&'c'));
- }
-
- #[test]
- #[cfg(has_std)]
- fn from_array() {
- let map = IndexMap::from([(1, 2), (3, 4)]);
- let mut expected = IndexMap::new();
- expected.insert(1, 2);
- expected.insert(3, 4);
-
- assert_eq!(map, expected)
- }
-}
diff --git a/third_party/rust/indexmap/src/map/core.rs b/third_party/rust/indexmap/src/map/core.rs
index ea7aaae62e..16e87c7c6a 100644
--- a/third_party/rust/indexmap/src/map/core.rs
+++ b/third_party/rust/indexmap/src/map/core.rs
@@ -7,19 +7,22 @@
//!
//! However, we should probably not let this show in the public API or docs.
+mod entry;
mod raw;
+pub mod raw_entry_v1;
+
use hashbrown::raw::RawTable;
-use crate::vec::{Drain, Vec};
-use core::cmp;
-use core::fmt;
-use core::mem::replace;
+use crate::vec::{self, Vec};
+use crate::TryReserveError;
+use core::mem;
use core::ops::RangeBounds;
-use crate::equivalent::Equivalent;
use crate::util::simplify_range;
-use crate::{Bucket, Entries, HashValue};
+use crate::{Bucket, Entries, Equivalent, HashValue};
+
+pub use entry::{Entry, IndexedEntry, OccupiedEntry, VacantEntry};
/// Core of the map that does not depend on S
pub(crate) struct IndexMapCore<K, V> {
@@ -62,29 +65,30 @@ where
V: Clone,
{
fn clone(&self) -> Self {
- let indices = self.indices.clone();
- let mut entries = Vec::with_capacity(indices.capacity());
- entries.clone_from(&self.entries);
- IndexMapCore { indices, entries }
+ let mut new = Self::new();
+ new.clone_from(self);
+ new
}
fn clone_from(&mut self, other: &Self) {
let hasher = get_hash(&other.entries);
self.indices.clone_from_with_hasher(&other.indices, hasher);
if self.entries.capacity() < other.entries.len() {
- // If we must resize, match the indices capacity
- self.reserve_entries();
+ // If we must resize, match the indices capacity.
+ let additional = other.entries.len() - self.entries.len();
+ self.reserve_entries(additional);
}
self.entries.clone_from(&other.entries);
}
}
-impl<K, V> fmt::Debug for IndexMapCore<K, V>
+#[cfg(feature = "test_debug")]
+impl<K, V> core::fmt::Debug for IndexMapCore<K, V>
where
- K: fmt::Debug,
- V: fmt::Debug,
+ K: core::fmt::Debug,
+ V: core::fmt::Debug,
{
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("IndexMapCore")
.field("indices", &raw::DebugIndices(&self.indices))
.field("entries", &self.entries)
@@ -120,6 +124,9 @@ impl<K, V> Entries for IndexMapCore<K, V> {
}
impl<K, V> IndexMapCore<K, V> {
+ /// The maximum capacity before the `entries` allocation would exceed `isize::MAX`.
+ const MAX_ENTRIES_CAPACITY: usize = (isize::MAX as usize) / mem::size_of::<Bucket<K, V>>();
+
#[inline]
pub(crate) const fn new() -> Self {
IndexMapCore {
@@ -143,7 +150,7 @@ impl<K, V> IndexMapCore<K, V> {
#[inline]
pub(crate) fn capacity(&self) -> usize {
- cmp::min(self.indices.capacity(), self.entries.capacity())
+ Ord::min(self.indices.capacity(), self.entries.capacity())
}
pub(crate) fn clear(&mut self) {
@@ -158,7 +165,7 @@ impl<K, V> IndexMapCore<K, V> {
}
}
- pub(crate) fn drain<R>(&mut self, range: R) -> Drain<'_, Bucket<K, V>>
+ pub(crate) fn drain<R>(&mut self, range: R) -> vec::Drain<'_, Bucket<K, V>>
where
R: RangeBounds<usize>,
{
@@ -190,18 +197,92 @@ impl<K, V> IndexMapCore<K, V> {
Self { indices, entries }
}
+ pub(crate) fn split_splice<R>(&mut self, range: R) -> (Self, vec::IntoIter<Bucket<K, V>>)
+ where
+ R: RangeBounds<usize>,
+ {
+ let range = simplify_range(range, self.len());
+ self.erase_indices(range.start, self.entries.len());
+ let entries = self.entries.split_off(range.end);
+ let drained = self.entries.split_off(range.start);
+
+ let mut indices = RawTable::with_capacity(entries.len());
+ raw::insert_bulk_no_grow(&mut indices, &entries);
+ (Self { indices, entries }, drained.into_iter())
+ }
+
+ /// Append from another map without checking whether items already exist.
+ pub(crate) fn append_unchecked(&mut self, other: &mut Self) {
+ self.reserve(other.len());
+ raw::insert_bulk_no_grow(&mut self.indices, &other.entries);
+ self.entries.append(&mut other.entries);
+ other.indices.clear();
+ }
+
/// Reserve capacity for `additional` more key-value pairs.
pub(crate) fn reserve(&mut self, additional: usize) {
self.indices.reserve(additional, get_hash(&self.entries));
- self.reserve_entries();
+ // Only grow entries if necessary, since we also round up capacity.
+ if additional > self.entries.capacity() - self.entries.len() {
+ self.reserve_entries(additional);
+ }
+ }
+
+ /// Reserve entries capacity, rounded up to match the indices
+ fn reserve_entries(&mut self, additional: usize) {
+ // Use a soft-limit on the maximum capacity, but if the caller explicitly
+ // requested more, do it and let them have the resulting panic.
+ let new_capacity = Ord::min(self.indices.capacity(), Self::MAX_ENTRIES_CAPACITY);
+ let try_add = new_capacity - self.entries.len();
+ if try_add > additional && self.entries.try_reserve_exact(try_add).is_ok() {
+ return;
+ }
+ self.entries.reserve_exact(additional);
}
- /// Reserve entries capacity to match the indices
- fn reserve_entries(&mut self) {
- let additional = self.indices.capacity() - self.entries.len();
+ /// Reserve capacity for `additional` more key-value pairs, without over-allocating.
+ pub(crate) fn reserve_exact(&mut self, additional: usize) {
+ self.indices.reserve(additional, get_hash(&self.entries));
self.entries.reserve_exact(additional);
}
+ /// Try to reserve capacity for `additional` more key-value pairs.
+ pub(crate) fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> {
+ self.indices
+ .try_reserve(additional, get_hash(&self.entries))
+ .map_err(TryReserveError::from_hashbrown)?;
+ // Only grow entries if necessary, since we also round up capacity.
+ if additional > self.entries.capacity() - self.entries.len() {
+ self.try_reserve_entries(additional)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Try to reserve entries capacity, rounded up to match the indices
+ fn try_reserve_entries(&mut self, additional: usize) -> Result<(), TryReserveError> {
+ // Use a soft-limit on the maximum capacity, but if the caller explicitly
+ // requested more, do it and let them have the resulting error.
+ let new_capacity = Ord::min(self.indices.capacity(), Self::MAX_ENTRIES_CAPACITY);
+ let try_add = new_capacity - self.entries.len();
+ if try_add > additional && self.entries.try_reserve_exact(try_add).is_ok() {
+ return Ok(());
+ }
+ self.entries
+ .try_reserve_exact(additional)
+ .map_err(TryReserveError::from_alloc)
+ }
+
+ /// Try to reserve capacity for `additional` more key-value pairs, without over-allocating.
+ pub(crate) fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> {
+ self.indices
+ .try_reserve(additional, get_hash(&self.entries))
+ .map_err(TryReserveError::from_hashbrown)?;
+ self.entries
+ .try_reserve_exact(additional)
+ .map_err(TryReserveError::from_alloc)
+ }
+
/// Shrink the capacity of the map with a lower bound
pub(crate) fn shrink_to(&mut self, min_capacity: usize) {
self.indices
@@ -220,18 +301,25 @@ impl<K, V> IndexMapCore<K, V> {
}
}
- /// Append a key-value pair, *without* checking whether it already exists,
- /// and return the pair's new index.
- fn push(&mut self, hash: HashValue, key: K, value: V) -> usize {
- let i = self.entries.len();
- self.indices.insert(hash.get(), i, get_hash(&self.entries));
- if i == self.entries.capacity() {
+ /// Append a key-value pair to `entries`, *without* checking whether it already exists.
+ fn push_entry(&mut self, hash: HashValue, key: K, value: V) {
+ if self.entries.len() == self.entries.capacity() {
// Reserve our own capacity synced to the indices,
// rather than letting `Vec::push` just double it.
- self.reserve_entries();
+ self.reserve_entries(1);
}
self.entries.push(Bucket { hash, key, value });
- i
+ }
+
+ /// Insert a key-value pair in `entries` at a particular index,
+ /// *without* checking whether it already exists.
+ fn insert_entry(&mut self, index: usize, hash: HashValue, key: K, value: V) {
+ if self.entries.len() == self.entries.capacity() {
+ // Reserve our own capacity synced to the indices,
+ // rather than letting `Vec::insert` just double it.
+ self.reserve_entries(1);
+ }
+ self.entries.insert(index, Bucket { hash, key, value });
}
/// Return the index in `entries` where an equivalent key can be found
@@ -247,12 +335,66 @@ impl<K, V> IndexMapCore<K, V> {
where
K: Eq,
{
- match self.get_index_of(hash, &key) {
- Some(i) => (i, Some(replace(&mut self.entries[i].value, value))),
- None => (self.push(hash, key, value), None),
+ match self.find_or_insert(hash, &key) {
+ Ok(i) => (i, Some(mem::replace(&mut self.entries[i].value, value))),
+ Err(i) => {
+ debug_assert_eq!(i, self.entries.len());
+ self.push_entry(hash, key, value);
+ (i, None)
+ }
+ }
+ }
+
+ /// Same as `insert_full`, except it also replaces the key
+ pub(crate) fn replace_full(
+ &mut self,
+ hash: HashValue,
+ key: K,
+ value: V,
+ ) -> (usize, Option<(K, V)>)
+ where
+ K: Eq,
+ {
+ match self.find_or_insert(hash, &key) {
+ Ok(i) => {
+ let entry = &mut self.entries[i];
+ let kv = (
+ mem::replace(&mut entry.key, key),
+ mem::replace(&mut entry.value, value),
+ );
+ (i, Some(kv))
+ }
+ Err(i) => {
+ debug_assert_eq!(i, self.entries.len());
+ self.push_entry(hash, key, value);
+ (i, None)
+ }
}
}
+ fn insert_unique(&mut self, hash: HashValue, key: K, value: V) -> usize {
+ let i = self.indices.len();
+ self.indices.insert(hash.get(), i, get_hash(&self.entries));
+ debug_assert_eq!(i, self.entries.len());
+ self.push_entry(hash, key, value);
+ i
+ }
+
+ fn shift_insert_unique(&mut self, index: usize, hash: HashValue, key: K, value: V) {
+ let end = self.indices.len();
+ assert!(index <= end);
+ // Increment others first so we don't have duplicate indices.
+ self.increment_indices(index, end);
+ let entries = &*self.entries;
+ self.indices.insert(hash.get(), index, move |&i| {
+ // Adjust for the incremented indices to find hashes.
+ debug_assert_ne!(i, index);
+ let i = if i < index { i } else { i - 1 };
+ entries[i].hash.get()
+ });
+ self.insert_entry(index, hash, key, value);
+ }
+
/// Remove an entry by shifting all entries that follow it
pub(crate) fn shift_remove_full<Q>(&mut self, hash: HashValue, key: &Q) -> Option<(usize, K, V)>
where
@@ -339,7 +481,7 @@ impl<K, V> IndexMapCore<K, V> {
pub(super) fn move_index(&mut self, from: usize, to: usize) {
let from_hash = self.entries[from].hash;
if from != to {
- // Use a sentinal index so other indices don't collide.
+ // Use a sentinel index so other indices don't collide.
update_index(&mut self.indices, from_hash, from, usize::MAX);
// Update all other indices and rotate the entry positions.
@@ -351,11 +493,31 @@ impl<K, V> IndexMapCore<K, V> {
self.entries[to..=from].rotate_right(1);
}
- // Change the sentinal index to its final position.
+ // Change the sentinel index to its final position.
update_index(&mut self.indices, from_hash, usize::MAX, to);
}
}
+ pub(crate) fn swap_indices(&mut self, a: usize, b: usize) {
+ // If they're equal and in-bounds, there's nothing to do.
+ if a == b && a < self.entries.len() {
+ return;
+ }
+
+ // We'll get a "nice" bounds-check from indexing `self.entries`,
+ // and then we expect to find it in the table as well.
+ let [ref_a, ref_b] = self
+ .indices
+ .get_many_mut(
+ [self.entries[a].hash.get(), self.entries[b].hash.get()],
+ move |i, &x| if i == 0 { x == a } else { x == b },
+ )
+ .expect("indices not found");
+
+ mem::swap(ref_a, ref_b);
+ self.entries.swap(a, b);
+ }
+
/// Remove an entry by swapping it with the last
pub(crate) fn swap_remove_full<Q>(&mut self, hash: HashValue, key: &Q) -> Option<(usize, K, V)>
where
@@ -447,25 +609,9 @@ impl<K, V> IndexMapCore<K, V> {
where
F: FnMut(&mut K, &mut V) -> bool,
{
- // FIXME: This could use Vec::retain_mut with MSRV 1.61.
- // Like Vec::retain in self.entries, but with mutable K and V.
- // We swap-shift all the items we want to keep, truncate the rest,
- // then rebuild the raw hash table with the new indexes.
- let len = self.entries.len();
- let mut n_deleted = 0;
- for i in 0..len {
- let will_keep = {
- let entry = &mut self.entries[i];
- keep(&mut entry.key, &mut entry.value)
- };
- if !will_keep {
- n_deleted += 1;
- } else if n_deleted > 0 {
- self.entries.swap(i - n_deleted, i);
- }
- }
- if n_deleted > 0 {
- self.entries.truncate(len - n_deleted);
+ self.entries
+ .retain_mut(|entry| keep(&mut entry.key, &mut entry.value));
+ if self.entries.len() < self.indices.len() {
self.rebuild_hash_table();
}
}
@@ -487,214 +633,10 @@ impl<K, V> IndexMapCore<K, V> {
}
}
-/// Entry for an existing key-value pair or a vacant location to
-/// insert one.
-pub enum Entry<'a, K, V> {
- /// Existing slot with equivalent key.
- Occupied(OccupiedEntry<'a, K, V>),
- /// Vacant slot (no equivalent key in the map).
- Vacant(VacantEntry<'a, K, V>),
-}
-
-impl<'a, K, V> Entry<'a, K, V> {
- /// Inserts the given default value in the entry if it is vacant and returns a mutable
- /// reference to it. Otherwise a mutable reference to an already existent value is returned.
- ///
- /// Computes in **O(1)** time (amortized average).
- pub fn or_insert(self, default: V) -> &'a mut V {
- match self {
- Entry::Occupied(entry) => entry.into_mut(),
- Entry::Vacant(entry) => entry.insert(default),
- }
- }
-
- /// Inserts the result of the `call` function in the entry if it is vacant and returns a mutable
- /// reference to it. Otherwise a mutable reference to an already existent value is returned.
- ///
- /// Computes in **O(1)** time (amortized average).
- pub fn or_insert_with<F>(self, call: F) -> &'a mut V
- where
- F: FnOnce() -> V,
- {
- match self {
- Entry::Occupied(entry) => entry.into_mut(),
- Entry::Vacant(entry) => entry.insert(call()),
- }
- }
-
- /// Inserts the result of the `call` function with a reference to the entry's key if it is
- /// vacant, and returns a mutable reference to the new value. Otherwise a mutable reference to
- /// an already existent value is returned.
- ///
- /// Computes in **O(1)** time (amortized average).
- pub fn or_insert_with_key<F>(self, call: F) -> &'a mut V
- where
- F: FnOnce(&K) -> V,
- {
- match self {
- Entry::Occupied(entry) => entry.into_mut(),
- Entry::Vacant(entry) => {
- let value = call(&entry.key);
- entry.insert(value)
- }
- }
- }
-
- /// Gets a reference to the entry's key, either within the map if occupied,
- /// or else the new key that was used to find the entry.
- pub fn key(&self) -> &K {
- match *self {
- Entry::Occupied(ref entry) => entry.key(),
- Entry::Vacant(ref entry) => entry.key(),
- }
- }
-
- /// Return the index where the key-value pair exists or will be inserted.
- pub fn index(&self) -> usize {
- match *self {
- Entry::Occupied(ref entry) => entry.index(),
- Entry::Vacant(ref entry) => entry.index(),
- }
- }
-
- /// Modifies the entry if it is occupied.
- pub fn and_modify<F>(self, f: F) -> Self
- where
- F: FnOnce(&mut V),
- {
- match self {
- Entry::Occupied(mut o) => {
- f(o.get_mut());
- Entry::Occupied(o)
- }
- x => x,
- }
- }
-
- /// Inserts a default-constructed value in the entry if it is vacant and returns a mutable
- /// reference to it. Otherwise a mutable reference to an already existent value is returned.
- ///
- /// Computes in **O(1)** time (amortized average).
- pub fn or_default(self) -> &'a mut V
- where
- V: Default,
- {
- match self {
- Entry::Occupied(entry) => entry.into_mut(),
- Entry::Vacant(entry) => entry.insert(V::default()),
- }
- }
-}
-
-impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Entry<'_, K, V> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- match *self {
- Entry::Vacant(ref v) => f.debug_tuple(stringify!(Entry)).field(v).finish(),
- Entry::Occupied(ref o) => f.debug_tuple(stringify!(Entry)).field(o).finish(),
- }
- }
-}
-
-pub use self::raw::OccupiedEntry;
-
-// Extra methods that don't threaten the unsafe encapsulation.
-impl<K, V> OccupiedEntry<'_, K, V> {
- /// Sets the value of the entry to `value`, and returns the entry's old value.
- pub fn insert(&mut self, value: V) -> V {
- replace(self.get_mut(), value)
- }
-
- /// Remove the key, value pair stored in the map for this entry, and return the value.
- ///
- /// **NOTE:** This is equivalent to `.swap_remove()`.
- pub fn remove(self) -> V {
- self.swap_remove()
- }
-
- /// Remove the key, value pair stored in the map for this entry, and return the value.
- ///
- /// Like `Vec::swap_remove`, the pair is removed by swapping it with the
- /// last element of the map and popping it off. **This perturbs
- /// the position of what used to be the last element!**
- ///
- /// Computes in **O(1)** time (average).
- pub fn swap_remove(self) -> V {
- self.swap_remove_entry().1
- }
-
- /// Remove the key, value pair stored in the map for this entry, and return the value.
- ///
- /// Like `Vec::remove`, the pair is removed by shifting all of the
- /// elements that follow it, preserving their relative order.
- /// **This perturbs the index of all of those elements!**
- ///
- /// Computes in **O(n)** time (average).
- pub fn shift_remove(self) -> V {
- self.shift_remove_entry().1
- }
-
- /// Remove and return the key, value pair stored in the map for this entry
- ///
- /// **NOTE:** This is equivalent to `.swap_remove_entry()`.
- pub fn remove_entry(self) -> (K, V) {
- self.swap_remove_entry()
- }
-}
-
-impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for OccupiedEntry<'_, K, V> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_struct(stringify!(OccupiedEntry))
- .field("key", self.key())
- .field("value", self.get())
- .finish()
- }
-}
-
-/// A view into a vacant entry in a `IndexMap`.
-/// It is part of the [`Entry`] enum.
-///
-/// [`Entry`]: enum.Entry.html
-pub struct VacantEntry<'a, K, V> {
- map: &'a mut IndexMapCore<K, V>,
- hash: HashValue,
- key: K,
-}
-
-impl<'a, K, V> VacantEntry<'a, K, V> {
- /// Gets a reference to the key that was used to find the entry.
- pub fn key(&self) -> &K {
- &self.key
- }
-
- /// Takes ownership of the key, leaving the entry vacant.
- pub fn into_key(self) -> K {
- self.key
- }
-
- /// Return the index where the key-value pair will be inserted.
- pub fn index(&self) -> usize {
- self.map.len()
- }
-
- /// Inserts the entry's key and the given value into the map, and returns a mutable reference
- /// to the value.
- pub fn insert(self, value: V) -> &'a mut V {
- let i = self.map.push(self.hash, self.key, value);
- &mut self.map.entries[i].value
- }
-}
-
-impl<K: fmt::Debug, V> fmt::Debug for VacantEntry<'_, K, V> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_tuple(stringify!(VacantEntry))
- .field(self.key())
- .finish()
- }
-}
-
#[test]
fn assert_send_sync() {
fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<IndexMapCore<i32, i32>>();
assert_send_sync::<Entry<'_, i32, i32>>();
+ assert_send_sync::<IndexedEntry<'_, i32, i32>>();
}
diff --git a/third_party/rust/indexmap/src/map/core/entry.rs b/third_party/rust/indexmap/src/map/core/entry.rs
new file mode 100644
index 0000000000..6c31070788
--- /dev/null
+++ b/third_party/rust/indexmap/src/map/core/entry.rs
@@ -0,0 +1,481 @@
+use super::raw::RawTableEntry;
+use super::IndexMapCore;
+use crate::HashValue;
+use core::{fmt, mem};
+
+impl<K, V> IndexMapCore<K, V> {
+ pub(crate) fn entry(&mut self, hash: HashValue, key: K) -> Entry<'_, K, V>
+ where
+ K: Eq,
+ {
+ match self.raw_entry(hash, |k| *k == key) {
+ Ok(raw) => Entry::Occupied(OccupiedEntry { raw }),
+ Err(map) => Entry::Vacant(VacantEntry { map, hash, key }),
+ }
+ }
+}
+
+/// Entry for an existing key-value pair in an [`IndexMap`][crate::IndexMap]
+/// or a vacant location to insert one.
+pub enum Entry<'a, K, V> {
+ /// Existing slot with equivalent key.
+ Occupied(OccupiedEntry<'a, K, V>),
+ /// Vacant slot (no equivalent key in the map).
+ Vacant(VacantEntry<'a, K, V>),
+}
+
+impl<'a, K, V> Entry<'a, K, V> {
+ /// Return the index where the key-value pair exists or will be inserted.
+ pub fn index(&self) -> usize {
+ match *self {
+ Entry::Occupied(ref entry) => entry.index(),
+ Entry::Vacant(ref entry) => entry.index(),
+ }
+ }
+
+ /// Inserts the given default value in the entry if it is vacant and returns a mutable
+ /// reference to it. Otherwise a mutable reference to an already existent value is returned.
+ ///
+ /// Computes in **O(1)** time (amortized average).
+ pub fn or_insert(self, default: V) -> &'a mut V {
+ match self {
+ Entry::Occupied(entry) => entry.into_mut(),
+ Entry::Vacant(entry) => entry.insert(default),
+ }
+ }
+
+ /// Inserts the result of the `call` function in the entry if it is vacant and returns a mutable
+ /// reference to it. Otherwise a mutable reference to an already existent value is returned.
+ ///
+ /// Computes in **O(1)** time (amortized average).
+ pub fn or_insert_with<F>(self, call: F) -> &'a mut V
+ where
+ F: FnOnce() -> V,
+ {
+ match self {
+ Entry::Occupied(entry) => entry.into_mut(),
+ Entry::Vacant(entry) => entry.insert(call()),
+ }
+ }
+
+ /// Inserts the result of the `call` function with a reference to the entry's key if it is
+ /// vacant, and returns a mutable reference to the new value. Otherwise a mutable reference to
+ /// an already existent value is returned.
+ ///
+ /// Computes in **O(1)** time (amortized average).
+ pub fn or_insert_with_key<F>(self, call: F) -> &'a mut V
+ where
+ F: FnOnce(&K) -> V,
+ {
+ match self {
+ Entry::Occupied(entry) => entry.into_mut(),
+ Entry::Vacant(entry) => {
+ let value = call(&entry.key);
+ entry.insert(value)
+ }
+ }
+ }
+
+ /// Gets a reference to the entry's key, either within the map if occupied,
+ /// or else the new key that was used to find the entry.
+ pub fn key(&self) -> &K {
+ match *self {
+ Entry::Occupied(ref entry) => entry.key(),
+ Entry::Vacant(ref entry) => entry.key(),
+ }
+ }
+
+ /// Modifies the entry if it is occupied.
+ pub fn and_modify<F>(mut self, f: F) -> Self
+ where
+ F: FnOnce(&mut V),
+ {
+ if let Entry::Occupied(entry) = &mut self {
+ f(entry.get_mut());
+ }
+ self
+ }
+
+ /// Inserts a default-constructed value in the entry if it is vacant and returns a mutable
+ /// reference to it. Otherwise a mutable reference to an already existent value is returned.
+ ///
+ /// Computes in **O(1)** time (amortized average).
+ pub fn or_default(self) -> &'a mut V
+ where
+ V: Default,
+ {
+ match self {
+ Entry::Occupied(entry) => entry.into_mut(),
+ Entry::Vacant(entry) => entry.insert(V::default()),
+ }
+ }
+}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Entry<'_, K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let mut tuple = f.debug_tuple("Entry");
+ match self {
+ Entry::Vacant(v) => tuple.field(v),
+ Entry::Occupied(o) => tuple.field(o),
+ };
+ tuple.finish()
+ }
+}
+
+/// A view into an occupied entry in an [`IndexMap`][crate::IndexMap].
+/// It is part of the [`Entry`] enum.
+pub struct OccupiedEntry<'a, K, V> {
+ raw: RawTableEntry<'a, K, V>,
+}
+
+impl<'a, K, V> OccupiedEntry<'a, K, V> {
+ /// Return the index of the key-value pair
+ #[inline]
+ pub fn index(&self) -> usize {
+ self.raw.index()
+ }
+
+ /// Gets a reference to the entry's key in the map.
+ ///
+ /// Note that this is not the key that was used to find the entry. There may be an observable
+ /// difference if the key type has any distinguishing features outside of `Hash` and `Eq`, like
+ /// extra fields or the memory address of an allocation.
+ pub fn key(&self) -> &K {
+ &self.raw.bucket().key
+ }
+
+ /// Gets a reference to the entry's value in the map.
+ pub fn get(&self) -> &V {
+ &self.raw.bucket().value
+ }
+
+ /// Gets a mutable reference to the entry's value in the map.
+ ///
+ /// If you need a reference which may outlive the destruction of the
+ /// [`Entry`] value, see [`into_mut`][Self::into_mut].
+ pub fn get_mut(&mut self) -> &mut V {
+ &mut self.raw.bucket_mut().value
+ }
+
+ /// Converts into a mutable reference to the entry's value in the map,
+ /// with a lifetime bound to the map itself.
+ pub fn into_mut(self) -> &'a mut V {
+ &mut self.raw.into_bucket().value
+ }
+
+ /// Sets the value of the entry to `value`, and returns the entry's old value.
+ pub fn insert(&mut self, value: V) -> V {
+ mem::replace(self.get_mut(), value)
+ }
+
+ /// Remove the key, value pair stored in the map for this entry, and return the value.
+ ///
+ /// **NOTE:** This is equivalent to [`.swap_remove()`][Self::swap_remove], replacing this
+ /// entry's position with the last element, and it is deprecated in favor of calling that
+ /// explicitly. If you need to preserve the relative order of the keys in the map, use
+ /// [`.shift_remove()`][Self::shift_remove] instead.
+ #[deprecated(note = "`remove` disrupts the map order -- \
+ use `swap_remove` or `shift_remove` for explicit behavior.")]
+ pub fn remove(self) -> V {
+ self.swap_remove()
+ }
+
+ /// Remove the key, value pair stored in the map for this entry, and return the value.
+ ///
+ /// Like [`Vec::swap_remove`][crate::Vec::swap_remove], the pair is removed by swapping it with
+ /// the last element of the map and popping it off.
+ /// **This perturbs the position of what used to be the last element!**
+ ///
+ /// Computes in **O(1)** time (average).
+ pub fn swap_remove(self) -> V {
+ self.swap_remove_entry().1
+ }
+
+ /// Remove the key, value pair stored in the map for this entry, and return the value.
+ ///
+ /// Like [`Vec::remove`][crate::Vec::remove], the pair is removed by shifting all of the
+ /// elements that follow it, preserving their relative order.
+ /// **This perturbs the index of all of those elements!**
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn shift_remove(self) -> V {
+ self.shift_remove_entry().1
+ }
+
+ /// Remove and return the key, value pair stored in the map for this entry
+ ///
+ /// **NOTE:** This is equivalent to [`.swap_remove_entry()`][Self::swap_remove_entry],
+ /// replacing this entry's position with the last element, and it is deprecated in favor of
+ /// calling that explicitly. If you need to preserve the relative order of the keys in the map,
+ /// use [`.shift_remove_entry()`][Self::shift_remove_entry] instead.
+ #[deprecated(note = "`remove_entry` disrupts the map order -- \
+ use `swap_remove_entry` or `shift_remove_entry` for explicit behavior.")]
+ pub fn remove_entry(self) -> (K, V) {
+ self.swap_remove_entry()
+ }
+
+ /// Remove and return the key, value pair stored in the map for this entry
+ ///
+ /// Like [`Vec::swap_remove`][crate::Vec::swap_remove], the pair is removed by swapping it with
+ /// the last element of the map and popping it off.
+ /// **This perturbs the position of what used to be the last element!**
+ ///
+ /// Computes in **O(1)** time (average).
+ pub fn swap_remove_entry(self) -> (K, V) {
+ let (map, index) = self.raw.remove_index();
+ map.swap_remove_finish(index)
+ }
+
+ /// Remove and return the key, value pair stored in the map for this entry
+ ///
+ /// Like [`Vec::remove`][crate::Vec::remove], the pair is removed by shifting all of the
+ /// elements that follow it, preserving their relative order.
+ /// **This perturbs the index of all of those elements!**
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn shift_remove_entry(self) -> (K, V) {
+ let (map, index) = self.raw.remove_index();
+ map.shift_remove_finish(index)
+ }
+
+ /// Moves the position of the entry to a new index
+ /// by shifting all other entries in-between.
+ ///
+ /// This is equivalent to [`IndexMap::move_index`][`crate::IndexMap::move_index`]
+ /// coming `from` the current [`.index()`][Self::index].
+ ///
+ /// * If `self.index() < to`, the other pairs will shift down while the targeted pair moves up.
+ /// * If `self.index() > to`, the other pairs will shift up while the targeted pair moves down.
+ ///
+ /// ***Panics*** if `to` is out of bounds.
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn move_index(self, to: usize) {
+ let (map, index) = self.raw.into_inner();
+ map.move_index(index, to);
+ }
+
+ /// Swaps the position of entry with another.
+ ///
+ /// This is equivalent to [`IndexMap::swap_indices`][`crate::IndexMap::swap_indices`]
+ /// with the current [`.index()`][Self::index] as one of the two being swapped.
+ ///
+ /// ***Panics*** if the `other` index is out of bounds.
+ ///
+ /// Computes in **O(1)** time (average).
+ pub fn swap_indices(self, other: usize) {
+ let (map, index) = self.raw.into_inner();
+ map.swap_indices(index, other)
+ }
+}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for OccupiedEntry<'_, K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("OccupiedEntry")
+ .field("key", self.key())
+ .field("value", self.get())
+ .finish()
+ }
+}
+
+/// A view into a vacant entry in an [`IndexMap`][crate::IndexMap].
+/// It is part of the [`Entry`] enum.
+pub struct VacantEntry<'a, K, V> {
+ map: &'a mut IndexMapCore<K, V>,
+ hash: HashValue,
+ key: K,
+}
+
+impl<'a, K, V> VacantEntry<'a, K, V> {
+ /// Return the index where a key-value pair may be inserted.
+ pub fn index(&self) -> usize {
+ self.map.indices.len()
+ }
+
+ /// Gets a reference to the key that was used to find the entry.
+ pub fn key(&self) -> &K {
+ &self.key
+ }
+
+ /// Takes ownership of the key, leaving the entry vacant.
+ pub fn into_key(self) -> K {
+ self.key
+ }
+
+ /// Inserts the entry's key and the given value into the map, and returns a mutable reference
+ /// to the value.
+ pub fn insert(self, value: V) -> &'a mut V {
+ let Self { map, hash, key } = self;
+ let i = map.insert_unique(hash, key, value);
+ &mut map.entries[i].value
+ }
+
+ /// Inserts the entry's key and the given value into the map at its ordered
+ /// position among sorted keys, and returns the new index and a mutable
+ /// reference to the value.
+ ///
+ /// If the existing keys are **not** already sorted, then the insertion
+ /// index is unspecified (like [`slice::binary_search`]), but the key-value
+ /// pair is inserted at that position regardless.
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn insert_sorted(self, value: V) -> (usize, &'a mut V)
+ where
+ K: Ord,
+ {
+ let slice = crate::map::Slice::from_slice(&self.map.entries);
+ let i = slice.binary_search_keys(&self.key).unwrap_err();
+ (i, self.shift_insert(i, value))
+ }
+
+ /// Inserts the entry's key and the given value into the map at the given index,
+ /// shifting others to the right, and returns a mutable reference to the value.
+ ///
+ /// ***Panics*** if `index` is out of bounds.
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn shift_insert(self, index: usize, value: V) -> &'a mut V {
+ let Self { map, hash, key } = self;
+ map.shift_insert_unique(index, hash, key, value);
+ &mut map.entries[index].value
+ }
+}
+
+impl<K: fmt::Debug, V> fmt::Debug for VacantEntry<'_, K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_tuple("VacantEntry").field(self.key()).finish()
+ }
+}
+
+/// A view into an occupied entry in an [`IndexMap`][crate::IndexMap] obtained by index.
+///
+/// This `struct` is created from the [`get_index_entry`][crate::IndexMap::get_index_entry] method.
+pub struct IndexedEntry<'a, K, V> {
+ map: &'a mut IndexMapCore<K, V>,
+ // We have a mutable reference to the map, which keeps the index
+ // valid and pointing to the correct entry.
+ index: usize,
+}
+
+impl<'a, K, V> IndexedEntry<'a, K, V> {
+ pub(crate) fn new(map: &'a mut IndexMapCore<K, V>, index: usize) -> Self {
+ Self { map, index }
+ }
+
+ /// Return the index of the key-value pair
+ #[inline]
+ pub fn index(&self) -> usize {
+ self.index
+ }
+
+ /// Gets a reference to the entry's key in the map.
+ pub fn key(&self) -> &K {
+ &self.map.entries[self.index].key
+ }
+
+ /// Gets a reference to the entry's value in the map.
+ pub fn get(&self) -> &V {
+ &self.map.entries[self.index].value
+ }
+
+ /// Gets a mutable reference to the entry's value in the map.
+ ///
+ /// If you need a reference which may outlive the destruction of the
+ /// `IndexedEntry` value, see [`into_mut`][Self::into_mut].
+ pub fn get_mut(&mut self) -> &mut V {
+ &mut self.map.entries[self.index].value
+ }
+
+ /// Sets the value of the entry to `value`, and returns the entry's old value.
+ pub fn insert(&mut self, value: V) -> V {
+ mem::replace(self.get_mut(), value)
+ }
+
+ /// Converts into a mutable reference to the entry's value in the map,
+ /// with a lifetime bound to the map itself.
+ pub fn into_mut(self) -> &'a mut V {
+ &mut self.map.entries[self.index].value
+ }
+
+ /// Remove and return the key, value pair stored in the map for this entry
+ ///
+ /// Like [`Vec::swap_remove`][crate::Vec::swap_remove], the pair is removed by swapping it with
+ /// the last element of the map and popping it off.
+ /// **This perturbs the position of what used to be the last element!**
+ ///
+ /// Computes in **O(1)** time (average).
+ pub fn swap_remove_entry(self) -> (K, V) {
+ self.map.swap_remove_index(self.index).unwrap()
+ }
+
+ /// Remove and return the key, value pair stored in the map for this entry
+ ///
+ /// Like [`Vec::remove`][crate::Vec::remove], the pair is removed by shifting all of the
+ /// elements that follow it, preserving their relative order.
+ /// **This perturbs the index of all of those elements!**
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn shift_remove_entry(self) -> (K, V) {
+ self.map.shift_remove_index(self.index).unwrap()
+ }
+
+ /// Remove the key, value pair stored in the map for this entry, and return the value.
+ ///
+ /// Like [`Vec::swap_remove`][crate::Vec::swap_remove], the pair is removed by swapping it with
+ /// the last element of the map and popping it off.
+ /// **This perturbs the position of what used to be the last element!**
+ ///
+ /// Computes in **O(1)** time (average).
+ pub fn swap_remove(self) -> V {
+ self.swap_remove_entry().1
+ }
+
+ /// Remove the key, value pair stored in the map for this entry, and return the value.
+ ///
+ /// Like [`Vec::remove`][crate::Vec::remove], the pair is removed by shifting all of the
+ /// elements that follow it, preserving their relative order.
+ /// **This perturbs the index of all of those elements!**
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn shift_remove(self) -> V {
+ self.shift_remove_entry().1
+ }
+
+ /// Moves the position of the entry to a new index
+ /// by shifting all other entries in-between.
+ ///
+ /// This is equivalent to [`IndexMap::move_index`][`crate::IndexMap::move_index`]
+ /// coming `from` the current [`.index()`][Self::index].
+ ///
+ /// * If `self.index() < to`, the other pairs will shift down while the targeted pair moves up.
+ /// * If `self.index() > to`, the other pairs will shift up while the targeted pair moves down.
+ ///
+ /// ***Panics*** if `to` is out of bounds.
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn move_index(self, to: usize) {
+ self.map.move_index(self.index, to);
+ }
+
+ /// Swaps the position of entry with another.
+ ///
+ /// This is equivalent to [`IndexMap::swap_indices`][`crate::IndexMap::swap_indices`]
+ /// with the current [`.index()`][Self::index] as one of the two being swapped.
+ ///
+ /// ***Panics*** if the `other` index is out of bounds.
+ ///
+ /// Computes in **O(1)** time (average).
+ pub fn swap_indices(self, other: usize) {
+ self.map.swap_indices(self.index, other)
+ }
+}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IndexedEntry<'_, K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("IndexedEntry")
+ .field("index", &self.index)
+ .field("key", self.key())
+ .field("value", self.get())
+ .finish()
+ }
+}
diff --git a/third_party/rust/indexmap/src/map/core/raw.rs b/third_party/rust/indexmap/src/map/core/raw.rs
index bf1672d52a..451994339a 100644
--- a/third_party/rust/indexmap/src/map/core/raw.rs
+++ b/third_party/rust/indexmap/src/map/core/raw.rs
@@ -2,9 +2,7 @@
//! This module encapsulates the `unsafe` access to `hashbrown::raw::RawTable`,
//! mostly in dealing with its bucket "pointers".
-use super::{equivalent, Bucket, Entry, HashValue, IndexMapCore, VacantEntry};
-use core::fmt;
-use core::mem::replace;
+use super::{equivalent, get_hash, Bucket, HashValue, IndexMapCore};
use hashbrown::raw::RawTable;
type RawBucket = hashbrown::raw::Bucket<usize>;
@@ -22,11 +20,14 @@ pub(super) fn insert_bulk_no_grow<K, V>(indices: &mut RawTable<usize>, entries:
}
}
+#[cfg(feature = "test_debug")]
pub(super) struct DebugIndices<'a>(pub &'a RawTable<usize>);
-impl fmt::Debug for DebugIndices<'_> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+
+#[cfg(feature = "test_debug")]
+impl core::fmt::Debug for DebugIndices<'_> {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
// SAFETY: we're not letting any of the buckets escape this function
- let indices = unsafe { self.0.iter().map(|raw_bucket| raw_bucket.read()) };
+ let indices = unsafe { self.0.iter().map(|raw_bucket| *raw_bucket.as_ref()) };
f.debug_list().entries(indices).finish()
}
}
@@ -38,34 +39,57 @@ impl<K, V> IndexMapCore<K, V> {
unsafe {
let offset = end - start;
for bucket in self.indices.iter() {
- let i = bucket.read();
- if i >= end {
- bucket.write(i - offset);
- } else if i >= start {
+ let i = bucket.as_mut();
+ if *i >= end {
+ *i -= offset;
+ } else if *i >= start {
self.indices.erase(bucket);
}
}
}
}
- pub(crate) fn entry(&mut self, hash: HashValue, key: K) -> Entry<'_, K, V>
+ /// Search for a key in the table and return `Ok(entry_index)` if found.
+ /// Otherwise, insert the key and return `Err(new_index)`.
+ ///
+ /// Note that hashbrown may resize the table to reserve space for insertion,
+ /// even before checking if it's already present, so this is somewhat biased
+ /// towards new items.
+ pub(crate) fn find_or_insert(&mut self, hash: HashValue, key: &K) -> Result<usize, usize>
where
K: Eq,
{
- let eq = equivalent(&key, &self.entries);
+ let hash = hash.get();
+ let eq = equivalent(key, &self.entries);
+ let hasher = get_hash(&self.entries);
+ // SAFETY: We're not mutating between find and read/insert.
+ unsafe {
+ match self.indices.find_or_find_insert_slot(hash, eq, hasher) {
+ Ok(raw_bucket) => Ok(*raw_bucket.as_ref()),
+ Err(slot) => {
+ let index = self.indices.len();
+ self.indices.insert_in_slot(hash, slot, index);
+ Err(index)
+ }
+ }
+ }
+ }
+
+ pub(super) fn raw_entry(
+ &mut self,
+ hash: HashValue,
+ mut is_match: impl FnMut(&K) -> bool,
+ ) -> Result<RawTableEntry<'_, K, V>, &mut Self> {
+ let entries = &*self.entries;
+ let eq = move |&i: &usize| is_match(&entries[i].key);
match self.indices.find(hash.get(), eq) {
// SAFETY: The entry is created with a live raw bucket, at the same time
// we have a &mut reference to the map, so it can not be modified further.
- Some(raw_bucket) => Entry::Occupied(OccupiedEntry {
+ Some(raw_bucket) => Ok(RawTableEntry {
map: self,
raw_bucket,
- key,
- }),
- None => Entry::Vacant(VacantEntry {
- map: self,
- hash,
- key,
}),
+ None => Err(self),
}
}
@@ -74,118 +98,56 @@ impl<K, V> IndexMapCore<K, V> {
// only the item references that are appropriately bound to `&mut self`.
unsafe { self.indices.iter().map(|bucket| bucket.as_mut()) }
}
-
- /// Return the raw bucket for the given index
- fn find_index(&self, index: usize) -> RawBucket {
- // We'll get a "nice" bounds-check from indexing `self.entries`,
- // and then we expect to find it in the table as well.
- let hash = self.entries[index].hash.get();
- self.indices
- .find(hash, move |&i| i == index)
- .expect("index not found")
- }
-
- pub(crate) fn swap_indices(&mut self, a: usize, b: usize) {
- // SAFETY: Can't take two `get_mut` references from one table, so we
- // must use raw buckets to do the swap. This is still safe because we
- // are locally sure they won't dangle, and we write them individually.
- unsafe {
- let raw_bucket_a = self.find_index(a);
- let raw_bucket_b = self.find_index(b);
- raw_bucket_a.write(b);
- raw_bucket_b.write(a);
- }
- self.entries.swap(a, b);
- }
}
-/// A view into an occupied entry in a `IndexMap`.
-/// It is part of the [`Entry`] enum.
-///
-/// [`Entry`]: enum.Entry.html
+/// A view into an occupied raw entry in an `IndexMap`.
// SAFETY: The lifetime of the map reference also constrains the raw bucket,
// which is essentially a raw pointer into the map indices.
-pub struct OccupiedEntry<'a, K, V> {
+pub(super) struct RawTableEntry<'a, K, V> {
map: &'a mut IndexMapCore<K, V>,
raw_bucket: RawBucket,
- key: K,
}
// `hashbrown::raw::Bucket` is only `Send`, not `Sync`.
// SAFETY: `&self` only accesses the bucket to read it.
-unsafe impl<K: Sync, V: Sync> Sync for OccupiedEntry<'_, K, V> {}
-
-// The parent module also adds methods that don't threaten the unsafe encapsulation.
-impl<'a, K, V> OccupiedEntry<'a, K, V> {
- /// Gets a reference to the entry's key in the map.
- ///
- /// Note that this is not the key that was used to find the entry. There may be an observable
- /// difference if the key type has any distinguishing features outside of `Hash` and `Eq`, like
- /// extra fields or the memory address of an allocation.
- pub fn key(&self) -> &K {
- &self.map.entries[self.index()].key
- }
+unsafe impl<K: Sync, V: Sync> Sync for RawTableEntry<'_, K, V> {}
- /// Gets a reference to the entry's value in the map.
- pub fn get(&self) -> &V {
- &self.map.entries[self.index()].value
+impl<'a, K, V> RawTableEntry<'a, K, V> {
+ /// Return the index of the key-value pair
+ #[inline]
+ pub(super) fn index(&self) -> usize {
+ // SAFETY: we have `&mut map` keeping the bucket stable
+ unsafe { *self.raw_bucket.as_ref() }
}
- /// Gets a mutable reference to the entry's value in the map.
- ///
- /// If you need a reference which may outlive the destruction of the
- /// `Entry` value, see `into_mut`.
- pub fn get_mut(&mut self) -> &mut V {
- let index = self.index();
- &mut self.map.entries[index].value
+ #[inline]
+ pub(super) fn bucket(&self) -> &Bucket<K, V> {
+ &self.map.entries[self.index()]
}
- /// Put the new key in the occupied entry's key slot
- pub(crate) fn replace_key(self) -> K {
+ #[inline]
+ pub(super) fn bucket_mut(&mut self) -> &mut Bucket<K, V> {
let index = self.index();
- let old_key = &mut self.map.entries[index].key;
- replace(old_key, self.key)
+ &mut self.map.entries[index]
}
- /// Return the index of the key-value pair
#[inline]
- pub fn index(&self) -> usize {
- // SAFETY: we have &mut map keep keeping the bucket stable
- unsafe { self.raw_bucket.read() }
- }
-
- /// Converts into a mutable reference to the entry's value in the map,
- /// with a lifetime bound to the map itself.
- pub fn into_mut(self) -> &'a mut V {
+ pub(super) fn into_bucket(self) -> &'a mut Bucket<K, V> {
let index = self.index();
- &mut self.map.entries[index].value
+ &mut self.map.entries[index]
}
- /// Remove and return the key, value pair stored in the map for this entry
- ///
- /// Like `Vec::swap_remove`, the pair is removed by swapping it with the
- /// last element of the map and popping it off. **This perturbs
- /// the position of what used to be the last element!**
- ///
- /// Computes in **O(1)** time (average).
- pub fn swap_remove_entry(self) -> (K, V) {
+ /// Remove the index from indices, leaving the actual entries to the caller.
+ pub(super) fn remove_index(self) -> (&'a mut IndexMapCore<K, V>, usize) {
// SAFETY: This is safe because it can only happen once (self is consumed)
// and map.indices have not been modified since entry construction
- let index = unsafe { self.map.indices.remove(self.raw_bucket) };
- self.map.swap_remove_finish(index)
+ let (index, _slot) = unsafe { self.map.indices.remove(self.raw_bucket) };
+ (self.map, index)
}
- /// Remove and return the key, value pair stored in the map for this entry
- ///
- /// Like `Vec::remove`, the pair is removed by shifting all of the
- /// elements that follow it, preserving their relative order.
- /// **This perturbs the index of all of those elements!**
- ///
- /// Computes in **O(n)** time (average).
- pub fn shift_remove_entry(self) -> (K, V) {
- // SAFETY: This is safe because it can only happen once (self is consumed)
- // and map.indices have not been modified since entry construction
- let index = unsafe { self.map.indices.remove(self.raw_bucket) };
- self.map.shift_remove_finish(index)
+ /// Take no action, just return the index and the original map reference.
+ pub(super) fn into_inner(self) -> (&'a mut IndexMapCore<K, V>, usize) {
+ let index = self.index();
+ (self.map, index)
}
}
diff --git a/third_party/rust/indexmap/src/map/core/raw_entry_v1.rs b/third_party/rust/indexmap/src/map/core/raw_entry_v1.rs
new file mode 100644
index 0000000000..87e532d557
--- /dev/null
+++ b/third_party/rust/indexmap/src/map/core/raw_entry_v1.rs
@@ -0,0 +1,652 @@
+//! Opt-in access to the experimental raw entry API.
+//!
+//! This module is designed to mimic the raw entry API of [`HashMap`][std::collections::hash_map],
+//! matching its unstable state as of Rust 1.75. See the tracking issue
+//! [rust#56167](https://github.com/rust-lang/rust/issues/56167) for more details.
+//!
+//! The trait [`RawEntryApiV1`] and the `_v1` suffix on its methods are meant to insulate this for
+//! the future, in case later breaking changes are needed. If the standard library stabilizes its
+//! `hash_raw_entry` feature (or some replacement), matching *inherent* methods will be added to
+//! `IndexMap` without such an opt-in trait.
+
+use super::raw::RawTableEntry;
+use super::IndexMapCore;
+use crate::{Equivalent, HashValue, IndexMap};
+use core::fmt;
+use core::hash::{BuildHasher, Hash, Hasher};
+use core::marker::PhantomData;
+use core::mem;
+
+/// Opt-in access to the experimental raw entry API.
+///
+/// See the [`raw_entry_v1`][self] module documentation for more information.
+pub trait RawEntryApiV1<K, V, S>: private::Sealed {
+ /// Creates a raw immutable entry builder for the [`IndexMap`].
+ ///
+ /// Raw entries provide the lowest level of control for searching and
+ /// manipulating a map. They must be manually initialized with a hash and
+ /// then manually searched.
+ ///
+ /// This is useful for
+ /// * Hash memoization
+ /// * Using a search key that doesn't work with the [`Equivalent`] trait
+ /// * Using custom comparison logic without newtype wrappers
+ ///
+ /// Unless you are in such a situation, higher-level and more foolproof APIs like
+ /// [`get`][IndexMap::get] should be preferred.
+ ///
+ /// Immutable raw entries have very limited use; you might instead want
+ /// [`raw_entry_mut_v1`][Self::raw_entry_mut_v1].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use core::hash::{BuildHasher, Hash};
+ /// use indexmap::map::{IndexMap, RawEntryApiV1};
+ ///
+ /// let mut map = IndexMap::new();
+ /// map.extend([("a", 100), ("b", 200), ("c", 300)]);
+ ///
+ /// fn compute_hash<K: Hash + ?Sized, S: BuildHasher>(hash_builder: &S, key: &K) -> u64 {
+ /// use core::hash::Hasher;
+ /// let mut state = hash_builder.build_hasher();
+ /// key.hash(&mut state);
+ /// state.finish()
+ /// }
+ ///
+ /// for k in ["a", "b", "c", "d", "e", "f"] {
+ /// let hash = compute_hash(map.hasher(), k);
+ /// let i = map.get_index_of(k);
+ /// let v = map.get(k);
+ /// let kv = map.get_key_value(k);
+ /// let ikv = map.get_full(k);
+ ///
+ /// println!("Key: {} and value: {:?}", k, v);
+ ///
+ /// assert_eq!(map.raw_entry_v1().from_key(k), kv);
+ /// assert_eq!(map.raw_entry_v1().from_hash(hash, |q| *q == k), kv);
+ /// assert_eq!(map.raw_entry_v1().from_key_hashed_nocheck(hash, k), kv);
+ /// assert_eq!(map.raw_entry_v1().from_hash_full(hash, |q| *q == k), ikv);
+ /// assert_eq!(map.raw_entry_v1().index_from_hash(hash, |q| *q == k), i);
+ /// }
+ /// ```
+ fn raw_entry_v1(&self) -> RawEntryBuilder<'_, K, V, S>;
+
+ /// Creates a raw entry builder for the [`IndexMap`].
+ ///
+ /// Raw entries provide the lowest level of control for searching and
+ /// manipulating a map. They must be manually initialized with a hash and
+ /// then manually searched. After this, insertions into a vacant entry
+ /// still require an owned key to be provided.
+ ///
+ /// Raw entries are useful for such exotic situations as:
+ ///
+ /// * Hash memoization
+ /// * Deferring the creation of an owned key until it is known to be required
+ /// * Using a search key that doesn't work with the [`Equivalent`] trait
+ /// * Using custom comparison logic without newtype wrappers
+ ///
+ /// Because raw entries provide much more low-level control, it's much easier
+ /// to put the `IndexMap` into an inconsistent state which, while memory-safe,
+ /// will cause the map to produce seemingly random results. Higher-level and more
+ /// foolproof APIs like [`entry`][IndexMap::entry] should be preferred when possible.
+ ///
+ /// Raw entries give mutable access to the keys. This must not be used
+ /// to modify how the key would compare or hash, as the map will not re-evaluate
+ /// where the key should go, meaning the keys may become "lost" if their
+ /// location does not reflect their state. For instance, if you change a key
+ /// so that the map now contains keys which compare equal, search may start
+ /// acting erratically, with two keys randomly masking each other. Implementations
+ /// are free to assume this doesn't happen (within the limits of memory-safety).
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use core::hash::{BuildHasher, Hash};
+ /// use indexmap::map::{IndexMap, RawEntryApiV1};
+ /// use indexmap::map::raw_entry_v1::RawEntryMut;
+ ///
+ /// let mut map = IndexMap::new();
+ /// map.extend([("a", 100), ("b", 200), ("c", 300)]);
+ ///
+ /// fn compute_hash<K: Hash + ?Sized, S: BuildHasher>(hash_builder: &S, key: &K) -> u64 {
+ /// use core::hash::Hasher;
+ /// let mut state = hash_builder.build_hasher();
+ /// key.hash(&mut state);
+ /// state.finish()
+ /// }
+ ///
+ /// // Existing key (insert and update)
+ /// match map.raw_entry_mut_v1().from_key("a") {
+ /// RawEntryMut::Vacant(_) => unreachable!(),
+ /// RawEntryMut::Occupied(mut view) => {
+ /// assert_eq!(view.index(), 0);
+ /// assert_eq!(view.get(), &100);
+ /// let v = view.get_mut();
+ /// let new_v = (*v) * 10;
+ /// *v = new_v;
+ /// assert_eq!(view.insert(1111), 1000);
+ /// }
+ /// }
+ ///
+ /// assert_eq!(map["a"], 1111);
+ /// assert_eq!(map.len(), 3);
+ ///
+ /// // Existing key (take)
+ /// let hash = compute_hash(map.hasher(), "c");
+ /// match map.raw_entry_mut_v1().from_key_hashed_nocheck(hash, "c") {
+ /// RawEntryMut::Vacant(_) => unreachable!(),
+ /// RawEntryMut::Occupied(view) => {
+ /// assert_eq!(view.index(), 2);
+ /// assert_eq!(view.shift_remove_entry(), ("c", 300));
+ /// }
+ /// }
+ /// assert_eq!(map.raw_entry_v1().from_key("c"), None);
+ /// assert_eq!(map.len(), 2);
+ ///
+ /// // Nonexistent key (insert and update)
+ /// let key = "d";
+ /// let hash = compute_hash(map.hasher(), key);
+ /// match map.raw_entry_mut_v1().from_hash(hash, |q| *q == key) {
+ /// RawEntryMut::Occupied(_) => unreachable!(),
+ /// RawEntryMut::Vacant(view) => {
+ /// assert_eq!(view.index(), 2);
+ /// let (k, value) = view.insert("d", 4000);
+ /// assert_eq!((*k, *value), ("d", 4000));
+ /// *value = 40000;
+ /// }
+ /// }
+ /// assert_eq!(map["d"], 40000);
+ /// assert_eq!(map.len(), 3);
+ ///
+ /// match map.raw_entry_mut_v1().from_hash(hash, |q| *q == key) {
+ /// RawEntryMut::Vacant(_) => unreachable!(),
+ /// RawEntryMut::Occupied(view) => {
+ /// assert_eq!(view.index(), 2);
+ /// assert_eq!(view.swap_remove_entry(), ("d", 40000));
+ /// }
+ /// }
+ /// assert_eq!(map.get("d"), None);
+ /// assert_eq!(map.len(), 2);
+ /// ```
+ fn raw_entry_mut_v1(&mut self) -> RawEntryBuilderMut<'_, K, V, S>;
+}
+
+impl<K, V, S> RawEntryApiV1<K, V, S> for IndexMap<K, V, S> {
+ fn raw_entry_v1(&self) -> RawEntryBuilder<'_, K, V, S> {
+ RawEntryBuilder { map: self }
+ }
+
+ fn raw_entry_mut_v1(&mut self) -> RawEntryBuilderMut<'_, K, V, S> {
+ RawEntryBuilderMut { map: self }
+ }
+}
+
+/// A builder for computing where in an [`IndexMap`] a key-value pair would be stored.
+///
+/// This `struct` is created by the [`IndexMap::raw_entry_v1`] method, provided by the
+/// [`RawEntryApiV1`] trait. See its documentation for more.
+pub struct RawEntryBuilder<'a, K, V, S> {
+ map: &'a IndexMap<K, V, S>,
+}
+
+impl<K, V, S> fmt::Debug for RawEntryBuilder<'_, K, V, S> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("RawEntryBuilder").finish_non_exhaustive()
+ }
+}
+
+impl<'a, K, V, S> RawEntryBuilder<'a, K, V, S> {
+ /// Access an entry by key.
+ pub fn from_key<Q>(self, key: &Q) -> Option<(&'a K, &'a V)>
+ where
+ S: BuildHasher,
+ Q: ?Sized + Hash + Equivalent<K>,
+ {
+ self.map.get_key_value(key)
+ }
+
+ /// Access an entry by a key and its hash.
+ pub fn from_key_hashed_nocheck<Q>(self, hash: u64, key: &Q) -> Option<(&'a K, &'a V)>
+ where
+ Q: ?Sized + Equivalent<K>,
+ {
+ let hash = HashValue(hash as usize);
+ let i = self.map.core.get_index_of(hash, key)?;
+ self.map.get_index(i)
+ }
+
+ /// Access an entry by hash.
+ pub fn from_hash<F>(self, hash: u64, is_match: F) -> Option<(&'a K, &'a V)>
+ where
+ F: FnMut(&K) -> bool,
+ {
+ let map = self.map;
+ let i = self.index_from_hash(hash, is_match)?;
+ map.get_index(i)
+ }
+
+ /// Access an entry by hash, including its index.
+ pub fn from_hash_full<F>(self, hash: u64, is_match: F) -> Option<(usize, &'a K, &'a V)>
+ where
+ F: FnMut(&K) -> bool,
+ {
+ let map = self.map;
+ let i = self.index_from_hash(hash, is_match)?;
+ let (key, value) = map.get_index(i)?;
+ Some((i, key, value))
+ }
+
+ /// Access the index of an entry by hash.
+ pub fn index_from_hash<F>(self, hash: u64, mut is_match: F) -> Option<usize>
+ where
+ F: FnMut(&K) -> bool,
+ {
+ let hash = HashValue(hash as usize);
+ let entries = &*self.map.core.entries;
+ let eq = move |&i: &usize| is_match(&entries[i].key);
+ self.map.core.indices.get(hash.get(), eq).copied()
+ }
+}
+
+/// A builder for computing where in an [`IndexMap`] a key-value pair would be stored.
+///
+/// This `struct` is created by the [`IndexMap::raw_entry_mut_v1`] method, provided by the
+/// [`RawEntryApiV1`] trait. See its documentation for more.
+pub struct RawEntryBuilderMut<'a, K, V, S> {
+ map: &'a mut IndexMap<K, V, S>,
+}
+
+impl<K, V, S> fmt::Debug for RawEntryBuilderMut<'_, K, V, S> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("RawEntryBuilderMut").finish_non_exhaustive()
+ }
+}
+
+impl<'a, K, V, S> RawEntryBuilderMut<'a, K, V, S> {
+ /// Access an entry by key.
+ pub fn from_key<Q>(self, key: &Q) -> RawEntryMut<'a, K, V, S>
+ where
+ S: BuildHasher,
+ Q: ?Sized + Hash + Equivalent<K>,
+ {
+ let hash = self.map.hash(key);
+ self.from_key_hashed_nocheck(hash.get(), key)
+ }
+
+ /// Access an entry by a key and its hash.
+ pub fn from_key_hashed_nocheck<Q>(self, hash: u64, key: &Q) -> RawEntryMut<'a, K, V, S>
+ where
+ Q: ?Sized + Equivalent<K>,
+ {
+ self.from_hash(hash, |k| Q::equivalent(key, k))
+ }
+
+ /// Access an entry by hash.
+ pub fn from_hash<F>(self, hash: u64, is_match: F) -> RawEntryMut<'a, K, V, S>
+ where
+ F: FnMut(&K) -> bool,
+ {
+ let hash = HashValue(hash as usize);
+ match self.map.core.raw_entry(hash, is_match) {
+ Ok(raw) => RawEntryMut::Occupied(RawOccupiedEntryMut {
+ raw,
+ hash_builder: PhantomData,
+ }),
+ Err(map) => RawEntryMut::Vacant(RawVacantEntryMut {
+ map,
+ hash_builder: &self.map.hash_builder,
+ }),
+ }
+ }
+}
+
+/// Raw entry for an existing key-value pair or a vacant location to
+/// insert one.
+pub enum RawEntryMut<'a, K, V, S> {
+ /// Existing slot with equivalent key.
+ Occupied(RawOccupiedEntryMut<'a, K, V, S>),
+ /// Vacant slot (no equivalent key in the map).
+ Vacant(RawVacantEntryMut<'a, K, V, S>),
+}
+
+impl<K: fmt::Debug, V: fmt::Debug, S> fmt::Debug for RawEntryMut<'_, K, V, S> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let mut tuple = f.debug_tuple("RawEntryMut");
+ match self {
+ Self::Vacant(v) => tuple.field(v),
+ Self::Occupied(o) => tuple.field(o),
+ };
+ tuple.finish()
+ }
+}
+
+impl<'a, K, V, S> RawEntryMut<'a, K, V, S> {
+ /// Return the index where the key-value pair exists or may be inserted.
+ #[inline]
+ pub fn index(&self) -> usize {
+ match self {
+ Self::Occupied(entry) => entry.index(),
+ Self::Vacant(entry) => entry.index(),
+ }
+ }
+
+ /// Inserts the given default key and value in the entry if it is vacant and returns mutable
+ /// references to them. Otherwise mutable references to an already existent pair are returned.
+ pub fn or_insert(self, default_key: K, default_value: V) -> (&'a mut K, &'a mut V)
+ where
+ K: Hash,
+ S: BuildHasher,
+ {
+ match self {
+ Self::Occupied(entry) => entry.into_key_value_mut(),
+ Self::Vacant(entry) => entry.insert(default_key, default_value),
+ }
+ }
+
+ /// Inserts the result of the `call` function in the entry if it is vacant and returns mutable
+ /// references to them. Otherwise mutable references to an already existent pair are returned.
+ pub fn or_insert_with<F>(self, call: F) -> (&'a mut K, &'a mut V)
+ where
+ F: FnOnce() -> (K, V),
+ K: Hash,
+ S: BuildHasher,
+ {
+ match self {
+ Self::Occupied(entry) => entry.into_key_value_mut(),
+ Self::Vacant(entry) => {
+ let (key, value) = call();
+ entry.insert(key, value)
+ }
+ }
+ }
+
+ /// Modifies the entry if it is occupied.
+ pub fn and_modify<F>(mut self, f: F) -> Self
+ where
+ F: FnOnce(&mut K, &mut V),
+ {
+ if let Self::Occupied(entry) = &mut self {
+ let (k, v) = entry.get_key_value_mut();
+ f(k, v);
+ }
+ self
+ }
+}
+
+/// A raw view into an occupied entry in an [`IndexMap`].
+/// It is part of the [`RawEntryMut`] enum.
+pub struct RawOccupiedEntryMut<'a, K, V, S> {
+ raw: RawTableEntry<'a, K, V>,
+ hash_builder: PhantomData<&'a S>,
+}
+
+impl<K: fmt::Debug, V: fmt::Debug, S> fmt::Debug for RawOccupiedEntryMut<'_, K, V, S> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("RawOccupiedEntryMut")
+ .field("key", self.key())
+ .field("value", self.get())
+ .finish_non_exhaustive()
+ }
+}
+
+impl<'a, K, V, S> RawOccupiedEntryMut<'a, K, V, S> {
+ /// Return the index of the key-value pair
+ #[inline]
+ pub fn index(&self) -> usize {
+ self.raw.index()
+ }
+
+ /// Gets a reference to the entry's key in the map.
+ ///
+ /// Note that this is not the key that was used to find the entry. There may be an observable
+ /// difference if the key type has any distinguishing features outside of `Hash` and `Eq`, like
+ /// extra fields or the memory address of an allocation.
+ pub fn key(&self) -> &K {
+ &self.raw.bucket().key
+ }
+
+ /// Gets a mutable reference to the entry's key in the map.
+ ///
+ /// Note that this is not the key that was used to find the entry. There may be an observable
+ /// difference if the key type has any distinguishing features outside of `Hash` and `Eq`, like
+ /// extra fields or the memory address of an allocation.
+ pub fn key_mut(&mut self) -> &mut K {
+ &mut self.raw.bucket_mut().key
+ }
+
+ /// Converts into a mutable reference to the entry's key in the map,
+ /// with a lifetime bound to the map itself.
+ ///
+ /// Note that this is not the key that was used to find the entry. There may be an observable
+ /// difference if the key type has any distinguishing features outside of `Hash` and `Eq`, like
+ /// extra fields or the memory address of an allocation.
+ pub fn into_key(self) -> &'a mut K {
+ &mut self.raw.into_bucket().key
+ }
+
+ /// Gets a reference to the entry's value in the map.
+ pub fn get(&self) -> &V {
+ &self.raw.bucket().value
+ }
+
+ /// Gets a mutable reference to the entry's value in the map.
+ ///
+ /// If you need a reference which may outlive the destruction of the
+ /// [`RawEntryMut`] value, see [`into_mut`][Self::into_mut].
+ pub fn get_mut(&mut self) -> &mut V {
+ &mut self.raw.bucket_mut().value
+ }
+
+ /// Converts into a mutable reference to the entry's value in the map,
+ /// with a lifetime bound to the map itself.
+ pub fn into_mut(self) -> &'a mut V {
+ &mut self.raw.into_bucket().value
+ }
+
+ /// Gets a reference to the entry's key and value in the map.
+ pub fn get_key_value(&self) -> (&K, &V) {
+ self.raw.bucket().refs()
+ }
+
+ /// Gets a reference to the entry's key and value in the map.
+ pub fn get_key_value_mut(&mut self) -> (&mut K, &mut V) {
+ self.raw.bucket_mut().muts()
+ }
+
+ /// Converts into a mutable reference to the entry's key and value in the map,
+ /// with a lifetime bound to the map itself.
+ pub fn into_key_value_mut(self) -> (&'a mut K, &'a mut V) {
+ self.raw.into_bucket().muts()
+ }
+
+ /// Sets the value of the entry, and returns the entry's old value.
+ pub fn insert(&mut self, value: V) -> V {
+ mem::replace(self.get_mut(), value)
+ }
+
+ /// Sets the key of the entry, and returns the entry's old key.
+ pub fn insert_key(&mut self, key: K) -> K {
+ mem::replace(self.key_mut(), key)
+ }
+
+ /// Remove the key, value pair stored in the map for this entry, and return the value.
+ ///
+ /// **NOTE:** This is equivalent to [`.swap_remove()`][Self::swap_remove], replacing this
+ /// entry's position with the last element, and it is deprecated in favor of calling that
+ /// explicitly. If you need to preserve the relative order of the keys in the map, use
+ /// [`.shift_remove()`][Self::shift_remove] instead.
+ #[deprecated(note = "`remove` disrupts the map order -- \
+ use `swap_remove` or `shift_remove` for explicit behavior.")]
+ pub fn remove(self) -> V {
+ self.swap_remove()
+ }
+
+ /// Remove the key, value pair stored in the map for this entry, and return the value.
+ ///
+ /// Like [`Vec::swap_remove`][crate::Vec::swap_remove], the pair is removed by swapping it with
+ /// the last element of the map and popping it off.
+ /// **This perturbs the position of what used to be the last element!**
+ ///
+ /// Computes in **O(1)** time (average).
+ pub fn swap_remove(self) -> V {
+ self.swap_remove_entry().1
+ }
+
+ /// Remove the key, value pair stored in the map for this entry, and return the value.
+ ///
+ /// Like [`Vec::remove`][crate::Vec::remove], the pair is removed by shifting all of the
+ /// elements that follow it, preserving their relative order.
+ /// **This perturbs the index of all of those elements!**
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn shift_remove(self) -> V {
+ self.shift_remove_entry().1
+ }
+
+ /// Remove and return the key, value pair stored in the map for this entry
+ ///
+ /// **NOTE:** This is equivalent to [`.swap_remove_entry()`][Self::swap_remove_entry],
+ /// replacing this entry's position with the last element, and it is deprecated in favor of
+ /// calling that explicitly. If you need to preserve the relative order of the keys in the map,
+ /// use [`.shift_remove_entry()`][Self::shift_remove_entry] instead.
+ #[deprecated(note = "`remove_entry` disrupts the map order -- \
+ use `swap_remove_entry` or `shift_remove_entry` for explicit behavior.")]
+ pub fn remove_entry(self) -> (K, V) {
+ self.swap_remove_entry()
+ }
+
+ /// Remove and return the key, value pair stored in the map for this entry
+ ///
+ /// Like [`Vec::swap_remove`][crate::Vec::swap_remove], the pair is removed by swapping it with
+ /// the last element of the map and popping it off.
+ /// **This perturbs the position of what used to be the last element!**
+ ///
+ /// Computes in **O(1)** time (average).
+ pub fn swap_remove_entry(self) -> (K, V) {
+ let (map, index) = self.raw.remove_index();
+ map.swap_remove_finish(index)
+ }
+
+ /// Remove and return the key, value pair stored in the map for this entry
+ ///
+ /// Like [`Vec::remove`][crate::Vec::remove], the pair is removed by shifting all of the
+ /// elements that follow it, preserving their relative order.
+ /// **This perturbs the index of all of those elements!**
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn shift_remove_entry(self) -> (K, V) {
+ let (map, index) = self.raw.remove_index();
+ map.shift_remove_finish(index)
+ }
+
+ /// Moves the position of the entry to a new index
+ /// by shifting all other entries in-between.
+ ///
+ /// This is equivalent to [`IndexMap::move_index`]
+ /// coming `from` the current [`.index()`][Self::index].
+ ///
+ /// * If `self.index() < to`, the other pairs will shift down while the targeted pair moves up.
+ /// * If `self.index() > to`, the other pairs will shift up while the targeted pair moves down.
+ ///
+ /// ***Panics*** if `to` is out of bounds.
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn move_index(self, to: usize) {
+ let (map, index) = self.raw.into_inner();
+ map.move_index(index, to);
+ }
+
+ /// Swaps the position of entry with another.
+ ///
+ /// This is equivalent to [`IndexMap::swap_indices`]
+ /// with the current [`.index()`][Self::index] as one of the two being swapped.
+ ///
+ /// ***Panics*** if the `other` index is out of bounds.
+ ///
+ /// Computes in **O(1)** time (average).
+ pub fn swap_indices(self, other: usize) {
+ let (map, index) = self.raw.into_inner();
+ map.swap_indices(index, other)
+ }
+}
+
+/// A view into a vacant raw entry in an [`IndexMap`].
+/// It is part of the [`RawEntryMut`] enum.
+pub struct RawVacantEntryMut<'a, K, V, S> {
+ map: &'a mut IndexMapCore<K, V>,
+ hash_builder: &'a S,
+}
+
+impl<K, V, S> fmt::Debug for RawVacantEntryMut<'_, K, V, S> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("RawVacantEntryMut").finish_non_exhaustive()
+ }
+}
+
+impl<'a, K, V, S> RawVacantEntryMut<'a, K, V, S> {
+ /// Return the index where a key-value pair may be inserted.
+ pub fn index(&self) -> usize {
+ self.map.indices.len()
+ }
+
+ /// Inserts the given key and value into the map,
+ /// and returns mutable references to them.
+ pub fn insert(self, key: K, value: V) -> (&'a mut K, &'a mut V)
+ where
+ K: Hash,
+ S: BuildHasher,
+ {
+ let mut h = self.hash_builder.build_hasher();
+ key.hash(&mut h);
+ self.insert_hashed_nocheck(h.finish(), key, value)
+ }
+
+ /// Inserts the given key and value into the map with the provided hash,
+ /// and returns mutable references to them.
+ pub fn insert_hashed_nocheck(self, hash: u64, key: K, value: V) -> (&'a mut K, &'a mut V) {
+ let hash = HashValue(hash as usize);
+ let i = self.map.insert_unique(hash, key, value);
+ self.map.entries[i].muts()
+ }
+
+ /// Inserts the given key and value into the map at the given index,
+ /// shifting others to the right, and returns mutable references to them.
+ ///
+ /// ***Panics*** if `index` is out of bounds.
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn shift_insert(self, index: usize, key: K, value: V) -> (&'a mut K, &'a mut V)
+ where
+ K: Hash,
+ S: BuildHasher,
+ {
+ let mut h = self.hash_builder.build_hasher();
+ key.hash(&mut h);
+ self.shift_insert_hashed_nocheck(index, h.finish(), key, value)
+ }
+
+ /// Inserts the given key and value into the map with the provided hash
+ /// at the given index, and returns mutable references to them.
+ ///
+ /// ***Panics*** if `index` is out of bounds.
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn shift_insert_hashed_nocheck(
+ self,
+ index: usize,
+ hash: u64,
+ key: K,
+ value: V,
+ ) -> (&'a mut K, &'a mut V) {
+ let hash = HashValue(hash as usize);
+ self.map.shift_insert_unique(index, hash, key, value);
+ self.map.entries[index].muts()
+ }
+}
+
+mod private {
+ pub trait Sealed {}
+
+ impl<K, V, S> Sealed for super::IndexMap<K, V, S> {}
+}
diff --git a/third_party/rust/indexmap/src/map/iter.rs b/third_party/rust/indexmap/src/map/iter.rs
new file mode 100644
index 0000000000..1ec3703cfb
--- /dev/null
+++ b/third_party/rust/indexmap/src/map/iter.rs
@@ -0,0 +1,713 @@
+use super::core::IndexMapCore;
+use super::{Bucket, Entries, IndexMap, Slice};
+
+use alloc::vec::{self, Vec};
+use core::fmt;
+use core::hash::{BuildHasher, Hash};
+use core::iter::FusedIterator;
+use core::ops::{Index, RangeBounds};
+use core::slice;
+
+impl<'a, K, V, S> IntoIterator for &'a IndexMap<K, V, S> {
+ type Item = (&'a K, &'a V);
+ type IntoIter = Iter<'a, K, V>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.iter()
+ }
+}
+
+impl<'a, K, V, S> IntoIterator for &'a mut IndexMap<K, V, S> {
+ type Item = (&'a K, &'a mut V);
+ type IntoIter = IterMut<'a, K, V>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.iter_mut()
+ }
+}
+
+impl<K, V, S> IntoIterator for IndexMap<K, V, S> {
+ type Item = (K, V);
+ type IntoIter = IntoIter<K, V>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ IntoIter::new(self.into_entries())
+ }
+}
+
+/// An iterator over the entries of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::iter`] method.
+/// See its documentation for more.
+pub struct Iter<'a, K, V> {
+ iter: slice::Iter<'a, Bucket<K, V>>,
+}
+
+impl<'a, K, V> Iter<'a, K, V> {
+ pub(super) fn new(entries: &'a [Bucket<K, V>]) -> Self {
+ Self {
+ iter: entries.iter(),
+ }
+ }
+
+ /// Returns a slice of the remaining entries in the iterator.
+ pub fn as_slice(&self) -> &'a Slice<K, V> {
+ Slice::from_slice(self.iter.as_slice())
+ }
+}
+
+impl<'a, K, V> Iterator for Iter<'a, K, V> {
+ type Item = (&'a K, &'a V);
+
+ iterator_methods!(Bucket::refs);
+}
+
+impl<K, V> DoubleEndedIterator for Iter<'_, K, V> {
+ double_ended_iterator_methods!(Bucket::refs);
+}
+
+impl<K, V> ExactSizeIterator for Iter<'_, K, V> {
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+}
+
+impl<K, V> FusedIterator for Iter<'_, K, V> {}
+
+// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
+impl<K, V> Clone for Iter<'_, K, V> {
+ fn clone(&self) -> Self {
+ Iter {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Iter<'_, K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+impl<K, V> Default for Iter<'_, K, V> {
+ fn default() -> Self {
+ Self { iter: [].iter() }
+ }
+}
+
+/// A mutable iterator over the entries of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::iter_mut`] method.
+/// See its documentation for more.
+pub struct IterMut<'a, K, V> {
+ iter: slice::IterMut<'a, Bucket<K, V>>,
+}
+
+impl<'a, K, V> IterMut<'a, K, V> {
+ pub(super) fn new(entries: &'a mut [Bucket<K, V>]) -> Self {
+ Self {
+ iter: entries.iter_mut(),
+ }
+ }
+
+ /// Returns a slice of the remaining entries in the iterator.
+ pub fn as_slice(&self) -> &Slice<K, V> {
+ Slice::from_slice(self.iter.as_slice())
+ }
+
+ /// Returns a mutable slice of the remaining entries in the iterator.
+ ///
+ /// To avoid creating `&mut` references that alias, this is forced to consume the iterator.
+ pub fn into_slice(self) -> &'a mut Slice<K, V> {
+ Slice::from_mut_slice(self.iter.into_slice())
+ }
+}
+
+impl<'a, K, V> Iterator for IterMut<'a, K, V> {
+ type Item = (&'a K, &'a mut V);
+
+ iterator_methods!(Bucket::ref_mut);
+}
+
+impl<K, V> DoubleEndedIterator for IterMut<'_, K, V> {
+ double_ended_iterator_methods!(Bucket::ref_mut);
+}
+
+impl<K, V> ExactSizeIterator for IterMut<'_, K, V> {
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+}
+
+impl<K, V> FusedIterator for IterMut<'_, K, V> {}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IterMut<'_, K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let iter = self.iter.as_slice().iter().map(Bucket::refs);
+ f.debug_list().entries(iter).finish()
+ }
+}
+
+impl<K, V> Default for IterMut<'_, K, V> {
+ fn default() -> Self {
+ Self {
+ iter: [].iter_mut(),
+ }
+ }
+}
+
+/// An owning iterator over the entries of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::into_iter`] method
+/// (provided by the [`IntoIterator`] trait). See its documentation for more.
+pub struct IntoIter<K, V> {
+ iter: vec::IntoIter<Bucket<K, V>>,
+}
+
+impl<K, V> IntoIter<K, V> {
+ pub(super) fn new(entries: Vec<Bucket<K, V>>) -> Self {
+ Self {
+ iter: entries.into_iter(),
+ }
+ }
+
+ /// Returns a slice of the remaining entries in the iterator.
+ pub fn as_slice(&self) -> &Slice<K, V> {
+ Slice::from_slice(self.iter.as_slice())
+ }
+
+ /// Returns a mutable slice of the remaining entries in the iterator.
+ pub fn as_mut_slice(&mut self) -> &mut Slice<K, V> {
+ Slice::from_mut_slice(self.iter.as_mut_slice())
+ }
+}
+
+impl<K, V> Iterator for IntoIter<K, V> {
+ type Item = (K, V);
+
+ iterator_methods!(Bucket::key_value);
+}
+
+impl<K, V> DoubleEndedIterator for IntoIter<K, V> {
+ double_ended_iterator_methods!(Bucket::key_value);
+}
+
+impl<K, V> ExactSizeIterator for IntoIter<K, V> {
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+}
+
+impl<K, V> FusedIterator for IntoIter<K, V> {}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IntoIter<K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let iter = self.iter.as_slice().iter().map(Bucket::refs);
+ f.debug_list().entries(iter).finish()
+ }
+}
+
+impl<K, V> Default for IntoIter<K, V> {
+ fn default() -> Self {
+ Self {
+ iter: Vec::new().into_iter(),
+ }
+ }
+}
+
+/// A draining iterator over the entries of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::drain`] method.
+/// See its documentation for more.
+pub struct Drain<'a, K, V> {
+ iter: vec::Drain<'a, Bucket<K, V>>,
+}
+
+impl<'a, K, V> Drain<'a, K, V> {
+ pub(super) fn new(iter: vec::Drain<'a, Bucket<K, V>>) -> Self {
+ Self { iter }
+ }
+
+ /// Returns a slice of the remaining entries in the iterator.
+ pub fn as_slice(&self) -> &Slice<K, V> {
+ Slice::from_slice(self.iter.as_slice())
+ }
+}
+
+impl<K, V> Iterator for Drain<'_, K, V> {
+ type Item = (K, V);
+
+ iterator_methods!(Bucket::key_value);
+}
+
+impl<K, V> DoubleEndedIterator for Drain<'_, K, V> {
+ double_ended_iterator_methods!(Bucket::key_value);
+}
+
+impl<K, V> ExactSizeIterator for Drain<'_, K, V> {
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+}
+
+impl<K, V> FusedIterator for Drain<'_, K, V> {}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Drain<'_, K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let iter = self.iter.as_slice().iter().map(Bucket::refs);
+ f.debug_list().entries(iter).finish()
+ }
+}
+
+/// An iterator over the keys of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::keys`] method.
+/// See its documentation for more.
+pub struct Keys<'a, K, V> {
+ iter: slice::Iter<'a, Bucket<K, V>>,
+}
+
+impl<'a, K, V> Keys<'a, K, V> {
+ pub(super) fn new(entries: &'a [Bucket<K, V>]) -> Self {
+ Self {
+ iter: entries.iter(),
+ }
+ }
+}
+
+impl<'a, K, V> Iterator for Keys<'a, K, V> {
+ type Item = &'a K;
+
+ iterator_methods!(Bucket::key_ref);
+}
+
+impl<K, V> DoubleEndedIterator for Keys<'_, K, V> {
+ double_ended_iterator_methods!(Bucket::key_ref);
+}
+
+impl<K, V> ExactSizeIterator for Keys<'_, K, V> {
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+}
+
+impl<K, V> FusedIterator for Keys<'_, K, V> {}
+
+// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
+impl<K, V> Clone for Keys<'_, K, V> {
+ fn clone(&self) -> Self {
+ Keys {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<K: fmt::Debug, V> fmt::Debug for Keys<'_, K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+impl<K, V> Default for Keys<'_, K, V> {
+ fn default() -> Self {
+ Self { iter: [].iter() }
+ }
+}
+
+/// Access [`IndexMap`] keys at indexed positions.
+///
+/// While [`Index<usize> for IndexMap`][values] accesses a map's values,
+/// indexing through [`IndexMap::keys`] offers an alternative to access a map's
+/// keys instead.
+///
+/// [values]: IndexMap#impl-Index<usize>-for-IndexMap<K,+V,+S>
+///
+/// Since `Keys` is also an iterator, consuming items from the iterator will
+/// offset the effective indexes. Similarly, if `Keys` is obtained from
+/// [`Slice::keys`], indexes will be interpreted relative to the position of
+/// that slice.
+///
+/// # Examples
+///
+/// ```
+/// use indexmap::IndexMap;
+///
+/// let mut map = IndexMap::new();
+/// for word in "Lorem ipsum dolor sit amet".split_whitespace() {
+/// map.insert(word.to_lowercase(), word.to_uppercase());
+/// }
+///
+/// assert_eq!(map[0], "LOREM");
+/// assert_eq!(map.keys()[0], "lorem");
+/// assert_eq!(map[1], "IPSUM");
+/// assert_eq!(map.keys()[1], "ipsum");
+///
+/// map.reverse();
+/// assert_eq!(map.keys()[0], "amet");
+/// assert_eq!(map.keys()[1], "sit");
+///
+/// map.sort_keys();
+/// assert_eq!(map.keys()[0], "amet");
+/// assert_eq!(map.keys()[1], "dolor");
+///
+/// // Advancing the iterator will offset the indexing
+/// let mut keys = map.keys();
+/// assert_eq!(keys[0], "amet");
+/// assert_eq!(keys.next().map(|s| &**s), Some("amet"));
+/// assert_eq!(keys[0], "dolor");
+/// assert_eq!(keys[1], "ipsum");
+///
+/// // Slices may have an offset as well
+/// let slice = &map[2..];
+/// assert_eq!(slice[0], "IPSUM");
+/// assert_eq!(slice.keys()[0], "ipsum");
+/// ```
+///
+/// ```should_panic
+/// use indexmap::IndexMap;
+///
+/// let mut map = IndexMap::new();
+/// map.insert("foo", 1);
+/// println!("{:?}", map.keys()[10]); // panics!
+/// ```
+impl<'a, K, V> Index<usize> for Keys<'a, K, V> {
+ type Output = K;
+
+ /// Returns a reference to the key at the supplied `index`.
+ ///
+ /// ***Panics*** if `index` is out of bounds.
+ fn index(&self, index: usize) -> &K {
+ &self.iter.as_slice()[index].key
+ }
+}
+
+/// An owning iterator over the keys of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::into_keys`] method.
+/// See its documentation for more.
+pub struct IntoKeys<K, V> {
+ iter: vec::IntoIter<Bucket<K, V>>,
+}
+
+impl<K, V> IntoKeys<K, V> {
+ pub(super) fn new(entries: Vec<Bucket<K, V>>) -> Self {
+ Self {
+ iter: entries.into_iter(),
+ }
+ }
+}
+
+impl<K, V> Iterator for IntoKeys<K, V> {
+ type Item = K;
+
+ iterator_methods!(Bucket::key);
+}
+
+impl<K, V> DoubleEndedIterator for IntoKeys<K, V> {
+ double_ended_iterator_methods!(Bucket::key);
+}
+
+impl<K, V> ExactSizeIterator for IntoKeys<K, V> {
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+}
+
+impl<K, V> FusedIterator for IntoKeys<K, V> {}
+
+impl<K: fmt::Debug, V> fmt::Debug for IntoKeys<K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let iter = self.iter.as_slice().iter().map(Bucket::key_ref);
+ f.debug_list().entries(iter).finish()
+ }
+}
+
+impl<K, V> Default for IntoKeys<K, V> {
+ fn default() -> Self {
+ Self {
+ iter: Vec::new().into_iter(),
+ }
+ }
+}
+
+/// An iterator over the values of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::values`] method.
+/// See its documentation for more.
+pub struct Values<'a, K, V> {
+ iter: slice::Iter<'a, Bucket<K, V>>,
+}
+
+impl<'a, K, V> Values<'a, K, V> {
+ pub(super) fn new(entries: &'a [Bucket<K, V>]) -> Self {
+ Self {
+ iter: entries.iter(),
+ }
+ }
+}
+
+impl<'a, K, V> Iterator for Values<'a, K, V> {
+ type Item = &'a V;
+
+ iterator_methods!(Bucket::value_ref);
+}
+
+impl<K, V> DoubleEndedIterator for Values<'_, K, V> {
+ double_ended_iterator_methods!(Bucket::value_ref);
+}
+
+impl<K, V> ExactSizeIterator for Values<'_, K, V> {
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+}
+
+impl<K, V> FusedIterator for Values<'_, K, V> {}
+
+// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
+impl<K, V> Clone for Values<'_, K, V> {
+ fn clone(&self) -> Self {
+ Values {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<K, V: fmt::Debug> fmt::Debug for Values<'_, K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+impl<K, V> Default for Values<'_, K, V> {
+ fn default() -> Self {
+ Self { iter: [].iter() }
+ }
+}
+
+/// A mutable iterator over the values of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::values_mut`] method.
+/// See its documentation for more.
+pub struct ValuesMut<'a, K, V> {
+ iter: slice::IterMut<'a, Bucket<K, V>>,
+}
+
+impl<'a, K, V> ValuesMut<'a, K, V> {
+ pub(super) fn new(entries: &'a mut [Bucket<K, V>]) -> Self {
+ Self {
+ iter: entries.iter_mut(),
+ }
+ }
+}
+
+impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {
+ type Item = &'a mut V;
+
+ iterator_methods!(Bucket::value_mut);
+}
+
+impl<K, V> DoubleEndedIterator for ValuesMut<'_, K, V> {
+ double_ended_iterator_methods!(Bucket::value_mut);
+}
+
+impl<K, V> ExactSizeIterator for ValuesMut<'_, K, V> {
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+}
+
+impl<K, V> FusedIterator for ValuesMut<'_, K, V> {}
+
+impl<K, V: fmt::Debug> fmt::Debug for ValuesMut<'_, K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let iter = self.iter.as_slice().iter().map(Bucket::value_ref);
+ f.debug_list().entries(iter).finish()
+ }
+}
+
+impl<K, V> Default for ValuesMut<'_, K, V> {
+ fn default() -> Self {
+ Self {
+ iter: [].iter_mut(),
+ }
+ }
+}
+
+/// An owning iterator over the values of an [`IndexMap`].
+///
+/// This `struct` is created by the [`IndexMap::into_values`] method.
+/// See its documentation for more.
+pub struct IntoValues<K, V> {
+ iter: vec::IntoIter<Bucket<K, V>>,
+}
+
+impl<K, V> IntoValues<K, V> {
+ pub(super) fn new(entries: Vec<Bucket<K, V>>) -> Self {
+ Self {
+ iter: entries.into_iter(),
+ }
+ }
+}
+
+impl<K, V> Iterator for IntoValues<K, V> {
+ type Item = V;
+
+ iterator_methods!(Bucket::value);
+}
+
+impl<K, V> DoubleEndedIterator for IntoValues<K, V> {
+ double_ended_iterator_methods!(Bucket::value);
+}
+
+impl<K, V> ExactSizeIterator for IntoValues<K, V> {
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+}
+
+impl<K, V> FusedIterator for IntoValues<K, V> {}
+
+impl<K, V: fmt::Debug> fmt::Debug for IntoValues<K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let iter = self.iter.as_slice().iter().map(Bucket::value_ref);
+ f.debug_list().entries(iter).finish()
+ }
+}
+
+impl<K, V> Default for IntoValues<K, V> {
+ fn default() -> Self {
+ Self {
+ iter: Vec::new().into_iter(),
+ }
+ }
+}
+
+/// A splicing iterator for `IndexMap`.
+///
+/// This `struct` is created by [`IndexMap::splice()`].
+/// See its documentation for more.
+pub struct Splice<'a, I, K, V, S>
+where
+ I: Iterator<Item = (K, V)>,
+ K: Hash + Eq,
+ S: BuildHasher,
+{
+ map: &'a mut IndexMap<K, V, S>,
+ tail: IndexMapCore<K, V>,
+ drain: vec::IntoIter<Bucket<K, V>>,
+ replace_with: I,
+}
+
+impl<'a, I, K, V, S> Splice<'a, I, K, V, S>
+where
+ I: Iterator<Item = (K, V)>,
+ K: Hash + Eq,
+ S: BuildHasher,
+{
+ pub(super) fn new<R>(map: &'a mut IndexMap<K, V, S>, range: R, replace_with: I) -> Self
+ where
+ R: RangeBounds<usize>,
+ {
+ let (tail, drain) = map.core.split_splice(range);
+ Self {
+ map,
+ tail,
+ drain,
+ replace_with,
+ }
+ }
+}
+
+impl<I, K, V, S> Drop for Splice<'_, I, K, V, S>
+where
+ I: Iterator<Item = (K, V)>,
+ K: Hash + Eq,
+ S: BuildHasher,
+{
+ fn drop(&mut self) {
+ // Finish draining unconsumed items. We don't strictly *have* to do this
+ // manually, since we already split it into separate memory, but it will
+ // match the drop order of `vec::Splice` items this way.
+ let _ = self.drain.nth(usize::MAX);
+
+ // Now insert all the new items. If a key matches an existing entry, it
+ // keeps the original position and only replaces the value, like `insert`.
+ while let Some((key, value)) = self.replace_with.next() {
+ // Since the tail is disjoint, we can try to update it first,
+ // or else insert (update or append) the primary map.
+ let hash = self.map.hash(&key);
+ if let Some(i) = self.tail.get_index_of(hash, &key) {
+ self.tail.as_entries_mut()[i].value = value;
+ } else {
+ self.map.core.insert_full(hash, key, value);
+ }
+ }
+
+ // Finally, re-append the tail
+ self.map.core.append_unchecked(&mut self.tail);
+ }
+}
+
+impl<I, K, V, S> Iterator for Splice<'_, I, K, V, S>
+where
+ I: Iterator<Item = (K, V)>,
+ K: Hash + Eq,
+ S: BuildHasher,
+{
+ type Item = (K, V);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.drain.next().map(Bucket::key_value)
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.drain.size_hint()
+ }
+}
+
+impl<I, K, V, S> DoubleEndedIterator for Splice<'_, I, K, V, S>
+where
+ I: Iterator<Item = (K, V)>,
+ K: Hash + Eq,
+ S: BuildHasher,
+{
+ fn next_back(&mut self) -> Option<Self::Item> {
+ self.drain.next_back().map(Bucket::key_value)
+ }
+}
+
+impl<I, K, V, S> ExactSizeIterator for Splice<'_, I, K, V, S>
+where
+ I: Iterator<Item = (K, V)>,
+ K: Hash + Eq,
+ S: BuildHasher,
+{
+ fn len(&self) -> usize {
+ self.drain.len()
+ }
+}
+
+impl<I, K, V, S> FusedIterator for Splice<'_, I, K, V, S>
+where
+ I: Iterator<Item = (K, V)>,
+ K: Hash + Eq,
+ S: BuildHasher,
+{
+}
+
+impl<'a, I, K, V, S> fmt::Debug for Splice<'a, I, K, V, S>
+where
+ I: fmt::Debug + Iterator<Item = (K, V)>,
+ K: fmt::Debug + Hash + Eq,
+ V: fmt::Debug,
+ S: BuildHasher,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ // Follow `vec::Splice` in only printing the drain and replacement
+ f.debug_struct("Splice")
+ .field("drain", &self.drain)
+ .field("replace_with", &self.replace_with)
+ .finish()
+ }
+}
diff --git a/third_party/rust/indexmap/src/map/mutable.rs b/third_party/rust/indexmap/src/map/mutable.rs
new file mode 100644
index 0000000000..7df325948f
--- /dev/null
+++ b/third_party/rust/indexmap/src/map/mutable.rs
@@ -0,0 +1,87 @@
+use core::hash::{BuildHasher, Hash};
+
+use super::{Bucket, Entries, Equivalent, IndexMap};
+
+/// Opt-in mutable access to [`IndexMap`] keys.
+///
+/// These methods expose `&mut K`, mutable references to the key as it is stored
+/// in the map.
+/// You are allowed to modify the keys in the map **if the modification
+/// does not change the key’s hash and equality**.
+///
+/// If keys are modified erroneously, you can no longer look them up.
+/// This is sound (memory safe) but a logical error hazard (just like
+/// implementing `PartialEq`, `Eq`, or `Hash` incorrectly would be).
+///
+/// `use` this trait to enable its methods for `IndexMap`.
+///
+/// This trait is sealed and cannot be implemented for types outside this crate.
+pub trait MutableKeys: private::Sealed {
+ type Key;
+ type Value;
+
+ /// Return item index, mutable reference to key and value
+ ///
+ /// Computes in **O(1)** time (average).
+ fn get_full_mut2<Q>(&mut self, key: &Q) -> Option<(usize, &mut Self::Key, &mut Self::Value)>
+ where
+ Q: ?Sized + Hash + Equivalent<Self::Key>;
+
+ /// Return mutable reference to key and value at an index.
+ ///
+ /// Valid indices are *0 <= index < self.len()*
+ ///
+ /// Computes in **O(1)** time.
+ fn get_index_mut2(&mut self, index: usize) -> Option<(&mut Self::Key, &mut Self::Value)>;
+
+ /// Scan through each key-value pair in the map and keep those where the
+ /// closure `keep` returns `true`.
+ ///
+ /// The elements are visited in order, and remaining elements keep their
+ /// order.
+ ///
+ /// Computes in **O(n)** time (average).
+ fn retain2<F>(&mut self, keep: F)
+ where
+ F: FnMut(&mut Self::Key, &mut Self::Value) -> bool;
+}
+
+/// Opt-in mutable access to [`IndexMap`] keys.
+///
+/// See [`MutableKeys`] for more information.
+impl<K, V, S> MutableKeys for IndexMap<K, V, S>
+where
+ S: BuildHasher,
+{
+ type Key = K;
+ type Value = V;
+
+ fn get_full_mut2<Q>(&mut self, key: &Q) -> Option<(usize, &mut K, &mut V)>
+ where
+ Q: ?Sized + Hash + Equivalent<K>,
+ {
+ if let Some(i) = self.get_index_of(key) {
+ let entry = &mut self.as_entries_mut()[i];
+ Some((i, &mut entry.key, &mut entry.value))
+ } else {
+ None
+ }
+ }
+
+ fn get_index_mut2(&mut self, index: usize) -> Option<(&mut K, &mut V)> {
+ self.as_entries_mut().get_mut(index).map(Bucket::muts)
+ }
+
+ fn retain2<F>(&mut self, keep: F)
+ where
+ F: FnMut(&mut K, &mut V) -> bool,
+ {
+ self.core.retain_in_order(keep);
+ }
+}
+
+mod private {
+ pub trait Sealed {}
+
+ impl<K, V, S> Sealed for super::IndexMap<K, V, S> {}
+}
diff --git a/third_party/rust/indexmap/src/serde_seq.rs b/third_party/rust/indexmap/src/map/serde_seq.rs
index d326a02e37..602ae7dc74 100644
--- a/third_party/rust/indexmap/src/serde_seq.rs
+++ b/third_party/rust/indexmap/src/map/serde_seq.rs
@@ -1,4 +1,4 @@
-//! Functions to serialize and deserialize an `IndexMap` as an ordered sequence.
+//! 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
@@ -12,13 +12,11 @@
//! # use serde_derive::{Deserialize, Serialize};
//! #[derive(Deserialize, Serialize)]
//! struct Data {
-//! #[serde(with = "indexmap::serde_seq")]
+//! #[serde(with = "indexmap::map::serde_seq")]
//! map: IndexMap<i32, u64>,
//! // ...
//! }
//! ```
-//!
-//! Requires crate feature `"serde"` or `"serde-1"`
use serde::de::{Deserialize, Deserializer, SeqAccess, Visitor};
use serde::ser::{Serialize, Serializer};
@@ -27,29 +25,59 @@ use core::fmt::{self, Formatter};
use core::hash::{BuildHasher, Hash};
use core::marker::PhantomData;
+use crate::map::Slice as MapSlice;
+use crate::serde::cautious_capacity;
+use crate::set::Slice as SetSlice;
use crate::IndexMap;
-/// Serializes an `IndexMap` as an ordered sequence.
+/// Serializes a [`map::Slice`][MapSlice] as an ordered sequence.
///
-/// This function may be used in a field attribute for deriving `Serialize`:
+/// This behaves like [`crate::map::serde_seq`] for `IndexMap`, serializing a sequence
+/// of `(key, value)` pairs, rather than as a map that might not preserve order.
+impl<K, V> Serialize for MapSlice<K, V>
+where
+ K: Serialize,
+ V: Serialize,
+{
+ fn serialize<T>(&self, serializer: T) -> Result<T::Ok, T::Error>
+ where
+ T: Serializer,
+ {
+ serializer.collect_seq(self)
+ }
+}
+
+/// Serializes a [`set::Slice`][SetSlice] as an ordered sequence.
+impl<T> Serialize for SetSlice<T>
+where
+ T: Serialize,
+{
+ fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error>
+ where
+ Se: Serializer,
+ {
+ serializer.collect_seq(self)
+ }
+}
+
+/// Serializes an [`IndexMap`] as an ordered sequence.
+///
+/// This function may be used in a field attribute for deriving [`Serialize`]:
///
/// ```
/// # use indexmap::IndexMap;
/// # use serde_derive::Serialize;
/// #[derive(Serialize)]
/// struct Data {
-/// #[serde(serialize_with = "indexmap::serde_seq::serialize")]
+/// #[serde(serialize_with = "indexmap::map::serde_seq::serialize")]
/// map: IndexMap<i32, u64>,
/// // ...
/// }
/// ```
-///
-/// Requires crate feature `"serde"` or `"serde-1"`
pub fn serialize<K, V, S, T>(map: &IndexMap<K, V, S>, serializer: T) -> Result<T::Ok, T::Error>
where
- K: Serialize + Hash + Eq,
+ K: Serialize,
V: Serialize,
- S: BuildHasher,
T: Serializer,
{
serializer.collect_seq(map)
@@ -74,7 +102,7 @@ where
where
A: SeqAccess<'de>,
{
- let capacity = seq.size_hint().unwrap_or(0);
+ let capacity = cautious_capacity::<K, V>(seq.size_hint());
let mut map = IndexMap::with_capacity_and_hasher(capacity, S::default());
while let Some((key, value)) = seq.next_element()? {
@@ -85,22 +113,20 @@ where
}
}
-/// Deserializes an `IndexMap` from an ordered sequence.
+/// Deserializes an [`IndexMap`] from an ordered sequence.
///
-/// This function may be used in a field attribute for deriving `Deserialize`:
+/// This function may be used in a field attribute for deriving [`Deserialize`]:
///
/// ```
/// # use indexmap::IndexMap;
/// # use serde_derive::Deserialize;
/// #[derive(Deserialize)]
/// struct Data {
-/// #[serde(deserialize_with = "indexmap::serde_seq::deserialize")]
+/// #[serde(deserialize_with = "indexmap::map::serde_seq::deserialize")]
/// map: IndexMap<i32, u64>,
/// // ...
/// }
/// ```
-///
-/// Requires crate feature `"serde"` or `"serde-1"`
pub fn deserialize<'de, D, K, V, S>(deserializer: D) -> Result<IndexMap<K, V, S>, D::Error>
where
D: Deserializer<'de>,
diff --git a/third_party/rust/indexmap/src/map/slice.rs b/third_party/rust/indexmap/src/map/slice.rs
new file mode 100644
index 0000000000..b2f00f4807
--- /dev/null
+++ b/third_party/rust/indexmap/src/map/slice.rs
@@ -0,0 +1,539 @@
+use super::{
+ Bucket, Entries, IndexMap, IntoIter, IntoKeys, IntoValues, Iter, IterMut, Keys, Values,
+ ValuesMut,
+};
+use crate::util::try_simplify_range;
+
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use core::cmp::Ordering;
+use core::fmt;
+use core::hash::{Hash, Hasher};
+use core::ops::{self, Bound, Index, IndexMut, RangeBounds};
+
+/// A dynamically-sized slice of key-value pairs in an [`IndexMap`].
+///
+/// This supports indexed operations much like a `[(K, V)]` slice,
+/// but not any hashed operations on the map keys.
+///
+/// Unlike `IndexMap`, `Slice` does consider the order for [`PartialEq`]
+/// and [`Eq`], and it also implements [`PartialOrd`], [`Ord`], and [`Hash`].
+#[repr(transparent)]
+pub struct Slice<K, V> {
+ pub(crate) entries: [Bucket<K, V>],
+}
+
+// SAFETY: `Slice<K, V>` is a transparent wrapper around `[Bucket<K, V>]`,
+// and reference lifetimes are bound together in function signatures.
+#[allow(unsafe_code)]
+impl<K, V> Slice<K, V> {
+ pub(super) const fn from_slice(entries: &[Bucket<K, V>]) -> &Self {
+ unsafe { &*(entries as *const [Bucket<K, V>] as *const Self) }
+ }
+
+ pub(super) fn from_mut_slice(entries: &mut [Bucket<K, V>]) -> &mut Self {
+ unsafe { &mut *(entries as *mut [Bucket<K, V>] as *mut Self) }
+ }
+
+ pub(super) fn from_boxed(entries: Box<[Bucket<K, V>]>) -> Box<Self> {
+ unsafe { Box::from_raw(Box::into_raw(entries) as *mut Self) }
+ }
+
+ fn into_boxed(self: Box<Self>) -> Box<[Bucket<K, V>]> {
+ unsafe { Box::from_raw(Box::into_raw(self) as *mut [Bucket<K, V>]) }
+ }
+}
+
+impl<K, V> Slice<K, V> {
+ pub(crate) fn into_entries(self: Box<Self>) -> Vec<Bucket<K, V>> {
+ self.into_boxed().into_vec()
+ }
+
+ /// Returns an empty slice.
+ pub const fn new<'a>() -> &'a Self {
+ Self::from_slice(&[])
+ }
+
+ /// Returns an empty mutable slice.
+ pub fn new_mut<'a>() -> &'a mut Self {
+ Self::from_mut_slice(&mut [])
+ }
+
+ /// Return the number of key-value pairs in the map slice.
+ #[inline]
+ pub const fn len(&self) -> usize {
+ self.entries.len()
+ }
+
+ /// Returns true if the map slice contains no elements.
+ #[inline]
+ pub const fn is_empty(&self) -> bool {
+ self.entries.is_empty()
+ }
+
+ /// Get a key-value pair by index.
+ ///
+ /// Valid indices are *0 <= index < self.len()*
+ pub fn get_index(&self, index: usize) -> Option<(&K, &V)> {
+ self.entries.get(index).map(Bucket::refs)
+ }
+
+ /// Get a key-value pair by index, with mutable access to the value.
+ ///
+ /// Valid indices are *0 <= index < self.len()*
+ pub fn get_index_mut(&mut self, index: usize) -> Option<(&K, &mut V)> {
+ self.entries.get_mut(index).map(Bucket::ref_mut)
+ }
+
+ /// Returns a slice of key-value pairs in the given range of indices.
+ ///
+ /// Valid indices are *0 <= index < self.len()*
+ pub fn get_range<R: RangeBounds<usize>>(&self, range: R) -> Option<&Self> {
+ let range = try_simplify_range(range, self.entries.len())?;
+ self.entries.get(range).map(Slice::from_slice)
+ }
+
+ /// Returns a mutable slice of key-value pairs in the given range of indices.
+ ///
+ /// Valid indices are *0 <= index < self.len()*
+ pub fn get_range_mut<R: RangeBounds<usize>>(&mut self, range: R) -> Option<&mut Self> {
+ let range = try_simplify_range(range, self.entries.len())?;
+ self.entries.get_mut(range).map(Slice::from_mut_slice)
+ }
+
+ /// Get the first key-value pair.
+ pub fn first(&self) -> Option<(&K, &V)> {
+ self.entries.first().map(Bucket::refs)
+ }
+
+ /// Get the first key-value pair, with mutable access to the value.
+ pub fn first_mut(&mut self) -> Option<(&K, &mut V)> {
+ self.entries.first_mut().map(Bucket::ref_mut)
+ }
+
+ /// Get the last key-value pair.
+ pub fn last(&self) -> Option<(&K, &V)> {
+ self.entries.last().map(Bucket::refs)
+ }
+
+ /// Get the last key-value pair, with mutable access to the value.
+ pub fn last_mut(&mut self) -> Option<(&K, &mut V)> {
+ self.entries.last_mut().map(Bucket::ref_mut)
+ }
+
+ /// Divides one slice into two at an index.
+ ///
+ /// ***Panics*** if `index > len`.
+ pub fn split_at(&self, index: usize) -> (&Self, &Self) {
+ let (first, second) = self.entries.split_at(index);
+ (Self::from_slice(first), Self::from_slice(second))
+ }
+
+ /// Divides one mutable slice into two at an index.
+ ///
+ /// ***Panics*** if `index > len`.
+ pub fn split_at_mut(&mut self, index: usize) -> (&mut Self, &mut Self) {
+ let (first, second) = self.entries.split_at_mut(index);
+ (Self::from_mut_slice(first), Self::from_mut_slice(second))
+ }
+
+ /// Returns the first key-value pair and the rest of the slice,
+ /// or `None` if it is empty.
+ pub fn split_first(&self) -> Option<((&K, &V), &Self)> {
+ if let [first, rest @ ..] = &self.entries {
+ Some((first.refs(), Self::from_slice(rest)))
+ } else {
+ None
+ }
+ }
+
+ /// Returns the first key-value pair and the rest of the slice,
+ /// with mutable access to the value, or `None` if it is empty.
+ pub fn split_first_mut(&mut self) -> Option<((&K, &mut V), &mut Self)> {
+ if let [first, rest @ ..] = &mut self.entries {
+ Some((first.ref_mut(), Self::from_mut_slice(rest)))
+ } else {
+ None
+ }
+ }
+
+ /// Returns the last key-value pair and the rest of the slice,
+ /// or `None` if it is empty.
+ pub fn split_last(&self) -> Option<((&K, &V), &Self)> {
+ if let [rest @ .., last] = &self.entries {
+ Some((last.refs(), Self::from_slice(rest)))
+ } else {
+ None
+ }
+ }
+
+ /// Returns the last key-value pair and the rest of the slice,
+ /// with mutable access to the value, or `None` if it is empty.
+ pub fn split_last_mut(&mut self) -> Option<((&K, &mut V), &mut Self)> {
+ if let [rest @ .., last] = &mut self.entries {
+ Some((last.ref_mut(), Self::from_mut_slice(rest)))
+ } else {
+ None
+ }
+ }
+
+ /// Return an iterator over the key-value pairs of the map slice.
+ pub fn iter(&self) -> Iter<'_, K, V> {
+ Iter::new(&self.entries)
+ }
+
+ /// Return an iterator over the key-value pairs of the map slice.
+ pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
+ IterMut::new(&mut self.entries)
+ }
+
+ /// Return an iterator over the keys of the map slice.
+ pub fn keys(&self) -> Keys<'_, K, V> {
+ Keys::new(&self.entries)
+ }
+
+ /// Return an owning iterator over the keys of the map slice.
+ pub fn into_keys(self: Box<Self>) -> IntoKeys<K, V> {
+ IntoKeys::new(self.into_entries())
+ }
+
+ /// Return an iterator over the values of the map slice.
+ pub fn values(&self) -> Values<'_, K, V> {
+ Values::new(&self.entries)
+ }
+
+ /// Return an iterator over mutable references to the the values of the map slice.
+ pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> {
+ ValuesMut::new(&mut self.entries)
+ }
+
+ /// Return an owning iterator over the values of the map slice.
+ pub fn into_values(self: Box<Self>) -> IntoValues<K, V> {
+ IntoValues::new(self.into_entries())
+ }
+
+ /// Search over a sorted map for a key.
+ ///
+ /// Returns the position where that key is present, or the position where it can be inserted to
+ /// maintain the sort. See [`slice::binary_search`] for more details.
+ ///
+ /// Computes in **O(log(n))** time, which is notably less scalable than looking the key up in
+ /// the map this is a slice from using [`IndexMap::get_index_of`], but this can also position
+ /// missing keys.
+ pub fn binary_search_keys(&self, x: &K) -> Result<usize, usize>
+ where
+ K: Ord,
+ {
+ self.binary_search_by(|p, _| p.cmp(x))
+ }
+
+ /// Search over a sorted map with a comparator function.
+ ///
+ /// Returns the position where that value is present, or the position where it can be inserted
+ /// to maintain the sort. See [`slice::binary_search_by`] for more details.
+ ///
+ /// Computes in **O(log(n))** time.
+ #[inline]
+ pub fn binary_search_by<'a, F>(&'a self, mut f: F) -> Result<usize, usize>
+ where
+ F: FnMut(&'a K, &'a V) -> Ordering,
+ {
+ self.entries.binary_search_by(move |a| f(&a.key, &a.value))
+ }
+
+ /// Search over a sorted map with an extraction function.
+ ///
+ /// Returns the position where that value is present, or the position where it can be inserted
+ /// to maintain the sort. See [`slice::binary_search_by_key`] for more details.
+ ///
+ /// Computes in **O(log(n))** time.
+ #[inline]
+ pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, mut f: F) -> Result<usize, usize>
+ where
+ F: FnMut(&'a K, &'a V) -> B,
+ B: Ord,
+ {
+ self.binary_search_by(|k, v| f(k, v).cmp(b))
+ }
+
+ /// Returns the index of the partition point of a sorted map according to the given predicate
+ /// (the index of the first element of the second partition).
+ ///
+ /// See [`slice::partition_point`] for more details.
+ ///
+ /// Computes in **O(log(n))** time.
+ #[must_use]
+ pub fn partition_point<P>(&self, mut pred: P) -> usize
+ where
+ P: FnMut(&K, &V) -> bool,
+ {
+ self.entries
+ .partition_point(move |a| pred(&a.key, &a.value))
+ }
+}
+
+impl<'a, K, V> IntoIterator for &'a Slice<K, V> {
+ type IntoIter = Iter<'a, K, V>;
+ type Item = (&'a K, &'a V);
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.iter()
+ }
+}
+
+impl<'a, K, V> IntoIterator for &'a mut Slice<K, V> {
+ type IntoIter = IterMut<'a, K, V>;
+ type Item = (&'a K, &'a mut V);
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.iter_mut()
+ }
+}
+
+impl<K, V> IntoIterator for Box<Slice<K, V>> {
+ type IntoIter = IntoIter<K, V>;
+ type Item = (K, V);
+
+ fn into_iter(self) -> Self::IntoIter {
+ IntoIter::new(self.into_entries())
+ }
+}
+
+impl<K, V> Default for &'_ Slice<K, V> {
+ fn default() -> Self {
+ Slice::from_slice(&[])
+ }
+}
+
+impl<K, V> Default for &'_ mut Slice<K, V> {
+ fn default() -> Self {
+ Slice::from_mut_slice(&mut [])
+ }
+}
+
+impl<K, V> Default for Box<Slice<K, V>> {
+ fn default() -> Self {
+ Slice::from_boxed(Box::default())
+ }
+}
+
+impl<K: Clone, V: Clone> Clone for Box<Slice<K, V>> {
+ fn clone(&self) -> Self {
+ Slice::from_boxed(self.entries.to_vec().into_boxed_slice())
+ }
+}
+
+impl<K: Copy, V: Copy> From<&Slice<K, V>> for Box<Slice<K, V>> {
+ fn from(slice: &Slice<K, V>) -> Self {
+ Slice::from_boxed(Box::from(&slice.entries))
+ }
+}
+
+impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Slice<K, V> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_list().entries(self).finish()
+ }
+}
+
+impl<K: PartialEq, V: PartialEq> PartialEq for Slice<K, V> {
+ fn eq(&self, other: &Self) -> bool {
+ self.len() == other.len() && self.iter().eq(other)
+ }
+}
+
+impl<K: Eq, V: Eq> Eq for Slice<K, V> {}
+
+impl<K: PartialOrd, V: PartialOrd> PartialOrd for Slice<K, V> {
+ fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+ self.iter().partial_cmp(other)
+ }
+}
+
+impl<K: Ord, V: Ord> Ord for Slice<K, V> {
+ fn cmp(&self, other: &Self) -> Ordering {
+ self.iter().cmp(other)
+ }
+}
+
+impl<K: Hash, V: Hash> Hash for Slice<K, V> {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ self.len().hash(state);
+ for (key, value) in self {
+ key.hash(state);
+ value.hash(state);
+ }
+ }
+}
+
+impl<K, V> Index<usize> for Slice<K, V> {
+ type Output = V;
+
+ fn index(&self, index: usize) -> &V {
+ &self.entries[index].value
+ }
+}
+
+impl<K, V> IndexMut<usize> for Slice<K, V> {
+ fn index_mut(&mut self, index: usize) -> &mut V {
+ &mut self.entries[index].value
+ }
+}
+
+// We can't have `impl<I: RangeBounds<usize>> Index<I>` because that conflicts
+// both upstream with `Index<usize>` and downstream with `Index<&Q>`.
+// Instead, we repeat the implementations for all the core range types.
+macro_rules! impl_index {
+ ($($range:ty),*) => {$(
+ impl<K, V, S> Index<$range> for IndexMap<K, V, S> {
+ type Output = Slice<K, V>;
+
+ fn index(&self, range: $range) -> &Self::Output {
+ Slice::from_slice(&self.as_entries()[range])
+ }
+ }
+
+ impl<K, V, S> IndexMut<$range> for IndexMap<K, V, S> {
+ fn index_mut(&mut self, range: $range) -> &mut Self::Output {
+ Slice::from_mut_slice(&mut self.as_entries_mut()[range])
+ }
+ }
+
+ impl<K, V> Index<$range> for Slice<K, V> {
+ type Output = Slice<K, V>;
+
+ fn index(&self, range: $range) -> &Self {
+ Self::from_slice(&self.entries[range])
+ }
+ }
+
+ impl<K, V> IndexMut<$range> for Slice<K, V> {
+ fn index_mut(&mut self, range: $range) -> &mut Self {
+ Self::from_mut_slice(&mut self.entries[range])
+ }
+ }
+ )*}
+}
+impl_index!(
+ ops::Range<usize>,
+ ops::RangeFrom<usize>,
+ ops::RangeFull,
+ ops::RangeInclusive<usize>,
+ ops::RangeTo<usize>,
+ ops::RangeToInclusive<usize>,
+ (Bound<usize>, Bound<usize>)
+);
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn slice_index() {
+ fn check(
+ vec_slice: &[(i32, i32)],
+ map_slice: &Slice<i32, i32>,
+ sub_slice: &Slice<i32, i32>,
+ ) {
+ assert_eq!(map_slice as *const _, sub_slice as *const _);
+ itertools::assert_equal(
+ vec_slice.iter().copied(),
+ map_slice.iter().map(|(&k, &v)| (k, v)),
+ );
+ itertools::assert_equal(vec_slice.iter().map(|(k, _)| k), map_slice.keys());
+ itertools::assert_equal(vec_slice.iter().map(|(_, v)| v), map_slice.values());
+ }
+
+ let vec: Vec<(i32, i32)> = (0..10).map(|i| (i, i * i)).collect();
+ let map: IndexMap<i32, i32> = vec.iter().cloned().collect();
+ let slice = map.as_slice();
+
+ // RangeFull
+ check(&vec[..], &map[..], &slice[..]);
+
+ for i in 0usize..10 {
+ // Index
+ assert_eq!(vec[i].1, map[i]);
+ assert_eq!(vec[i].1, slice[i]);
+ assert_eq!(map[&(i as i32)], map[i]);
+ assert_eq!(map[&(i as i32)], slice[i]);
+
+ // RangeFrom
+ check(&vec[i..], &map[i..], &slice[i..]);
+
+ // RangeTo
+ check(&vec[..i], &map[..i], &slice[..i]);
+
+ // RangeToInclusive
+ check(&vec[..=i], &map[..=i], &slice[..=i]);
+
+ // (Bound<usize>, Bound<usize>)
+ let bounds = (Bound::Excluded(i), Bound::Unbounded);
+ check(&vec[i + 1..], &map[bounds], &slice[bounds]);
+
+ for j in i..=10 {
+ // Range
+ check(&vec[i..j], &map[i..j], &slice[i..j]);
+ }
+
+ for j in i..10 {
+ // RangeInclusive
+ check(&vec[i..=j], &map[i..=j], &slice[i..=j]);
+ }
+ }
+ }
+
+ #[test]
+ fn slice_index_mut() {
+ fn check_mut(
+ vec_slice: &[(i32, i32)],
+ map_slice: &mut Slice<i32, i32>,
+ sub_slice: &mut Slice<i32, i32>,
+ ) {
+ assert_eq!(map_slice, sub_slice);
+ itertools::assert_equal(
+ vec_slice.iter().copied(),
+ map_slice.iter_mut().map(|(&k, &mut v)| (k, v)),
+ );
+ itertools::assert_equal(
+ vec_slice.iter().map(|&(_, v)| v),
+ map_slice.values_mut().map(|&mut v| v),
+ );
+ }
+
+ let vec: Vec<(i32, i32)> = (0..10).map(|i| (i, i * i)).collect();
+ let mut map: IndexMap<i32, i32> = vec.iter().cloned().collect();
+ let mut map2 = map.clone();
+ let slice = map2.as_mut_slice();
+
+ // RangeFull
+ check_mut(&vec[..], &mut map[..], &mut slice[..]);
+
+ for i in 0usize..10 {
+ // IndexMut
+ assert_eq!(&mut map[i], &mut slice[i]);
+
+ // RangeFrom
+ check_mut(&vec[i..], &mut map[i..], &mut slice[i..]);
+
+ // RangeTo
+ check_mut(&vec[..i], &mut map[..i], &mut slice[..i]);
+
+ // RangeToInclusive
+ check_mut(&vec[..=i], &mut map[..=i], &mut slice[..=i]);
+
+ // (Bound<usize>, Bound<usize>)
+ let bounds = (Bound::Excluded(i), Bound::Unbounded);
+ check_mut(&vec[i + 1..], &mut map[bounds], &mut slice[bounds]);
+
+ for j in i..=10 {
+ // Range
+ check_mut(&vec[i..j], &mut map[i..j], &mut slice[i..j]);
+ }
+
+ for j in i..10 {
+ // RangeInclusive
+ check_mut(&vec[i..=j], &mut map[i..=j], &mut slice[i..=j]);
+ }
+ }
+ }
+}
diff --git a/third_party/rust/indexmap/src/map/tests.rs b/third_party/rust/indexmap/src/map/tests.rs
new file mode 100644
index 0000000000..bba78ff54c
--- /dev/null
+++ b/third_party/rust/indexmap/src/map/tests.rs
@@ -0,0 +1,727 @@
+use super::*;
+use std::string::String;
+
+#[test]
+fn it_works() {
+ let mut map = IndexMap::new();
+ assert_eq!(map.is_empty(), true);
+ map.insert(1, ());
+ map.insert(1, ());
+ assert_eq!(map.len(), 1);
+ assert!(map.get(&1).is_some());
+ assert_eq!(map.is_empty(), false);
+}
+
+#[test]
+fn new() {
+ let map = IndexMap::<String, String>::new();
+ println!("{:?}", map);
+ assert_eq!(map.capacity(), 0);
+ assert_eq!(map.len(), 0);
+ assert_eq!(map.is_empty(), true);
+}
+
+#[test]
+fn insert() {
+ let insert = [0, 4, 2, 12, 8, 7, 11, 5];
+ let not_present = [1, 3, 6, 9, 10];
+ let mut map = IndexMap::with_capacity(insert.len());
+
+ for (i, &elt) in insert.iter().enumerate() {
+ assert_eq!(map.len(), i);
+ map.insert(elt, elt);
+ assert_eq!(map.len(), i + 1);
+ assert_eq!(map.get(&elt), Some(&elt));
+ assert_eq!(map[&elt], elt);
+ }
+ println!("{:?}", map);
+
+ for &elt in &not_present {
+ assert!(map.get(&elt).is_none());
+ }
+}
+
+#[test]
+fn insert_full() {
+ let insert = vec![9, 2, 7, 1, 4, 6, 13];
+ let present = vec![1, 6, 2];
+ let mut map = IndexMap::with_capacity(insert.len());
+
+ for (i, &elt) in insert.iter().enumerate() {
+ assert_eq!(map.len(), i);
+ let (index, existing) = map.insert_full(elt, elt);
+ assert_eq!(existing, None);
+ assert_eq!(Some(index), map.get_full(&elt).map(|x| x.0));
+ assert_eq!(map.len(), i + 1);
+ }
+
+ let len = map.len();
+ for &elt in &present {
+ let (index, existing) = map.insert_full(elt, elt);
+ assert_eq!(existing, Some(elt));
+ assert_eq!(Some(index), map.get_full(&elt).map(|x| x.0));
+ assert_eq!(map.len(), len);
+ }
+}
+
+#[test]
+fn insert_2() {
+ let mut map = IndexMap::with_capacity(16);
+
+ let mut keys = vec![];
+ keys.extend(0..16);
+ keys.extend(if cfg!(miri) { 32..64 } else { 128..267 });
+
+ for &i in &keys {
+ let old_map = map.clone();
+ map.insert(i, ());
+ for key in old_map.keys() {
+ if map.get(key).is_none() {
+ println!("old_map: {:?}", old_map);
+ println!("map: {:?}", map);
+ panic!("did not find {} in map", key);
+ }
+ }
+ }
+
+ for &i in &keys {
+ assert!(map.get(&i).is_some(), "did not find {}", i);
+ }
+}
+
+#[test]
+fn insert_order() {
+ let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+ let mut map = IndexMap::new();
+
+ for &elt in &insert {
+ map.insert(elt, ());
+ }
+
+ assert_eq!(map.keys().count(), map.len());
+ assert_eq!(map.keys().count(), insert.len());
+ for (a, b) in insert.iter().zip(map.keys()) {
+ assert_eq!(a, b);
+ }
+ for (i, k) in (0..insert.len()).zip(map.keys()) {
+ assert_eq!(map.get_index(i).unwrap().0, k);
+ }
+}
+
+#[test]
+fn shift_insert() {
+ let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+ let mut map = IndexMap::new();
+
+ for &elt in &insert {
+ map.shift_insert(0, elt, ());
+ }
+
+ assert_eq!(map.keys().count(), map.len());
+ assert_eq!(map.keys().count(), insert.len());
+ for (a, b) in insert.iter().rev().zip(map.keys()) {
+ assert_eq!(a, b);
+ }
+ for (i, k) in (0..insert.len()).zip(map.keys()) {
+ assert_eq!(map.get_index(i).unwrap().0, k);
+ }
+
+ // "insert" that moves an existing entry
+ map.shift_insert(0, insert[0], ());
+ assert_eq!(map.keys().count(), insert.len());
+ assert_eq!(insert[0], map.keys()[0]);
+ for (a, b) in insert[1..].iter().rev().zip(map.keys().skip(1)) {
+ assert_eq!(a, b);
+ }
+}
+
+#[test]
+fn grow() {
+ let insert = [0, 4, 2, 12, 8, 7, 11];
+ let not_present = [1, 3, 6, 9, 10];
+ let mut map = IndexMap::with_capacity(insert.len());
+
+ for (i, &elt) in insert.iter().enumerate() {
+ assert_eq!(map.len(), i);
+ map.insert(elt, elt);
+ assert_eq!(map.len(), i + 1);
+ assert_eq!(map.get(&elt), Some(&elt));
+ assert_eq!(map[&elt], elt);
+ }
+
+ println!("{:?}", map);
+ for &elt in &insert {
+ map.insert(elt * 10, elt);
+ }
+ for &elt in &insert {
+ map.insert(elt * 100, elt);
+ }
+ for (i, &elt) in insert.iter().cycle().enumerate().take(100) {
+ map.insert(elt * 100 + i as i32, elt);
+ }
+ println!("{:?}", map);
+ for &elt in &not_present {
+ assert!(map.get(&elt).is_none());
+ }
+}
+
+#[test]
+fn reserve() {
+ let mut map = IndexMap::<usize, usize>::new();
+ assert_eq!(map.capacity(), 0);
+ map.reserve(100);
+ let capacity = map.capacity();
+ assert!(capacity >= 100);
+ for i in 0..capacity {
+ assert_eq!(map.len(), i);
+ map.insert(i, i * i);
+ assert_eq!(map.len(), i + 1);
+ assert_eq!(map.capacity(), capacity);
+ assert_eq!(map.get(&i), Some(&(i * i)));
+ }
+ map.insert(capacity, std::usize::MAX);
+ assert_eq!(map.len(), capacity + 1);
+ assert!(map.capacity() > capacity);
+ assert_eq!(map.get(&capacity), Some(&std::usize::MAX));
+}
+
+#[test]
+fn try_reserve() {
+ let mut map = IndexMap::<usize, usize>::new();
+ assert_eq!(map.capacity(), 0);
+ assert_eq!(map.try_reserve(100), Ok(()));
+ assert!(map.capacity() >= 100);
+ assert!(map.try_reserve(usize::MAX).is_err());
+}
+
+#[test]
+fn shrink_to_fit() {
+ let mut map = IndexMap::<usize, usize>::new();
+ assert_eq!(map.capacity(), 0);
+ for i in 0..100 {
+ assert_eq!(map.len(), i);
+ map.insert(i, i * i);
+ assert_eq!(map.len(), i + 1);
+ assert!(map.capacity() >= i + 1);
+ assert_eq!(map.get(&i), Some(&(i * i)));
+ map.shrink_to_fit();
+ assert_eq!(map.len(), i + 1);
+ assert_eq!(map.capacity(), i + 1);
+ assert_eq!(map.get(&i), Some(&(i * i)));
+ }
+}
+
+#[test]
+fn remove() {
+ let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+ let mut map = IndexMap::new();
+
+ for &elt in &insert {
+ map.insert(elt, elt);
+ }
+
+ assert_eq!(map.keys().count(), map.len());
+ assert_eq!(map.keys().count(), insert.len());
+ for (a, b) in insert.iter().zip(map.keys()) {
+ assert_eq!(a, b);
+ }
+
+ let remove_fail = [99, 77];
+ let remove = [4, 12, 8, 7];
+
+ for &key in &remove_fail {
+ assert!(map.swap_remove_full(&key).is_none());
+ }
+ println!("{:?}", map);
+ for &key in &remove {
+ //println!("{:?}", map);
+ let index = map.get_full(&key).unwrap().0;
+ assert_eq!(map.swap_remove_full(&key), Some((index, key, key)));
+ }
+ println!("{:?}", map);
+
+ for key in &insert {
+ assert_eq!(map.get(key).is_some(), !remove.contains(key));
+ }
+ assert_eq!(map.len(), insert.len() - remove.len());
+ assert_eq!(map.keys().count(), insert.len() - remove.len());
+}
+
+#[test]
+fn remove_to_empty() {
+ let mut map = indexmap! { 0 => 0, 4 => 4, 5 => 5 };
+ map.swap_remove(&5).unwrap();
+ map.swap_remove(&4).unwrap();
+ map.swap_remove(&0).unwrap();
+ assert!(map.is_empty());
+}
+
+#[test]
+fn swap_remove_index() {
+ let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+ let mut map = IndexMap::new();
+
+ for &elt in &insert {
+ map.insert(elt, elt * 2);
+ }
+
+ let mut vector = insert.to_vec();
+ let remove_sequence = &[3, 3, 10, 4, 5, 4, 3, 0, 1];
+
+ // check that the same swap remove sequence on vec and map
+ // have the same result.
+ for &rm in remove_sequence {
+ let out_vec = vector.swap_remove(rm);
+ let (out_map, _) = map.swap_remove_index(rm).unwrap();
+ assert_eq!(out_vec, out_map);
+ }
+ assert_eq!(vector.len(), map.len());
+ for (a, b) in vector.iter().zip(map.keys()) {
+ assert_eq!(a, b);
+ }
+}
+
+#[test]
+fn partial_eq_and_eq() {
+ let mut map_a = IndexMap::new();
+ map_a.insert(1, "1");
+ map_a.insert(2, "2");
+ let mut map_b = map_a.clone();
+ assert_eq!(map_a, map_b);
+ map_b.swap_remove(&1);
+ assert_ne!(map_a, map_b);
+
+ let map_c: IndexMap<_, String> = map_b.into_iter().map(|(k, v)| (k, v.into())).collect();
+ assert_ne!(map_a, map_c);
+ assert_ne!(map_c, map_a);
+}
+
+#[test]
+fn extend() {
+ let mut map = IndexMap::new();
+ map.extend(vec![(&1, &2), (&3, &4)]);
+ map.extend(vec![(5, 6)]);
+ assert_eq!(
+ map.into_iter().collect::<Vec<_>>(),
+ vec![(1, 2), (3, 4), (5, 6)]
+ );
+}
+
+#[test]
+fn entry() {
+ let mut map = IndexMap::new();
+
+ map.insert(1, "1");
+ map.insert(2, "2");
+ {
+ let e = map.entry(3);
+ assert_eq!(e.index(), 2);
+ let e = e.or_insert("3");
+ assert_eq!(e, &"3");
+ }
+
+ let e = map.entry(2);
+ assert_eq!(e.index(), 1);
+ assert_eq!(e.key(), &2);
+ match e {
+ Entry::Occupied(ref e) => assert_eq!(e.get(), &"2"),
+ Entry::Vacant(_) => panic!(),
+ }
+ assert_eq!(e.or_insert("4"), &"2");
+}
+
+#[test]
+fn entry_and_modify() {
+ let mut map = IndexMap::new();
+
+ map.insert(1, "1");
+ map.entry(1).and_modify(|x| *x = "2");
+ assert_eq!(Some(&"2"), map.get(&1));
+
+ map.entry(2).and_modify(|x| *x = "doesn't exist");
+ assert_eq!(None, map.get(&2));
+}
+
+#[test]
+fn entry_or_default() {
+ let mut map = IndexMap::new();
+
+ #[derive(Debug, PartialEq)]
+ enum TestEnum {
+ DefaultValue,
+ NonDefaultValue,
+ }
+
+ impl Default for TestEnum {
+ fn default() -> Self {
+ TestEnum::DefaultValue
+ }
+ }
+
+ map.insert(1, TestEnum::NonDefaultValue);
+ assert_eq!(&mut TestEnum::NonDefaultValue, map.entry(1).or_default());
+
+ assert_eq!(&mut TestEnum::DefaultValue, map.entry(2).or_default());
+}
+
+#[test]
+fn occupied_entry_key() {
+ // These keys match hash and equality, but their addresses are distinct.
+ let (k1, k2) = (&mut 1, &mut 1);
+ let k1_ptr = k1 as *const i32;
+ let k2_ptr = k2 as *const i32;
+ assert_ne!(k1_ptr, k2_ptr);
+
+ let mut map = IndexMap::new();
+ map.insert(k1, "value");
+ match map.entry(k2) {
+ Entry::Occupied(ref e) => {
+ // `OccupiedEntry::key` should reference the key in the map,
+ // not the key that was used to find the entry.
+ let ptr = *e.key() as *const i32;
+ assert_eq!(ptr, k1_ptr);
+ assert_ne!(ptr, k2_ptr);
+ }
+ Entry::Vacant(_) => panic!(),
+ }
+}
+
+#[test]
+fn get_index_entry() {
+ let mut map = IndexMap::new();
+
+ assert!(map.get_index_entry(0).is_none());
+
+ map.insert(0, "0");
+ map.insert(1, "1");
+ map.insert(2, "2");
+ map.insert(3, "3");
+
+ assert!(map.get_index_entry(4).is_none());
+
+ {
+ let e = map.get_index_entry(1).unwrap();
+ assert_eq!(*e.key(), 1);
+ assert_eq!(*e.get(), "1");
+ assert_eq!(e.swap_remove(), "1");
+ }
+
+ {
+ let mut e = map.get_index_entry(1).unwrap();
+ assert_eq!(*e.key(), 3);
+ assert_eq!(*e.get(), "3");
+ assert_eq!(e.insert("4"), "3");
+ }
+
+ assert_eq!(*map.get(&3).unwrap(), "4");
+}
+
+#[test]
+fn keys() {
+ let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+ let map: IndexMap<_, _> = vec.into_iter().collect();
+ let keys: Vec<_> = map.keys().copied().collect();
+ assert_eq!(keys.len(), 3);
+ assert!(keys.contains(&1));
+ assert!(keys.contains(&2));
+ assert!(keys.contains(&3));
+}
+
+#[test]
+fn into_keys() {
+ let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+ let map: IndexMap<_, _> = vec.into_iter().collect();
+ let keys: Vec<i32> = map.into_keys().collect();
+ assert_eq!(keys.len(), 3);
+ assert!(keys.contains(&1));
+ assert!(keys.contains(&2));
+ assert!(keys.contains(&3));
+}
+
+#[test]
+fn values() {
+ let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+ let map: IndexMap<_, _> = vec.into_iter().collect();
+ let values: Vec<_> = map.values().copied().collect();
+ assert_eq!(values.len(), 3);
+ assert!(values.contains(&'a'));
+ assert!(values.contains(&'b'));
+ assert!(values.contains(&'c'));
+}
+
+#[test]
+fn values_mut() {
+ let vec = vec![(1, 1), (2, 2), (3, 3)];
+ let mut map: IndexMap<_, _> = vec.into_iter().collect();
+ for value in map.values_mut() {
+ *value *= 2
+ }
+ let values: Vec<_> = map.values().copied().collect();
+ assert_eq!(values.len(), 3);
+ assert!(values.contains(&2));
+ assert!(values.contains(&4));
+ assert!(values.contains(&6));
+}
+
+#[test]
+fn into_values() {
+ let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+ let map: IndexMap<_, _> = vec.into_iter().collect();
+ let values: Vec<char> = map.into_values().collect();
+ assert_eq!(values.len(), 3);
+ assert!(values.contains(&'a'));
+ assert!(values.contains(&'b'));
+ assert!(values.contains(&'c'));
+}
+
+#[test]
+#[cfg(feature = "std")]
+fn from_array() {
+ let map = IndexMap::from([(1, 2), (3, 4)]);
+ let mut expected = IndexMap::new();
+ expected.insert(1, 2);
+ expected.insert(3, 4);
+
+ assert_eq!(map, expected)
+}
+
+#[test]
+fn iter_default() {
+ struct K;
+ struct V;
+ fn assert_default<T>()
+ where
+ T: Default + Iterator,
+ {
+ assert!(T::default().next().is_none());
+ }
+ assert_default::<Iter<'static, K, V>>();
+ assert_default::<IterMut<'static, K, V>>();
+ assert_default::<IntoIter<K, V>>();
+ assert_default::<Keys<'static, K, V>>();
+ assert_default::<IntoKeys<K, V>>();
+ assert_default::<Values<'static, K, V>>();
+ assert_default::<ValuesMut<'static, K, V>>();
+ assert_default::<IntoValues<K, V>>();
+}
+
+#[test]
+fn test_binary_search_by() {
+ // adapted from std's test for binary_search
+ let b: IndexMap<_, i32> = []
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&5)), Err(0));
+
+ let b: IndexMap<_, i32> = [4]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&3)), Err(0));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&4)), Ok(0));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&5)), Err(1));
+
+ let b: IndexMap<_, i32> = [1, 2, 4, 6, 8, 9]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&5)), Err(3));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&6)), Ok(3));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&7)), Err(4));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&8)), Ok(4));
+
+ let b: IndexMap<_, i32> = [1, 2, 4, 5, 6, 8]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&9)), Err(6));
+
+ let b: IndexMap<_, i32> = [1, 2, 4, 6, 7, 8, 9]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&6)), Ok(3));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&5)), Err(3));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&8)), Ok(5));
+
+ let b: IndexMap<_, i32> = [1, 2, 4, 5, 6, 8, 9]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&7)), Err(5));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&0)), Err(0));
+
+ let b: IndexMap<_, i32> = [1, 3, 3, 3, 7]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&0)), Err(0));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&1)), Ok(0));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&2)), Err(1));
+ assert!(match b.binary_search_by(|_, x| x.cmp(&3)) {
+ Ok(1..=3) => true,
+ _ => false,
+ });
+ assert!(match b.binary_search_by(|_, x| x.cmp(&3)) {
+ Ok(1..=3) => true,
+ _ => false,
+ });
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&4)), Err(4));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&5)), Err(4));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&6)), Err(4));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&7)), Ok(4));
+ assert_eq!(b.binary_search_by(|_, x| x.cmp(&8)), Err(5));
+}
+
+#[test]
+fn test_binary_search_by_key() {
+ // adapted from std's test for binary_search
+ let b: IndexMap<_, i32> = []
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by_key(&5, |_, &x| x), Err(0));
+
+ let b: IndexMap<_, i32> = [4]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by_key(&3, |_, &x| x), Err(0));
+ assert_eq!(b.binary_search_by_key(&4, |_, &x| x), Ok(0));
+ assert_eq!(b.binary_search_by_key(&5, |_, &x| x), Err(1));
+
+ let b: IndexMap<_, i32> = [1, 2, 4, 6, 8, 9]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by_key(&5, |_, &x| x), Err(3));
+ assert_eq!(b.binary_search_by_key(&6, |_, &x| x), Ok(3));
+ assert_eq!(b.binary_search_by_key(&7, |_, &x| x), Err(4));
+ assert_eq!(b.binary_search_by_key(&8, |_, &x| x), Ok(4));
+
+ let b: IndexMap<_, i32> = [1, 2, 4, 5, 6, 8]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by_key(&9, |_, &x| x), Err(6));
+
+ let b: IndexMap<_, i32> = [1, 2, 4, 6, 7, 8, 9]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by_key(&6, |_, &x| x), Ok(3));
+ assert_eq!(b.binary_search_by_key(&5, |_, &x| x), Err(3));
+ assert_eq!(b.binary_search_by_key(&8, |_, &x| x), Ok(5));
+
+ let b: IndexMap<_, i32> = [1, 2, 4, 5, 6, 8, 9]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by_key(&7, |_, &x| x), Err(5));
+ assert_eq!(b.binary_search_by_key(&0, |_, &x| x), Err(0));
+
+ let b: IndexMap<_, i32> = [1, 3, 3, 3, 7]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.binary_search_by_key(&0, |_, &x| x), Err(0));
+ assert_eq!(b.binary_search_by_key(&1, |_, &x| x), Ok(0));
+ assert_eq!(b.binary_search_by_key(&2, |_, &x| x), Err(1));
+ assert!(match b.binary_search_by_key(&3, |_, &x| x) {
+ Ok(1..=3) => true,
+ _ => false,
+ });
+ assert!(match b.binary_search_by_key(&3, |_, &x| x) {
+ Ok(1..=3) => true,
+ _ => false,
+ });
+ assert_eq!(b.binary_search_by_key(&4, |_, &x| x), Err(4));
+ assert_eq!(b.binary_search_by_key(&5, |_, &x| x), Err(4));
+ assert_eq!(b.binary_search_by_key(&6, |_, &x| x), Err(4));
+ assert_eq!(b.binary_search_by_key(&7, |_, &x| x), Ok(4));
+ assert_eq!(b.binary_search_by_key(&8, |_, &x| x), Err(5));
+}
+
+#[test]
+fn test_partition_point() {
+ // adapted from std's test for partition_point
+ let b: IndexMap<_, i32> = []
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.partition_point(|_, &x| x < 5), 0);
+
+ let b: IndexMap<_, i32> = [4]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.partition_point(|_, &x| x < 3), 0);
+ assert_eq!(b.partition_point(|_, &x| x < 4), 0);
+ assert_eq!(b.partition_point(|_, &x| x < 5), 1);
+
+ let b: IndexMap<_, i32> = [1, 2, 4, 6, 8, 9]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.partition_point(|_, &x| x < 5), 3);
+ assert_eq!(b.partition_point(|_, &x| x < 6), 3);
+ assert_eq!(b.partition_point(|_, &x| x < 7), 4);
+ assert_eq!(b.partition_point(|_, &x| x < 8), 4);
+
+ let b: IndexMap<_, i32> = [1, 2, 4, 5, 6, 8]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.partition_point(|_, &x| x < 9), 6);
+
+ let b: IndexMap<_, i32> = [1, 2, 4, 6, 7, 8, 9]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.partition_point(|_, &x| x < 6), 3);
+ assert_eq!(b.partition_point(|_, &x| x < 5), 3);
+ assert_eq!(b.partition_point(|_, &x| x < 8), 5);
+
+ let b: IndexMap<_, i32> = [1, 2, 4, 5, 6, 8, 9]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.partition_point(|_, &x| x < 7), 5);
+ assert_eq!(b.partition_point(|_, &x| x < 0), 0);
+
+ let b: IndexMap<_, i32> = [1, 3, 3, 3, 7]
+ .into_iter()
+ .enumerate()
+ .map(|(i, x)| (i + 100, x))
+ .collect();
+ assert_eq!(b.partition_point(|_, &x| x < 0), 0);
+ assert_eq!(b.partition_point(|_, &x| x < 1), 0);
+ assert_eq!(b.partition_point(|_, &x| x < 2), 1);
+ assert_eq!(b.partition_point(|_, &x| x < 3), 1);
+ assert_eq!(b.partition_point(|_, &x| x < 4), 4);
+ assert_eq!(b.partition_point(|_, &x| x < 5), 4);
+ assert_eq!(b.partition_point(|_, &x| x < 6), 4);
+ assert_eq!(b.partition_point(|_, &x| x < 7), 4);
+ assert_eq!(b.partition_point(|_, &x| x < 8), 5);
+}
diff --git a/third_party/rust/indexmap/src/mutable_keys.rs b/third_party/rust/indexmap/src/mutable_keys.rs
deleted file mode 100644
index 35a90c4723..0000000000
--- a/third_party/rust/indexmap/src/mutable_keys.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-use core::hash::{BuildHasher, Hash};
-
-use super::{Equivalent, IndexMap};
-
-pub struct PrivateMarker {}
-
-/// Opt-in mutable access to keys.
-///
-/// These methods expose `&mut K`, mutable references to the key as it is stored
-/// in the map.
-/// You are allowed to modify the keys in the hashmap **if the modification
-/// does not change the key’s hash and equality**.
-///
-/// If keys are modified erroneously, you can no longer look them up.
-/// This is sound (memory safe) but a logical error hazard (just like
-/// implementing PartialEq, Eq, or Hash incorrectly would be).
-///
-/// `use` this trait to enable its methods for `IndexMap`.
-pub trait MutableKeys {
- type Key;
- type Value;
-
- /// Return item index, mutable reference to key and value
- fn get_full_mut2<Q: ?Sized>(
- &mut self,
- key: &Q,
- ) -> Option<(usize, &mut Self::Key, &mut Self::Value)>
- where
- Q: Hash + Equivalent<Self::Key>;
-
- /// Scan through each key-value pair in the map and keep those where the
- /// closure `keep` returns `true`.
- ///
- /// The elements are visited in order, and remaining elements keep their
- /// order.
- ///
- /// Computes in **O(n)** time (average).
- fn retain2<F>(&mut self, keep: F)
- where
- F: FnMut(&mut Self::Key, &mut Self::Value) -> bool;
-
- /// This method is not useful in itself – it is there to “seal” the trait
- /// for external implementation, so that we can add methods without
- /// causing breaking changes.
- fn __private_marker(&self) -> PrivateMarker;
-}
-
-/// Opt-in mutable access to keys.
-///
-/// See [`MutableKeys`](trait.MutableKeys.html) for more information.
-impl<K, V, S> MutableKeys for IndexMap<K, V, S>
-where
- K: Eq + Hash,
- S: BuildHasher,
-{
- type Key = K;
- type Value = V;
- fn get_full_mut2<Q: ?Sized>(&mut self, key: &Q) -> Option<(usize, &mut K, &mut V)>
- where
- Q: Hash + Equivalent<K>,
- {
- self.get_full_mut2_impl(key)
- }
-
- fn retain2<F>(&mut self, keep: F)
- where
- F: FnMut(&mut K, &mut V) -> bool,
- {
- self.retain_mut(keep)
- }
-
- fn __private_marker(&self) -> PrivateMarker {
- PrivateMarker {}
- }
-}
diff --git a/third_party/rust/indexmap/src/rayon/map.rs b/third_party/rust/indexmap/src/rayon/map.rs
index 8819f13ed7..8236cf70f0 100644
--- a/third_party/rust/indexmap/src/rayon/map.rs
+++ b/third_party/rust/indexmap/src/rayon/map.rs
@@ -1,25 +1,24 @@
-//! Parallel iterator types for `IndexMap` with [rayon](https://docs.rs/rayon/1.0/rayon).
+//! Parallel iterator types for [`IndexMap`] with [`rayon`][::rayon].
//!
//! You will rarely need to interact with this module directly unless you need to name one of the
//! iterator types.
-//!
-//! Requires crate feature `"rayon"`
use super::collect;
use rayon::iter::plumbing::{Consumer, ProducerCallback, UnindexedConsumer};
use rayon::prelude::*;
use crate::vec::Vec;
+use alloc::boxed::Box;
use core::cmp::Ordering;
use core::fmt;
use core::hash::{BuildHasher, Hash};
use core::ops::RangeBounds;
+use crate::map::Slice;
use crate::Bucket;
use crate::Entries;
use crate::IndexMap;
-/// Requires crate feature `"rayon"`.
impl<K, V, S> IntoParallelIterator for IndexMap<K, V, S>
where
K: Send,
@@ -35,13 +34,25 @@ where
}
}
-/// A parallel owning iterator over the entries of a `IndexMap`.
-///
-/// This `struct` is created by the [`into_par_iter`] method on [`IndexMap`]
-/// (provided by rayon's `IntoParallelIterator` trait). See its documentation for more.
+impl<K, V> IntoParallelIterator for Box<Slice<K, V>>
+where
+ K: Send,
+ V: Send,
+{
+ type Item = (K, V);
+ type Iter = IntoParIter<K, V>;
+
+ fn into_par_iter(self) -> Self::Iter {
+ IntoParIter {
+ entries: self.into_entries(),
+ }
+ }
+}
+
+/// A parallel owning iterator over the entries of an [`IndexMap`].
///
-/// [`into_par_iter`]: ../struct.IndexMap.html#method.into_par_iter
-/// [`IndexMap`]: ../struct.IndexMap.html
+/// This `struct` is created by the [`IndexMap::into_par_iter`] method
+/// (provided by rayon's [`IntoParallelIterator`] trait). See its documentation for more.
pub struct IntoParIter<K, V> {
entries: Vec<Bucket<K, V>>,
}
@@ -63,7 +74,6 @@ impl<K: Send, V: Send> IndexedParallelIterator for IntoParIter<K, V> {
indexed_parallel_iterator_methods!(Bucket::key_value);
}
-/// Requires crate feature `"rayon"`.
impl<'a, K, V, S> IntoParallelIterator for &'a IndexMap<K, V, S>
where
K: Sync,
@@ -79,13 +89,27 @@ where
}
}
-/// A parallel iterator over the entries of a `IndexMap`.
+impl<'a, K, V> IntoParallelIterator for &'a Slice<K, V>
+where
+ K: Sync,
+ V: Sync,
+{
+ type Item = (&'a K, &'a V);
+ type Iter = ParIter<'a, K, V>;
+
+ fn into_par_iter(self) -> Self::Iter {
+ ParIter {
+ entries: &self.entries,
+ }
+ }
+}
+
+/// A parallel iterator over the entries of an [`IndexMap`].
///
-/// This `struct` is created by the [`par_iter`] method on [`IndexMap`]
-/// (provided by rayon's `IntoParallelRefIterator` trait). See its documentation for more.
+/// This `struct` is created by the [`IndexMap::par_iter`] method
+/// (provided by rayon's [`IntoParallelRefIterator`] trait). See its documentation for more.
///
-/// [`par_iter`]: ../struct.IndexMap.html#method.par_iter
-/// [`IndexMap`]: ../struct.IndexMap.html
+/// [`IndexMap::par_iter`]: ../struct.IndexMap.html#method.par_iter
pub struct ParIter<'a, K, V> {
entries: &'a [Bucket<K, V>],
}
@@ -113,7 +137,6 @@ impl<K: Sync, V: Sync> IndexedParallelIterator for ParIter<'_, K, V> {
indexed_parallel_iterator_methods!(Bucket::refs);
}
-/// Requires crate feature `"rayon"`.
impl<'a, K, V, S> IntoParallelIterator for &'a mut IndexMap<K, V, S>
where
K: Sync + Send,
@@ -129,13 +152,27 @@ where
}
}
-/// A parallel mutable iterator over the entries of a `IndexMap`.
+impl<'a, K, V> IntoParallelIterator for &'a mut Slice<K, V>
+where
+ K: Sync + Send,
+ V: Send,
+{
+ type Item = (&'a K, &'a mut V);
+ type Iter = ParIterMut<'a, K, V>;
+
+ fn into_par_iter(self) -> Self::Iter {
+ ParIterMut {
+ entries: &mut self.entries,
+ }
+ }
+}
+
+/// A parallel mutable iterator over the entries of an [`IndexMap`].
///
-/// This `struct` is created by the [`par_iter_mut`] method on [`IndexMap`]
-/// (provided by rayon's `IntoParallelRefMutIterator` trait). See its documentation for more.
+/// This `struct` is created by the [`IndexMap::par_iter_mut`] method
+/// (provided by rayon's [`IntoParallelRefMutIterator`] trait). See its documentation for more.
///
-/// [`par_iter_mut`]: ../struct.IndexMap.html#method.par_iter_mut
-/// [`IndexMap`]: ../struct.IndexMap.html
+/// [`IndexMap::par_iter_mut`]: ../struct.IndexMap.html#method.par_iter_mut
pub struct ParIterMut<'a, K, V> {
entries: &'a mut [Bucket<K, V>],
}
@@ -157,7 +194,6 @@ impl<K: Sync + Send, V: Send> IndexedParallelIterator for ParIterMut<'_, K, V> {
indexed_parallel_iterator_methods!(Bucket::ref_mut);
}
-/// Requires crate feature `"rayon"`.
impl<'a, K, V, S> ParallelDrainRange<usize> for &'a mut IndexMap<K, V, S>
where
K: Send,
@@ -173,13 +209,12 @@ where
}
}
-/// A parallel draining iterator over the entries of a `IndexMap`.
+/// A parallel draining iterator over the entries of an [`IndexMap`].
///
-/// This `struct` is created by the [`par_drain`] method on [`IndexMap`]
-/// (provided by rayon's `ParallelDrainRange` trait). See its documentation for more.
+/// This `struct` is created by the [`IndexMap::par_drain`] method
+/// (provided by rayon's [`ParallelDrainRange`] trait). See its documentation for more.
///
-/// [`par_drain`]: ../struct.IndexMap.html#method.par_drain
-/// [`IndexMap`]: ../struct.IndexMap.html
+/// [`IndexMap::par_drain`]: ../struct.IndexMap.html#method.par_drain
pub struct ParDrain<'a, K: Send, V: Send> {
entries: rayon::vec::Drain<'a, Bucket<K, V>>,
}
@@ -225,6 +260,37 @@ where
}
}
+/// Parallel iterator methods and other parallel methods.
+///
+/// The following methods **require crate feature `"rayon"`**.
+///
+/// See also the `IntoParallelIterator` implementations.
+impl<K, V> Slice<K, V>
+where
+ K: Sync,
+ V: Sync,
+{
+ /// Return a parallel iterator over the keys of the map slice.
+ ///
+ /// While parallel iterators can process items in any order, their relative order
+ /// in the slice is still preserved for operations like `reduce` and `collect`.
+ pub fn par_keys(&self) -> ParKeys<'_, K, V> {
+ ParKeys {
+ entries: &self.entries,
+ }
+ }
+
+ /// Return a parallel iterator over the values of the map slice.
+ ///
+ /// While parallel iterators can process items in any order, their relative order
+ /// in the slice is still preserved for operations like `reduce` and `collect`.
+ pub fn par_values(&self) -> ParValues<'_, K, V> {
+ ParValues {
+ entries: &self.entries,
+ }
+ }
+}
+
impl<K, V, S> IndexMap<K, V, S>
where
K: Hash + Eq + Sync,
@@ -246,13 +312,10 @@ where
}
}
-/// A parallel iterator over the keys of a `IndexMap`.
+/// A parallel iterator over the keys of an [`IndexMap`].
///
-/// This `struct` is created by the [`par_keys`] method on [`IndexMap`]. See its
-/// documentation for more.
-///
-/// [`par_keys`]: ../struct.IndexMap.html#method.par_keys
-/// [`IndexMap`]: ../struct.IndexMap.html
+/// This `struct` is created by the [`IndexMap::par_keys`] method.
+/// See its documentation for more.
pub struct ParKeys<'a, K, V> {
entries: &'a [Bucket<K, V>],
}
@@ -280,13 +343,10 @@ impl<K: Sync, V: Sync> IndexedParallelIterator for ParKeys<'_, K, V> {
indexed_parallel_iterator_methods!(Bucket::key_ref);
}
-/// A parallel iterator over the values of a `IndexMap`.
-///
-/// This `struct` is created by the [`par_values`] method on [`IndexMap`]. See its
-/// documentation for more.
+/// A parallel iterator over the values of an [`IndexMap`].
///
-/// [`par_values`]: ../struct.IndexMap.html#method.par_values
-/// [`IndexMap`]: ../struct.IndexMap.html
+/// This `struct` is created by the [`IndexMap::par_values`] method.
+/// See its documentation for more.
pub struct ParValues<'a, K, V> {
entries: &'a [Bucket<K, V>],
}
@@ -314,7 +374,6 @@ impl<K: Sync, V: Sync> IndexedParallelIterator for ParValues<'_, K, V> {
indexed_parallel_iterator_methods!(Bucket::value_ref);
}
-/// Requires crate feature `"rayon"`.
impl<K, V, S> IndexMap<K, V, S>
where
K: Send,
@@ -331,11 +390,26 @@ where
}
}
+impl<K, V> Slice<K, V>
+where
+ K: Send,
+ V: Send,
+{
+ /// Return a parallel iterator over mutable references to the the values of the map slice.
+ ///
+ /// While parallel iterators can process items in any order, their relative order
+ /// in the slice is still preserved for operations like `reduce` and `collect`.
+ pub fn par_values_mut(&mut self) -> ParValuesMut<'_, K, V> {
+ ParValuesMut {
+ entries: &mut self.entries,
+ }
+ }
+}
+
impl<K, V, S> IndexMap<K, V, S>
where
- K: Hash + Eq + Send,
+ K: Send,
V: Send,
- S: BuildHasher,
{
/// Sort the map’s key-value pairs in parallel, by the default ordering of the keys.
pub fn par_sort_keys(&mut self)
@@ -406,15 +480,24 @@ where
entries.par_sort_unstable_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
IntoParIter { entries }
}
+
+ /// Sort the map’s key-value pairs in place and in parallel, using a sort-key extraction
+ /// function.
+ pub fn par_sort_by_cached_key<T, F>(&mut self, sort_key: F)
+ where
+ T: Ord + Send,
+ F: Fn(&K, &V) -> T + Sync,
+ {
+ self.with_entries(move |entries| {
+ entries.par_sort_by_cached_key(move |a| sort_key(&a.key, &a.value));
+ });
+ }
}
-/// A parallel mutable iterator over the values of a `IndexMap`.
-///
-/// This `struct` is created by the [`par_values_mut`] method on [`IndexMap`]. See its
-/// documentation for more.
+/// A parallel mutable iterator over the values of an [`IndexMap`].
///
-/// [`par_values_mut`]: ../struct.IndexMap.html#method.par_values_mut
-/// [`IndexMap`]: ../struct.IndexMap.html
+/// This `struct` is created by the [`IndexMap::par_values_mut`] method.
+/// See its documentation for more.
pub struct ParValuesMut<'a, K, V> {
entries: &'a mut [Bucket<K, V>],
}
@@ -436,7 +519,6 @@ impl<K: Send, V: Send> IndexedParallelIterator for ParValuesMut<'_, K, V> {
indexed_parallel_iterator_methods!(Bucket::value_mut);
}
-/// Requires crate feature `"rayon"`.
impl<K, V, S> FromParallelIterator<(K, V)> for IndexMap<K, V, S>
where
K: Eq + Hash + Send,
@@ -457,7 +539,6 @@ where
}
}
-/// Requires crate feature `"rayon"`.
impl<K, V, S> ParallelExtend<(K, V)> for IndexMap<K, V, S>
where
K: Eq + Hash + Send,
@@ -474,7 +555,6 @@ where
}
}
-/// Requires crate feature `"rayon"`.
impl<'a, K: 'a, V: 'a, S> ParallelExtend<(&'a K, &'a V)> for IndexMap<K, V, S>
where
K: Copy + Eq + Hash + Send + Sync,
diff --git a/third_party/rust/indexmap/src/rayon/mod.rs b/third_party/rust/indexmap/src/rayon/mod.rs
index ebb1ac2d1e..1d21569c18 100644
--- a/third_party/rust/indexmap/src/rayon/mod.rs
+++ b/third_party/rust/indexmap/src/rayon/mod.rs
@@ -1,3 +1,5 @@
+#![cfg_attr(docsrs, doc(cfg(feature = "rayon")))]
+
use rayon::prelude::*;
use alloc::collections::LinkedList;
diff --git a/third_party/rust/indexmap/src/rayon/set.rs b/third_party/rust/indexmap/src/rayon/set.rs
index 6749dc0d7f..3904234b20 100644
--- a/third_party/rust/indexmap/src/rayon/set.rs
+++ b/third_party/rust/indexmap/src/rayon/set.rs
@@ -1,26 +1,25 @@
-//! Parallel iterator types for `IndexSet` with [rayon](https://docs.rs/rayon/1.0/rayon).
+//! Parallel iterator types for [`IndexSet`] with [rayon][::rayon].
//!
//! You will rarely need to interact with this module directly unless you need to name one of the
//! iterator types.
-//!
-//! Requires crate feature `"rayon"`.
use super::collect;
use rayon::iter::plumbing::{Consumer, ProducerCallback, UnindexedConsumer};
use rayon::prelude::*;
use crate::vec::Vec;
+use alloc::boxed::Box;
use core::cmp::Ordering;
use core::fmt;
use core::hash::{BuildHasher, Hash};
use core::ops::RangeBounds;
+use crate::set::Slice;
use crate::Entries;
use crate::IndexSet;
type Bucket<T> = crate::Bucket<T, ()>;
-/// Requires crate feature `"rayon"`.
impl<T, S> IntoParallelIterator for IndexSet<T, S>
where
T: Send,
@@ -35,13 +34,24 @@ where
}
}
-/// A parallel owning iterator over the items of a `IndexSet`.
-///
-/// This `struct` is created by the [`into_par_iter`] method on [`IndexSet`]
-/// (provided by rayon's `IntoParallelIterator` trait). See its documentation for more.
+impl<T> IntoParallelIterator for Box<Slice<T>>
+where
+ T: Send,
+{
+ type Item = T;
+ type Iter = IntoParIter<T>;
+
+ fn into_par_iter(self) -> Self::Iter {
+ IntoParIter {
+ entries: self.into_entries(),
+ }
+ }
+}
+
+/// A parallel owning iterator over the items of an [`IndexSet`].
///
-/// [`IndexSet`]: ../struct.IndexSet.html
-/// [`into_par_iter`]: ../struct.IndexSet.html#method.into_par_iter
+/// This `struct` is created by the [`IndexSet::into_par_iter`] method
+/// (provided by rayon's [`IntoParallelIterator`] trait). See its documentation for more.
pub struct IntoParIter<T> {
entries: Vec<Bucket<T>>,
}
@@ -63,7 +73,6 @@ impl<T: Send> IndexedParallelIterator for IntoParIter<T> {
indexed_parallel_iterator_methods!(Bucket::key);
}
-/// Requires crate feature `"rayon"`.
impl<'a, T, S> IntoParallelIterator for &'a IndexSet<T, S>
where
T: Sync,
@@ -78,13 +87,26 @@ where
}
}
-/// A parallel iterator over the items of a `IndexSet`.
+impl<'a, T> IntoParallelIterator for &'a Slice<T>
+where
+ T: Sync,
+{
+ type Item = &'a T;
+ type Iter = ParIter<'a, T>;
+
+ fn into_par_iter(self) -> Self::Iter {
+ ParIter {
+ entries: &self.entries,
+ }
+ }
+}
+
+/// A parallel iterator over the items of an [`IndexSet`].
///
-/// This `struct` is created by the [`par_iter`] method on [`IndexSet`]
-/// (provided by rayon's `IntoParallelRefIterator` trait). See its documentation for more.
+/// This `struct` is created by the [`IndexSet::par_iter`] method
+/// (provided by rayon's [`IntoParallelRefIterator`] trait). See its documentation for more.
///
-/// [`IndexSet`]: ../struct.IndexSet.html
-/// [`par_iter`]: ../struct.IndexSet.html#method.par_iter
+/// [`IndexSet::par_iter`]: ../struct.IndexSet.html#method.par_iter
pub struct ParIter<'a, T> {
entries: &'a [Bucket<T>],
}
@@ -112,7 +134,6 @@ impl<T: Sync> IndexedParallelIterator for ParIter<'_, T> {
indexed_parallel_iterator_methods!(Bucket::key_ref);
}
-/// Requires crate feature `"rayon"`.
impl<'a, T, S> ParallelDrainRange<usize> for &'a mut IndexSet<T, S>
where
T: Send,
@@ -127,13 +148,12 @@ where
}
}
-/// A parallel draining iterator over the items of a `IndexSet`.
+/// A parallel draining iterator over the items of an [`IndexSet`].
///
-/// This `struct` is created by the [`par_drain`] method on [`IndexSet`]
-/// (provided by rayon's `ParallelDrainRange` trait). See its documentation for more.
+/// This `struct` is created by the [`IndexSet::par_drain`] method
+/// (provided by rayon's [`ParallelDrainRange`] trait). See its documentation for more.
///
-/// [`par_drain`]: ../struct.IndexSet.html#method.par_drain
-/// [`IndexSet`]: ../struct.IndexSet.html
+/// [`IndexSet::par_drain`]: ../struct.IndexSet.html#method.par_drain
pub struct ParDrain<'a, T: Send> {
entries: rayon::vec::Drain<'a, Bucket<T>>,
}
@@ -269,13 +289,10 @@ where
}
}
-/// A parallel iterator producing elements in the difference of `IndexSet`s.
+/// A parallel iterator producing elements in the difference of [`IndexSet`]s.
///
-/// This `struct` is created by the [`par_difference`] method on [`IndexSet`].
+/// This `struct` is created by the [`IndexSet::par_difference`] method.
/// See its documentation for more.
-///
-/// [`IndexSet`]: ../struct.IndexSet.html
-/// [`par_difference`]: ../struct.IndexSet.html#method.par_difference
pub struct ParDifference<'a, T, S1, S2> {
set1: &'a IndexSet<T, S1>,
set2: &'a IndexSet<T, S2>,
@@ -320,13 +337,10 @@ where
}
}
-/// A parallel iterator producing elements in the intersection of `IndexSet`s.
+/// A parallel iterator producing elements in the intersection of [`IndexSet`]s.
///
-/// This `struct` is created by the [`par_intersection`] method on [`IndexSet`].
+/// This `struct` is created by the [`IndexSet::par_intersection`] method.
/// See its documentation for more.
-///
-/// [`IndexSet`]: ../struct.IndexSet.html
-/// [`par_intersection`]: ../struct.IndexSet.html#method.par_intersection
pub struct ParIntersection<'a, T, S1, S2> {
set1: &'a IndexSet<T, S1>,
set2: &'a IndexSet<T, S2>,
@@ -371,13 +385,10 @@ where
}
}
-/// A parallel iterator producing elements in the symmetric difference of `IndexSet`s.
-///
-/// This `struct` is created by the [`par_symmetric_difference`] method on
-/// [`IndexSet`]. See its documentation for more.
+/// A parallel iterator producing elements in the symmetric difference of [`IndexSet`]s.
///
-/// [`IndexSet`]: ../struct.IndexSet.html
-/// [`par_symmetric_difference`]: ../struct.IndexSet.html#method.par_symmetric_difference
+/// This `struct` is created by the [`IndexSet::par_symmetric_difference`] method.
+/// See its documentation for more.
pub struct ParSymmetricDifference<'a, T, S1, S2> {
set1: &'a IndexSet<T, S1>,
set2: &'a IndexSet<T, S2>,
@@ -422,13 +433,10 @@ where
}
}
-/// A parallel iterator producing elements in the union of `IndexSet`s.
+/// A parallel iterator producing elements in the union of [`IndexSet`]s.
///
-/// This `struct` is created by the [`par_union`] method on [`IndexSet`].
+/// This `struct` is created by the [`IndexSet::par_union`] method.
/// See its documentation for more.
-///
-/// [`IndexSet`]: ../struct.IndexSet.html
-/// [`par_union`]: ../struct.IndexSet.html#method.par_union
pub struct ParUnion<'a, T, S1, S2> {
set1: &'a IndexSet<T, S1>,
set2: &'a IndexSet<T, S2>,
@@ -476,8 +484,7 @@ where
/// The following methods **require crate feature `"rayon"`**.
impl<T, S> IndexSet<T, S>
where
- T: Hash + Eq + Send,
- S: BuildHasher + Send,
+ T: Send,
{
/// Sort the set’s values in parallel by their default ordering.
pub fn par_sort(&mut self)
@@ -540,9 +547,19 @@ where
entries.par_sort_unstable_by(move |a, b| cmp(&a.key, &b.key));
IntoParIter { entries }
}
+
+ /// Sort the set’s values in place and in parallel, using a key extraction function.
+ pub fn par_sort_by_cached_key<K, F>(&mut self, sort_key: F)
+ where
+ K: Ord + Send,
+ F: Fn(&T) -> K + Sync,
+ {
+ self.with_entries(move |entries| {
+ entries.par_sort_by_cached_key(move |a| sort_key(&a.key));
+ });
+ }
}
-/// Requires crate feature `"rayon"`.
impl<T, S> FromParallelIterator<T> for IndexSet<T, S>
where
T: Eq + Hash + Send,
@@ -562,7 +579,6 @@ where
}
}
-/// Requires crate feature `"rayon"`.
impl<T, S> ParallelExtend<T> for IndexSet<T, S>
where
T: Eq + Hash + Send,
@@ -578,7 +594,6 @@ where
}
}
-/// Requires crate feature `"rayon"`.
impl<'a, T: 'a, S> ParallelExtend<&'a T> for IndexSet<T, S>
where
T: Copy + Eq + Hash + Send + Sync,
diff --git a/third_party/rust/indexmap/src/serde.rs b/third_party/rust/indexmap/src/serde.rs
index c6dd6d5ea0..25546d531b 100644
--- a/third_party/rust/indexmap/src/serde.rs
+++ b/third_party/rust/indexmap/src/serde.rs
@@ -1,3 +1,5 @@
+#![cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+
use serde::de::value::{MapDeserializer, SeqDeserializer};
use serde::de::{
Deserialize, Deserializer, Error, IntoDeserializer, MapAccess, SeqAccess, Visitor,
@@ -7,15 +9,30 @@ use serde::ser::{Serialize, Serializer};
use core::fmt::{self, Formatter};
use core::hash::{BuildHasher, Hash};
use core::marker::PhantomData;
+use core::{cmp, mem};
+
+use crate::{Bucket, IndexMap, IndexSet};
+
+/// Limit our preallocated capacity from a deserializer `size_hint()`.
+///
+/// We do account for the `Bucket` overhead from its saved `hash` field, but we don't count the
+/// `RawTable` allocation or the fact that its raw capacity will be rounded up to a power of two.
+/// The "max" is an arbitrary choice anyway, not something that needs precise adherence.
+///
+/// This is based on the internal `serde::de::size_hint::cautious(hint)` function.
+pub(crate) fn cautious_capacity<K, V>(hint: Option<usize>) -> usize {
+ const MAX_PREALLOC_BYTES: usize = 1024 * 1024;
+
+ cmp::min(
+ hint.unwrap_or(0),
+ MAX_PREALLOC_BYTES / mem::size_of::<Bucket<K, V>>(),
+ )
+}
-use crate::IndexMap;
-
-/// Requires crate feature `"serde"` or `"serde-1"`
impl<K, V, S> Serialize for IndexMap<K, V, S>
where
- K: Serialize + Hash + Eq,
+ K: Serialize,
V: Serialize,
- S: BuildHasher,
{
fn serialize<T>(&self, serializer: T) -> Result<T::Ok, T::Error>
where
@@ -43,8 +60,8 @@ where
where
A: MapAccess<'de>,
{
- let mut values =
- IndexMap::with_capacity_and_hasher(map.size_hint().unwrap_or(0), S::default());
+ let capacity = cautious_capacity::<K, V>(map.size_hint());
+ let mut values = IndexMap::with_capacity_and_hasher(capacity, S::default());
while let Some((key, value)) = map.next_entry()? {
values.insert(key, value);
@@ -54,7 +71,6 @@ where
}
}
-/// Requires crate feature `"serde"` or `"serde-1"`
impl<'de, K, V, S> Deserialize<'de> for IndexMap<K, V, S>
where
K: Deserialize<'de> + Eq + Hash,
@@ -83,13 +99,9 @@ where
}
}
-use crate::IndexSet;
-
-/// Requires crate feature `"serde"` or `"serde-1"`
impl<T, S> Serialize for IndexSet<T, S>
where
- T: Serialize + Hash + Eq,
- S: BuildHasher,
+ T: Serialize,
{
fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error>
where
@@ -116,8 +128,8 @@ where
where
A: SeqAccess<'de>,
{
- let mut values =
- IndexSet::with_capacity_and_hasher(seq.size_hint().unwrap_or(0), S::default());
+ let capacity = cautious_capacity::<T, ()>(seq.size_hint());
+ let mut values = IndexSet::with_capacity_and_hasher(capacity, S::default());
while let Some(value) = seq.next_element()? {
values.insert(value);
@@ -127,7 +139,6 @@ where
}
}
-/// Requires crate feature `"serde"` or `"serde-1"`
impl<'de, T, S> Deserialize<'de> for IndexSet<T, S>
where
T: Deserialize<'de> + Eq + Hash,
diff --git a/third_party/rust/indexmap/src/set.rs b/third_party/rust/indexmap/src/set.rs
index 3728947426..b5bd05f1bc 100644
--- a/third_party/rust/indexmap/src/set.rs
+++ b/third_party/rust/indexmap/src/set.rs
@@ -1,18 +1,32 @@
-//! A hash set implemented using `IndexMap`
+//! A hash set implemented using [`IndexMap`]
+
+mod iter;
+mod mutable;
+mod slice;
+
+#[cfg(test)]
+mod tests;
+
+pub use self::iter::{
+ Difference, Drain, Intersection, IntoIter, Iter, Splice, SymmetricDifference, Union,
+};
+pub use self::mutable::MutableValues;
+pub use self::slice::Slice;
#[cfg(feature = "rayon")]
pub use crate::rayon::set as rayon;
+use crate::TryReserveError;
-#[cfg(has_std)]
+#[cfg(feature = "std")]
use std::collections::hash_map::RandomState;
-use crate::vec::{self, Vec};
+use crate::util::try_simplify_range;
+use alloc::boxed::Box;
+use alloc::vec::Vec;
use core::cmp::Ordering;
use core::fmt;
use core::hash::{BuildHasher, Hash};
-use core::iter::{Chain, FusedIterator};
use core::ops::{BitAnd, BitOr, BitXor, Index, RangeBounds, Sub};
-use core::slice;
use super::{Entries, Equivalent, IndexMap};
@@ -21,8 +35,9 @@ type Bucket<T> = super::Bucket<T, ()>;
/// A hash set where the iteration order of the values is independent of their
/// hash values.
///
-/// The interface is closely compatible with the standard `HashSet`, but also
-/// has additional features.
+/// The interface is closely compatible with the standard
+/// [`HashSet`][std::collections::HashSet],
+/// but also has additional features.
///
/// # Order
///
@@ -33,11 +48,12 @@ type Bucket<T> = super::Bucket<T, ()>;
/// already present.
///
/// All iterators traverse the set *in order*. Set operation iterators like
-/// `union` produce a concatenated order, as do their matching "bitwise"
+/// [`IndexSet::union`] produce a concatenated order, as do their matching "bitwise"
/// operators. See their documentation for specifics.
///
/// The insertion order is preserved, with **notable exceptions** like the
-/// `.remove()` or `.swap_remove()` methods. Methods such as `.sort_by()` of
+/// [`.remove()`][Self::remove] or [`.swap_remove()`][Self::swap_remove] methods.
+/// Methods such as [`.sort_by()`][Self::sort_by] of
/// course result in a new order, depending on the sorting order.
///
/// # Indices
@@ -46,6 +62,11 @@ type Bucket<T> = super::Bucket<T, ()>;
/// `0..self.len()`. For example, the method `.get_full` looks up the index for
/// a value, and the method `.get_index` looks up the value by index.
///
+/// # Complexity
+///
+/// Internally, `IndexSet<T, S>` just holds an [`IndexMap<T, (), S>`](IndexMap). Thus the complexity
+/// of the two are the same for most methods.
+///
/// # Examples
///
/// ```
@@ -59,11 +80,11 @@ type Bucket<T> = super::Bucket<T, ()>;
/// assert!(letters.contains(&'u'));
/// assert!(!letters.contains(&'y'));
/// ```
-#[cfg(has_std)]
+#[cfg(feature = "std")]
pub struct IndexSet<T, S = RandomState> {
pub(crate) map: IndexMap<T, (), S>,
}
-#[cfg(not(has_std))]
+#[cfg(not(feature = "std"))]
pub struct IndexSet<T, S> {
pub(crate) map: IndexMap<T, (), S>,
}
@@ -114,17 +135,20 @@ impl<T, S> fmt::Debug for IndexSet<T, S>
where
T: fmt::Debug,
{
+ #[cfg(not(feature = "test_debug"))]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- if cfg!(not(feature = "test_debug")) {
- f.debug_set().entries(self.iter()).finish()
- } else {
- // Let the inner `IndexMap` print all of its details
- f.debug_struct("IndexSet").field("map", &self.map).finish()
- }
+ f.debug_set().entries(self.iter()).finish()
+ }
+
+ #[cfg(feature = "test_debug")]
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ // Let the inner `IndexMap` print all of its details
+ f.debug_struct("IndexSet").field("map", &self.map).finish()
}
}
-#[cfg(has_std)]
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl<T> IndexSet<T> {
/// Create a new set. (Does not allocate.)
pub fn new() -> Self {
@@ -165,6 +189,11 @@ impl<T, S> IndexSet<T, S> {
}
}
+ /// Return the number of elements the set can hold without reallocating.
+ ///
+ /// This number is a lower bound; the set might be able to hold more,
+ /// but is guaranteed to be able to hold at least this many.
+ ///
/// Computes in **O(1)** time.
pub fn capacity(&self) -> usize {
self.map.capacity()
@@ -191,9 +220,7 @@ impl<T, S> IndexSet<T, S> {
/// Return an iterator over the values of the set, in their order
pub fn iter(&self) -> Iter<'_, T> {
- Iter {
- iter: self.map.as_entries().iter(),
- }
+ Iter::new(self.as_entries())
}
/// Remove all elements in the set, while preserving its capacity.
@@ -213,7 +240,7 @@ impl<T, S> IndexSet<T, S> {
/// Clears the `IndexSet` in the given index range, returning those values
/// as a drain iterator.
///
- /// The range may be any type that implements `RangeBounds<usize>`,
+ /// The range may be any type that implements [`RangeBounds<usize>`],
/// including all of the `std::ops::Range*` types, or even a tuple pair of
/// `Bound` start and end values. To drain the set entirely, use `RangeFull`
/// like `set.drain(..)`.
@@ -227,9 +254,7 @@ impl<T, S> IndexSet<T, S> {
where
R: RangeBounds<usize>,
{
- Drain {
- iter: self.map.drain(range).iter,
- }
+ Drain::new(self.map.core.drain(range))
}
/// Splits the collection into two at the given index.
@@ -247,13 +272,7 @@ impl<T, S> IndexSet<T, S> {
map: self.map.split_off(at),
}
}
-}
-impl<T, S> IndexSet<T, S>
-where
- T: Hash + Eq,
- S: BuildHasher,
-{
/// Reserve capacity for `additional` more values.
///
/// Computes in **O(n)** time.
@@ -261,6 +280,37 @@ where
self.map.reserve(additional);
}
+ /// Reserve capacity for `additional` more values, without over-allocating.
+ ///
+ /// Unlike `reserve`, this does not deliberately over-allocate the entry capacity to avoid
+ /// frequent re-allocations. However, the underlying data structures may still have internal
+ /// capacity requirements, and the allocator itself may give more space than requested, so this
+ /// cannot be relied upon to be precisely minimal.
+ ///
+ /// Computes in **O(n)** time.
+ pub fn reserve_exact(&mut self, additional: usize) {
+ self.map.reserve_exact(additional);
+ }
+
+ /// Try to reserve capacity for `additional` more values.
+ ///
+ /// Computes in **O(n)** time.
+ pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> {
+ self.map.try_reserve(additional)
+ }
+
+ /// Try to reserve capacity for `additional` more values, without over-allocating.
+ ///
+ /// Unlike `try_reserve`, this does not deliberately over-allocate the entry capacity to avoid
+ /// frequent re-allocations. However, the underlying data structures may still have internal
+ /// capacity requirements, and the allocator itself may give more space than requested, so this
+ /// cannot be relied upon to be precisely minimal.
+ ///
+ /// Computes in **O(n)** time.
+ pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> {
+ self.map.try_reserve_exact(additional)
+ }
+
/// Shrink the capacity of the set as much as possible.
///
/// Computes in **O(n)** time.
@@ -274,7 +324,13 @@ where
pub fn shrink_to(&mut self, min_capacity: usize) {
self.map.shrink_to(min_capacity);
}
+}
+impl<T, S> IndexSet<T, S>
+where
+ T: Hash + Eq,
+ S: BuildHasher,
+{
/// Insert the value into the set.
///
/// If an equivalent item already exists in the set, it returns
@@ -297,15 +353,69 @@ where
///
/// Computes in **O(1)** time (amortized average).
pub fn insert_full(&mut self, value: T) -> (usize, bool) {
- use super::map::Entry::*;
-
- match self.map.entry(value) {
- Occupied(e) => (e.index(), false),
- Vacant(e) => {
- let index = e.index();
- e.insert(());
- (index, true)
- }
+ let (index, existing) = self.map.insert_full(value, ());
+ (index, existing.is_none())
+ }
+
+ /// Insert the value into the set at its ordered position among sorted values.
+ ///
+ /// This is equivalent to finding the position with
+ /// [`binary_search`][Self::binary_search], and if needed calling
+ /// [`shift_insert`][Self::shift_insert] for a new value.
+ ///
+ /// If the sorted item is found in the set, it returns the index of that
+ /// existing item and `false`, without any change. Otherwise, it inserts the
+ /// new item and returns its sorted index and `true`.
+ ///
+ /// If the existing items are **not** already sorted, then the insertion
+ /// index is unspecified (like [`slice::binary_search`]), but the value
+ /// is moved to or inserted at that position regardless.
+ ///
+ /// Computes in **O(n)** time (average). Instead of repeating calls to
+ /// `insert_sorted`, it may be faster to call batched [`insert`][Self::insert]
+ /// or [`extend`][Self::extend] and only call [`sort`][Self::sort] or
+ /// [`sort_unstable`][Self::sort_unstable] once.
+ pub fn insert_sorted(&mut self, value: T) -> (usize, bool)
+ where
+ T: Ord,
+ {
+ let (index, existing) = self.map.insert_sorted(value, ());
+ (index, existing.is_none())
+ }
+
+ /// Insert the value into the set at the given index.
+ ///
+ /// If an equivalent item already exists in the set, it returns
+ /// `false` leaving the original value in the set, but moving it to
+ /// the new position in the set. Otherwise, it inserts the new
+ /// item at the given index and returns `true`.
+ ///
+ /// ***Panics*** if `index` is out of bounds.
+ ///
+ /// Computes in **O(n)** time (average).
+ pub fn shift_insert(&mut self, index: usize, value: T) -> bool {
+ self.map.shift_insert(index, value, ()).is_none()
+ }
+
+ /// Adds a value to the set, replacing the existing value, if any, that is
+ /// equal to the given one, without altering its insertion order. Returns
+ /// the replaced value.
+ ///
+ /// Computes in **O(1)** time (average).
+ pub fn replace(&mut self, value: T) -> Option<T> {
+ self.replace_full(value).1
+ }
+
+ /// Adds a value to the set, replacing the existing value, if any, that is
+ /// equal to the given one, without altering its insertion order. Returns
+ /// the index of the item and its replaced value.
+ ///
+ /// Computes in **O(1)** time (average).
+ pub fn replace_full(&mut self, value: T) -> (usize, Option<T>) {
+ let hash = self.map.hash(&value);
+ match self.map.core.replace_full(hash, value, ()) {
+ (i, Some((replaced, ()))) => (i, Some(replaced)),
+ (i, None) => (i, None),
}
}
@@ -316,10 +426,7 @@ where
where
S2: BuildHasher,
{
- Difference {
- iter: self.iter(),
- other,
- }
+ Difference::new(self, other)
}
/// Return an iterator over the values that are in `self` or `other`,
@@ -334,9 +441,7 @@ where
where
S2: BuildHasher,
{
- SymmetricDifference {
- iter: self.difference(other).chain(other.difference(self)),
- }
+ SymmetricDifference::new(self, other)
}
/// Return an iterator over the values that are in both `self` and `other`.
@@ -346,10 +451,7 @@ where
where
S2: BuildHasher,
{
- Intersection {
- iter: self.iter(),
- other,
- }
+ Intersection::new(self, other)
}
/// Return an iterator over all values that are in `self` or `other`.
@@ -360,17 +462,57 @@ where
where
S2: BuildHasher,
{
- Union {
- iter: self.iter().chain(other.difference(self)),
- }
+ Union::new(self, other)
}
+ /// Creates a splicing iterator that replaces the specified range in the set
+ /// with the given `replace_with` iterator and yields the removed items.
+ /// `replace_with` does not need to be the same length as `range`.
+ ///
+ /// The `range` is removed even if the iterator is not consumed until the
+ /// end. It is unspecified how many elements are removed from the set if the
+ /// `Splice` value is leaked.
+ ///
+ /// The input iterator `replace_with` is only consumed when the `Splice`
+ /// value is dropped. If a value from the iterator matches an existing entry
+ /// in the set (outside of `range`), then the original will be unchanged.
+ /// Otherwise, the new value will be inserted in the replaced `range`.
+ ///
+ /// ***Panics*** if the starting point is greater than the end point or if
+ /// the end point is greater than the length of the set.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use indexmap::IndexSet;
+ ///
+ /// let mut set = IndexSet::from([0, 1, 2, 3, 4]);
+ /// let new = [5, 4, 3, 2, 1];
+ /// let removed: Vec<_> = set.splice(2..4, new).collect();
+ ///
+ /// // 1 and 4 kept their positions, while 5, 3, and 2 were newly inserted.
+ /// assert!(set.into_iter().eq([0, 1, 5, 3, 2, 4]));
+ /// assert_eq!(removed, &[2, 3]);
+ /// ```
+ pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter, T, S>
+ where
+ R: RangeBounds<usize>,
+ I: IntoIterator<Item = T>,
+ {
+ Splice::new(self, range, replace_with.into_iter())
+ }
+}
+
+impl<T, S> IndexSet<T, S>
+where
+ S: BuildHasher,
+{
/// Return `true` if an equivalent to `value` exists in the set.
///
/// Computes in **O(1)** time (average).
- pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool
+ pub fn contains<Q>(&self, value: &Q) -> bool
where
- Q: Hash + Equivalent<T>,
+ Q: ?Sized + Hash + Equivalent<T>,
{
self.map.contains_key(value)
}
@@ -379,97 +521,74 @@ where
/// else `None`.
///
/// Computes in **O(1)** time (average).
- pub fn get<Q: ?Sized>(&self, value: &Q) -> Option<&T>
+ pub fn get<Q>(&self, value: &Q) -> Option<&T>
where
- Q: Hash + Equivalent<T>,
+ Q: ?Sized + Hash + Equivalent<T>,
{
self.map.get_key_value(value).map(|(x, &())| x)
}
/// Return item index and value
- pub fn get_full<Q: ?Sized>(&self, value: &Q) -> Option<(usize, &T)>
+ pub fn get_full<Q>(&self, value: &Q) -> Option<(usize, &T)>
where
- Q: Hash + Equivalent<T>,
+ Q: ?Sized + Hash + Equivalent<T>,
{
self.map.get_full(value).map(|(i, x, &())| (i, x))
}
/// Return item index, if it exists in the set
- pub fn get_index_of<Q: ?Sized>(&self, value: &Q) -> Option<usize>
+ ///
+ /// Computes in **O(1)** time (average).
+ pub fn get_index_of<Q>(&self, value: &Q) -> Option<usize>
where
- Q: Hash + Equivalent<T>,
+ Q: ?Sized + Hash + Equivalent<T>,
{
self.map.get_index_of(value)
}
- /// Adds a value to the set, replacing the existing value, if any, that is
- /// equal to the given one, without altering its insertion order. Returns
- /// the replaced value.
- ///
- /// Computes in **O(1)** time (average).
- pub fn replace(&mut self, value: T) -> Option<T> {
- self.replace_full(value).1
- }
-
- /// Adds a value to the set, replacing the existing value, if any, that is
- /// equal to the given one, without altering its insertion order. Returns
- /// the index of the item and its replaced value.
- ///
- /// Computes in **O(1)** time (average).
- pub fn replace_full(&mut self, value: T) -> (usize, Option<T>) {
- use super::map::Entry::*;
-
- match self.map.entry(value) {
- Vacant(e) => {
- let index = e.index();
- e.insert(());
- (index, None)
- }
- Occupied(e) => (e.index(), Some(e.replace_key())),
- }
- }
-
/// Remove the value from the set, and return `true` if it was present.
///
- /// **NOTE:** This is equivalent to `.swap_remove(value)`, if you want
- /// to preserve the order of the values in the set, use `.shift_remove(value)`.
- ///
- /// Computes in **O(1)** time (average).
- pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool
+ /// **NOTE:** This is equivalent to [`.swap_remove(value)`][Self::swap_remove], replacing this
+ /// value's position with the last element, and it is deprecated in favor of calling that
+ /// explicitly. If you need to preserve the relative order of the values in the set, use
+ /// [`.shift_remove(value)`][Self::shift_remove] instead.
+ #[deprecated(note = "`remove` disrupts the set order -- \
+ use `swap_remove` or `shift_remove` for explicit behavior.")]
+ pub fn remove<Q>(&mut self, value: &Q) -> bool
where
- Q: Hash + Equivalent<T>,
+ Q: ?Sized + Hash + Equivalent<T>,
{
self.swap_remove(value)
}
/// Remove the value from the set, and return `true` if it was present.
///
- /// Like `Vec::swap_remove`, the value is removed by swapping it with the
+ /// Like [`Vec::swap_remove`], the value is removed by swapping it with the
/// last element of the set and popping it off. **This perturbs
/// the position of what used to be the last element!**
///
/// Return `false` if `value` was not in the set.
///
/// Computes in **O(1)** time (average).
- pub fn swap_remove<Q: ?Sized>(&mut self, value: &Q) -> bool
+ pub fn swap_remove<Q>(&mut self, value: &Q) -> bool
where
- Q: Hash + Equivalent<T>,
+ Q: ?Sized + Hash + Equivalent<T>,
{
self.map.swap_remove(value).is_some()
}
/// Remove the value from the set, and return `true` if it was present.
///
- /// Like `Vec::remove`, the value is removed by shifting all of the
+ /// Like [`Vec::remove`], the value is removed by shifting all of the
/// elements that follow it, preserving their relative order.
/// **This perturbs the index of all of those elements!**
///
/// Return `false` if `value` was not in the set.
///
/// Computes in **O(n)** time (average).
- pub fn shift_remove<Q: ?Sized>(&mut self, value: &Q) -> bool
+ pub fn shift_remove<Q>(&mut self, value: &Q) -> bool
where
- Q: Hash + Equivalent<T>,
+ Q: ?Sized + Hash + Equivalent<T>,
{
self.map.shift_remove(value).is_some()
}
@@ -477,14 +596,15 @@ where
/// Removes and returns the value in the set, if any, that is equal to the
/// given one.
///
- /// **NOTE:** This is equivalent to `.swap_take(value)`, if you need to
- /// preserve the order of the values in the set, use `.shift_take(value)`
- /// instead.
- ///
- /// Computes in **O(1)** time (average).
- pub fn take<Q: ?Sized>(&mut self, value: &Q) -> Option<T>
+ /// **NOTE:** This is equivalent to [`.swap_take(value)`][Self::swap_take], replacing this
+ /// value's position with the last element, and it is deprecated in favor of calling that
+ /// explicitly. If you need to preserve the relative order of the values in the set, use
+ /// [`.shift_take(value)`][Self::shift_take] instead.
+ #[deprecated(note = "`take` disrupts the set order -- \
+ use `swap_take` or `shift_take` for explicit behavior.")]
+ pub fn take<Q>(&mut self, value: &Q) -> Option<T>
where
- Q: Hash + Equivalent<T>,
+ Q: ?Sized + Hash + Equivalent<T>,
{
self.swap_take(value)
}
@@ -492,16 +612,16 @@ where
/// Removes and returns the value in the set, if any, that is equal to the
/// given one.
///
- /// Like `Vec::swap_remove`, the value is removed by swapping it with the
+ /// Like [`Vec::swap_remove`], the value is removed by swapping it with the
/// last element of the set and popping it off. **This perturbs
/// the position of what used to be the last element!**
///
/// Return `None` if `value` was not in the set.
///
/// Computes in **O(1)** time (average).
- pub fn swap_take<Q: ?Sized>(&mut self, value: &Q) -> Option<T>
+ pub fn swap_take<Q>(&mut self, value: &Q) -> Option<T>
where
- Q: Hash + Equivalent<T>,
+ Q: ?Sized + Hash + Equivalent<T>,
{
self.map.swap_remove_entry(value).map(|(x, ())| x)
}
@@ -509,48 +629,50 @@ where
/// Removes and returns the value in the set, if any, that is equal to the
/// given one.
///
- /// Like `Vec::remove`, the value is removed by shifting all of the
+ /// Like [`Vec::remove`], the value is removed by shifting all of the
/// elements that follow it, preserving their relative order.
/// **This perturbs the index of all of those elements!**
///
/// Return `None` if `value` was not in the set.
///
/// Computes in **O(n)** time (average).
- pub fn shift_take<Q: ?Sized>(&mut self, value: &Q) -> Option<T>
+ pub fn shift_take<Q>(&mut self, value: &Q) -> Option<T>
where
- Q: Hash + Equivalent<T>,
+ Q: ?Sized + Hash + Equivalent<T>,
{
self.map.shift_remove_entry(value).map(|(x, ())| x)
}
/// Remove the value from the set return it and the index it had.
///
- /// Like `Vec::swap_remove`, the value is removed by swapping it with the
+ /// Like [`Vec::swap_remove`], the value is removed by swapping it with the
/// last element of the set and popping it off. **This perturbs
/// the position of what used to be the last element!**
///
/// Return `None` if `value` was not in the set.
- pub fn swap_remove_full<Q: ?Sized>(&mut self, value: &Q) -> Option<(usize, T)>
+ pub fn swap_remove_full<Q>(&mut self, value: &Q) -> Option<(usize, T)>
where
- Q: Hash + Equivalent<T>,
+ Q: ?Sized + Hash + Equivalent<T>,
{
self.map.swap_remove_full(value).map(|(i, x, ())| (i, x))
}
/// Remove the value from the set return it and the index it had.
///
- /// Like `Vec::remove`, the value is removed by shifting all of the
+ /// Like [`Vec::remove`], the value is removed by shifting all of the
/// elements that follow it, preserving their relative order.
/// **This perturbs the index of all of those elements!**
///
/// Return `None` if `value` was not in the set.
- pub fn shift_remove_full<Q: ?Sized>(&mut self, value: &Q) -> Option<(usize, T)>
+ pub fn shift_remove_full<Q>(&mut self, value: &Q) -> Option<(usize, T)>
where
- Q: Hash + Equivalent<T>,
+ Q: ?Sized + Hash + Equivalent<T>,
{
self.map.shift_remove_full(value).map(|(i, x, ())| (i, x))
}
+}
+impl<T, S> IndexSet<T, S> {
/// Remove the last value
///
/// This preserves the order of the remaining elements.
@@ -576,6 +698,10 @@ where
/// Sort the set’s values by their default ordering.
///
+ /// This is a stable sort -- but equivalent values should not normally coexist in
+ /// a set at all, so [`sort_unstable`][Self::sort_unstable] is preferred
+ /// because it is generally faster and doesn't allocate auxiliary memory.
+ ///
/// See [`sort_by`](Self::sort_by) for details.
pub fn sort(&mut self)
where
@@ -604,9 +730,7 @@ where
{
let mut entries = self.into_entries();
entries.sort_by(move |a, b| cmp(&a.key, &b.key));
- IntoIter {
- iter: entries.into_iter(),
- }
+ IntoIter::new(entries)
}
/// Sort the set's values by their default ordering.
@@ -619,7 +743,7 @@ where
self.map.sort_unstable_keys()
}
- /// Sort the set's values in place using the comparison funtion `cmp`.
+ /// Sort the set's values in place using the comparison function `cmp`.
///
/// Computes in **O(n log n)** time. The sort is unstable.
pub fn sort_unstable_by<F>(&mut self, mut cmp: F)
@@ -637,9 +761,82 @@ where
{
let mut entries = self.into_entries();
entries.sort_unstable_by(move |a, b| cmp(&a.key, &b.key));
- IntoIter {
- iter: entries.into_iter(),
- }
+ IntoIter::new(entries)
+ }
+
+ /// Sort the set’s values in place using a key extraction function.
+ ///
+ /// During sorting, the function is called at most once per entry, by using temporary storage
+ /// to remember the results of its evaluation. The order of calls to the function is
+ /// unspecified and may change between versions of `indexmap` or the standard library.
+ ///
+ /// Computes in **O(m n + n log n + c)** time () and **O(n)** space, where the function is
+ /// **O(m)**, *n* is the length of the map, and *c* the capacity. The sort is stable.
+ pub fn sort_by_cached_key<K, F>(&mut self, mut sort_key: F)
+ where
+ K: Ord,
+ F: FnMut(&T) -> K,
+ {
+ self.with_entries(move |entries| {
+ entries.sort_by_cached_key(move |a| sort_key(&a.key));
+ });
+ }
+
+ /// Search over a sorted set for a value.
+ ///
+ /// Returns the position where that value is present, or the position where it can be inserted
+ /// to maintain the sort. See [`slice::binary_search`] for more details.
+ ///
+ /// Computes in **O(log(n))** time, which is notably less scalable than looking the value up
+ /// using [`get_index_of`][IndexSet::get_index_of], but this can also position missing values.
+ pub fn binary_search(&self, x: &T) -> Result<usize, usize>
+ where
+ T: Ord,
+ {
+ self.as_slice().binary_search(x)
+ }
+
+ /// Search over a sorted set with a comparator function.
+ ///
+ /// Returns the position where that value is present, or the position where it can be inserted
+ /// to maintain the sort. See [`slice::binary_search_by`] for more details.
+ ///
+ /// Computes in **O(log(n))** time.
+ #[inline]
+ pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
+ where
+ F: FnMut(&'a T) -> Ordering,
+ {
+ self.as_slice().binary_search_by(f)
+ }
+
+ /// Search over a sorted set with an extraction function.
+ ///
+ /// Returns the position where that value is present, or the position where it can be inserted
+ /// to maintain the sort. See [`slice::binary_search_by_key`] for more details.
+ ///
+ /// Computes in **O(log(n))** time.
+ #[inline]
+ pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<usize, usize>
+ where
+ F: FnMut(&'a T) -> B,
+ B: Ord,
+ {
+ self.as_slice().binary_search_by_key(b, f)
+ }
+
+ /// Returns the index of the partition point of a sorted set according to the given predicate
+ /// (the index of the first element of the second partition).
+ ///
+ /// See [`slice::partition_point`] for more details.
+ ///
+ /// Computes in **O(log(n))** time.
+ #[must_use]
+ pub fn partition_point<P>(&self, pred: P) -> usize
+ where
+ P: FnMut(&T) -> bool,
+ {
+ self.as_slice().partition_point(pred)
}
/// Reverses the order of the set’s values in place.
@@ -648,9 +845,21 @@ where
pub fn reverse(&mut self) {
self.map.reverse()
}
-}
-impl<T, S> IndexSet<T, S> {
+ /// Returns a slice of all the values in the set.
+ ///
+ /// Computes in **O(1)** time.
+ pub fn as_slice(&self) -> &Slice<T> {
+ Slice::from_slice(self.as_entries())
+ }
+
+ /// Converts into a boxed slice of all the values in the set.
+ ///
+ /// Note that this will drop the inner hash table and any excess capacity.
+ pub fn into_boxed_slice(self) -> Box<Slice<T>> {
+ Slice::from_boxed(self.into_entries().into_boxed_slice())
+ }
+
/// Get a value by index
///
/// Valid indices are *0 <= index < self.len()*
@@ -660,6 +869,17 @@ impl<T, S> IndexSet<T, S> {
self.as_entries().get(index).map(Bucket::key_ref)
}
+ /// Returns a slice of values in the given range of indices.
+ ///
+ /// Valid indices are *0 <= index < self.len()*
+ ///
+ /// Computes in **O(1)** time.
+ pub fn get_range<R: RangeBounds<usize>>(&self, range: R) -> Option<&Slice<T>> {
+ let entries = self.as_entries();
+ let range = try_simplify_range(range, entries.len())?;
+ entries.get(range).map(Slice::from_slice)
+ }
+
/// Get the first value
///
/// Computes in **O(1)** time.
@@ -678,7 +898,7 @@ impl<T, S> IndexSet<T, S> {
///
/// Valid indices are *0 <= index < self.len()*
///
- /// Like `Vec::swap_remove`, the value is removed by swapping it with the
+ /// Like [`Vec::swap_remove`], the value is removed by swapping it with the
/// last element of the set and popping it off. **This perturbs
/// the position of what used to be the last element!**
///
@@ -691,7 +911,7 @@ impl<T, S> IndexSet<T, S> {
///
/// Valid indices are *0 <= index < self.len()*
///
- /// Like `Vec::remove`, the value is removed by shifting all of the
+ /// Like [`Vec::remove`], the value is removed by shifting all of the
/// elements that follow it, preserving their relative order.
/// **This perturbs the index of all of those elements!**
///
@@ -716,12 +936,14 @@ impl<T, S> IndexSet<T, S> {
/// Swaps the position of two values in the set.
///
/// ***Panics*** if `a` or `b` are out of bounds.
+ ///
+ /// Computes in **O(1)** time (average).
pub fn swap_indices(&mut self, a: usize, b: usize) {
self.map.swap_indices(a, b)
}
}
-/// Access `IndexSet` values at indexed positions.
+/// Access [`IndexSet`] values at indexed positions.
///
/// # Examples
///
@@ -761,141 +983,6 @@ impl<T, S> Index<usize> for IndexSet<T, S> {
}
}
-/// An owning iterator over the items of a `IndexSet`.
-///
-/// This `struct` is created by the [`into_iter`] method on [`IndexSet`]
-/// (provided by the `IntoIterator` trait). See its documentation for more.
-///
-/// [`IndexSet`]: struct.IndexSet.html
-/// [`into_iter`]: struct.IndexSet.html#method.into_iter
-pub struct IntoIter<T> {
- iter: vec::IntoIter<Bucket<T>>,
-}
-
-impl<T> Iterator for IntoIter<T> {
- type Item = T;
-
- iterator_methods!(Bucket::key);
-}
-
-impl<T> DoubleEndedIterator for IntoIter<T> {
- double_ended_iterator_methods!(Bucket::key);
-}
-
-impl<T> ExactSizeIterator for IntoIter<T> {
- fn len(&self) -> usize {
- self.iter.len()
- }
-}
-
-impl<T> FusedIterator for IntoIter<T> {}
-
-impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- let iter = self.iter.as_slice().iter().map(Bucket::key_ref);
- f.debug_list().entries(iter).finish()
- }
-}
-
-/// An iterator over the items of a `IndexSet`.
-///
-/// This `struct` is created by the [`iter`] method on [`IndexSet`].
-/// See its documentation for more.
-///
-/// [`IndexSet`]: struct.IndexSet.html
-/// [`iter`]: struct.IndexSet.html#method.iter
-pub struct Iter<'a, T> {
- iter: slice::Iter<'a, Bucket<T>>,
-}
-
-impl<'a, T> Iterator for Iter<'a, T> {
- type Item = &'a T;
-
- iterator_methods!(Bucket::key_ref);
-}
-
-impl<T> DoubleEndedIterator for Iter<'_, T> {
- double_ended_iterator_methods!(Bucket::key_ref);
-}
-
-impl<T> ExactSizeIterator for Iter<'_, T> {
- fn len(&self) -> usize {
- self.iter.len()
- }
-}
-
-impl<T> FusedIterator for Iter<'_, T> {}
-
-impl<T> Clone for Iter<'_, T> {
- fn clone(&self) -> Self {
- Iter {
- iter: self.iter.clone(),
- }
- }
-}
-
-impl<T: fmt::Debug> fmt::Debug for Iter<'_, T> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_list().entries(self.clone()).finish()
- }
-}
-
-/// A draining iterator over the items of a `IndexSet`.
-///
-/// This `struct` is created by the [`drain`] method on [`IndexSet`].
-/// See its documentation for more.
-///
-/// [`IndexSet`]: struct.IndexSet.html
-/// [`drain`]: struct.IndexSet.html#method.drain
-pub struct Drain<'a, T> {
- iter: vec::Drain<'a, Bucket<T>>,
-}
-
-impl<T> Iterator for Drain<'_, T> {
- type Item = T;
-
- iterator_methods!(Bucket::key);
-}
-
-impl<T> DoubleEndedIterator for Drain<'_, T> {
- double_ended_iterator_methods!(Bucket::key);
-}
-
-impl<T> ExactSizeIterator for Drain<'_, T> {
- fn len(&self) -> usize {
- self.iter.len()
- }
-}
-
-impl<T> FusedIterator for Drain<'_, T> {}
-
-impl<T: fmt::Debug> fmt::Debug for Drain<'_, T> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- let iter = self.iter.as_slice().iter().map(Bucket::key_ref);
- f.debug_list().entries(iter).finish()
- }
-}
-
-impl<'a, T, S> IntoIterator for &'a IndexSet<T, S> {
- type Item = &'a T;
- type IntoIter = Iter<'a, T>;
-
- fn into_iter(self) -> Self::IntoIter {
- self.iter()
- }
-}
-
-impl<T, S> IntoIterator for IndexSet<T, S> {
- type Item = T;
- type IntoIter = IntoIter<T>;
-
- fn into_iter(self) -> Self::IntoIter {
- IntoIter {
- iter: self.into_entries().into_iter(),
- }
- }
-}
-
impl<T, S> FromIterator<T> for IndexSet<T, S>
where
T: Hash + Eq,
@@ -909,7 +996,8 @@ where
}
}
-#[cfg(has_std)]
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl<T, const N: usize> From<[T; N]> for IndexSet<T, RandomState>
where
T: Eq + Hash,
@@ -954,7 +1042,7 @@ impl<T, S> Default for IndexSet<T, S>
where
S: Default,
{
- /// Return an empty `IndexSet`
+ /// Return an empty [`IndexSet`]
fn default() -> Self {
IndexSet {
map: IndexMap::default(),
@@ -1014,310 +1102,6 @@ where
}
}
-/// A lazy iterator producing elements in the difference of `IndexSet`s.
-///
-/// This `struct` is created by the [`difference`] method on [`IndexSet`].
-/// See its documentation for more.
-///
-/// [`IndexSet`]: struct.IndexSet.html
-/// [`difference`]: struct.IndexSet.html#method.difference
-pub struct Difference<'a, T, S> {
- iter: Iter<'a, T>,
- other: &'a IndexSet<T, S>,
-}
-
-impl<'a, T, S> Iterator for Difference<'a, T, S>
-where
- T: Eq + Hash,
- S: BuildHasher,
-{
- type Item = &'a T;
-
- fn next(&mut self) -> Option<Self::Item> {
- while let Some(item) = self.iter.next() {
- if !self.other.contains(item) {
- return Some(item);
- }
- }
- None
- }
-
- fn size_hint(&self) -> (usize, Option<usize>) {
- (0, self.iter.size_hint().1)
- }
-}
-
-impl<T, S> DoubleEndedIterator for Difference<'_, T, S>
-where
- T: Eq + Hash,
- S: BuildHasher,
-{
- fn next_back(&mut self) -> Option<Self::Item> {
- while let Some(item) = self.iter.next_back() {
- if !self.other.contains(item) {
- return Some(item);
- }
- }
- None
- }
-}
-
-impl<T, S> FusedIterator for Difference<'_, T, S>
-where
- T: Eq + Hash,
- S: BuildHasher,
-{
-}
-
-impl<T, S> Clone for Difference<'_, T, S> {
- fn clone(&self) -> Self {
- Difference {
- iter: self.iter.clone(),
- ..*self
- }
- }
-}
-
-impl<T, S> fmt::Debug for Difference<'_, T, S>
-where
- T: fmt::Debug + Eq + Hash,
- S: BuildHasher,
-{
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_list().entries(self.clone()).finish()
- }
-}
-
-/// A lazy iterator producing elements in the intersection of `IndexSet`s.
-///
-/// This `struct` is created by the [`intersection`] method on [`IndexSet`].
-/// See its documentation for more.
-///
-/// [`IndexSet`]: struct.IndexSet.html
-/// [`intersection`]: struct.IndexSet.html#method.intersection
-pub struct Intersection<'a, T, S> {
- iter: Iter<'a, T>,
- other: &'a IndexSet<T, S>,
-}
-
-impl<'a, T, S> Iterator for Intersection<'a, T, S>
-where
- T: Eq + Hash,
- S: BuildHasher,
-{
- type Item = &'a T;
-
- fn next(&mut self) -> Option<Self::Item> {
- while let Some(item) = self.iter.next() {
- if self.other.contains(item) {
- return Some(item);
- }
- }
- None
- }
-
- fn size_hint(&self) -> (usize, Option<usize>) {
- (0, self.iter.size_hint().1)
- }
-}
-
-impl<T, S> DoubleEndedIterator for Intersection<'_, T, S>
-where
- T: Eq + Hash,
- S: BuildHasher,
-{
- fn next_back(&mut self) -> Option<Self::Item> {
- while let Some(item) = self.iter.next_back() {
- if self.other.contains(item) {
- return Some(item);
- }
- }
- None
- }
-}
-
-impl<T, S> FusedIterator for Intersection<'_, T, S>
-where
- T: Eq + Hash,
- S: BuildHasher,
-{
-}
-
-impl<T, S> Clone for Intersection<'_, T, S> {
- fn clone(&self) -> Self {
- Intersection {
- iter: self.iter.clone(),
- ..*self
- }
- }
-}
-
-impl<T, S> fmt::Debug for Intersection<'_, T, S>
-where
- T: fmt::Debug + Eq + Hash,
- S: BuildHasher,
-{
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_list().entries(self.clone()).finish()
- }
-}
-
-/// A lazy iterator producing elements in the symmetric difference of `IndexSet`s.
-///
-/// This `struct` is created by the [`symmetric_difference`] method on
-/// [`IndexSet`]. See its documentation for more.
-///
-/// [`IndexSet`]: struct.IndexSet.html
-/// [`symmetric_difference`]: struct.IndexSet.html#method.symmetric_difference
-pub struct SymmetricDifference<'a, T, S1, S2> {
- iter: Chain<Difference<'a, T, S2>, Difference<'a, T, S1>>,
-}
-
-impl<'a, T, S1, S2> Iterator for SymmetricDifference<'a, T, S1, S2>
-where
- T: Eq + Hash,
- S1: BuildHasher,
- S2: BuildHasher,
-{
- type Item = &'a T;
-
- fn next(&mut self) -> Option<Self::Item> {
- self.iter.next()
- }
-
- fn size_hint(&self) -> (usize, Option<usize>) {
- self.iter.size_hint()
- }
-
- fn fold<B, F>(self, init: B, f: F) -> B
- where
- F: FnMut(B, Self::Item) -> B,
- {
- self.iter.fold(init, f)
- }
-}
-
-impl<T, S1, S2> DoubleEndedIterator for SymmetricDifference<'_, T, S1, S2>
-where
- T: Eq + Hash,
- S1: BuildHasher,
- S2: BuildHasher,
-{
- fn next_back(&mut self) -> Option<Self::Item> {
- self.iter.next_back()
- }
-
- fn rfold<B, F>(self, init: B, f: F) -> B
- where
- F: FnMut(B, Self::Item) -> B,
- {
- self.iter.rfold(init, f)
- }
-}
-
-impl<T, S1, S2> FusedIterator for SymmetricDifference<'_, T, S1, S2>
-where
- T: Eq + Hash,
- S1: BuildHasher,
- S2: BuildHasher,
-{
-}
-
-impl<T, S1, S2> Clone for SymmetricDifference<'_, T, S1, S2> {
- fn clone(&self) -> Self {
- SymmetricDifference {
- iter: self.iter.clone(),
- }
- }
-}
-
-impl<T, S1, S2> fmt::Debug for SymmetricDifference<'_, T, S1, S2>
-where
- T: fmt::Debug + Eq + Hash,
- S1: BuildHasher,
- S2: BuildHasher,
-{
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_list().entries(self.clone()).finish()
- }
-}
-
-/// A lazy iterator producing elements in the union of `IndexSet`s.
-///
-/// This `struct` is created by the [`union`] method on [`IndexSet`].
-/// See its documentation for more.
-///
-/// [`IndexSet`]: struct.IndexSet.html
-/// [`union`]: struct.IndexSet.html#method.union
-pub struct Union<'a, T, S> {
- iter: Chain<Iter<'a, T>, Difference<'a, T, S>>,
-}
-
-impl<'a, T, S> Iterator for Union<'a, T, S>
-where
- T: Eq + Hash,
- S: BuildHasher,
-{
- type Item = &'a T;
-
- fn next(&mut self) -> Option<Self::Item> {
- self.iter.next()
- }
-
- fn size_hint(&self) -> (usize, Option<usize>) {
- self.iter.size_hint()
- }
-
- fn fold<B, F>(self, init: B, f: F) -> B
- where
- F: FnMut(B, Self::Item) -> B,
- {
- self.iter.fold(init, f)
- }
-}
-
-impl<T, S> DoubleEndedIterator for Union<'_, T, S>
-where
- T: Eq + Hash,
- S: BuildHasher,
-{
- fn next_back(&mut self) -> Option<Self::Item> {
- self.iter.next_back()
- }
-
- fn rfold<B, F>(self, init: B, f: F) -> B
- where
- F: FnMut(B, Self::Item) -> B,
- {
- self.iter.rfold(init, f)
- }
-}
-
-impl<T, S> FusedIterator for Union<'_, T, S>
-where
- T: Eq + Hash,
- S: BuildHasher,
-{
-}
-
-impl<T, S> Clone for Union<'_, T, S> {
- fn clone(&self) -> Self {
- Union {
- iter: self.iter.clone(),
- }
- }
-}
-
-impl<T, S> fmt::Debug for Union<'_, T, S>
-where
- T: fmt::Debug + Eq + Hash,
- S: BuildHasher,
-{
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_list().entries(self.clone()).finish()
- }
-}
-
impl<T, S1, S2> BitAnd<&IndexSet<T, S2>> for &IndexSet<T, S1>
where
T: Eq + Hash + Clone,
@@ -1383,530 +1167,3 @@ where
self.difference(other).cloned().collect()
}
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use std::string::String;
-
- #[test]
- fn it_works() {
- let mut set = IndexSet::new();
- assert_eq!(set.is_empty(), true);
- set.insert(1);
- set.insert(1);
- assert_eq!(set.len(), 1);
- assert!(set.get(&1).is_some());
- assert_eq!(set.is_empty(), false);
- }
-
- #[test]
- fn new() {
- let set = IndexSet::<String>::new();
- println!("{:?}", set);
- assert_eq!(set.capacity(), 0);
- assert_eq!(set.len(), 0);
- assert_eq!(set.is_empty(), true);
- }
-
- #[test]
- fn insert() {
- let insert = [0, 4, 2, 12, 8, 7, 11, 5];
- let not_present = [1, 3, 6, 9, 10];
- let mut set = IndexSet::with_capacity(insert.len());
-
- for (i, &elt) in insert.iter().enumerate() {
- assert_eq!(set.len(), i);
- set.insert(elt);
- assert_eq!(set.len(), i + 1);
- assert_eq!(set.get(&elt), Some(&elt));
- }
- println!("{:?}", set);
-
- for &elt in &not_present {
- assert!(set.get(&elt).is_none());
- }
- }
-
- #[test]
- fn insert_full() {
- let insert = vec![9, 2, 7, 1, 4, 6, 13];
- let present = vec![1, 6, 2];
- let mut set = IndexSet::with_capacity(insert.len());
-
- for (i, &elt) in insert.iter().enumerate() {
- assert_eq!(set.len(), i);
- let (index, success) = set.insert_full(elt);
- assert!(success);
- assert_eq!(Some(index), set.get_full(&elt).map(|x| x.0));
- assert_eq!(set.len(), i + 1);
- }
-
- let len = set.len();
- for &elt in &present {
- let (index, success) = set.insert_full(elt);
- assert!(!success);
- assert_eq!(Some(index), set.get_full(&elt).map(|x| x.0));
- assert_eq!(set.len(), len);
- }
- }
-
- #[test]
- fn insert_2() {
- let mut set = IndexSet::with_capacity(16);
-
- let mut values = vec![];
- values.extend(0..16);
- values.extend(if cfg!(miri) { 32..64 } else { 128..267 });
-
- for &i in &values {
- let old_set = set.clone();
- set.insert(i);
- for value in old_set.iter() {
- if set.get(value).is_none() {
- println!("old_set: {:?}", old_set);
- println!("set: {:?}", set);
- panic!("did not find {} in set", value);
- }
- }
- }
-
- for &i in &values {
- assert!(set.get(&i).is_some(), "did not find {}", i);
- }
- }
-
- #[test]
- fn insert_dup() {
- let mut elements = vec![0, 2, 4, 6, 8];
- let mut set: IndexSet<u8> = elements.drain(..).collect();
- {
- let (i, v) = set.get_full(&0).unwrap();
- assert_eq!(set.len(), 5);
- assert_eq!(i, 0);
- assert_eq!(*v, 0);
- }
- {
- let inserted = set.insert(0);
- let (i, v) = set.get_full(&0).unwrap();
- assert_eq!(set.len(), 5);
- assert_eq!(inserted, false);
- assert_eq!(i, 0);
- assert_eq!(*v, 0);
- }
- }
-
- #[test]
- fn insert_order() {
- let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
- let mut set = IndexSet::new();
-
- for &elt in &insert {
- set.insert(elt);
- }
-
- assert_eq!(set.iter().count(), set.len());
- assert_eq!(set.iter().count(), insert.len());
- for (a, b) in insert.iter().zip(set.iter()) {
- assert_eq!(a, b);
- }
- for (i, v) in (0..insert.len()).zip(set.iter()) {
- assert_eq!(set.get_index(i).unwrap(), v);
- }
- }
-
- #[test]
- fn replace() {
- let replace = [0, 4, 2, 12, 8, 7, 11, 5];
- let not_present = [1, 3, 6, 9, 10];
- let mut set = IndexSet::with_capacity(replace.len());
-
- for (i, &elt) in replace.iter().enumerate() {
- assert_eq!(set.len(), i);
- set.replace(elt);
- assert_eq!(set.len(), i + 1);
- assert_eq!(set.get(&elt), Some(&elt));
- }
- println!("{:?}", set);
-
- for &elt in &not_present {
- assert!(set.get(&elt).is_none());
- }
- }
-
- #[test]
- fn replace_full() {
- let replace = vec![9, 2, 7, 1, 4, 6, 13];
- let present = vec![1, 6, 2];
- let mut set = IndexSet::with_capacity(replace.len());
-
- for (i, &elt) in replace.iter().enumerate() {
- assert_eq!(set.len(), i);
- let (index, replaced) = set.replace_full(elt);
- assert!(replaced.is_none());
- assert_eq!(Some(index), set.get_full(&elt).map(|x| x.0));
- assert_eq!(set.len(), i + 1);
- }
-
- let len = set.len();
- for &elt in &present {
- let (index, replaced) = set.replace_full(elt);
- assert_eq!(Some(elt), replaced);
- assert_eq!(Some(index), set.get_full(&elt).map(|x| x.0));
- assert_eq!(set.len(), len);
- }
- }
-
- #[test]
- fn replace_2() {
- let mut set = IndexSet::with_capacity(16);
-
- let mut values = vec![];
- values.extend(0..16);
- values.extend(if cfg!(miri) { 32..64 } else { 128..267 });
-
- for &i in &values {
- let old_set = set.clone();
- set.replace(i);
- for value in old_set.iter() {
- if set.get(value).is_none() {
- println!("old_set: {:?}", old_set);
- println!("set: {:?}", set);
- panic!("did not find {} in set", value);
- }
- }
- }
-
- for &i in &values {
- assert!(set.get(&i).is_some(), "did not find {}", i);
- }
- }
-
- #[test]
- fn replace_dup() {
- let mut elements = vec![0, 2, 4, 6, 8];
- let mut set: IndexSet<u8> = elements.drain(..).collect();
- {
- let (i, v) = set.get_full(&0).unwrap();
- assert_eq!(set.len(), 5);
- assert_eq!(i, 0);
- assert_eq!(*v, 0);
- }
- {
- let replaced = set.replace(0);
- let (i, v) = set.get_full(&0).unwrap();
- assert_eq!(set.len(), 5);
- assert_eq!(replaced, Some(0));
- assert_eq!(i, 0);
- assert_eq!(*v, 0);
- }
- }
-
- #[test]
- fn replace_order() {
- let replace = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
- let mut set = IndexSet::new();
-
- for &elt in &replace {
- set.replace(elt);
- }
-
- assert_eq!(set.iter().count(), set.len());
- assert_eq!(set.iter().count(), replace.len());
- for (a, b) in replace.iter().zip(set.iter()) {
- assert_eq!(a, b);
- }
- for (i, v) in (0..replace.len()).zip(set.iter()) {
- assert_eq!(set.get_index(i).unwrap(), v);
- }
- }
-
- #[test]
- fn grow() {
- let insert = [0, 4, 2, 12, 8, 7, 11];
- let not_present = [1, 3, 6, 9, 10];
- let mut set = IndexSet::with_capacity(insert.len());
-
- for (i, &elt) in insert.iter().enumerate() {
- assert_eq!(set.len(), i);
- set.insert(elt);
- assert_eq!(set.len(), i + 1);
- assert_eq!(set.get(&elt), Some(&elt));
- }
-
- println!("{:?}", set);
- for &elt in &insert {
- set.insert(elt * 10);
- }
- for &elt in &insert {
- set.insert(elt * 100);
- }
- for (i, &elt) in insert.iter().cycle().enumerate().take(100) {
- set.insert(elt * 100 + i as i32);
- }
- println!("{:?}", set);
- for &elt in &not_present {
- assert!(set.get(&elt).is_none());
- }
- }
-
- #[test]
- fn reserve() {
- let mut set = IndexSet::<usize>::new();
- assert_eq!(set.capacity(), 0);
- set.reserve(100);
- let capacity = set.capacity();
- assert!(capacity >= 100);
- for i in 0..capacity {
- assert_eq!(set.len(), i);
- set.insert(i);
- assert_eq!(set.len(), i + 1);
- assert_eq!(set.capacity(), capacity);
- assert_eq!(set.get(&i), Some(&i));
- }
- set.insert(capacity);
- assert_eq!(set.len(), capacity + 1);
- assert!(set.capacity() > capacity);
- assert_eq!(set.get(&capacity), Some(&capacity));
- }
-
- #[test]
- fn shrink_to_fit() {
- let mut set = IndexSet::<usize>::new();
- assert_eq!(set.capacity(), 0);
- for i in 0..100 {
- assert_eq!(set.len(), i);
- set.insert(i);
- assert_eq!(set.len(), i + 1);
- assert!(set.capacity() >= i + 1);
- assert_eq!(set.get(&i), Some(&i));
- set.shrink_to_fit();
- assert_eq!(set.len(), i + 1);
- assert_eq!(set.capacity(), i + 1);
- assert_eq!(set.get(&i), Some(&i));
- }
- }
-
- #[test]
- fn remove() {
- let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
- let mut set = IndexSet::new();
-
- for &elt in &insert {
- set.insert(elt);
- }
-
- assert_eq!(set.iter().count(), set.len());
- assert_eq!(set.iter().count(), insert.len());
- for (a, b) in insert.iter().zip(set.iter()) {
- assert_eq!(a, b);
- }
-
- let remove_fail = [99, 77];
- let remove = [4, 12, 8, 7];
-
- for &value in &remove_fail {
- assert!(set.swap_remove_full(&value).is_none());
- }
- println!("{:?}", set);
- for &value in &remove {
- //println!("{:?}", set);
- let index = set.get_full(&value).unwrap().0;
- assert_eq!(set.swap_remove_full(&value), Some((index, value)));
- }
- println!("{:?}", set);
-
- for value in &insert {
- assert_eq!(set.get(value).is_some(), !remove.contains(value));
- }
- assert_eq!(set.len(), insert.len() - remove.len());
- assert_eq!(set.iter().count(), insert.len() - remove.len());
- }
-
- #[test]
- fn swap_remove_index() {
- let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
- let mut set = IndexSet::new();
-
- for &elt in &insert {
- set.insert(elt);
- }
-
- let mut vector = insert.to_vec();
- let remove_sequence = &[3, 3, 10, 4, 5, 4, 3, 0, 1];
-
- // check that the same swap remove sequence on vec and set
- // have the same result.
- for &rm in remove_sequence {
- let out_vec = vector.swap_remove(rm);
- let out_set = set.swap_remove_index(rm).unwrap();
- assert_eq!(out_vec, out_set);
- }
- assert_eq!(vector.len(), set.len());
- for (a, b) in vector.iter().zip(set.iter()) {
- assert_eq!(a, b);
- }
- }
-
- #[test]
- fn partial_eq_and_eq() {
- let mut set_a = IndexSet::new();
- set_a.insert(1);
- set_a.insert(2);
- let mut set_b = set_a.clone();
- assert_eq!(set_a, set_b);
- set_b.swap_remove(&1);
- assert_ne!(set_a, set_b);
-
- let set_c: IndexSet<_> = set_b.into_iter().collect();
- assert_ne!(set_a, set_c);
- assert_ne!(set_c, set_a);
- }
-
- #[test]
- fn extend() {
- let mut set = IndexSet::new();
- set.extend(vec![&1, &2, &3, &4]);
- set.extend(vec![5, 6]);
- assert_eq!(set.into_iter().collect::<Vec<_>>(), vec![1, 2, 3, 4, 5, 6]);
- }
-
- #[test]
- fn comparisons() {
- let set_a: IndexSet<_> = (0..3).collect();
- let set_b: IndexSet<_> = (3..6).collect();
- let set_c: IndexSet<_> = (0..6).collect();
- let set_d: IndexSet<_> = (3..9).collect();
-
- assert!(!set_a.is_disjoint(&set_a));
- assert!(set_a.is_subset(&set_a));
- assert!(set_a.is_superset(&set_a));
-
- assert!(set_a.is_disjoint(&set_b));
- assert!(set_b.is_disjoint(&set_a));
- assert!(!set_a.is_subset(&set_b));
- assert!(!set_b.is_subset(&set_a));
- assert!(!set_a.is_superset(&set_b));
- assert!(!set_b.is_superset(&set_a));
-
- assert!(!set_a.is_disjoint(&set_c));
- assert!(!set_c.is_disjoint(&set_a));
- assert!(set_a.is_subset(&set_c));
- assert!(!set_c.is_subset(&set_a));
- assert!(!set_a.is_superset(&set_c));
- assert!(set_c.is_superset(&set_a));
-
- assert!(!set_c.is_disjoint(&set_d));
- assert!(!set_d.is_disjoint(&set_c));
- assert!(!set_c.is_subset(&set_d));
- assert!(!set_d.is_subset(&set_c));
- assert!(!set_c.is_superset(&set_d));
- assert!(!set_d.is_superset(&set_c));
- }
-
- #[test]
- fn iter_comparisons() {
- use std::iter::empty;
-
- fn check<'a, I1, I2>(iter1: I1, iter2: I2)
- where
- I1: Iterator<Item = &'a i32>,
- I2: Iterator<Item = i32>,
- {
- assert!(iter1.copied().eq(iter2));
- }
-
- let set_a: IndexSet<_> = (0..3).collect();
- let set_b: IndexSet<_> = (3..6).collect();
- let set_c: IndexSet<_> = (0..6).collect();
- let set_d: IndexSet<_> = (3..9).rev().collect();
-
- check(set_a.difference(&set_a), empty());
- check(set_a.symmetric_difference(&set_a), empty());
- check(set_a.intersection(&set_a), 0..3);
- check(set_a.union(&set_a), 0..3);
-
- check(set_a.difference(&set_b), 0..3);
- check(set_b.difference(&set_a), 3..6);
- check(set_a.symmetric_difference(&set_b), 0..6);
- check(set_b.symmetric_difference(&set_a), (3..6).chain(0..3));
- check(set_a.intersection(&set_b), empty());
- check(set_b.intersection(&set_a), empty());
- check(set_a.union(&set_b), 0..6);
- check(set_b.union(&set_a), (3..6).chain(0..3));
-
- check(set_a.difference(&set_c), empty());
- check(set_c.difference(&set_a), 3..6);
- check(set_a.symmetric_difference(&set_c), 3..6);
- check(set_c.symmetric_difference(&set_a), 3..6);
- check(set_a.intersection(&set_c), 0..3);
- check(set_c.intersection(&set_a), 0..3);
- check(set_a.union(&set_c), 0..6);
- check(set_c.union(&set_a), 0..6);
-
- check(set_c.difference(&set_d), 0..3);
- check(set_d.difference(&set_c), (6..9).rev());
- check(
- set_c.symmetric_difference(&set_d),
- (0..3).chain((6..9).rev()),
- );
- check(set_d.symmetric_difference(&set_c), (6..9).rev().chain(0..3));
- check(set_c.intersection(&set_d), 3..6);
- check(set_d.intersection(&set_c), (3..6).rev());
- check(set_c.union(&set_d), (0..6).chain((6..9).rev()));
- check(set_d.union(&set_c), (3..9).rev().chain(0..3));
- }
-
- #[test]
- fn ops() {
- let empty = IndexSet::<i32>::new();
- let set_a: IndexSet<_> = (0..3).collect();
- let set_b: IndexSet<_> = (3..6).collect();
- let set_c: IndexSet<_> = (0..6).collect();
- let set_d: IndexSet<_> = (3..9).rev().collect();
-
- #[allow(clippy::eq_op)]
- {
- assert_eq!(&set_a & &set_a, set_a);
- assert_eq!(&set_a | &set_a, set_a);
- assert_eq!(&set_a ^ &set_a, empty);
- assert_eq!(&set_a - &set_a, empty);
- }
-
- assert_eq!(&set_a & &set_b, empty);
- assert_eq!(&set_b & &set_a, empty);
- assert_eq!(&set_a | &set_b, set_c);
- assert_eq!(&set_b | &set_a, set_c);
- assert_eq!(&set_a ^ &set_b, set_c);
- assert_eq!(&set_b ^ &set_a, set_c);
- assert_eq!(&set_a - &set_b, set_a);
- assert_eq!(&set_b - &set_a, set_b);
-
- assert_eq!(&set_a & &set_c, set_a);
- assert_eq!(&set_c & &set_a, set_a);
- assert_eq!(&set_a | &set_c, set_c);
- assert_eq!(&set_c | &set_a, set_c);
- assert_eq!(&set_a ^ &set_c, set_b);
- assert_eq!(&set_c ^ &set_a, set_b);
- assert_eq!(&set_a - &set_c, empty);
- assert_eq!(&set_c - &set_a, set_b);
-
- assert_eq!(&set_c & &set_d, set_b);
- assert_eq!(&set_d & &set_c, set_b);
- assert_eq!(&set_c | &set_d, &set_a | &set_d);
- assert_eq!(&set_d | &set_c, &set_a | &set_d);
- assert_eq!(&set_c ^ &set_d, &set_a | &(&set_d - &set_b));
- assert_eq!(&set_d ^ &set_c, &set_a | &(&set_d - &set_b));
- assert_eq!(&set_c - &set_d, set_a);
- assert_eq!(&set_d - &set_c, &set_d - &set_b);
- }
-
- #[test]
- #[cfg(has_std)]
- fn from_array() {
- let set1 = IndexSet::from([1, 2, 3, 4]);
- let set2: IndexSet<_> = [1, 2, 3, 4].into();
-
- assert_eq!(set1, set2);
- }
-}
diff --git a/third_party/rust/indexmap/src/set/iter.rs b/third_party/rust/indexmap/src/set/iter.rs
new file mode 100644
index 0000000000..3f8033c2db
--- /dev/null
+++ b/third_party/rust/indexmap/src/set/iter.rs
@@ -0,0 +1,626 @@
+use super::{Bucket, Entries, IndexSet, Slice};
+
+use alloc::vec::{self, Vec};
+use core::fmt;
+use core::hash::{BuildHasher, Hash};
+use core::iter::{Chain, FusedIterator};
+use core::ops::RangeBounds;
+use core::slice::Iter as SliceIter;
+
+impl<'a, T, S> IntoIterator for &'a IndexSet<T, S> {
+ type Item = &'a T;
+ type IntoIter = Iter<'a, T>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.iter()
+ }
+}
+
+impl<T, S> IntoIterator for IndexSet<T, S> {
+ type Item = T;
+ type IntoIter = IntoIter<T>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ IntoIter::new(self.into_entries())
+ }
+}
+
+/// An iterator over the items of an [`IndexSet`].
+///
+/// This `struct` is created by the [`IndexSet::iter`] method.
+/// See its documentation for more.
+pub struct Iter<'a, T> {
+ iter: SliceIter<'a, Bucket<T>>,
+}
+
+impl<'a, T> Iter<'a, T> {
+ pub(super) fn new(entries: &'a [Bucket<T>]) -> Self {
+ Self {
+ iter: entries.iter(),
+ }
+ }
+
+ /// Returns a slice of the remaining entries in the iterator.
+ pub fn as_slice(&self) -> &'a Slice<T> {
+ Slice::from_slice(self.iter.as_slice())
+ }
+}
+
+impl<'a, T> Iterator for Iter<'a, T> {
+ type Item = &'a T;
+
+ iterator_methods!(Bucket::key_ref);
+}
+
+impl<T> DoubleEndedIterator for Iter<'_, T> {
+ double_ended_iterator_methods!(Bucket::key_ref);
+}
+
+impl<T> ExactSizeIterator for Iter<'_, T> {
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+}
+
+impl<T> FusedIterator for Iter<'_, T> {}
+
+impl<T> Clone for Iter<'_, T> {
+ fn clone(&self) -> Self {
+ Iter {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<T: fmt::Debug> fmt::Debug for Iter<'_, T> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+impl<T> Default for Iter<'_, T> {
+ fn default() -> Self {
+ Self { iter: [].iter() }
+ }
+}
+
+/// An owning iterator over the items of an [`IndexSet`].
+///
+/// This `struct` is created by the [`IndexSet::into_iter`] method
+/// (provided by the [`IntoIterator`] trait). See its documentation for more.
+pub struct IntoIter<T> {
+ iter: vec::IntoIter<Bucket<T>>,
+}
+
+impl<T> IntoIter<T> {
+ pub(super) fn new(entries: Vec<Bucket<T>>) -> Self {
+ Self {
+ iter: entries.into_iter(),
+ }
+ }
+
+ /// Returns a slice of the remaining entries in the iterator.
+ pub fn as_slice(&self) -> &Slice<T> {
+ Slice::from_slice(self.iter.as_slice())
+ }
+}
+
+impl<T> Iterator for IntoIter<T> {
+ type Item = T;
+
+ iterator_methods!(Bucket::key);
+}
+
+impl<T> DoubleEndedIterator for IntoIter<T> {
+ double_ended_iterator_methods!(Bucket::key);
+}
+
+impl<T> ExactSizeIterator for IntoIter<T> {
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+}
+
+impl<T> FusedIterator for IntoIter<T> {}
+
+impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let iter = self.iter.as_slice().iter().map(Bucket::key_ref);
+ f.debug_list().entries(iter).finish()
+ }
+}
+
+impl<T> Default for IntoIter<T> {
+ fn default() -> Self {
+ Self {
+ iter: Vec::new().into_iter(),
+ }
+ }
+}
+
+/// A draining iterator over the items of an [`IndexSet`].
+///
+/// This `struct` is created by the [`IndexSet::drain`] method.
+/// See its documentation for more.
+pub struct Drain<'a, T> {
+ iter: vec::Drain<'a, Bucket<T>>,
+}
+
+impl<'a, T> Drain<'a, T> {
+ pub(super) fn new(iter: vec::Drain<'a, Bucket<T>>) -> Self {
+ Self { iter }
+ }
+
+ /// Returns a slice of the remaining entries in the iterator.
+ pub fn as_slice(&self) -> &Slice<T> {
+ Slice::from_slice(self.iter.as_slice())
+ }
+}
+
+impl<T> Iterator for Drain<'_, T> {
+ type Item = T;
+
+ iterator_methods!(Bucket::key);
+}
+
+impl<T> DoubleEndedIterator for Drain<'_, T> {
+ double_ended_iterator_methods!(Bucket::key);
+}
+
+impl<T> ExactSizeIterator for Drain<'_, T> {
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+}
+
+impl<T> FusedIterator for Drain<'_, T> {}
+
+impl<T: fmt::Debug> fmt::Debug for Drain<'_, T> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let iter = self.iter.as_slice().iter().map(Bucket::key_ref);
+ f.debug_list().entries(iter).finish()
+ }
+}
+
+/// A lazy iterator producing elements in the difference of [`IndexSet`]s.
+///
+/// This `struct` is created by the [`IndexSet::difference`] method.
+/// See its documentation for more.
+pub struct Difference<'a, T, S> {
+ iter: Iter<'a, T>,
+ other: &'a IndexSet<T, S>,
+}
+
+impl<'a, T, S> Difference<'a, T, S> {
+ pub(super) fn new<S1>(set: &'a IndexSet<T, S1>, other: &'a IndexSet<T, S>) -> Self {
+ Self {
+ iter: set.iter(),
+ other,
+ }
+ }
+}
+
+impl<'a, T, S> Iterator for Difference<'a, T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher,
+{
+ type Item = &'a T;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ while let Some(item) = self.iter.next() {
+ if !self.other.contains(item) {
+ return Some(item);
+ }
+ }
+ None
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ (0, self.iter.size_hint().1)
+ }
+}
+
+impl<T, S> DoubleEndedIterator for Difference<'_, T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher,
+{
+ fn next_back(&mut self) -> Option<Self::Item> {
+ while let Some(item) = self.iter.next_back() {
+ if !self.other.contains(item) {
+ return Some(item);
+ }
+ }
+ None
+ }
+}
+
+impl<T, S> FusedIterator for Difference<'_, T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher,
+{
+}
+
+impl<T, S> Clone for Difference<'_, T, S> {
+ fn clone(&self) -> Self {
+ Difference {
+ iter: self.iter.clone(),
+ ..*self
+ }
+ }
+}
+
+impl<T, S> fmt::Debug for Difference<'_, T, S>
+where
+ T: fmt::Debug + Eq + Hash,
+ S: BuildHasher,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+/// A lazy iterator producing elements in the intersection of [`IndexSet`]s.
+///
+/// This `struct` is created by the [`IndexSet::intersection`] method.
+/// See its documentation for more.
+pub struct Intersection<'a, T, S> {
+ iter: Iter<'a, T>,
+ other: &'a IndexSet<T, S>,
+}
+
+impl<'a, T, S> Intersection<'a, T, S> {
+ pub(super) fn new<S1>(set: &'a IndexSet<T, S1>, other: &'a IndexSet<T, S>) -> Self {
+ Self {
+ iter: set.iter(),
+ other,
+ }
+ }
+}
+
+impl<'a, T, S> Iterator for Intersection<'a, T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher,
+{
+ type Item = &'a T;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ while let Some(item) = self.iter.next() {
+ if self.other.contains(item) {
+ return Some(item);
+ }
+ }
+ None
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ (0, self.iter.size_hint().1)
+ }
+}
+
+impl<T, S> DoubleEndedIterator for Intersection<'_, T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher,
+{
+ fn next_back(&mut self) -> Option<Self::Item> {
+ while let Some(item) = self.iter.next_back() {
+ if self.other.contains(item) {
+ return Some(item);
+ }
+ }
+ None
+ }
+}
+
+impl<T, S> FusedIterator for Intersection<'_, T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher,
+{
+}
+
+impl<T, S> Clone for Intersection<'_, T, S> {
+ fn clone(&self) -> Self {
+ Intersection {
+ iter: self.iter.clone(),
+ ..*self
+ }
+ }
+}
+
+impl<T, S> fmt::Debug for Intersection<'_, T, S>
+where
+ T: fmt::Debug + Eq + Hash,
+ S: BuildHasher,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+/// A lazy iterator producing elements in the symmetric difference of [`IndexSet`]s.
+///
+/// This `struct` is created by the [`IndexSet::symmetric_difference`] method.
+/// See its documentation for more.
+pub struct SymmetricDifference<'a, T, S1, S2> {
+ iter: Chain<Difference<'a, T, S2>, Difference<'a, T, S1>>,
+}
+
+impl<'a, T, S1, S2> SymmetricDifference<'a, T, S1, S2>
+where
+ T: Eq + Hash,
+ S1: BuildHasher,
+ S2: BuildHasher,
+{
+ pub(super) fn new(set1: &'a IndexSet<T, S1>, set2: &'a IndexSet<T, S2>) -> Self {
+ let diff1 = set1.difference(set2);
+ let diff2 = set2.difference(set1);
+ Self {
+ iter: diff1.chain(diff2),
+ }
+ }
+}
+
+impl<'a, T, S1, S2> Iterator for SymmetricDifference<'a, T, S1, S2>
+where
+ T: Eq + Hash,
+ S1: BuildHasher,
+ S2: BuildHasher,
+{
+ type Item = &'a T;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.iter.next()
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
+
+ fn fold<B, F>(self, init: B, f: F) -> B
+ where
+ F: FnMut(B, Self::Item) -> B,
+ {
+ self.iter.fold(init, f)
+ }
+}
+
+impl<T, S1, S2> DoubleEndedIterator for SymmetricDifference<'_, T, S1, S2>
+where
+ T: Eq + Hash,
+ S1: BuildHasher,
+ S2: BuildHasher,
+{
+ fn next_back(&mut self) -> Option<Self::Item> {
+ self.iter.next_back()
+ }
+
+ fn rfold<B, F>(self, init: B, f: F) -> B
+ where
+ F: FnMut(B, Self::Item) -> B,
+ {
+ self.iter.rfold(init, f)
+ }
+}
+
+impl<T, S1, S2> FusedIterator for SymmetricDifference<'_, T, S1, S2>
+where
+ T: Eq + Hash,
+ S1: BuildHasher,
+ S2: BuildHasher,
+{
+}
+
+impl<T, S1, S2> Clone for SymmetricDifference<'_, T, S1, S2> {
+ fn clone(&self) -> Self {
+ SymmetricDifference {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<T, S1, S2> fmt::Debug for SymmetricDifference<'_, T, S1, S2>
+where
+ T: fmt::Debug + Eq + Hash,
+ S1: BuildHasher,
+ S2: BuildHasher,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+/// A lazy iterator producing elements in the union of [`IndexSet`]s.
+///
+/// This `struct` is created by the [`IndexSet::union`] method.
+/// See its documentation for more.
+pub struct Union<'a, T, S> {
+ iter: Chain<Iter<'a, T>, Difference<'a, T, S>>,
+}
+
+impl<'a, T, S> Union<'a, T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher,
+{
+ pub(super) fn new<S2>(set1: &'a IndexSet<T, S>, set2: &'a IndexSet<T, S2>) -> Self
+ where
+ S2: BuildHasher,
+ {
+ Self {
+ iter: set1.iter().chain(set2.difference(set1)),
+ }
+ }
+}
+
+impl<'a, T, S> Iterator for Union<'a, T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher,
+{
+ type Item = &'a T;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.iter.next()
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
+
+ fn fold<B, F>(self, init: B, f: F) -> B
+ where
+ F: FnMut(B, Self::Item) -> B,
+ {
+ self.iter.fold(init, f)
+ }
+}
+
+impl<T, S> DoubleEndedIterator for Union<'_, T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher,
+{
+ fn next_back(&mut self) -> Option<Self::Item> {
+ self.iter.next_back()
+ }
+
+ fn rfold<B, F>(self, init: B, f: F) -> B
+ where
+ F: FnMut(B, Self::Item) -> B,
+ {
+ self.iter.rfold(init, f)
+ }
+}
+
+impl<T, S> FusedIterator for Union<'_, T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher,
+{
+}
+
+impl<T, S> Clone for Union<'_, T, S> {
+ fn clone(&self) -> Self {
+ Union {
+ iter: self.iter.clone(),
+ }
+ }
+}
+
+impl<T, S> fmt::Debug for Union<'_, T, S>
+where
+ T: fmt::Debug + Eq + Hash,
+ S: BuildHasher,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_list().entries(self.clone()).finish()
+ }
+}
+
+/// A splicing iterator for `IndexSet`.
+///
+/// This `struct` is created by [`IndexSet::splice()`].
+/// See its documentation for more.
+pub struct Splice<'a, I, T, S>
+where
+ I: Iterator<Item = T>,
+ T: Hash + Eq,
+ S: BuildHasher,
+{
+ iter: crate::map::Splice<'a, UnitValue<I>, T, (), S>,
+}
+
+impl<'a, I, T, S> Splice<'a, I, T, S>
+where
+ I: Iterator<Item = T>,
+ T: Hash + Eq,
+ S: BuildHasher,
+{
+ pub(super) fn new<R>(set: &'a mut IndexSet<T, S>, range: R, replace_with: I) -> Self
+ where
+ R: RangeBounds<usize>,
+ {
+ Self {
+ iter: set.map.splice(range, UnitValue(replace_with)),
+ }
+ }
+}
+
+impl<I, T, S> Iterator for Splice<'_, I, T, S>
+where
+ I: Iterator<Item = T>,
+ T: Hash + Eq,
+ S: BuildHasher,
+{
+ type Item = T;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ Some(self.iter.next()?.0)
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
+}
+
+impl<I, T, S> DoubleEndedIterator for Splice<'_, I, T, S>
+where
+ I: Iterator<Item = T>,
+ T: Hash + Eq,
+ S: BuildHasher,
+{
+ fn next_back(&mut self) -> Option<Self::Item> {
+ Some(self.iter.next_back()?.0)
+ }
+}
+
+impl<I, T, S> ExactSizeIterator for Splice<'_, I, T, S>
+where
+ I: Iterator<Item = T>,
+ T: Hash + Eq,
+ S: BuildHasher,
+{
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+}
+
+impl<I, T, S> FusedIterator for Splice<'_, I, T, S>
+where
+ I: Iterator<Item = T>,
+ T: Hash + Eq,
+ S: BuildHasher,
+{
+}
+
+struct UnitValue<I>(I);
+
+impl<I: Iterator> Iterator for UnitValue<I> {
+ type Item = (I::Item, ());
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.0.next().map(|x| (x, ()))
+ }
+}
+
+impl<'a, I, T, S> fmt::Debug for Splice<'a, I, T, S>
+where
+ I: fmt::Debug + Iterator<Item = T>,
+ T: fmt::Debug + Hash + Eq,
+ S: BuildHasher,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt::Debug::fmt(&self.iter, f)
+ }
+}
+
+impl<I: fmt::Debug> fmt::Debug for UnitValue<I> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt::Debug::fmt(&self.0, f)
+ }
+}
diff --git a/third_party/rust/indexmap/src/set/mutable.rs b/third_party/rust/indexmap/src/set/mutable.rs
new file mode 100644
index 0000000000..20eaa11221
--- /dev/null
+++ b/third_party/rust/indexmap/src/set/mutable.rs
@@ -0,0 +1,86 @@
+use core::hash::{BuildHasher, Hash};
+
+use super::{Equivalent, IndexSet};
+use crate::map::MutableKeys;
+
+/// Opt-in mutable access to [`IndexSet`] values.
+///
+/// These methods expose `&mut T`, mutable references to the value as it is stored
+/// in the set.
+/// You are allowed to modify the values in the set **if the modification
+/// does not change the value’s hash and equality**.
+///
+/// If values are modified erroneously, you can no longer look them up.
+/// This is sound (memory safe) but a logical error hazard (just like
+/// implementing `PartialEq`, `Eq`, or `Hash` incorrectly would be).
+///
+/// `use` this trait to enable its methods for `IndexSet`.
+///
+/// This trait is sealed and cannot be implemented for types outside this crate.
+pub trait MutableValues: private::Sealed {
+ type Value;
+
+ /// Return item index and mutable reference to the value
+ ///
+ /// Computes in **O(1)** time (average).
+ fn get_full_mut2<Q>(&mut self, value: &Q) -> Option<(usize, &mut Self::Value)>
+ where
+ Q: ?Sized + Hash + Equivalent<Self::Value>;
+
+ /// Return mutable reference to the value at an index.
+ ///
+ /// Valid indices are *0 <= index < self.len()*
+ ///
+ /// Computes in **O(1)** time.
+ fn get_index_mut2(&mut self, index: usize) -> Option<&mut Self::Value>;
+
+ /// Scan through each value in the set and keep those where the
+ /// closure `keep` returns `true`.
+ ///
+ /// The values are visited in order, and remaining values keep their order.
+ ///
+ /// Computes in **O(n)** time (average).
+ fn retain2<F>(&mut self, keep: F)
+ where
+ F: FnMut(&mut Self::Value) -> bool;
+}
+
+/// Opt-in mutable access to [`IndexSet`] values.
+///
+/// See [`MutableValues`] for more information.
+impl<T, S> MutableValues for IndexSet<T, S>
+where
+ S: BuildHasher,
+{
+ type Value = T;
+
+ fn get_full_mut2<Q>(&mut self, value: &Q) -> Option<(usize, &mut T)>
+ where
+ Q: ?Sized + Hash + Equivalent<T>,
+ {
+ match self.map.get_full_mut2(value) {
+ Some((index, value, ())) => Some((index, value)),
+ None => None,
+ }
+ }
+
+ fn get_index_mut2(&mut self, index: usize) -> Option<&mut T> {
+ match self.map.get_index_mut2(index) {
+ Some((value, ())) => Some(value),
+ None => None,
+ }
+ }
+
+ fn retain2<F>(&mut self, mut keep: F)
+ where
+ F: FnMut(&mut T) -> bool,
+ {
+ self.map.retain2(move |value, ()| keep(value));
+ }
+}
+
+mod private {
+ pub trait Sealed {}
+
+ impl<T, S> Sealed for super::IndexSet<T, S> {}
+}
diff --git a/third_party/rust/indexmap/src/set/slice.rs b/third_party/rust/indexmap/src/set/slice.rs
new file mode 100644
index 0000000000..9fc208c706
--- /dev/null
+++ b/third_party/rust/indexmap/src/set/slice.rs
@@ -0,0 +1,340 @@
+use super::{Bucket, Entries, IndexSet, IntoIter, Iter};
+use crate::util::try_simplify_range;
+
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use core::cmp::Ordering;
+use core::fmt;
+use core::hash::{Hash, Hasher};
+use core::ops::{self, Bound, Index, RangeBounds};
+
+/// A dynamically-sized slice of values in an [`IndexSet`].
+///
+/// This supports indexed operations much like a `[T]` slice,
+/// but not any hashed operations on the values.
+///
+/// Unlike `IndexSet`, `Slice` does consider the order for [`PartialEq`]
+/// and [`Eq`], and it also implements [`PartialOrd`], [`Ord`], and [`Hash`].
+#[repr(transparent)]
+pub struct Slice<T> {
+ pub(crate) entries: [Bucket<T>],
+}
+
+// SAFETY: `Slice<T>` is a transparent wrapper around `[Bucket<T>]`,
+// and reference lifetimes are bound together in function signatures.
+#[allow(unsafe_code)]
+impl<T> Slice<T> {
+ pub(super) const fn from_slice(entries: &[Bucket<T>]) -> &Self {
+ unsafe { &*(entries as *const [Bucket<T>] as *const Self) }
+ }
+
+ pub(super) fn from_boxed(entries: Box<[Bucket<T>]>) -> Box<Self> {
+ unsafe { Box::from_raw(Box::into_raw(entries) as *mut Self) }
+ }
+
+ fn into_boxed(self: Box<Self>) -> Box<[Bucket<T>]> {
+ unsafe { Box::from_raw(Box::into_raw(self) as *mut [Bucket<T>]) }
+ }
+}
+
+impl<T> Slice<T> {
+ pub(crate) fn into_entries(self: Box<Self>) -> Vec<Bucket<T>> {
+ self.into_boxed().into_vec()
+ }
+
+ /// Returns an empty slice.
+ pub const fn new<'a>() -> &'a Self {
+ Self::from_slice(&[])
+ }
+
+ /// Return the number of elements in the set slice.
+ pub const fn len(&self) -> usize {
+ self.entries.len()
+ }
+
+ /// Returns true if the set slice contains no elements.
+ pub const fn is_empty(&self) -> bool {
+ self.entries.is_empty()
+ }
+
+ /// Get a value by index.
+ ///
+ /// Valid indices are *0 <= index < self.len()*
+ pub fn get_index(&self, index: usize) -> Option<&T> {
+ self.entries.get(index).map(Bucket::key_ref)
+ }
+
+ /// Returns a slice of values in the given range of indices.
+ ///
+ /// Valid indices are *0 <= index < self.len()*
+ pub fn get_range<R: RangeBounds<usize>>(&self, range: R) -> Option<&Self> {
+ let range = try_simplify_range(range, self.entries.len())?;
+ self.entries.get(range).map(Self::from_slice)
+ }
+
+ /// Get the first value.
+ pub fn first(&self) -> Option<&T> {
+ self.entries.first().map(Bucket::key_ref)
+ }
+
+ /// Get the last value.
+ pub fn last(&self) -> Option<&T> {
+ self.entries.last().map(Bucket::key_ref)
+ }
+
+ /// Divides one slice into two at an index.
+ ///
+ /// ***Panics*** if `index > len`.
+ pub fn split_at(&self, index: usize) -> (&Self, &Self) {
+ let (first, second) = self.entries.split_at(index);
+ (Self::from_slice(first), Self::from_slice(second))
+ }
+
+ /// Returns the first value and the rest of the slice,
+ /// or `None` if it is empty.
+ pub fn split_first(&self) -> Option<(&T, &Self)> {
+ if let [first, rest @ ..] = &self.entries {
+ Some((&first.key, Self::from_slice(rest)))
+ } else {
+ None
+ }
+ }
+
+ /// Returns the last value and the rest of the slice,
+ /// or `None` if it is empty.
+ pub fn split_last(&self) -> Option<(&T, &Self)> {
+ if let [rest @ .., last] = &self.entries {
+ Some((&last.key, Self::from_slice(rest)))
+ } else {
+ None
+ }
+ }
+
+ /// Return an iterator over the values of the set slice.
+ pub fn iter(&self) -> Iter<'_, T> {
+ Iter::new(&self.entries)
+ }
+
+ /// Search over a sorted set for a value.
+ ///
+ /// Returns the position where that value is present, or the position where it can be inserted
+ /// to maintain the sort. See [`slice::binary_search`] for more details.
+ ///
+ /// Computes in **O(log(n))** time, which is notably less scalable than looking the value up in
+ /// the set this is a slice from using [`IndexSet::get_index_of`], but this can also position
+ /// missing values.
+ pub fn binary_search(&self, x: &T) -> Result<usize, usize>
+ where
+ T: Ord,
+ {
+ self.binary_search_by(|p| p.cmp(x))
+ }
+
+ /// Search over a sorted set with a comparator function.
+ ///
+ /// Returns the position where that value is present, or the position where it can be inserted
+ /// to maintain the sort. See [`slice::binary_search_by`] for more details.
+ ///
+ /// Computes in **O(log(n))** time.
+ #[inline]
+ pub fn binary_search_by<'a, F>(&'a self, mut f: F) -> Result<usize, usize>
+ where
+ F: FnMut(&'a T) -> Ordering,
+ {
+ self.entries.binary_search_by(move |a| f(&a.key))
+ }
+
+ /// Search over a sorted set with an extraction function.
+ ///
+ /// Returns the position where that value is present, or the position where it can be inserted
+ /// to maintain the sort. See [`slice::binary_search_by_key`] for more details.
+ ///
+ /// Computes in **O(log(n))** time.
+ #[inline]
+ pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, mut f: F) -> Result<usize, usize>
+ where
+ F: FnMut(&'a T) -> B,
+ B: Ord,
+ {
+ self.binary_search_by(|k| f(k).cmp(b))
+ }
+
+ /// Returns the index of the partition point of a sorted set according to the given predicate
+ /// (the index of the first element of the second partition).
+ ///
+ /// See [`slice::partition_point`] for more details.
+ ///
+ /// Computes in **O(log(n))** time.
+ #[must_use]
+ pub fn partition_point<P>(&self, mut pred: P) -> usize
+ where
+ P: FnMut(&T) -> bool,
+ {
+ self.entries.partition_point(move |a| pred(&a.key))
+ }
+}
+
+impl<'a, T> IntoIterator for &'a Slice<T> {
+ type IntoIter = Iter<'a, T>;
+ type Item = &'a T;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.iter()
+ }
+}
+
+impl<T> IntoIterator for Box<Slice<T>> {
+ type IntoIter = IntoIter<T>;
+ type Item = T;
+
+ fn into_iter(self) -> Self::IntoIter {
+ IntoIter::new(self.into_entries())
+ }
+}
+
+impl<T> Default for &'_ Slice<T> {
+ fn default() -> Self {
+ Slice::from_slice(&[])
+ }
+}
+
+impl<T> Default for Box<Slice<T>> {
+ fn default() -> Self {
+ Slice::from_boxed(Box::default())
+ }
+}
+
+impl<T: Clone> Clone for Box<Slice<T>> {
+ fn clone(&self) -> Self {
+ Slice::from_boxed(self.entries.to_vec().into_boxed_slice())
+ }
+}
+
+impl<T: Copy> From<&Slice<T>> for Box<Slice<T>> {
+ fn from(slice: &Slice<T>) -> Self {
+ Slice::from_boxed(Box::from(&slice.entries))
+ }
+}
+
+impl<T: fmt::Debug> fmt::Debug for Slice<T> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_list().entries(self).finish()
+ }
+}
+
+impl<T: PartialEq> PartialEq for Slice<T> {
+ fn eq(&self, other: &Self) -> bool {
+ self.len() == other.len() && self.iter().eq(other)
+ }
+}
+
+impl<T: Eq> Eq for Slice<T> {}
+
+impl<T: PartialOrd> PartialOrd for Slice<T> {
+ fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+ self.iter().partial_cmp(other)
+ }
+}
+
+impl<T: Ord> Ord for Slice<T> {
+ fn cmp(&self, other: &Self) -> Ordering {
+ self.iter().cmp(other)
+ }
+}
+
+impl<T: Hash> Hash for Slice<T> {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ self.len().hash(state);
+ for value in self {
+ value.hash(state);
+ }
+ }
+}
+
+impl<T> Index<usize> for Slice<T> {
+ type Output = T;
+
+ fn index(&self, index: usize) -> &Self::Output {
+ &self.entries[index].key
+ }
+}
+
+// We can't have `impl<I: RangeBounds<usize>> Index<I>` because that conflicts with `Index<usize>`.
+// Instead, we repeat the implementations for all the core range types.
+macro_rules! impl_index {
+ ($($range:ty),*) => {$(
+ impl<T, S> Index<$range> for IndexSet<T, S> {
+ type Output = Slice<T>;
+
+ fn index(&self, range: $range) -> &Self::Output {
+ Slice::from_slice(&self.as_entries()[range])
+ }
+ }
+
+ impl<T> Index<$range> for Slice<T> {
+ type Output = Self;
+
+ fn index(&self, range: $range) -> &Self::Output {
+ Slice::from_slice(&self.entries[range])
+ }
+ }
+ )*}
+}
+impl_index!(
+ ops::Range<usize>,
+ ops::RangeFrom<usize>,
+ ops::RangeFull,
+ ops::RangeInclusive<usize>,
+ ops::RangeTo<usize>,
+ ops::RangeToInclusive<usize>,
+ (Bound<usize>, Bound<usize>)
+);
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn slice_index() {
+ fn check(vec_slice: &[i32], set_slice: &Slice<i32>, sub_slice: &Slice<i32>) {
+ assert_eq!(set_slice as *const _, sub_slice as *const _);
+ itertools::assert_equal(vec_slice, set_slice);
+ }
+
+ let vec: Vec<i32> = (0..10).map(|i| i * i).collect();
+ let set: IndexSet<i32> = vec.iter().cloned().collect();
+ let slice = set.as_slice();
+
+ // RangeFull
+ check(&vec[..], &set[..], &slice[..]);
+
+ for i in 0usize..10 {
+ // Index
+ assert_eq!(vec[i], set[i]);
+ assert_eq!(vec[i], slice[i]);
+
+ // RangeFrom
+ check(&vec[i..], &set[i..], &slice[i..]);
+
+ // RangeTo
+ check(&vec[..i], &set[..i], &slice[..i]);
+
+ // RangeToInclusive
+ check(&vec[..=i], &set[..=i], &slice[..=i]);
+
+ // (Bound<usize>, Bound<usize>)
+ let bounds = (Bound::Excluded(i), Bound::Unbounded);
+ check(&vec[i + 1..], &set[bounds], &slice[bounds]);
+
+ for j in i..=10 {
+ // Range
+ check(&vec[i..j], &set[i..j], &slice[i..j]);
+ }
+
+ for j in i..10 {
+ // RangeInclusive
+ check(&vec[i..=j], &set[i..=j], &slice[i..=j]);
+ }
+ }
+ }
+}
diff --git a/third_party/rust/indexmap/src/set/tests.rs b/third_party/rust/indexmap/src/set/tests.rs
new file mode 100644
index 0000000000..35a076e8de
--- /dev/null
+++ b/third_party/rust/indexmap/src/set/tests.rs
@@ -0,0 +1,723 @@
+use super::*;
+use std::string::String;
+
+#[test]
+fn it_works() {
+ let mut set = IndexSet::new();
+ assert_eq!(set.is_empty(), true);
+ set.insert(1);
+ set.insert(1);
+ assert_eq!(set.len(), 1);
+ assert!(set.get(&1).is_some());
+ assert_eq!(set.is_empty(), false);
+}
+
+#[test]
+fn new() {
+ let set = IndexSet::<String>::new();
+ println!("{:?}", set);
+ assert_eq!(set.capacity(), 0);
+ assert_eq!(set.len(), 0);
+ assert_eq!(set.is_empty(), true);
+}
+
+#[test]
+fn insert() {
+ let insert = [0, 4, 2, 12, 8, 7, 11, 5];
+ let not_present = [1, 3, 6, 9, 10];
+ let mut set = IndexSet::with_capacity(insert.len());
+
+ for (i, &elt) in insert.iter().enumerate() {
+ assert_eq!(set.len(), i);
+ set.insert(elt);
+ assert_eq!(set.len(), i + 1);
+ assert_eq!(set.get(&elt), Some(&elt));
+ }
+ println!("{:?}", set);
+
+ for &elt in &not_present {
+ assert!(set.get(&elt).is_none());
+ }
+}
+
+#[test]
+fn insert_full() {
+ let insert = vec![9, 2, 7, 1, 4, 6, 13];
+ let present = vec![1, 6, 2];
+ let mut set = IndexSet::with_capacity(insert.len());
+
+ for (i, &elt) in insert.iter().enumerate() {
+ assert_eq!(set.len(), i);
+ let (index, success) = set.insert_full(elt);
+ assert!(success);
+ assert_eq!(Some(index), set.get_full(&elt).map(|x| x.0));
+ assert_eq!(set.len(), i + 1);
+ }
+
+ let len = set.len();
+ for &elt in &present {
+ let (index, success) = set.insert_full(elt);
+ assert!(!success);
+ assert_eq!(Some(index), set.get_full(&elt).map(|x| x.0));
+ assert_eq!(set.len(), len);
+ }
+}
+
+#[test]
+fn insert_2() {
+ let mut set = IndexSet::with_capacity(16);
+
+ let mut values = vec![];
+ values.extend(0..16);
+ values.extend(if cfg!(miri) { 32..64 } else { 128..267 });
+
+ for &i in &values {
+ let old_set = set.clone();
+ set.insert(i);
+ for value in old_set.iter() {
+ if set.get(value).is_none() {
+ println!("old_set: {:?}", old_set);
+ println!("set: {:?}", set);
+ panic!("did not find {} in set", value);
+ }
+ }
+ }
+
+ for &i in &values {
+ assert!(set.get(&i).is_some(), "did not find {}", i);
+ }
+}
+
+#[test]
+fn insert_dup() {
+ let mut elements = vec![0, 2, 4, 6, 8];
+ let mut set: IndexSet<u8> = elements.drain(..).collect();
+ {
+ let (i, v) = set.get_full(&0).unwrap();
+ assert_eq!(set.len(), 5);
+ assert_eq!(i, 0);
+ assert_eq!(*v, 0);
+ }
+ {
+ let inserted = set.insert(0);
+ let (i, v) = set.get_full(&0).unwrap();
+ assert_eq!(set.len(), 5);
+ assert_eq!(inserted, false);
+ assert_eq!(i, 0);
+ assert_eq!(*v, 0);
+ }
+}
+
+#[test]
+fn insert_order() {
+ let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+ let mut set = IndexSet::new();
+
+ for &elt in &insert {
+ set.insert(elt);
+ }
+
+ assert_eq!(set.iter().count(), set.len());
+ assert_eq!(set.iter().count(), insert.len());
+ for (a, b) in insert.iter().zip(set.iter()) {
+ assert_eq!(a, b);
+ }
+ for (i, v) in (0..insert.len()).zip(set.iter()) {
+ assert_eq!(set.get_index(i).unwrap(), v);
+ }
+}
+
+#[test]
+fn shift_insert() {
+ let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+ let mut set = IndexSet::new();
+
+ for &elt in &insert {
+ set.shift_insert(0, elt);
+ }
+
+ assert_eq!(set.iter().count(), set.len());
+ assert_eq!(set.iter().count(), insert.len());
+ for (a, b) in insert.iter().rev().zip(set.iter()) {
+ assert_eq!(a, b);
+ }
+ for (i, v) in (0..insert.len()).zip(set.iter()) {
+ assert_eq!(set.get_index(i).unwrap(), v);
+ }
+
+ // "insert" that moves an existing entry
+ set.shift_insert(0, insert[0]);
+ assert_eq!(set.iter().count(), insert.len());
+ assert_eq!(insert[0], set[0]);
+ for (a, b) in insert[1..].iter().rev().zip(set.iter().skip(1)) {
+ assert_eq!(a, b);
+ }
+}
+
+#[test]
+fn replace() {
+ let replace = [0, 4, 2, 12, 8, 7, 11, 5];
+ let not_present = [1, 3, 6, 9, 10];
+ let mut set = IndexSet::with_capacity(replace.len());
+
+ for (i, &elt) in replace.iter().enumerate() {
+ assert_eq!(set.len(), i);
+ set.replace(elt);
+ assert_eq!(set.len(), i + 1);
+ assert_eq!(set.get(&elt), Some(&elt));
+ }
+ println!("{:?}", set);
+
+ for &elt in &not_present {
+ assert!(set.get(&elt).is_none());
+ }
+}
+
+#[test]
+fn replace_full() {
+ let replace = vec![9, 2, 7, 1, 4, 6, 13];
+ let present = vec![1, 6, 2];
+ let mut set = IndexSet::with_capacity(replace.len());
+
+ for (i, &elt) in replace.iter().enumerate() {
+ assert_eq!(set.len(), i);
+ let (index, replaced) = set.replace_full(elt);
+ assert!(replaced.is_none());
+ assert_eq!(Some(index), set.get_full(&elt).map(|x| x.0));
+ assert_eq!(set.len(), i + 1);
+ }
+
+ let len = set.len();
+ for &elt in &present {
+ let (index, replaced) = set.replace_full(elt);
+ assert_eq!(Some(elt), replaced);
+ assert_eq!(Some(index), set.get_full(&elt).map(|x| x.0));
+ assert_eq!(set.len(), len);
+ }
+}
+
+#[test]
+fn replace_2() {
+ let mut set = IndexSet::with_capacity(16);
+
+ let mut values = vec![];
+ values.extend(0..16);
+ values.extend(if cfg!(miri) { 32..64 } else { 128..267 });
+
+ for &i in &values {
+ let old_set = set.clone();
+ set.replace(i);
+ for value in old_set.iter() {
+ if set.get(value).is_none() {
+ println!("old_set: {:?}", old_set);
+ println!("set: {:?}", set);
+ panic!("did not find {} in set", value);
+ }
+ }
+ }
+
+ for &i in &values {
+ assert!(set.get(&i).is_some(), "did not find {}", i);
+ }
+}
+
+#[test]
+fn replace_dup() {
+ let mut elements = vec![0, 2, 4, 6, 8];
+ let mut set: IndexSet<u8> = elements.drain(..).collect();
+ {
+ let (i, v) = set.get_full(&0).unwrap();
+ assert_eq!(set.len(), 5);
+ assert_eq!(i, 0);
+ assert_eq!(*v, 0);
+ }
+ {
+ let replaced = set.replace(0);
+ let (i, v) = set.get_full(&0).unwrap();
+ assert_eq!(set.len(), 5);
+ assert_eq!(replaced, Some(0));
+ assert_eq!(i, 0);
+ assert_eq!(*v, 0);
+ }
+}
+
+#[test]
+fn replace_order() {
+ let replace = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+ let mut set = IndexSet::new();
+
+ for &elt in &replace {
+ set.replace(elt);
+ }
+
+ assert_eq!(set.iter().count(), set.len());
+ assert_eq!(set.iter().count(), replace.len());
+ for (a, b) in replace.iter().zip(set.iter()) {
+ assert_eq!(a, b);
+ }
+ for (i, v) in (0..replace.len()).zip(set.iter()) {
+ assert_eq!(set.get_index(i).unwrap(), v);
+ }
+}
+
+#[test]
+fn replace_change() {
+ // Check pointers to make sure it really changes
+ let mut set = indexset!(vec![42]);
+ let old_ptr = set[0].as_ptr();
+ let new = set[0].clone();
+ let new_ptr = new.as_ptr();
+ assert_ne!(old_ptr, new_ptr);
+ let replaced = set.replace(new).unwrap();
+ assert_eq!(replaced.as_ptr(), old_ptr);
+}
+
+#[test]
+fn grow() {
+ let insert = [0, 4, 2, 12, 8, 7, 11];
+ let not_present = [1, 3, 6, 9, 10];
+ let mut set = IndexSet::with_capacity(insert.len());
+
+ for (i, &elt) in insert.iter().enumerate() {
+ assert_eq!(set.len(), i);
+ set.insert(elt);
+ assert_eq!(set.len(), i + 1);
+ assert_eq!(set.get(&elt), Some(&elt));
+ }
+
+ println!("{:?}", set);
+ for &elt in &insert {
+ set.insert(elt * 10);
+ }
+ for &elt in &insert {
+ set.insert(elt * 100);
+ }
+ for (i, &elt) in insert.iter().cycle().enumerate().take(100) {
+ set.insert(elt * 100 + i as i32);
+ }
+ println!("{:?}", set);
+ for &elt in &not_present {
+ assert!(set.get(&elt).is_none());
+ }
+}
+
+#[test]
+fn reserve() {
+ let mut set = IndexSet::<usize>::new();
+ assert_eq!(set.capacity(), 0);
+ set.reserve(100);
+ let capacity = set.capacity();
+ assert!(capacity >= 100);
+ for i in 0..capacity {
+ assert_eq!(set.len(), i);
+ set.insert(i);
+ assert_eq!(set.len(), i + 1);
+ assert_eq!(set.capacity(), capacity);
+ assert_eq!(set.get(&i), Some(&i));
+ }
+ set.insert(capacity);
+ assert_eq!(set.len(), capacity + 1);
+ assert!(set.capacity() > capacity);
+ assert_eq!(set.get(&capacity), Some(&capacity));
+}
+
+#[test]
+fn try_reserve() {
+ let mut set = IndexSet::<usize>::new();
+ assert_eq!(set.capacity(), 0);
+ assert_eq!(set.try_reserve(100), Ok(()));
+ assert!(set.capacity() >= 100);
+ assert!(set.try_reserve(usize::MAX).is_err());
+}
+
+#[test]
+fn shrink_to_fit() {
+ let mut set = IndexSet::<usize>::new();
+ assert_eq!(set.capacity(), 0);
+ for i in 0..100 {
+ assert_eq!(set.len(), i);
+ set.insert(i);
+ assert_eq!(set.len(), i + 1);
+ assert!(set.capacity() >= i + 1);
+ assert_eq!(set.get(&i), Some(&i));
+ set.shrink_to_fit();
+ assert_eq!(set.len(), i + 1);
+ assert_eq!(set.capacity(), i + 1);
+ assert_eq!(set.get(&i), Some(&i));
+ }
+}
+
+#[test]
+fn remove() {
+ let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+ let mut set = IndexSet::new();
+
+ for &elt in &insert {
+ set.insert(elt);
+ }
+
+ assert_eq!(set.iter().count(), set.len());
+ assert_eq!(set.iter().count(), insert.len());
+ for (a, b) in insert.iter().zip(set.iter()) {
+ assert_eq!(a, b);
+ }
+
+ let remove_fail = [99, 77];
+ let remove = [4, 12, 8, 7];
+
+ for &value in &remove_fail {
+ assert!(set.swap_remove_full(&value).is_none());
+ }
+ println!("{:?}", set);
+ for &value in &remove {
+ //println!("{:?}", set);
+ let index = set.get_full(&value).unwrap().0;
+ assert_eq!(set.swap_remove_full(&value), Some((index, value)));
+ }
+ println!("{:?}", set);
+
+ for value in &insert {
+ assert_eq!(set.get(value).is_some(), !remove.contains(value));
+ }
+ assert_eq!(set.len(), insert.len() - remove.len());
+ assert_eq!(set.iter().count(), insert.len() - remove.len());
+}
+
+#[test]
+fn swap_remove_index() {
+ let insert = [0, 4, 2, 12, 8, 7, 11, 5, 3, 17, 19, 22, 23];
+ let mut set = IndexSet::new();
+
+ for &elt in &insert {
+ set.insert(elt);
+ }
+
+ let mut vector = insert.to_vec();
+ let remove_sequence = &[3, 3, 10, 4, 5, 4, 3, 0, 1];
+
+ // check that the same swap remove sequence on vec and set
+ // have the same result.
+ for &rm in remove_sequence {
+ let out_vec = vector.swap_remove(rm);
+ let out_set = set.swap_remove_index(rm).unwrap();
+ assert_eq!(out_vec, out_set);
+ }
+ assert_eq!(vector.len(), set.len());
+ for (a, b) in vector.iter().zip(set.iter()) {
+ assert_eq!(a, b);
+ }
+}
+
+#[test]
+fn partial_eq_and_eq() {
+ let mut set_a = IndexSet::new();
+ set_a.insert(1);
+ set_a.insert(2);
+ let mut set_b = set_a.clone();
+ assert_eq!(set_a, set_b);
+ set_b.swap_remove(&1);
+ assert_ne!(set_a, set_b);
+
+ let set_c: IndexSet<_> = set_b.into_iter().collect();
+ assert_ne!(set_a, set_c);
+ assert_ne!(set_c, set_a);
+}
+
+#[test]
+fn extend() {
+ let mut set = IndexSet::new();
+ set.extend(vec![&1, &2, &3, &4]);
+ set.extend(vec![5, 6]);
+ assert_eq!(set.into_iter().collect::<Vec<_>>(), vec![1, 2, 3, 4, 5, 6]);
+}
+
+#[test]
+fn comparisons() {
+ let set_a: IndexSet<_> = (0..3).collect();
+ let set_b: IndexSet<_> = (3..6).collect();
+ let set_c: IndexSet<_> = (0..6).collect();
+ let set_d: IndexSet<_> = (3..9).collect();
+
+ assert!(!set_a.is_disjoint(&set_a));
+ assert!(set_a.is_subset(&set_a));
+ assert!(set_a.is_superset(&set_a));
+
+ assert!(set_a.is_disjoint(&set_b));
+ assert!(set_b.is_disjoint(&set_a));
+ assert!(!set_a.is_subset(&set_b));
+ assert!(!set_b.is_subset(&set_a));
+ assert!(!set_a.is_superset(&set_b));
+ assert!(!set_b.is_superset(&set_a));
+
+ assert!(!set_a.is_disjoint(&set_c));
+ assert!(!set_c.is_disjoint(&set_a));
+ assert!(set_a.is_subset(&set_c));
+ assert!(!set_c.is_subset(&set_a));
+ assert!(!set_a.is_superset(&set_c));
+ assert!(set_c.is_superset(&set_a));
+
+ assert!(!set_c.is_disjoint(&set_d));
+ assert!(!set_d.is_disjoint(&set_c));
+ assert!(!set_c.is_subset(&set_d));
+ assert!(!set_d.is_subset(&set_c));
+ assert!(!set_c.is_superset(&set_d));
+ assert!(!set_d.is_superset(&set_c));
+}
+
+#[test]
+fn iter_comparisons() {
+ use std::iter::empty;
+
+ fn check<'a, I1, I2>(iter1: I1, iter2: I2)
+ where
+ I1: Iterator<Item = &'a i32>,
+ I2: Iterator<Item = i32>,
+ {
+ assert!(iter1.copied().eq(iter2));
+ }
+
+ let set_a: IndexSet<_> = (0..3).collect();
+ let set_b: IndexSet<_> = (3..6).collect();
+ let set_c: IndexSet<_> = (0..6).collect();
+ let set_d: IndexSet<_> = (3..9).rev().collect();
+
+ check(set_a.difference(&set_a), empty());
+ check(set_a.symmetric_difference(&set_a), empty());
+ check(set_a.intersection(&set_a), 0..3);
+ check(set_a.union(&set_a), 0..3);
+
+ check(set_a.difference(&set_b), 0..3);
+ check(set_b.difference(&set_a), 3..6);
+ check(set_a.symmetric_difference(&set_b), 0..6);
+ check(set_b.symmetric_difference(&set_a), (3..6).chain(0..3));
+ check(set_a.intersection(&set_b), empty());
+ check(set_b.intersection(&set_a), empty());
+ check(set_a.union(&set_b), 0..6);
+ check(set_b.union(&set_a), (3..6).chain(0..3));
+
+ check(set_a.difference(&set_c), empty());
+ check(set_c.difference(&set_a), 3..6);
+ check(set_a.symmetric_difference(&set_c), 3..6);
+ check(set_c.symmetric_difference(&set_a), 3..6);
+ check(set_a.intersection(&set_c), 0..3);
+ check(set_c.intersection(&set_a), 0..3);
+ check(set_a.union(&set_c), 0..6);
+ check(set_c.union(&set_a), 0..6);
+
+ check(set_c.difference(&set_d), 0..3);
+ check(set_d.difference(&set_c), (6..9).rev());
+ check(
+ set_c.symmetric_difference(&set_d),
+ (0..3).chain((6..9).rev()),
+ );
+ check(set_d.symmetric_difference(&set_c), (6..9).rev().chain(0..3));
+ check(set_c.intersection(&set_d), 3..6);
+ check(set_d.intersection(&set_c), (3..6).rev());
+ check(set_c.union(&set_d), (0..6).chain((6..9).rev()));
+ check(set_d.union(&set_c), (3..9).rev().chain(0..3));
+}
+
+#[test]
+fn ops() {
+ let empty = IndexSet::<i32>::new();
+ let set_a: IndexSet<_> = (0..3).collect();
+ let set_b: IndexSet<_> = (3..6).collect();
+ let set_c: IndexSet<_> = (0..6).collect();
+ let set_d: IndexSet<_> = (3..9).rev().collect();
+
+ #[allow(clippy::eq_op)]
+ {
+ assert_eq!(&set_a & &set_a, set_a);
+ assert_eq!(&set_a | &set_a, set_a);
+ assert_eq!(&set_a ^ &set_a, empty);
+ assert_eq!(&set_a - &set_a, empty);
+ }
+
+ assert_eq!(&set_a & &set_b, empty);
+ assert_eq!(&set_b & &set_a, empty);
+ assert_eq!(&set_a | &set_b, set_c);
+ assert_eq!(&set_b | &set_a, set_c);
+ assert_eq!(&set_a ^ &set_b, set_c);
+ assert_eq!(&set_b ^ &set_a, set_c);
+ assert_eq!(&set_a - &set_b, set_a);
+ assert_eq!(&set_b - &set_a, set_b);
+
+ assert_eq!(&set_a & &set_c, set_a);
+ assert_eq!(&set_c & &set_a, set_a);
+ assert_eq!(&set_a | &set_c, set_c);
+ assert_eq!(&set_c | &set_a, set_c);
+ assert_eq!(&set_a ^ &set_c, set_b);
+ assert_eq!(&set_c ^ &set_a, set_b);
+ assert_eq!(&set_a - &set_c, empty);
+ assert_eq!(&set_c - &set_a, set_b);
+
+ assert_eq!(&set_c & &set_d, set_b);
+ assert_eq!(&set_d & &set_c, set_b);
+ assert_eq!(&set_c | &set_d, &set_a | &set_d);
+ assert_eq!(&set_d | &set_c, &set_a | &set_d);
+ assert_eq!(&set_c ^ &set_d, &set_a | &(&set_d - &set_b));
+ assert_eq!(&set_d ^ &set_c, &set_a | &(&set_d - &set_b));
+ assert_eq!(&set_c - &set_d, set_a);
+ assert_eq!(&set_d - &set_c, &set_d - &set_b);
+}
+
+#[test]
+#[cfg(feature = "std")]
+fn from_array() {
+ let set1 = IndexSet::from([1, 2, 3, 4]);
+ let set2: IndexSet<_> = [1, 2, 3, 4].into();
+
+ assert_eq!(set1, set2);
+}
+
+#[test]
+fn iter_default() {
+ struct Item;
+ fn assert_default<T>()
+ where
+ T: Default + Iterator,
+ {
+ assert!(T::default().next().is_none());
+ }
+ assert_default::<Iter<'static, Item>>();
+ assert_default::<IntoIter<Item>>();
+}
+
+#[test]
+fn test_binary_search_by() {
+ // adapted from std's test for binary_search
+ let b: IndexSet<i32> = [].into();
+ assert_eq!(b.binary_search_by(|x| x.cmp(&5)), Err(0));
+
+ let b: IndexSet<i32> = [4].into();
+ assert_eq!(b.binary_search_by(|x| x.cmp(&3)), Err(0));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&4)), Ok(0));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&5)), Err(1));
+
+ let b: IndexSet<i32> = [1, 2, 4, 6, 8, 9].into();
+ assert_eq!(b.binary_search_by(|x| x.cmp(&5)), Err(3));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&6)), Ok(3));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&7)), Err(4));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&8)), Ok(4));
+
+ let b: IndexSet<i32> = [1, 2, 4, 5, 6, 8].into();
+ assert_eq!(b.binary_search_by(|x| x.cmp(&9)), Err(6));
+
+ let b: IndexSet<i32> = [1, 2, 4, 6, 7, 8, 9].into();
+ assert_eq!(b.binary_search_by(|x| x.cmp(&6)), Ok(3));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&5)), Err(3));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&8)), Ok(5));
+
+ let b: IndexSet<i32> = [1, 2, 4, 5, 6, 8, 9].into();
+ assert_eq!(b.binary_search_by(|x| x.cmp(&7)), Err(5));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&0)), Err(0));
+
+ let b: IndexSet<i32> = [1, 3, 3, 3, 7].into();
+ assert_eq!(b.binary_search_by(|x| x.cmp(&0)), Err(0));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&1)), Ok(0));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&2)), Err(1));
+ // diff from std as set merges the duplicate keys
+ assert!(match b.binary_search_by(|x| x.cmp(&3)) {
+ Ok(1..=2) => true,
+ _ => false,
+ });
+ assert!(match b.binary_search_by(|x| x.cmp(&3)) {
+ Ok(1..=2) => true,
+ _ => false,
+ });
+ assert_eq!(b.binary_search_by(|x| x.cmp(&4)), Err(2));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&5)), Err(2));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&6)), Err(2));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&7)), Ok(2));
+ assert_eq!(b.binary_search_by(|x| x.cmp(&8)), Err(3));
+}
+
+#[test]
+fn test_binary_search_by_key() {
+ // adapted from std's test for binary_search
+ let b: IndexSet<i32> = [].into();
+ assert_eq!(b.binary_search_by_key(&5, |&x| x), Err(0));
+
+ let b: IndexSet<i32> = [4].into();
+ assert_eq!(b.binary_search_by_key(&3, |&x| x), Err(0));
+ assert_eq!(b.binary_search_by_key(&4, |&x| x), Ok(0));
+ assert_eq!(b.binary_search_by_key(&5, |&x| x), Err(1));
+
+ let b: IndexSet<i32> = [1, 2, 4, 6, 8, 9].into();
+ assert_eq!(b.binary_search_by_key(&5, |&x| x), Err(3));
+ assert_eq!(b.binary_search_by_key(&6, |&x| x), Ok(3));
+ assert_eq!(b.binary_search_by_key(&7, |&x| x), Err(4));
+ assert_eq!(b.binary_search_by_key(&8, |&x| x), Ok(4));
+
+ let b: IndexSet<i32> = [1, 2, 4, 5, 6, 8].into();
+ assert_eq!(b.binary_search_by_key(&9, |&x| x), Err(6));
+
+ let b: IndexSet<i32> = [1, 2, 4, 6, 7, 8, 9].into();
+ assert_eq!(b.binary_search_by_key(&6, |&x| x), Ok(3));
+ assert_eq!(b.binary_search_by_key(&5, |&x| x), Err(3));
+ assert_eq!(b.binary_search_by_key(&8, |&x| x), Ok(5));
+
+ let b: IndexSet<i32> = [1, 2, 4, 5, 6, 8, 9].into();
+ assert_eq!(b.binary_search_by_key(&7, |&x| x), Err(5));
+ assert_eq!(b.binary_search_by_key(&0, |&x| x), Err(0));
+
+ let b: IndexSet<i32> = [1, 3, 3, 3, 7].into();
+ assert_eq!(b.binary_search_by_key(&0, |&x| x), Err(0));
+ assert_eq!(b.binary_search_by_key(&1, |&x| x), Ok(0));
+ assert_eq!(b.binary_search_by_key(&2, |&x| x), Err(1));
+ // diff from std as set merges the duplicate keys
+ assert!(match b.binary_search_by_key(&3, |&x| x) {
+ Ok(1..=2) => true,
+ _ => false,
+ });
+ assert!(match b.binary_search_by_key(&3, |&x| x) {
+ Ok(1..=2) => true,
+ _ => false,
+ });
+ assert_eq!(b.binary_search_by_key(&4, |&x| x), Err(2));
+ assert_eq!(b.binary_search_by_key(&5, |&x| x), Err(2));
+ assert_eq!(b.binary_search_by_key(&6, |&x| x), Err(2));
+ assert_eq!(b.binary_search_by_key(&7, |&x| x), Ok(2));
+ assert_eq!(b.binary_search_by_key(&8, |&x| x), Err(3));
+}
+
+#[test]
+fn test_partition_point() {
+ // adapted from std's test for partition_point
+ let b: IndexSet<i32> = [].into();
+ assert_eq!(b.partition_point(|&x| x < 5), 0);
+
+ let b: IndexSet<_> = [4].into();
+ assert_eq!(b.partition_point(|&x| x < 3), 0);
+ assert_eq!(b.partition_point(|&x| x < 4), 0);
+ assert_eq!(b.partition_point(|&x| x < 5), 1);
+
+ let b: IndexSet<_> = [1, 2, 4, 6, 8, 9].into();
+ assert_eq!(b.partition_point(|&x| x < 5), 3);
+ assert_eq!(b.partition_point(|&x| x < 6), 3);
+ assert_eq!(b.partition_point(|&x| x < 7), 4);
+ assert_eq!(b.partition_point(|&x| x < 8), 4);
+
+ let b: IndexSet<_> = [1, 2, 4, 5, 6, 8].into();
+ assert_eq!(b.partition_point(|&x| x < 9), 6);
+
+ let b: IndexSet<_> = [1, 2, 4, 6, 7, 8, 9].into();
+ assert_eq!(b.partition_point(|&x| x < 6), 3);
+ assert_eq!(b.partition_point(|&x| x < 5), 3);
+ assert_eq!(b.partition_point(|&x| x < 8), 5);
+
+ let b: IndexSet<_> = [1, 2, 4, 5, 6, 8, 9].into();
+ assert_eq!(b.partition_point(|&x| x < 7), 5);
+ assert_eq!(b.partition_point(|&x| x < 0), 0);
+
+ let b: IndexSet<_> = [1, 3, 3, 3, 7].into();
+ assert_eq!(b.partition_point(|&x| x < 0), 0);
+ assert_eq!(b.partition_point(|&x| x < 1), 0);
+ assert_eq!(b.partition_point(|&x| x < 2), 1);
+ assert_eq!(b.partition_point(|&x| x < 3), 1);
+ assert_eq!(b.partition_point(|&x| x < 4), 2); // diff from std as set merges the duplicate keys
+ assert_eq!(b.partition_point(|&x| x < 5), 2);
+ assert_eq!(b.partition_point(|&x| x < 6), 2);
+ assert_eq!(b.partition_point(|&x| x < 7), 2);
+ assert_eq!(b.partition_point(|&x| x < 8), 3);
+}
diff --git a/third_party/rust/indexmap/src/util.rs b/third_party/rust/indexmap/src/util.rs
index a24dfafde7..377ff516f0 100644
--- a/third_party/rust/indexmap/src/util.rs
+++ b/third_party/rust/indexmap/src/util.rs
@@ -29,3 +29,25 @@ where
}
start..end
}
+
+pub(crate) fn try_simplify_range<R>(range: R, len: usize) -> Option<Range<usize>>
+where
+ R: RangeBounds<usize>,
+{
+ let start = match range.start_bound() {
+ Bound::Unbounded => 0,
+ Bound::Included(&i) if i <= len => i,
+ Bound::Excluded(&i) if i < len => i + 1,
+ _ => return None,
+ };
+ let end = match range.end_bound() {
+ Bound::Unbounded => len,
+ Bound::Excluded(&i) if i <= len => i,
+ Bound::Included(&i) if i < len => i + 1,
+ _ => return None,
+ };
+ if start > end {
+ return None;
+ }
+ Some(start..end)
+}
diff --git a/third_party/rust/indexmap/tests/quick.rs b/third_party/rust/indexmap/tests/quick.rs
index e9d96acccb..56afee7239 100644
--- a/third_party/rust/indexmap/tests/quick.rs
+++ b/third_party/rust/indexmap/tests/quick.rs
@@ -19,8 +19,8 @@ use std::hash::Hash;
use std::ops::Bound;
use std::ops::Deref;
-use indexmap::map::Entry as OEntry;
-use std::collections::hash_map::Entry as HEntry;
+use indexmap::map::Entry;
+use std::collections::hash_map::Entry as StdEntry;
fn set<'a, T: 'a, I>(iter: I) -> HashSet<T>
where
@@ -113,6 +113,23 @@ quickcheck_limit! {
true
}
+ fn insert_sorted(insert: Vec<(u32, u32)>) -> bool {
+ let mut hmap = HashMap::new();
+ let mut map = IndexMap::new();
+ let mut map2 = IndexMap::new();
+ for &(key, value) in &insert {
+ hmap.insert(key, value);
+ map.insert_sorted(key, value);
+ match map2.entry(key) {
+ Entry::Occupied(e) => *e.into_mut() = value,
+ Entry::Vacant(e) => { e.insert_sorted(value); }
+ }
+ }
+ itertools::assert_equal(hmap.iter().sorted(), &map);
+ itertools::assert_equal(&map, &map2);
+ true
+ }
+
fn pop(insert: Vec<u8>) -> bool {
let mut map = IndexMap::new();
for &key in &insert {
@@ -218,7 +235,7 @@ quickcheck_limit! {
}
// Use `u8` test indices so quickcheck is less likely to go out of bounds.
- fn swap_indices(vec: Vec<u8>, a: u8, b: u8) -> TestResult {
+ fn set_swap_indices(vec: Vec<u8>, a: u8, b: u8) -> TestResult {
let mut set = IndexSet::<u8>::from_iter(vec);
let a = usize::from(a);
let b = usize::from(b);
@@ -240,8 +257,39 @@ quickcheck_limit! {
TestResult::passed()
}
+ fn map_swap_indices(vec: Vec<u8>, from: u8, to: u8) -> TestResult {
+ test_map_swap_indices(vec, from, to, IndexMap::swap_indices)
+ }
+
+ fn occupied_entry_swap_indices(vec: Vec<u8>, from: u8, to: u8) -> TestResult {
+ test_map_swap_indices(vec, from, to, |map, from, to| {
+ let key = map.keys()[from];
+ match map.entry(key) {
+ Entry::Occupied(entry) => entry.swap_indices(to),
+ _ => unreachable!(),
+ }
+ })
+ }
+
+ fn indexed_entry_swap_indices(vec: Vec<u8>, from: u8, to: u8) -> TestResult {
+ test_map_swap_indices(vec, from, to, |map, from, to| {
+ map.get_index_entry(from).unwrap().swap_indices(to);
+ })
+ }
+
+ fn raw_occupied_entry_swap_indices(vec: Vec<u8>, from: u8, to: u8) -> TestResult {
+ use indexmap::map::raw_entry_v1::{RawEntryApiV1, RawEntryMut};
+ test_map_swap_indices(vec, from, to, |map, from, to| {
+ let key = map.keys()[from];
+ match map.raw_entry_mut_v1().from_key(&key) {
+ RawEntryMut::Occupied(entry) => entry.swap_indices(to),
+ _ => unreachable!(),
+ }
+ })
+ }
+
// Use `u8` test indices so quickcheck is less likely to go out of bounds.
- fn move_index(vec: Vec<u8>, from: u8, to: u8) -> TestResult {
+ fn set_move_index(vec: Vec<u8>, from: u8, to: u8) -> TestResult {
let mut set = IndexSet::<u8>::from_iter(vec);
let from = usize::from(from);
let to = usize::from(to);
@@ -263,6 +311,138 @@ quickcheck_limit! {
}));
TestResult::passed()
}
+
+ fn map_move_index(vec: Vec<u8>, from: u8, to: u8) -> TestResult {
+ test_map_move_index(vec, from, to, IndexMap::move_index)
+ }
+
+ fn occupied_entry_move_index(vec: Vec<u8>, from: u8, to: u8) -> TestResult {
+ test_map_move_index(vec, from, to, |map, from, to| {
+ let key = map.keys()[from];
+ match map.entry(key) {
+ Entry::Occupied(entry) => entry.move_index(to),
+ _ => unreachable!(),
+ }
+ })
+ }
+
+ fn indexed_entry_move_index(vec: Vec<u8>, from: u8, to: u8) -> TestResult {
+ test_map_move_index(vec, from, to, |map, from, to| {
+ map.get_index_entry(from).unwrap().move_index(to);
+ })
+ }
+
+ fn raw_occupied_entry_move_index(vec: Vec<u8>, from: u8, to: u8) -> TestResult {
+ use indexmap::map::raw_entry_v1::{RawEntryApiV1, RawEntryMut};
+ test_map_move_index(vec, from, to, |map, from, to| {
+ let key = map.keys()[from];
+ match map.raw_entry_mut_v1().from_key(&key) {
+ RawEntryMut::Occupied(entry) => entry.move_index(to),
+ _ => unreachable!(),
+ }
+ })
+ }
+
+ fn occupied_entry_shift_insert(vec: Vec<u8>, i: u8) -> TestResult {
+ test_map_shift_insert(vec, i, |map, i, key| {
+ match map.entry(key) {
+ Entry::Vacant(entry) => entry.shift_insert(i, ()),
+ _ => unreachable!(),
+ };
+ })
+ }
+
+ fn raw_occupied_entry_shift_insert(vec: Vec<u8>, i: u8) -> TestResult {
+ use indexmap::map::raw_entry_v1::{RawEntryApiV1, RawEntryMut};
+ test_map_shift_insert(vec, i, |map, i, key| {
+ match map.raw_entry_mut_v1().from_key(&key) {
+ RawEntryMut::Vacant(entry) => entry.shift_insert(i, key, ()),
+ _ => unreachable!(),
+ };
+ })
+ }
+}
+
+fn test_map_swap_indices<F>(vec: Vec<u8>, a: u8, b: u8, swap_indices: F) -> TestResult
+where
+ F: FnOnce(&mut IndexMap<u8, ()>, usize, usize),
+{
+ let mut map = IndexMap::<u8, ()>::from_iter(vec.into_iter().map(|k| (k, ())));
+ let a = usize::from(a);
+ let b = usize::from(b);
+
+ if a >= map.len() || b >= map.len() {
+ return TestResult::discard();
+ }
+
+ let mut vec = Vec::from_iter(map.keys().copied());
+ vec.swap(a, b);
+
+ swap_indices(&mut map, a, b);
+
+ // Check both iteration order and hash lookups
+ assert!(map.keys().eq(vec.iter()));
+ assert!(vec
+ .iter()
+ .enumerate()
+ .all(|(i, x)| { map.get_index_of(x) == Some(i) }));
+ TestResult::passed()
+}
+
+fn test_map_move_index<F>(vec: Vec<u8>, from: u8, to: u8, move_index: F) -> TestResult
+where
+ F: FnOnce(&mut IndexMap<u8, ()>, usize, usize),
+{
+ let mut map = IndexMap::<u8, ()>::from_iter(vec.into_iter().map(|k| (k, ())));
+ let from = usize::from(from);
+ let to = usize::from(to);
+
+ if from >= map.len() || to >= map.len() {
+ return TestResult::discard();
+ }
+
+ let mut vec = Vec::from_iter(map.keys().copied());
+ let x = vec.remove(from);
+ vec.insert(to, x);
+
+ move_index(&mut map, from, to);
+
+ // Check both iteration order and hash lookups
+ assert!(map.keys().eq(vec.iter()));
+ assert!(vec
+ .iter()
+ .enumerate()
+ .all(|(i, x)| { map.get_index_of(x) == Some(i) }));
+ TestResult::passed()
+}
+
+fn test_map_shift_insert<F>(vec: Vec<u8>, i: u8, shift_insert: F) -> TestResult
+where
+ F: FnOnce(&mut IndexMap<u8, ()>, usize, u8),
+{
+ let mut map = IndexMap::<u8, ()>::from_iter(vec.into_iter().map(|k| (k, ())));
+ let i = usize::from(i);
+ if i >= map.len() {
+ return TestResult::discard();
+ }
+
+ let mut vec = Vec::from_iter(map.keys().copied());
+ let x = vec.pop().unwrap();
+ vec.insert(i, x);
+
+ let (last, ()) = map.pop().unwrap();
+ assert_eq!(x, last);
+ map.shrink_to_fit(); // so we might have to grow and rehash the table
+
+ shift_insert(&mut map, i, last);
+
+ // Check both iteration order and hash lookups
+ assert!(map.keys().eq(vec.iter()));
+ assert!(vec
+ .iter()
+ .enumerate()
+ .all(|(i, x)| { map.get_index_of(x) == Some(i) }));
+ TestResult::passed()
}
use crate::Op::*;
@@ -310,10 +490,10 @@ where
b.remove(k);
}
RemoveEntry(ref k) => {
- if let OEntry::Occupied(ent) = a.entry(k.clone()) {
+ if let Entry::Occupied(ent) = a.entry(k.clone()) {
ent.swap_remove_entry();
}
- if let HEntry::Occupied(ent) = b.entry(k.clone()) {
+ if let StdEntry::Occupied(ent) = b.entry(k.clone()) {
ent.remove_entry();
}
}
@@ -452,6 +632,12 @@ quickcheck_limit! {
assert_sorted_by_key(map, |t| t.1);
}
+ fn sort_3(keyvals: Large<Vec<(i8, i8)>>) -> () {
+ let mut map: IndexMap<_, _> = IndexMap::from_iter(keyvals.to_vec());
+ map.sort_by_cached_key(|&k, _| std::cmp::Reverse(k));
+ assert_sorted_by_key(map, |t| std::cmp::Reverse(t.0));
+ }
+
fn reverse(keyvals: Large<Vec<(i8, i8)>>) -> () {
let mut map: IndexMap<_, _> = IndexMap::from_iter(keyvals.to_vec());