fix clippy warnings

src/argument/group.rs

@@ -101,7 +101,7 @@ impl<G: Clone + Ord> GroupCount<G> {
  GroupCount::One(ref g2, c2),
  ) => {
  if g2.cmp(&max_group.0) == Ordering::Equal {
- max_group.1 = max_group.1 + c2;
+ max_group.1 += c2;
  } else {
  max_group = (g2.clone(), *c2);
  group_count += 1;
@@ -350,10 +350,10 @@ where
  }
  }
 
- return match slot {
+ match slot {
  Ok(_) => Ok(Some((group_for_key, count))),
  Err(_) => Err(Some((group_for_key, count))),
- };
+ }
  }
 }
 
@@ -425,7 +425,7 @@ mod visit {
  }
  }
 
- return Some(self.element_count);
+ Some(self.element_count)
  }
  }
 }

src/argument/mod.rs

@@ -69,11 +69,11 @@ impl<K: Key> Argument<K> for () {
 
  #[inline(always)]
  fn from_leaf(_: &[K]) -> Self {
- ()
+
  }
 
  #[inline(always)]
  fn from_inner(_: &[K], _: &[Self]) -> Self {
- ()
+
  }
 }

src/lib.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::type_complexity)]
+
 mod set;
 pub use set::*;
 

src/set.rs

@@ -97,9 +97,9 @@ impl<K: Key> BPlusTreeSet<K> {
  /// assert!(!set.remove(&2));
  /// ```
  #[inline]
- pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> bool
+ pub fn remove<Q>(&mut self, k: &Q) -> bool
  where
- Q: Ord,
+ Q: ?Sized + Ord,
  K: Borrow<Q>,
  {
  self.tree.remove(k).is_some()
@@ -118,9 +118,9 @@ impl<K: Key> BPlusTreeSet<K> {
  /// assert!(!set.contains(&1));
  /// ```
  #[inline]
- pub fn contains<Q: ?Sized>(&self, k: &Q) -> bool
+ pub fn contains<Q>(&self, k: &Q) -> bool
  where
- Q: Ord,
+ Q: ?Sized + Ord,
  K: Borrow<Q>,
  {
  self.tree.get(k).is_some()
@@ -206,28 +206,6 @@ impl<K: Key> BPlusTreeSet<K> {
  }
  }
 
- /// Returns a iterator over the keys in the set
- ///
- /// # Examples
- /// ```rust
- /// use sweep_bptree::BPlusTreeSet;
- ///
- /// let mut set = BPlusTreeSet::<String>::new();
- ///
- /// set.insert(1.to_string());
- /// set.insert(2.to_string());
- ///
- /// let keys = set.into_iter().collect::<Vec<_>>();
- /// assert_eq!(keys.len(), 2);
- ///
- /// ```
- #[inline]
- pub fn into_iter(self) -> iter::IntoIter<K> {
- iter::IntoIter {
- inner: self.tree.into_iter(),
- }
- }
-
  /// Visits the elements representing the union,
  /// i.e., all the elements in `self` or `other`, without duplicates,
  /// in ascending order.
@@ -274,7 +252,34 @@ impl<K: Key> FromIterator<K> for BPlusTreeSet<K> {
  }
 }
 
-mod iter {
+impl<K: Key> IntoIterator for BPlusTreeSet<K> {
+ type Item = K;
+ type IntoIter = iter::IntoIter<K>;
+
+ /// Returns an iterator over the keys in the set
+ ///
+ /// # Examples
+ /// ```rust
+ /// use sweep_bptree::BPlusTreeSet;
+ ///
+ /// let mut set = BPlusTreeSet::<String>::new();
+ ///
+ /// set.insert(1.to_string());
+ /// set.insert(2.to_string());
+ ///
+ /// let keys = set.into_iter().collect::<Vec<_>>();
+ /// assert_eq!(keys.len(), 2);
+ ///
+ /// ```
+ #[inline]
+ fn into_iter(self) -> Self::IntoIter {
+ iter::IntoIter {
+ inner: self.tree.into_iter(),
+ }
+ }
+}
+
+pub mod iter {
  use std::{cmp::max, iter::FusedIterator};
 
  use crate::merge_iter::MergeIterInner;

src/tree/bulk_load.rs

@@ -24,7 +24,7 @@ impl<S: NodeStore> crate::BPlusTree<S> {
  let mut leaf = LeafNode::<S::K, S::V>::new();
  leaf.set_data(&mut data_iter);
 
- if leaf.len() == 0 {
+ if leaf.is_empty() {
  // there is no data left
  break;
  }

src/tree/cursor.rs

@@ -49,7 +49,7 @@ impl<'k, K: Key + 'k> Cursor<K> {
  leaf_id_hint: leaf_id,
  offset_hint: 0,
  },
- &kv.1,
+ kv.1,
  ))
  }
 
@@ -69,13 +69,13 @@ impl<'k, K: Key + 'k> Cursor<K> {
  leaf_id_hint: leaf_id,
  offset_hint: leaf.len() - 1,
  },
- &kv.1,
+ kv.1,
  ))
  }
 
  /// Get the `Cursor` points to the prev key-value pair. If the key for `self` is deleted, then
  /// this returns the cursor for the key value pair just under the deleted key.
