Fix warnings and remove dead code

src/ex_node.rs

@@ -1,69 +0,0 @@
-use std::{fmt, mem, ops, slice};
-
-use Extent;
-use BLOCK_SIZE;
-
-/// An extra node
-#[repr(packed)]
-pub struct ExNode {
-    pub prev: u64,
-    pub next: u64,
-    pub extents: [Extent; (BLOCK_SIZE as usize - 16) / 16],
-}
-
-impl ExNode {
-    pub fn default() -> ExNode {
-        ExNode {
-            prev: 0,
-            next: 0,
-            extents: [Extent::default(); (BLOCK_SIZE as usize - 16) / 16],
-        }
-    }
-
-    pub fn size(&self) -> u64 {
-        self.extents
-            .iter()
-            .fold(0, |size, extent| size + extent.length)
-    }
-}
-
-impl fmt::Debug for ExNode {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let extents: Vec<&Extent> = self
-            .extents
-            .iter()
-            .filter(|extent| -> bool { extent.length > 0 })
-            .collect();
-        unsafe {
-            f.debug_struct("ExNode")
-                .field("prev", &self.prev)
-                .field("next", &self.next)
-                .field("extents", &extents)
-                .finish()
-        }
-    }
-}
-
-impl ops::Deref for ExNode {
-    type Target = [u8];
-    fn deref(&self) -> &[u8] {
-        unsafe {
-            slice::from_raw_parts(self as *const ExNode as *const u8, mem::size_of::<ExNode>())
-                as &[u8]
-        }
-    }
-}
-
-impl ops::DerefMut for ExNode {
-    fn deref_mut(&mut self) -> &mut [u8] {
-        unsafe {
-            slice::from_raw_parts_mut(self as *mut ExNode as *mut u8, mem::size_of::<ExNode>())
-                as &mut [u8]
-        }
-    }
-}
-
-#[test]
-fn ex_node_size_test() {
-    assert_eq!(mem::size_of::<ExNode>(), BLOCK_SIZE as usize);
-}

src/filesystem.rs

@@ -3,7 +3,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use syscall::error::{Error, Result, EEXIST, EINVAL, EISDIR, ENOENT, ENOSPC, ENOTDIR, ENOTEMPTY};
 
-use {Disk, ExNode, Extent, Header, Node, BLOCK_SIZE};
+use {Disk, Extent, Header, Node, BLOCK_SIZE};
 
 /// A file system
 pub struct FileSystem<D: Disk> {
@@ -131,12 +131,6 @@ impl<D: Disk> FileSystem<D> {
         Ok((block, node))
     }
 
-    pub fn ex_node(&mut self, block: u64) -> Result<(u64, ExNode)> {
-        let mut node = ExNode::default();
-        self.read_at(block, &mut node)?;
-        Ok((block, node))
-    }
-
     pub fn child_nodes(
         &mut self,
         children: &mut Vec<(u64, Node)>,

src/header.rs

@@ -58,16 +58,20 @@ impl Header {
 
 impl fmt::Debug for Header {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        unsafe {
-            f.debug_struct("Header")
-                .field("signature", &self.signature)
-                .field("version", &self.version)
-                .field("uuid", &self.uuid)
-                .field("size", &self.size)
-                .field("root", &self.root)
-                .field("free", &self.free)
-                .finish()
-        }
+        let signature = self.signature;
+        let version = self.version;
+        let uuid = self.uuid;
+        let size = self.size;
+        let root = self.root;
+        let free = self.free;
+        f.debug_struct("Header")
+            .field("signature", &signature)
+            .field("version", &version)
+            .field("uuid", &uuid)
+            .field("size", &size)
+            .field("root", &root)
+            .field("free", &free)
+            .finish()
     }
 }
 

src/lib.rs

@@ -13,7 +13,6 @@ pub static IS_UMT: AtomicUsize = AtomicUsize::new(0);
 
 pub use self::archive::{archive, archive_at};
 pub use self::disk::{Disk, DiskCache, DiskFile, DiskSparse};
-pub use self::ex_node::ExNode;
 pub use self::extent::Extent;
 pub use self::filesystem::FileSystem;
 pub use self::header::Header;
@@ -22,7 +21,6 @@ pub use self::node::Node;
 
 mod archive;
 mod disk;
-mod ex_node;
 mod extent;
 mod filesystem;
 mod header;

src/node.rs

@@ -156,25 +156,32 @@ impl Node {
 
 impl fmt::Debug for Node {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mode = self.mode;
+        let uid = self.uid;
+        let gid = self.gid;
+        let ctime = self.ctime;
+        let ctime_nsec = self.ctime_nsec;
+        let mtime = self.mtime;
+        let mtime_nsec = self.mtime_nsec;
+        let name = self.name();
+        let next = self.next;
         let extents: Vec<&Extent> = self
             .extents
             .iter()
             .filter(|extent| -> bool { extent.length > 0 })
             .collect();
-        unsafe {
-            f.debug_struct("Node")
-                .field("mode", &self.mode)
-                .field("uid", &self.uid)
-                .field("gid", &self.gid)
-                .field("ctime", &self.ctime)
-                .field("ctime_nsec", &self.ctime_nsec)
-                .field("mtime", &self.mtime)
-                .field("mtime_nsec", &self.mtime_nsec)
-                .field("name", &self.name())
-                .field("next", &self.next)
-                .field("extents", &extents)
-                .finish()
-        }
+        f.debug_struct("Node")
+            .field("mode", &mode)
+            .field("uid", &uid)
+            .field("gid", &gid)
+            .field("ctime", &ctime)
+            .field("ctime_nsec", &ctime_nsec)
+            .field("mtime", &mtime)
+            .field("mtime_nsec", &mtime_nsec)
+            .field("name", &name)
+            .field("next", &next)
+            .field("extents", &extents)
+            .finish()
     }
 }