cargo fmt

Author: cfvescovo

src/iter.rs

@@ -1,12 +1,12 @@
-use std::{slice, vec};
 use std::ops::Range;
+use std::{slice, vec};
 
-use {Tree, NodeId, Node, NodeRef};
+use {Node, NodeId, NodeRef, Tree};
 
 /// Iterator that moves out of a tree in insert order.
 #[derive(Debug)]
 pub struct IntoIter<T>(vec::IntoIter<Node<T>>);
-impl<T> ExactSizeIterator for IntoIter<T> { }
+impl<T> ExactSizeIterator for IntoIter<T> {}
 impl<T> Iterator for IntoIter<T> {
     type Item = T;
     fn next(&mut self) -> Option<Self::Item> {
@@ -30,7 +30,7 @@ impl<'a, T: 'a> Clone for Values<'a, T> {
         Values(self.0.clone())
     }
 }
-impl<'a, T: 'a> ExactSizeIterator for Values<'a, T> { }
+impl<'a, T: 'a> ExactSizeIterator for Values<'a, T> {}
 impl<'a, T: 'a> Iterator for Values<'a, T> {
     type Item = &'a T;
     fn next(&mut self) -> Option<Self::Item> {
@@ -49,7 +49,7 @@ impl<'a, T: 'a> DoubleEndedIterator for Values<'a, T> {
 /// Mutable iterator over values in insert order.
 #[derive(Debug)]
 pub struct ValuesMut<'a, T: 'a>(slice::IterMut<'a, Node<T>>);
-impl<'a, T: 'a> ExactSizeIterator for ValuesMut<'a, T> { }
+impl<'a, T: 'a> ExactSizeIterator for ValuesMut<'a, T> {}
 impl<'a, T: 'a> Iterator for ValuesMut<'a, T> {
     type Item = &'a mut T;
     fn next(&mut self) -> Option<Self::Item> {
@@ -73,22 +73,29 @@ pub struct Nodes<'a, T: 'a> {
 }
 impl<'a, T: 'a> Clone for Nodes<'a, T> {
     fn clone(&self) -> Self {
-        Self { tree: self.tree, iter: self.iter.clone() }
+        Self {
+            tree: self.tree,
+            iter: self.iter.clone(),
+        }
     }
 }
-impl<'a, T: 'a> ExactSizeIterator for Nodes<'a, T> { }
+impl<'a, T: 'a> ExactSizeIterator for Nodes<'a, T> {}
 impl<'a, T: 'a> Iterator for Nodes<'a, T> {
     type Item = NodeRef<'a, T>;
     fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next().map(|i| unsafe { self.tree.get_unchecked(NodeId::from_index(i)) })
+        self.iter
+            .next()
+            .map(|i| unsafe { self.tree.get_unchecked(NodeId::from_index(i)) })
     }
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.iter.size_hint()
     }
 }
 impl<'a, T: 'a> DoubleEndedIterator for Nodes<'a, T> {
     fn next_back(&mut self) -> Option<Self::Item> {
-        self.iter.next_back().map(|i| unsafe { self.tree.get_unchecked(NodeId::from_index(i)) })
+        self.iter
+            .next_back()
+            .map(|i| unsafe { self.tree.get_unchecked(NodeId::from_index(i)) })
     }
 }
 
@@ -113,7 +120,10 @@ impl<T> Tree<T> {
 
     /// Returns an iterator over nodes in insert order.
     pub fn nodes(&self) -> Nodes<T> {
-        Nodes { tree: self, iter: 0..self.vec.len() }
+        Nodes {
+            tree: self,
+            iter: 0..self.vec.len(),
+        }
     }
 }
 
@@ -165,7 +175,10 @@ pub struct Children<'a, T: 'a> {
 }
 impl<'a, T: 'a> Clone for Children<'a, T> {
     fn clone(&self) -> Self {
-        Self { front: self.front.clone(), back: self.back.clone() }
+        Self {
+            front: self.front.clone(),
+            back: self.back.clone(),
+        }
     }
 }
 impl<'a, T: 'a> Iterator for Children<'a, T> {
@@ -204,17 +217,17 @@ pub enum Edge<'a, T: 'a> {
     /// Close.
     Close(NodeRef<'a, T>),
 }
-impl<'a, T: 'a> Copy for Edge<'a, T> { }
+impl<'a, T: 'a> Copy for Edge<'a, T> {}
 impl<'a, T: 'a> Clone for Edge<'a, T> {
-    fn clone(&self) -> Self { *self }
+    fn clone(&self) -> Self {
+        *self
+    }
 }