- pub fn prev<'a, 'b, S: NodeStore<K = K>>(&'a self, tree: &'b BPlusTree<S>) -> Option<Self> {
+ pub fn prev<S: NodeStore<K = K>>(&self, tree: &BPlusTree<S>) -> Option<Self> {
  self.prev_with_value(tree).map(|x| x.0)
  }
 
@@ -125,13 +125,13 @@ impl<'k, K: Key + 'k> Cursor<K> {
  leaf_id_hint: leaf_id,
  offset_hint: offset,
  },
- &kv.1,
+ kv.1,
  ))
  }
 
  /// Get the `Cursor` points to the next key-value pair. If the key for `self` is deleted, then
  /// this returns the cursor for the key value pair just larger than the deleted key.
- pub fn next<'a, 'b, S: NodeStore<K = K>>(&'a self, tree: &'b BPlusTree<S>) -> Option<Self> {
+ pub fn next<S: NodeStore<K = K>>(&self, tree: &BPlusTree<S>) -> Option<Self> {
  self.next_with_value(tree).map(|x| x.0)
  }
 
@@ -164,7 +164,7 @@ impl<'k, K: Key + 'k> Cursor<K> {
  leaf_id_hint: leaf_id,
  offset_hint: next_offset,
  },
- &kv.1,
+ kv.1,
  ))
  } else {
  let leaf_id = leaf.next()?;
@@ -177,13 +177,13 @@ impl<'k, K: Key + 'k> Cursor<K> {
  leaf_id_hint: leaf_id,
  offset_hint: 0,
  },
- &kv.1,
+ kv.1,
  ))
  }
  }
 
  /// whether current cursor is still valid
