changeset 531:c2ad4d2af4e3

Run cargo-fmt
author Lewin Bormann <lewin@lewin-bormann.info>
date Wed, 27 May 2020 12:18:51 +0200
parents 1036c175f4c6
children dd122e4ef0d8 1a2f56c87ab6
files src/blockhandle.rs src/cmp.rs src/db_impl.rs src/disk_env.rs src/error.rs src/filter.rs src/lib.rs src/merging_iter.rs src/version.rs src/version_edit.rs src/version_set.rs src/write_batch.rs
diffstat 12 files changed, 33 insertions(+), 40 deletions(-) [+]
line wrap: on
line diff
--- a/src/blockhandle.rs	Wed May 27 12:13:51 2020 +0200
+++ b/src/blockhandle.rs	Wed May 27 12:18:51 2020 +0200
@@ -27,10 +27,7 @@
     }
 
     pub fn new(offset: usize, size: usize) -> BlockHandle {
-        BlockHandle {
-            offset,
-            size,
-        }
+        BlockHandle { offset, size }
     }
 
     pub fn offset(&self) -> usize {
--- a/src/cmp.rs	Wed May 27 12:13:51 2020 +0200
+++ b/src/cmp.rs	Wed May 27 12:18:51 2020 +0200
@@ -131,7 +131,7 @@
                 .internal_key()
                 .to_vec();
         }
-       LookupKey::new(&sep, seqa).internal_key().to_vec()
+        LookupKey::new(&sep, seqa).internal_key().to_vec()
     }
 
     fn find_short_succ(&self, a: &[u8]) -> Vec<u8> {
--- a/src/db_impl.rs	Wed May 27 12:13:51 2020 +0200
+++ b/src/db_impl.rs	Wed May 27 12:18:51 2020 +0200
@@ -1031,7 +1031,7 @@
     match firstkey {
         None => {
             let _ = opt.env.delete(Path::new(&filename));
-        },
+        }
         Some(key) => {
             md.num = num;
             md.size = opt.env.size_of(Path::new(&filename))?;
@@ -1039,7 +1039,7 @@
             md.largest = kbuf;
         }
     }
