Updated to compiler bug

Author: ambaxter

Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 license-file = "LICENSE"
 categories = ["command-line-utilities", "database-implementations"]
 keywords = ["cli", "bbolt", "database", "db"]
-rust-version = "1.75"
+rust-version = "1.76"
 description = "A Rust port of the Bolt database"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -19,8 +19,8 @@ bumpalo = { version = "3.16", features = ["collections", "allocator-api2"]}
 hashbrown = "0.14.5"
 memmap2 = "0.9.4"
 page_size = "0.6.0"
-itertools = "0.12.1"
-bytemuck = { version = "1.15", features = ["derive"] }
+itertools = "0.13.0"
+bytemuck = { version = "1.16", features = ["derive"] }
 size = "0.4.1"
 getset = "0.1.2"
 once_cell = "1.19.0"

src/common/pool.rs

@@ -148,7 +148,7 @@ impl<T> Drop for SyncReusable<T> {
 
 #[cfg(test)]
 mod tests {
-  use crate::common::pool::{SyncPool};
+  use crate::common::pool::SyncPool;
   use std::rc::Rc;
   use std::sync::Arc;
 
@@ -163,5 +163,4 @@ mod tests {
 
     assert_eq!(1, pool.len());
   }
-
 }

src/common/utility.rs

@@ -1,7 +1,65 @@
+use std::fmt::{Debug, Formatter};
+
 // https://stackoverflow.com/questions/51272571/how-do-i-check-if-a-slice-is-sorted
 pub fn is_sorted<T>(data: &[T]) -> bool
 where
   T: Ord,
 {
   data.windows(2).all(|w| w[0] <= w[1])
 }
+
+pub enum Breadcrumb<'a, T> {
+  Root(T),
+  Extend(&'a Breadcrumb<'a, T>, T),
+}
+
+impl<'a, T> Breadcrumb<'a, T> {
+  pub fn new(value: T) -> Breadcrumb<'a, T> {
+    Breadcrumb::Root(value)
+  }
+
+  pub fn push(&self, value: T) -> Breadcrumb<T> {
+    Breadcrumb::Extend(self, value)
+  }
+
+  pub fn len(&self) -> usize {
+    match self {
+      Breadcrumb::Root(_) => 1,
+      Breadcrumb::Extend(parent, _) => parent.len() + 1,
+    }
+  }
+}
+
+impl<'a, T> Debug for Breadcrumb<'a, T>
+where
+  T: Debug,
+{
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Breadcrumb::Root(value) => f.write_fmt(format_args!("Breadcrumb: {:?}", value)),
+      Breadcrumb::Extend(parent, value) => {
+        parent.fmt(f)?;
+        f.write_fmt(format_args!(", {:?}", value))
+      }
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::common::utility::Breadcrumb;
+
+  fn cascade<'a>(dist: usize, bc: &'a Breadcrumb<'a, usize>) {
+    let push = bc.push(6 - dist);
+    assert_eq!(7 - dist, push.len());
+    if dist > 0 {
+      cascade(dist - 1, &push);
+    }
+  }
+
+  #[test]
+  fn test_breadcrumb() {
+    let a = Breadcrumb::new(0);
+    cascade(5, &a);
+  }
+}

src/lib.rs

@@ -33,6 +33,8 @@ mod node;
 mod test_support;
 mod tx;
 
+mod util;
+
 pub use bucket::{BucketApi, BucketImpl, BucketRwApi, BucketRwImpl, BucketStats};
 pub use common::errors::{Error, Result};
 pub use common::ids::{PgId, TxId};

src/util.rs

@@ -0,0 +1,45 @@
+use crate::common::utility::Breadcrumb;
+use crate::{Bolt, BucketApi, BucketImpl, DbApi, TxApi};
+use size::Size;
+
+pub fn copy() {}
+
+pub fn compact(src: &Bolt, dst: &mut Bolt, max_size: u64) -> crate::Result<()> {
+  assert_ne!(src.path(), dst.path());
+  let mut size = 0u64;
+  let mut dst_tx = dst.begin_rw_tx()?;
+  Ok(())
+}
+
+fn walk<F>(src: &Bolt, f: &mut F) -> crate::Result<()>
+where
+  F: FnMut(&Breadcrumb<&[u8]>, &[u8], Option<&[u8]>, u64) -> crate::Result<()>,
+{
+  src.view(|tx| {
+    let tx_root = Breadcrumb::Root(b"tx".as_slice());
+    tx.for_each(|name, b| walk_bucket(&b, &tx_root, name, None, b.sequence(), f))
+  })
+}
+
+fn walk_bucket<F>(
+  b: &BucketImpl, key_path: &Breadcrumb<&[u8]>, key: &[u8], value: Option<&[u8]>, seq: u64,
+  f: &mut F,
+) -> crate::Result<()>
+where
+  F: FnMut(&Breadcrumb<&[u8]>, &[u8], Option<&[u8]>, u64) -> crate::Result<()>,
+{
+  f(key_path, key, value, seq)?;
+
+  if value.is_none() {
+    let key_path = key_path.push(key);
+    b.for_each(|k, v| {
+      if v.is_none() {
+        let bkt = b.bucket(k).unwrap();
+        walk_bucket(&bkt, &key_path, k, None, bkt.sequence(), f)
+      } else {
+        walk_bucket(b, &key_path, k, v, b.sequence(), f)
+      }
+    })?;
+  }
+  Ok(())
+}