cargo-clippy fixes

diff --git a/src/dupsort_func.rs b/src/dupsort_func.rs
index 96d0bf1d43d0684d4135549fbe62be620bef9b54..529b45d7c6ec39a5ab6c49dd6f3aa8428ed2e6b7 100644 (file)
--- a/src/dupsort_func.rs
+++ b/src/dupsort_func.rs
@@ -81,7 +81,7 @@ where
                 .push(self.next.take().or_else(|| self.iter.next())?);
 
             //   println!("2: {:?} / {:?}", self.next, self.run);
-            while let Some(e) = self.iter.next() {
+            for e in &mut self.iter {
                 if e == self.run[0] {
                     self.run.push(e);
                     continue;
@@ -117,18 +117,16 @@ fn test_dupsort() {
 
     let ts = TestSource(
         (1u8..10)
-            .map(|i| (i..1).map(move |j| Entry::new(vec![i], vec![j])))
-            .flatten()
+            .flat_map(|i| (i..1).map(move |j| Entry::new(vec![i], vec![j])))
             .collect(),
     );
 
     let s = ts.dupsort_func(|a, b| a.value()[0].cmp(&b.value()[0]));
 
     assert_eq!(
-        Vec::from_iter((&s).iter()),
+        Vec::from_iter(s.iter()),
         (1u8..10)
-            .map(|i| (i..1).map(move |j| Entry::new(vec![i], vec![j])))
-            .flatten()
+            .flat_map(|i| (i..1).map(move |j| Entry::new(vec![i], vec![j])))
             .collect::<Vec<_>>()
     );
 }

diff --git a/src/fileset.rs b/src/fileset.rs
index 5a5bf9e683633f20b1bd3fd9f232b23c4cdac1d1..6e2ec74f6394c7d9dc22896721aeda379a339407 100644 (file)
--- a/src/fileset.rs
+++ b/src/fileset.rs
@@ -23,10 +23,10 @@ fn load_fs_file(f: &PathBuf) -> Result<Vec<PathBuf>> {
     dir.pop();
 
     read_to_string(f)
-        .and_then(|s| {
-            Ok(s.lines()
+        .map(|s| {
+            s.lines()
                 .map(|l| dir.clone().join(PathBuf::from(l)))
-                .collect::<Vec<_>>())
+                .collect::<Vec<_>>()
         })
         .map_err(|e| e.into())
 }
@@ -80,7 +80,6 @@ impl Fileset {
 
         clean.iter().for_each(|f| {
             readers.remove(f);
-            ()
         });
 
         self.last_reload = now;

diff --git a/src/filter.rs b/src/filter.rs
index 2aed71d593bd0a64be91de7eee21fca1489a6cdc..8f02f8c2075857ccd38286e17ecf53d7ab3536b6 100644 (file)
--- a/src/filter.rs
+++ b/src/filter.rs
@@ -36,7 +36,7 @@ where
             if (self.filter)(&item, &mut self.seek_key) {
                 return Some(item);
             }
-            if self.seek_key.len() > 0 {
+            if !self.seek_key.is_empty() {
                 self.iter.seek(self.seek_key.as_slice());
             }
         }
@@ -90,23 +90,18 @@ fn test_filter() {
     use crate::source::test_source::TestSource;
     use crate::Entry;
 
-    let ts = TestSource(
-        (0u8..10)
-            .into_iter()
-            .map(|n| Entry::new(vec![n], vec![]))
-            .collect(),
-    )
-    .filter(|e, sv| {
-        // pass only even values
-        if e.key()[0] % 2 != 0 {
-            return false;
-        } else if e.key()[0] == 4 {
-            // at key 4, seek to 8
-            sv.push(8);
-            return false;
-        }
-        true
-    });
+    let ts =
+        TestSource((0u8..10).map(|n| Entry::new(vec![n], vec![])).collect()).filter(|e, sv| {
+            // pass only even values
+            if e.key()[0] % 2 != 0 {
+                return false;
+            } else if e.key()[0] == 4 {
+                // at key 4, seek to 8
+                sv.push(8);
+                return false;
+            }
+            true
+        });
 
     assert_eq!(
         vec![0, 2, 8],

diff --git a/src/merge_func.rs b/src/merge_func.rs
index ef1038058617b801edb67a592791fe3a4622d081..c4dba8310e21be9264fdaff8578fd8b8a82a9003 100644 (file)
--- a/src/merge_func.rs
+++ b/src/merge_func.rs
@@ -60,7 +60,7 @@ where
     type Item = Entry;
     fn next(&mut self) -> Option<Self::Item> {
         let mut cur = self.prev.take().or_else(|| self.iter.next())?;
-        while let Some(e) = self.iter.next() {
+        for e in &mut self.iter {
             if e.key() == cur.key() {
                 (self.merge_func)(cur.value_mut(), &e);
             } else {
@@ -89,8 +89,7 @@ fn test_merge_func() {
 
     let ts = TestSource(
         (1u8..8)
-            .map(|n| vec![n; n as usize])
-            .flatten()
+            .flat_map(|n| vec![n; n as usize])
             .map(|n| Entry::new(vec![n], vec![1]))
             .collect(),
     );

diff --git a/src/merger.rs b/src/merger.rs
index a5e2bb3bb84b87157fd1954015aa34bbe71eb785..cd7d7b28c7ec2ae7b0796925258230e702ab27b4 100644 (file)
--- a/src/merger.rs
+++ b/src/merger.rs
@@ -31,13 +31,13 @@ impl<I: SeekableIter> Eq for MergeEntry<I> {}
 
 impl<I: SeekableIter> PartialOrd for MergeEntry<I> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(other.e.key().cmp(&self.e.key()))
+        Some(other.e.key().cmp(self.e.key()))
     }
 }
 
 impl<I: SeekableIter> Ord for MergeEntry<I> {
     fn cmp(&self, other: &Self) -> Ordering {
-        other.e.key().cmp(&self.e.key())
+        other.e.key().cmp(self.e.key())
     }
 }
 
@@ -153,7 +153,7 @@ mod test {
     use crate::Source;
 
     fn tnum(m: u8) -> Vec<u8> {
-        Vec::from_iter((1u8..255).into_iter().filter(|i| i % m == 0))
+        Vec::from_iter((1u8..255).filter(|i| i % m == 0))
     }
 
     fn test_source(m: u8) -> TestSource {
@@ -165,7 +165,7 @@ mod test {
     #[test]
     fn test_merge() {
         let range = 1..8;
-        let iters: Vec<_> = range.clone().into_iter().map(test_source).collect();
+        let iters: Vec<_> = range.clone().map(test_source).collect();
         let s = Merger::from(iters);
         let mut v = Vec::<u8>::new();
         for i in range {
@@ -182,7 +182,7 @@ mod test {
 
         let v: Vec<u8> = vec![1, 8, 2, 9, 4, 7, 3];
         let vs = v.as_slice();
-        let h = BinaryHeap::from_iter(vs.into_iter().map(|p| *p));
+        let h = BinaryHeap::from_iter(vs.iter().copied());
         assert_ne!(h.into_vec(), v);
     }
 }

diff --git a/src/reader/block.rs b/src/reader/block.rs
index 0563108652f975317114a3012b977a396873dc95..69e352a5b5cd37fabfbc91e84bb8740c0631c090 100644 (file)
--- a/src/reader/block.rs
+++ b/src/reader/block.rs
@@ -185,7 +185,7 @@ impl<D: AsRef<[u8]>> Iterator for BlockIter<D> {
     type Item = Entry;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.decode().map(|e| e.clone())
+        self.decode().cloned()
     }
 }
 
@@ -236,7 +236,7 @@ mod test {
         Vec::from_iter(
             (0..n)
                 .map(|i| i * skip)
-                .map(|i| Entry::new(&u32::to_be_bytes(i), &u32::to_be_bytes(i * 1024))),
+                .map(|i| Entry::new(u32::to_be_bytes(i), u32::to_be_bytes(i * 1024))),
         )
     }
 

diff --git a/src/sorter.rs b/src/sorter.rs
index c8bab83c140eec92a4ca7d736a1adddbfc79f8f2..367c26ee35c5186f9d4c3f90ded3c6252881186d 100644 (file)
--- a/src/sorter.rs
+++ b/src/sorter.rs
@@ -35,15 +35,15 @@ where
         self.batch_size += esize;
     }
 
-    pub fn source<'a>(&'a mut self) -> impl Source<'a, Item = Entry> {
-        if self.batch.get_mut().len() > 0 {
+    pub fn source(&mut self) -> impl Source<'_, Item = Entry> {
+        if !self.batch.get_mut().is_empty() {
             self.write_chunk();
         }
         Merger::from(self.readers.clone()).merge_func(&self.merge_func)
     }
 
     pub fn write<W: std::io::Write>(mut self, mut w: Writer<W>) {
-        if self.batch.get_mut().len() > 0 {
+        if !self.batch.get_mut().is_empty() {
             self.write_chunk();
         }
         let m = Merger::from(self.readers).merge_func(self.merge_func);

diff --git a/src/source.rs b/src/source.rs
index 6a8015d944d1d71f0c18191c2e78e29b347b7d69..61f0b70190c46224bb1ef57eda759b91448aa336 100644 (file)
--- a/src/source.rs
+++ b/src/source.rs
@@ -49,7 +49,7 @@ pub struct VecIter<'a> {
     vec: &'a Vec<Entry>,
 }
 
-impl<'a> Iterator for VecIter<'a> {
+impl Iterator for VecIter<'_> {
     type Item = Entry;
     fn next(&mut self) -> Option<Self::Item> {
         if self.index > self.vec.len() {
@@ -62,7 +62,7 @@ impl<'a> Iterator for VecIter<'a> {
     }
 }
 
-impl<'a> SeekableIter for VecIter<'a> {
+impl SeekableIter for VecIter<'_> {
     fn seek(&mut self, key: &[u8]) {
         let mut left = 0;
         let mut right = self.vec.len() - 1;
@@ -101,7 +101,7 @@ pub mod test_source {
         off: usize,
     }
 
-    impl<'a> Iterator for TestIter<'a> {
+    impl Iterator for TestIter<'_> {
         type Item = Entry;
 
         fn next(&mut self) -> Option<Self::Item> {
@@ -115,7 +115,7 @@ pub mod test_source {
         }
     }
 
-    impl<'a> SeekableIter for TestIter<'a> {
+    impl SeekableIter for TestIter<'_> {
         fn seek(&mut self, key: &[u8]) {
             self.off = 0;
             while self.off < self.source.0.len() && self.source.0[self.off].key() < key {

diff --git a/src/writer/mod.rs b/src/writer/mod.rs
index a19f6db5009077954ce40eeffc0a86e9ab84e4ff..e231e9a31a83f059890f2529d96a2ad7cac43f6d 100644 (file)
--- a/src/writer/mod.rs
+++ b/src/writer/mod.rs
@@ -169,7 +169,7 @@ impl<W: std::io::Write> Writer<W> {
         let b = self.index.as_slice();
         let start = self.written;
         self.written += self.out.write_varint(b.len())?;
-        self.written += self.out.write_fixedint(crc32c(&b))?;
+        self.written += self.out.write_fixedint(crc32c(b))?;
         self.out.write_all(b)?;
         self.written += b.len();
         self.meta.add_index_block(start, self.written - start);