Merge pull request #5 from cuviper/sync

Sync changes from indexmap and release 0.5.4

.github/workflows/ci.yml

@@ -46,6 +46,11 @@ jobs:
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ matrix.rust }}
+      - name: Downgrade dependencies
+        if: matrix.rust == '1.63.0'
+        run: |
+          cargo generate-lockfile
+          cargo update -p hashbrown --precise 0.15.0
       - name: Tests
         run: |
           cargo build --verbose --features "${{ matrix.features }}"
@@ -81,6 +86,11 @@ jobs:
         with:
           toolchain: ${{ matrix.rust }}
           target: ${{ matrix.target }}
+      - name: Downgrade dependencies
+        if: matrix.rust == '1.63.0'
+        run: |
+          cargo generate-lockfile
+          cargo update -p hashbrown --precise 0.15.0
       - name: Tests
         run: |
           cargo build -vv --target=${{ matrix.target }} --no-default-features
@@ -119,6 +129,7 @@ jobs:
         with:
           tool: cargo-hack
       - run: cargo +nightly hack generate-lockfile --remove-dev-deps -Z direct-minimal-versions
+      - run: cargo update -p hashbrown --precise 0.15.0
       - name: Build (nightly)
         run: cargo +nightly build --verbose --all-features
       - name: Build (MSRV)

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "ordermap"
 edition = "2021"
-version = "0.5.3"
+version = "0.5.4"
 documentation = "https://docs.rs/ordermap/"
 repository = "https://github.com/indexmap-rs/ordermap"
 license = "Apache-2.0 OR MIT"
@@ -14,13 +14,13 @@ rust-version = "1.63"
 bench = false
 
 [dependencies]
-indexmap = { version = "2.5.0", default-features = false }
+indexmap = { version = "2.7.0", default-features = false }
 
 arbitrary = { version = "1.0", optional = true, default-features = false }
 quickcheck = { version = "1.0", optional = true, default-features = false }
 serde = { version = "1.0", optional = true, default-features = false }
 borsh = { version = "1.2", optional = true, default-features = false }
-rayon = { version = "1.5.3", optional = true }
+rayon = { version = "1.9", optional = true }
 
 [dev-dependencies]
 itertools = "0.13"

RELEASES.md

@@ -1,5 +1,12 @@
 # Releases
 
+## 0.5.4 (2024-11-30)
+
+- Added methods `Entry::insert_entry` and `VacantEntry::insert_entry`, returning
+  an `OccupiedEntry` after insertion.
+- Updated the `indexmap` dependency to version 2.7.0, indirectly updating to
+  `hashbrown` version 0.15 as well.
+
 ## 0.5.3 (2024-08-30)
 
 - Added an `insert_before` method to `OrderMap` and `OrderSet`, as an

src/map.rs