-impl<'a, T: 'a> Eq for Edge<'a, T> { }
+impl<'a, T: 'a> Eq for Edge<'a, T> {}
 impl<'a, T: 'a> PartialEq for Edge<'a, T> {
     fn eq(&self, other: &Self) -> bool {
         match (*self, *other) {
-            (Edge::Open(a), Edge::Open(b)) | (Edge::Close(a), Edge::Close(b)) => {
-                a == b
-            },
+            (Edge::Open(a), Edge::Open(b)) | (Edge::Close(a), Edge::Close(b)) => a == b,
             _ => false,
         }
     }
@@ -228,7 +241,10 @@ pub struct Traverse<'a, T: 'a> {
 }
 impl<'a, T: 'a> Clone for Traverse<'a, T> {
     fn clone(&self) -> Self {
-        Self { root: self.root, edge: self.edge }
+        Self {
+            root: self.root,
+            edge: self.edge,
+        }
     }
 }
 impl<'a, T: 'a> Iterator for Traverse<'a, T> {
@@ -237,23 +253,23 @@ impl<'a, T: 'a> Iterator for Traverse<'a, T> {
         match self.edge {
             None => {
                 self.edge = Some(Edge::Open(self.root));
-            },
+            }
             Some(Edge::Open(node)) => {
                 if let Some(first_child) = node.first_child() {
                     self.edge = Some(Edge::Open(first_child));
                 } else {
                     self.edge = Some(Edge::Close(node));
                 }
-            },
+            }
             Some(Edge::Close(node)) => {
                 if node == self.root {
-                     self.edge = None;
+                    self.edge = None;
                 } else if let Some(next_sibling) = node.next_sibling() {
                     self.edge = Some(Edge::Open(next_sibling));
                 } else {
                     self.edge = node.parent().map(Edge::Close);
                 }
-            },
+            }
         }
         self.edge
     }

src/lib.rs

@@ -32,7 +32,7 @@
 #![warn(
     missing_docs,
     missing_debug_implementations,
-    missing_copy_implementations,
+    missing_copy_implementations
 )]
 
 use std::fmt::{self, Debug, Formatter};
@@ -117,12 +117,14 @@ pub struct NodeMut<'a, T: 'a> {
 
 // Trait implementations regardless of T.
 
-impl<'a, T: 'a> Copy for NodeRef<'a, T> { }
+impl<'a, T: 'a> Copy for NodeRef<'a, T> {}
 impl<'a, T: 'a> Clone for NodeRef<'a, T> {
-    fn clone(&self) -> Self { *self }
+    fn clone(&self) -> Self {
+        *self
+    }
 }
 
-impl<'a, T: 'a> Eq for NodeRef<'a, T> { }
+impl<'a, T: 'a> Eq for NodeRef<'a, T> {}
 impl<'a, T: 'a> PartialEq for NodeRef<'a, T> {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
