Support SkipMap::insert_with

- Make `SkipMap::insert` and `SkipSet::insert` return the current value if the key and trailer already exist.
- Add the `SkipMap::insert_with` method to support inserting an occupied key first, then write the value in the closure semantic.

Author: al8n

.github/workflows/ci.yml

@@ -54,21 +54,6 @@ jobs:
     - name: Apply clippy lints
       run: cargo clippy --all-features
 
-  # This represents the minimum Rust version supported by
-  # Bytes. Updating this should be done in a dedicated PR.
-  #
-  # Tests are not run as tests may require newer versions of
-  # rust.
-  minrust:
-    name: minrust
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust
-        run: rustup update 1.72.0 && rustup default 1.72.0
-      - name: Check
-        run: . ci/test-stable.sh check
-
   # Stable
   stable:
     name: stable
@@ -221,8 +206,7 @@ jobs:
       - stable
       - no_std
       - sanitizer
-      - valgrind 
-      - minrust
+      - valgrind
     steps:
       - uses: actions/checkout@v3
       - name: Install latest nightly

CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 0.8.0
+
+- Make `SkipMap::insert` and `SkipSet::insert` return the current value if the key and trailer already exist.
+- Add the `SkipMap::insert_with` method to support inserting an occupied key first, then write the value in the closure semantic.
+
 ## 0.7.0
 
 - Implement `Iterator` for `MapIterator` and `SetIterator`.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "skl"
-version = "0.7.1"
+version = "0.8.0"
 edition = "2021"
 rust-version = "1.56.0"
 repository = "https://github.com/al8n/skl-rs"
@@ -34,7 +34,7 @@ required-features = ["memmap"]
 default = ["std"]
 alloc = []
 memmap = ["memmap2", "fs4", "std"]
-std = ["rand/default"]
+std = ["rand/default", "either/default"]
 
 [target.'cfg(loom)'.dependencies]
 loom = "0.7"
@@ -44,6 +44,7 @@ getrandom = { version = "0.2", features = ["js"] }
 
 [dependencies]
 crossbeam-utils = { version = "0.8", default-features = false }
+either = { version = "1", default-features = false }
 rand = { version = "0.8", default-features = false, features = ["getrandom"] }
 
 fs4 = { version = "0.8", optional = true }

README.md

@@ -28,14 +28,14 @@
 
     ```toml
     [dependencies]
-    skl = "0.7"
+    skl = "0.8"
     ```
 
 - Enable memory map backend
 
     ```toml
     [dependencies]
-    skl = { version = "0.7", features = ["memmap"] }
+    skl = { version = "0.8", features = ["memmap"] }
     ```
 
 ## Features

src/lib.rs

@@ -130,6 +130,108 @@ impl Comparator for Descend {
   }
 }
 
+/// Returns when the bytes are too large to be written to the occupied value.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct TooLarge {
+  remaining: usize,
+  write: usize,
+}
+
+impl core::fmt::Display for TooLarge {
+  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    write!(
+      f,
+      "OccupiedValue does not have enough space (remaining {}, want {})",
+      self.remaining, self.write
+    )
+  }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for TooLarge {}
+
+/// An occupied value in the skiplist.
+#[must_use = "occupied value must be fully filled with bytes."]
+#[derive(Debug)]
+pub struct OccupiedValue<'a> {
+  value: &'a mut [u8],
+  len: usize,
+  cap: usize,
+}
+
+impl<'a> OccupiedValue<'a> {
+  /// Write bytes to the occupied value.
+  pub fn write(&mut self, bytes: &[u8]) -> Result<(), TooLarge> {
+    let len = bytes.len();
+    let remaining = self.cap - self.len;
+    if len > remaining {
+      return Err(TooLarge {
+        remaining,
+        write: len,
+      });
+    }
+
+    self.value[self.len..self.len + len].copy_from_slice(bytes);
+    self.len += len;
+    Ok(())
+  }
+
+  /// Returns the capacity of the occupied value.
+  #[inline]
+  pub const fn capacity(&self) -> usize {
+    self.cap
+  }
+
+  /// Returns the length of the occupied value.
+  #[inline]
+  pub const fn len(&self) -> usize {
+    self.len
+  }
+
+  /// Returns `true` if the occupied value is empty.
+  #[inline]
+  pub const fn is_empty(&self) -> bool {
+    self.len == 0
+  }
+
+  /// Returns the remaining space of the occupied value.
+  #[inline]
+  pub const fn remaining(&self) -> usize {
+    self.cap - self.len
+  }
+
+  #[inline]
+  fn new(cap: usize, value: &'a mut [u8]) -> Self {
+    Self { value, len: 0, cap }
+  }
+}
+
+impl<'a> core::ops::Deref for OccupiedValue<'a> {
+  type Target = [u8];
+
+  fn deref(&self) -> &Self::Target {
+    &self.value[..self.len]
+  }
+}
+
+impl<'a> core::ops::DerefMut for OccupiedValue<'a> {
+  fn deref_mut(&mut self) -> &mut Self::Target {
+    &mut self.value[..self.len]
+  }
+}
+
+impl<'a> Drop for OccupiedValue<'a> {
+  fn drop(&mut self) {
+    assert_eq!(
+      self.len,
+      self.cap,
+      "OccupiedValue was not fully filled with bytes, capacity is {}, remaining is {}",
+      self.cap,
+      self.cap - self.len
+    );
+  }
+}
+
 /// A trait for extra information that can be stored with entry in the skiplist.
 pub trait Trailer: Copy {
   /// Returns the version of the trailer.