- pub fn exists<'a, 'b, S: NodeStore<K = K>>(&'a self, tree: &'b BPlusTree<S>) -> bool {
+ pub fn exists<S: NodeStore<K = K>>(&self, tree: &BPlusTree<S>) -> bool {
  self.value(tree).is_some()
  }
 
@@ -195,7 +195,7 @@ impl<'k, K: Key + 'k> Cursor<K> {
  let (_, leaf) = self.locate_leaf(tree)?;
 
  match leaf.try_data_at(self.offset_hint) {
- Some(kv) if kv.0.eq(&self.k) => Some(&kv.1),
+ Some(kv) if kv.0.eq(&self.k) => Some(kv.1),
  _ => {
  // todo: consider update self?
  let (_, value) = leaf.locate_slot_with_value(&self.k);
@@ -205,8 +205,8 @@ impl<'k, K: Key + 'k> Cursor<K> {
  }
 
  #[inline]
- fn locate_leaf<'a, 'b, S: NodeStore<K = K>>(
- &'a self,
+ fn locate_leaf<'b, S: NodeStore<K = K>>(
+ &self,
  tree: &'b BPlusTree<S>,
  ) -> Option<(LeafNodeId, &'b LeafNode<S::K, S::V>)> {
  let leaf_id = self.leaf_id_hint;

src/tree/entry_ref.rs

@@ -79,7 +79,7 @@ impl VisitStack {
  offset,
  child_id,
  } = self.stack[self.len as usize];
- Some((id, offset as usize, child_id))
+ Some((id, offset, child_id))
  }
 }
 
@@ -93,7 +93,7 @@ pub struct EntryRefDetached {
 
 impl EntryRefDetached {
  /// This is a hack to get around the borrow checker
- pub fn to_ref<TR>(self, tree: TR) -> EntryRef<TR> {
+ pub fn into_ref<TR>(self, tree: TR) -> EntryRef<TR> {
  EntryRef::<TR> {
  inner_stack: self.inner_stack,
  leaf_id: self.leaf_id,
@@ -121,7 +121,7 @@ impl<TR> EntryRef<TR> {
  }
  }
 
- pub fn to_detached(self) -> EntryRefDetached {
+ pub fn into_detached(self) -> EntryRefDetached {
  EntryRefDetached {
  inner_stack: self.inner_stack,
  leaf_id: self.leaf_id,

src/tree/inner_node.rs

@@ -61,9 +61,9 @@ impl<K: Key, A: Argument<K>> Clone for InnerNode<K, A> {
  }
 
  Self {
- size: self.size.clone(),
+ size: self.size,
  slot_key: new_key,
- child_id: self.child_id.clone(),
+ child_id: self.child_id,
  arguments: new_arguments,
  }
  }
@@ -75,6 +75,11 @@ impl<K: Key, A: Argument<K>> InnerNode<K, A> {
  self.size as usize
  }
 
+ /// whether this node is empty
+ pub fn is_empty(&self) -> bool {
+ self.len() == 0
+ }
+
  /// Max key capacity
  pub const fn max_capacity() -> u16 {
  N as u16
@@ -195,10 +200,10 @@ impl<K: Key, A: Argument<K>> InnerNode<K, A> {
 
  /// returns the child index for k
  #[inline]
- pub fn locate_child<Q: ?Sized>(&self, k: &Q) -> (usize, NodeId)
+ pub fn locate_child<Q>(&self, k: &Q) -> (usize, NodeId)
  where
  K: std::borrow::Borrow<Q>,
- Q: Ord,
+ Q: ?Sized + Ord,
  {
  match self.keys().binary_search_by_key(&k, |f| f.borrow()) {
  Err(idx) => {
@@ -266,6 +271,7 @@ impl<K: Key, A: Argument<K>> InnerNode<K, A> {
 
  self.size = split_origin_size as u16;
 
+ #[allow(clippy::comparison_chain)]
  if child_idx < split_origin_size {
  // take node_size 4 as example
  // new key 2, new node n

src/tree/iterator.rs

@@ -165,7 +165,7 @@ impl<S: NodeStore> Iterator for IntoIter<S> {
  // safety: right after we called this, the pos moves to next.
  let kv = unsafe { leaf.take_data(offset) };
  self.pos = (leaf_id, offset + 1);
- return Some(kv);
+ Some(kv)
  } else {
  // move to next leaf
  match leaf.next() {
@@ -200,7 +200,7 @@ impl<S: NodeStore> DoubleEndedIterator for IntoIter<S> {
  // safety: right after we called this, the pos moves to next.
  let kv = unsafe { leaf.take_data(offset - 1) };
  self.end = (leaf_id, offset - 1);
- return Some(kv);
+ Some(kv)
  } else {
  // move to prev leaf
  match leaf.prev() {