@@ -134,7 +136,9 @@ impl<'a, T: 'a> PartialEq for NodeRef<'a, T> {
 impl<T> Tree<T> {
     /// Creates a tree with a root node.
     pub fn new(root: T) -> Self {
-        Tree { vec: vec![Node::new(root)] }
+        Tree {
+            vec: vec![Node::new(root)],
+        }
     }
 
     /// Creates a tree with a root node and the specified capacity.
@@ -146,7 +150,11 @@ impl<T> Tree<T> {
 
     /// Returns a reference to the specified node.
     pub fn get(&self, id: NodeId) -> Option<NodeRef<T>> {
-        self.vec.get(id.to_index()).map(|node| NodeRef { id, node, tree: self })
+        self.vec.get(id.to_index()).map(|node| NodeRef {
+            id,
+            node,
+            tree: self,
+        })
     }
 
     /// Returns a mutator of the specified node.
@@ -165,7 +173,11 @@ impl<T> Tree<T> {
 
     /// Returns a reference to the specified node.
     pub unsafe fn get_unchecked(&self, id: NodeId) -> NodeRef<T> {
-        NodeRef { id, node: self.node(id), tree: self }
+        NodeRef {
+            id,
+            node: self.node(id),
+            tree: self,
+        }
     }
 
     /// Returns a mutator of the specified node.
@@ -209,27 +221,37 @@ impl<'a, T: 'a> NodeRef<'a, T> {
 
     /// Returns the parent of this node.
     pub fn parent(&self) -> Option<Self> {
-        self.node.parent.map(|id| unsafe { self.tree.get_unchecked(id) })
+        self.node
+            .parent
+            .map(|id| unsafe { self.tree.get_unchecked(id) })
     }
 
     /// Returns the previous sibling of this node.
     pub fn prev_sibling(&self) -> Option<Self> {
-        self.node.prev_sibling.map(|id| unsafe { self.tree.get_unchecked(id) })
+        self.node
+            .prev_sibling
+            .map(|id| unsafe { self.tree.get_unchecked(id) })
     }
 
     /// Returns the next sibling of this node.
     pub fn next_sibling(&self) -> Option<Self> {
-        self.node.next_sibling.map(|id| unsafe { self.tree.get_unchecked(id) })
+        self.node
+            .next_sibling
+            .map(|id| unsafe { self.tree.get_unchecked(id) })
     }
 
     /// Returns the first child of this node.
     pub fn first_child(&self) -> Option<Self> {
-        self.node.children.map(|(id, _)| unsafe { self.tree.get_unchecked(id) })
+        self.node
+            .children
+            .map(|(id, _)| unsafe { self.tree.get_unchecked(id) })
     }
 
     /// Returns the last child of this node.
     pub fn last_child(&self) -> Option<Self> {
-        self.node.children.map(|(_, id)| unsafe { self.tree.get_unchecked(id) })
+        self.node
+            .children
+            .map(|(_, id)| unsafe { self.tree.get_unchecked(id) })
     }
 
     /// Returns true if this node has siblings.
@@ -351,10 +373,14 @@ impl<'a, T: 'a> NodeMut<'a, T> {
         }
 
         if let Some(id) = prev_sibling_id {
-            unsafe { self.tree.node_mut(id).next_sibling = next_sibling_id; }
+            unsafe {
+                self.tree.node_mut(id).next_sibling = next_sibling_id;
+            }
         }
         if let Some(id) = next_sibling_id {
-            unsafe { self.tree.node_mut(id).prev_sibling = prev_sibling_id; }
+            unsafe {
+                self.tree.node_mut(id).prev_sibling = prev_sibling_id;
+            }
         }
 
         let parent = unsafe { self.tree.node_mut(parent_id) };
@@ -383,7 +409,9 @@ impl<'a, T: 'a> NodeMut<'a, T> {
         }
 
         if let Some(id) = last_child_id {
-            unsafe { self.tree.node_mut(id).next_sibling = Some(new_child_id); }
+            unsafe {
+                self.tree.node_mut(id).next_sibling = Some(new_child_id);
+            }
         }
 
         {
@@ -412,7 +440,9 @@ impl<'a, T: 'a> NodeMut<'a, T> {
         }
 
         if let Some(id) = first_child_id {
-            unsafe { self.tree.node_mut(id).prev_sibling = Some(new_child_id); }
+            unsafe {
+                self.tree.node_mut(id).prev_sibling = Some(new_child_id);
+            }
         }
 
         {
@@ -444,7 +474,9 @@ impl<'a, T: 'a> NodeMut<'a, T> {
         }
 
         if let Some(id) = prev_sibling_id {
-            unsafe { self.tree.node_mut(id).next_sibling = Some(new_sibling_id); }
+            unsafe {
+                self.tree.node_mut(id).next_sibling = Some(new_sibling_id);
+            }
         }
 
         self.node().prev_sibling = Some(new_sibling_id);
@@ -478,7 +510,9 @@ impl<'a, T: 'a> NodeMut<'a, T> {
         }
 
         if let Some(id) = next_sibling_id {
-            unsafe { self.tree.node_mut(id).prev_sibling = Some(new_sibling_id); }
+            unsafe {
+                self.tree.node_mut(id).prev_sibling = Some(new_sibling_id);
+            }
         }
 
         self.node().next_sibling = Some(new_sibling_id);
@@ -655,21 +689,21 @@ impl<T: Debug> Debug for Tree<T> {
                 match edge {
                     Edge::Open(node) if node.has_children() => {
                         write!(f, " {:?} => {{", node.value())?;
-                    },
+                    }
                     Edge::Open(node) if node.next_sibling().is_some() => {
                         write!(f, " {:?},", node.value())?;
-                    },
+                    }
                     Edge::Open(node) => {
                         write!(f, " {:?}", node.value())?;
-                    },
+                    }
                     Edge::Close(node) if node.has_children() => {
                         if node.next_sibling().is_some() {
                             write!(f, " }},")?;
                         } else {
                             write!(f, " }}")?;
                         }
-                    },
-                    _ => {},
+                    }
+                    _ => {}
                 }
             }
             write!(f, " }}")