-        Ok(md)
+    Ok(md)
 }
 
 fn log_file_name(db: &Path, num: FileNum) -> PathBuf {
--- a/src/disk_env.rs	Wed May 27 12:13:51 2020 +0200
+++ b/src/disk_env.rs	Wed May 27 12:18:51 2020 +0200
@@ -5,7 +5,7 @@
 
 use std::collections::HashMap;
 use std::fs::{self, File};
-use std::io::{self, Read, Write, ErrorKind};
+use std::io::{self, ErrorKind, Read, Write};
 use std::iter::FromIterator;
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
@@ -80,14 +80,12 @@
     fn children(&self, p: &Path) -> Result<Vec<PathBuf>> {
         let dir_reader = fs::read_dir(p).map_err(|e| map_err_with_name("children", p, e))?;
         let filenames = dir_reader
-            .map(|r| {
-                match r {
-                    Ok(_) => {
-                        let direntry = r.unwrap();
-                        Path::new(&direntry.file_name()).to_owned()
-                    },
-                    Err(_) => Path::new("").to_owned(),
+            .map(|r| match r {
+                Ok(_) => {
+                    let direntry = r.unwrap();
+                    Path::new(&direntry.file_name()).to_owned()
                 }
+                Err(_) => Path::new("").to_owned(),
             })
             .filter(|s| !s.as_os_str().is_empty());
         Ok(Vec::from_iter(filenames))
@@ -123,14 +121,18 @@
                 .map_err(|e| map_err_with_name("lock", p, e))?;
 
             match f.try_lock_exclusive() {
-                Err(err) if err.kind() == ErrorKind::WouldBlock => return Err(Status::new(
+                Err(err) if err.kind() == ErrorKind::WouldBlock => {
+                    return Err(Status::new(
                         StatusCode::LockError,
                         "lock on database is already held by different process",
-                    )),
-                Err(_) => return Err(Status::new(
-                    StatusCode::Errno(errno::errno()),
-                    &format!("unknown lock error on file {:?} (file {})", f, p.display()),
-                )),
+                    ))
+                }
+                Err(_) => {
+                    return Err(Status::new(
+                        StatusCode::Errno(errno::errno()),
+                        &format!("unknown lock error on file {:?} (file {})", f, p.display()),
+                    ))
+                }
                 _ => (),
             };
 
--- a/src/error.rs	Wed May 27 12:13:51 2020 +0200
+++ b/src/error.rs	Wed May 27 12:18:51 2020 +0200
@@ -65,10 +65,7 @@
         } else {
             err = format!("{:?}: {}", code, msg);
         }
-        Status {
-            code,
-            err,
-        }
+        Status { code, err }
     }
 }
 
--- a/src/filter.rs	Wed May 27 12:13:51 2020 +0200
+++ b/src/filter.rs	Wed May 27 12:18:51 2020 +0200
@@ -79,10 +79,7 @@
             k = 30;
         }
 
-        BloomPolicy {
-            bits_per_key,
-            k,
-        }
+        BloomPolicy { bits_per_key, k }
     }
 
     fn bloom_hash(&self, data: &[u8]) -> u32 {
--- a/src/lib.rs	Wed May 27 12:13:51 2020 +0200
+++ b/src/lib.rs	Wed May 27 12:18:51 2020 +0200
@@ -25,10 +25,10 @@
 
 extern crate crc;
 extern crate errno;
+extern crate fs2;
 extern crate integer_encoding;
 extern crate rand;
 extern crate snap;
-extern crate fs2;
 
 #[cfg(test)]
 #[macro_use]
--- a/src/merging_iter.rs	Wed May 27 12:13:51 2020 +0200
+++ b/src/merging_iter.rs	Wed May 27 12:18:51 2020 +0200
@@ -67,7 +67,9 @@
                                 // This doesn't work if two iterators are returning the exact same
                                 // keys. However, in reality, two entries will always have differing
                                 // sequence numbers.
-                                if self.iters[i].current(&mut keybuf, &mut valbuf) && self.cmp.cmp(&keybuf, &key) == Ordering::Equal  {
+                                if self.iters[i].current(&mut keybuf, &mut valbuf)
+                                    && self.cmp.cmp(&keybuf, &key) == Ordering::Equal
+                                {
                                     self.iters[i].advance();
                                 }
                             }
--- a/src/version.rs	Wed May 27 12:13:51 2020 +0200
+++ b/src/version.rs	Wed May 27 12:18:51 2020 +0200
@@ -254,7 +254,7 @@
 
     /// overlap_in_level returns true if the specified level's files overlap the range [smallest;
     /// largest].
-    pub fn overlap_in_level<'a> (
+    pub fn overlap_in_level<'a>(
         &self,
         level: usize,
         smallest: UserKey<'a>,
--- a/src/version_edit.rs	Wed May 27 12:13:51 2020 +0200
+++ b/src/version_edit.rs	Wed May 27 12:18:51 2020 +0200
@@ -236,10 +236,8 @@
                         if let Ok(lvl) = reader.read_varint() {
                             let key = read_length_prefixed(&mut reader)?;
 
-                            ve.compaction_ptrs.push(CompactionPointer {
-                                level: lvl,
-                                key,
-                            });
+                            ve.compaction_ptrs
+                                .push(CompactionPointer { level: lvl, key });
                         } else {
                             return err(StatusCode::IOError, "Couldn't read level");
                         }
--- a/src/version_set.rs	Wed May 27 12:13:51 2020 +0200
+++ b/src/version_set.rs	Wed May 27 12:18:51 2020 +0200
@@ -851,9 +851,7 @@
 }
 
 fn temp_file_name<P: AsRef<Path>>(dbname: P, file_num: FileNum) -> PathBuf {
-    dbname
-        .as_ref()
-        .join(format!("{:06}.dbtmp", file_num))
+    dbname.as_ref().join(format!("{:06}.dbtmp", file_num))
 }
 
 fn current_file_name<P: AsRef<Path>>(dbname: P) -> PathBuf {
--- a/src/write_batch.rs	Wed May 27 12:13:51 2020 +0200
+++ b/src/write_batch.rs	Wed May 27 12:18:51 2020 +0200
@@ -35,7 +35,9 @@
     /// Adds an entry to a WriteBatch, to be added to the database.
     #[allow(unused_assignments)]
     pub fn put(&mut self, k: &[u8], v: &[u8]) {
-        self.entries.write_all(&[ValueType::TypeValue as u8]).unwrap();
+        self.entries
+            .write_all(&[ValueType::TypeValue as u8])
+            .unwrap();
         self.entries.write_varint(k.len()).unwrap();
         self.entries.write_all(k).unwrap();
         self.entries.write_varint(v.len()).unwrap();