@@ -981,7 +981,7 @@ impl<K, V, S> OrderMap<K, V, S> {
 
     /// Get a key-value pair by index
     ///
-    /// Valid indices are *0 <= index < self.len()*
+    /// Valid indices are `0 <= index < self.len()`.
     ///
     /// Computes in **O(1)** time.
     pub fn get_index(&self, index: usize) -> Option<(&K, &V)> {
@@ -990,7 +990,7 @@ impl<K, V, S> OrderMap<K, V, S> {
 
     /// Get a key-value pair by index
     ///
-    /// Valid indices are *0 <= index < self.len()*
+    /// Valid indices are `0 <= index < self.len()`.
     ///
     /// Computes in **O(1)** time.
     pub fn get_index_mut(&mut self, index: usize) -> Option<(&K, &mut V)> {
@@ -999,7 +999,7 @@ impl<K, V, S> OrderMap<K, V, S> {
 
     /// Get an entry in the map by index for in-place manipulation.
     ///
-    /// Valid indices are *0 <= index < self.len()*
+    /// 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>> {
@@ -1008,7 +1008,7 @@ impl<K, V, S> OrderMap<K, V, S> {
 
     /// Returns a slice of key-value pairs in the given range of indices.
     ///
-    /// Valid indices are *0 <= index < self.len()*
+    /// 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>> {
@@ -1017,7 +1017,7 @@ impl<K, V, S> OrderMap<K, V, S> {
 
     /// Returns a mutable slice of key-value pairs in the given range of indices.
     ///
-    /// Valid indices are *0 <= index < self.len()*
+    /// 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>> {
@@ -1070,7 +1070,7 @@ impl<K, V, S> OrderMap<K, V, S> {
 
     /// Remove the key-value pair by index
     ///
-    /// Valid indices are *0 <= index < self.len()*
+    /// Valid indices are `0 <= index < self.len()`
     ///
     /// **NOTE:** This is equivalent to [`IndexMap::shift_remove_index`], and
     /// like [`Vec::remove`], the pair is removed by shifting all of the
@@ -1084,7 +1084,7 @@ impl<K, V, S> OrderMap<K, V, S> {
 
     /// Remove the key-value pair by index
     ///
-    /// Valid indices are *0 <= index < self.len()*
+    /// Valid indices are `0 <= index < self.len()`.
     ///
     /// Like [`Vec::swap_remove`], the pair is removed by swapping it with the
     /// last element of the map and popping it off. **This perturbs

src/map/entry.rs

@@ -29,6 +29,19 @@ impl<'a, K, V> Entry<'a, K, V> {
         }
     }
 
+    /// Sets the value of the entry (after inserting if vacant), and returns an `OccupiedEntry`.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V> {
+        match self {
+            Entry::Occupied(mut entry) => {
+                entry.insert(value);
+                entry
+            }
+            Entry::Vacant(entry) => entry.insert_entry(value),
+        }
+    }
+
     /// 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.
     ///
@@ -286,6 +299,15 @@ impl<'a, K, V> VacantEntry<'a, K, V> {
         self.inner.insert(value)
     }
 
+    /// Inserts the entry's key and the given value into the map, and returns an `OccupiedEntry`.
+    ///
+    /// Computes in **O(1)** time (amortized average).
+    pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V> {
+        OccupiedEntry {
+            inner: self.inner.insert_entry(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.

src/map/mutable.rs

@@ -30,7 +30,7 @@ pub trait MutableKeys: private::Sealed {
 
     /// Return mutable reference to key and value at an index.
     ///
-    /// Valid indices are *0 <= index < self.len()*
+    /// 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)>;

src/map/tests.rs

@@ -538,6 +538,26 @@ fn into_values() {
     assert!(values.contains(&'c'));
 }
 
+#[test]
+fn drain_range() {
+    // Test the various heuristics of `erase_indices`
+    for range in [
+        0..0,   // nothing erased
+        10..90, // reinsert the few kept (..10 and 90..)
+        80..90, // update the few to adjust (80..)
+        20..30, // sweep everything
+    ] {
+        let mut vec = Vec::from_iter(0..100);
+        let mut map: IndexMap<i32, ()> = (0..100).map(|i| (i, ())).collect();
+        drop(vec.drain(range.clone()));
+        drop(map.drain(range));
+        assert!(vec.iter().eq(map.keys()));
+        for (i, x) in vec.iter().enumerate() {
+            assert_eq!(map.get_index_of(x), Some(i));
+        }
+    }
+}
+
 #[test]
 #[cfg(feature = "std")]
 fn from_array() {

src/set.rs

@@ -917,7 +917,7 @@ impl<T, S> OrderSet<T, S> {
 
     /// Get a value by index
     ///
-    /// Valid indices are *0 <= index < self.len()*
+    /// Valid indices are `0 <= index < self.len()`.
     ///
     /// Computes in **O(1)** time.
     pub fn get_index(&self, index: usize) -> Option<&T> {
@@ -926,7 +926,7 @@ impl<T, S> OrderSet<T, S> {
 
     /// Returns a slice of values in the given range of indices.
     ///
-    /// Valid indices are *0 <= index < self.len()*
+    /// 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>> {
@@ -949,7 +949,7 @@ impl<T, S> OrderSet<T, S> {
 
     /// Remove the value by index
     ///
-    /// Valid indices are *0 <= index < self.len()*
+    /// Valid indices are `0 <= index < self.len()`
     ///
     /// **NOTE:** This is equivalent to [`IndexSet::shift_remove_index`], and
     /// like [`Vec::remove`], the value is removed by shifting all of the
@@ -963,7 +963,7 @@ impl<T, S> OrderSet<T, S> {
 
     /// Remove the value by index
     ///
-    /// Valid indices are *0 <= index < self.len()*
+    /// Valid indices are `0 <= index < self.len()`.
     ///
     /// Like [`Vec::swap_remove`], the value is removed by swapping it with the
     /// last element of the set and popping it off. **This perturbs

src/set/mutable.rs

@@ -28,7 +28,7 @@ pub trait MutableValues: private::Sealed {
 
     /// Return mutable reference to the value at an index.
     ///
-    /// Valid indices are *0 <= index < self.len()*
+    /// Valid indices are `0 <= index < self.len()`.
     ///
     /// Computes in **O(1)** time.
     fn get_index_mut2(&mut self, index: usize) -> Option<&mut Self::Value>;