Format the codebase

src/disk/cache.rs

@@ -1,9 +1,9 @@
-use std::{cmp, ptr};
 use std::collections::{HashMap, VecDeque};
+use std::{cmp, ptr};
 use syscall::error::Result;
 
-use BLOCK_SIZE;
 use disk::Disk;
+use BLOCK_SIZE;
 
 fn copy_memory(src: &[u8], dest: &mut [u8]) -> usize {
     let len = cmp::min(src.len(), dest.len());
@@ -45,16 +45,16 @@ impl<T: Disk> Disk for DiskCache<T> {
 
         let mut read = 0;
         let mut failed = false;
-        for i in 0..(buffer.len() + BLOCK_SIZE as usize - 1)/(BLOCK_SIZE as usize) {
+        for i in 0..(buffer.len() + BLOCK_SIZE as usize - 1) / (BLOCK_SIZE as usize) {
             let block_i = block + i as u64;
 
             let buffer_i = i * BLOCK_SIZE as usize;
             let buffer_j = cmp::min(buffer_i + BLOCK_SIZE as usize, buffer.len());
-            let buffer_slice = &mut buffer[buffer_i .. buffer_j];
+            let buffer_slice = &mut buffer[buffer_i..buffer_j];
 
             if let Some(cache_buf) = self.cache.get_mut(&block_i) {
                 read += copy_memory(cache_buf, buffer_slice);
-            }else{
+            } else {
                 failed = true;
                 break;
             }
@@ -64,12 +64,12 @@ impl<T: Disk> Disk for DiskCache<T> {
             self.inner.read_at(block, buffer)?;
 
             read = 0;
-            for i in 0..(buffer.len() + BLOCK_SIZE as usize - 1)/(BLOCK_SIZE as usize) {
+            for i in 0..(buffer.len() + BLOCK_SIZE as usize - 1) / (BLOCK_SIZE as usize) {
                 let block_i = block + i as u64;
 
                 let buffer_i = i * BLOCK_SIZE as usize;
                 let buffer_j = cmp::min(buffer_i + BLOCK_SIZE as usize, buffer.len());
-                let buffer_slice = &buffer[buffer_i .. buffer_j];
+                let buffer_slice = &buffer[buffer_i..buffer_j];
 
                 let mut cache_buf = [0; BLOCK_SIZE as usize];
                 read += copy_memory(buffer_slice, &mut cache_buf);
@@ -87,12 +87,12 @@ impl<T: Disk> Disk for DiskCache<T> {
         self.inner.write_at(block, buffer)?;
 
         let mut written = 0;
-        for i in 0..(buffer.len() + BLOCK_SIZE as usize - 1)/(BLOCK_SIZE as usize) {
+        for i in 0..(buffer.len() + BLOCK_SIZE as usize - 1) / (BLOCK_SIZE as usize) {
             let block_i = block + i as u64;
 
             let buffer_i = i * BLOCK_SIZE as usize;
             let buffer_j = cmp::min(buffer_i + BLOCK_SIZE as usize, buffer.len());
-            let buffer_slice = &buffer[buffer_i .. buffer_j];
+            let buffer_slice = &buffer[buffer_i..buffer_j];
 
             let mut cache_buf = [0; BLOCK_SIZE as usize];
             written += copy_memory(buffer_slice, &mut cache_buf);

src/disk/file.rs

@@ -1,39 +1,41 @@
 use std::fs::{File, OpenOptions};
-use std::io::{Read, Write, Seek, SeekFrom};
+use std::io::{Read, Seek, SeekFrom, Write};
 use std::path::Path;
 use syscall::error::{Error, Result, EIO};
 
-use BLOCK_SIZE;
 use disk::Disk;
+use BLOCK_SIZE;
 
 macro_rules! try_disk {
-    ($expr:expr) => (match $expr {
-        Ok(val) => val,
-        Err(err) => {
-            eprintln!("Disk I/O Error: {}", err);
-            return Err(Error::new(EIO));
+    ($expr:expr) => {
+        match $expr {
+            Ok(val) => val,
+            Err(err) => {
+                eprintln!("Disk I/O Error: {}", err);
+                return Err(Error::new(EIO));
+            }
         }
-    })
+    };
 }
 
 pub struct DiskFile {
-    pub file: File
+    pub file: File,
 }
 
 impl DiskFile {
     pub fn open<P: AsRef<Path>>(path: P) -> Result<DiskFile> {
         let file = try_disk!(OpenOptions::new().read(true).write(true).open(path));
-        Ok(DiskFile {
-            file: file
-        })
+        Ok(DiskFile { file: file })
     }
 
     pub fn create<P: AsRef<Path>>(path: P, size: u64) -> Result<DiskFile> {
-        let file = try_disk!(OpenOptions::new().read(true).write(true).create(true).open(path));
+        let file = try_disk!(OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(path));
         try_disk!(file.set_len(size));
-        Ok(DiskFile {
-            file: file
-        })
+        Ok(DiskFile { file: file })
     }
 }
 

src/disk/sparse.rs

@@ -1,20 +1,22 @@
 use std::fs::{File, OpenOptions};
-use std::io::{Read, Write, Seek, SeekFrom};
+use std::io::{Read, Seek, SeekFrom, Write};
 use std::path::Path;
 use std::u64;
 use syscall::error::{Error, Result, EIO};
 
-use BLOCK_SIZE;
 use disk::Disk;
+use BLOCK_SIZE;
 
 macro_rules! try_disk {
-    ($expr:expr) => (match $expr {
-        Ok(val) => val,
-        Err(err) => {
-            eprintln!("Disk I/O Error: {}", err);
-            return Err(Error::new(EIO));
+    ($expr:expr) => {
+        match $expr {
+            Ok(val) => val,
+            Err(err) => {
+                eprintln!("Disk I/O Error: {}", err);
+                return Err(Error::new(EIO));
+            }
         }
-    })
+    };
 }
 
 pub struct DiskSparse {
@@ -23,10 +25,12 @@ pub struct DiskSparse {
 
 impl DiskSparse {
     pub fn create<P: AsRef<Path>>(path: P) -> Result<DiskSparse> {
-        let file = try_disk!(OpenOptions::new().read(true).write(true).create(true).open(path));
-        Ok(DiskSparse {
-            file
-        })
+        let file = try_disk!(OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(path));
+        Ok(DiskSparse { file })
     }
 }