From 75a21310acb645e8fdb6aed50118e5a4a68802d1 Mon Sep 17 00:00:00 2001 From: Jonathan S Date: Thu, 17 Dec 2015 14:41:34 -0600 Subject: [PATCH] BTreeMap: fix make tidy --- src/libcollections/btree/map.rs | 51 ++++-- src/libcollections/btree/node.rs | 249 +++++++++++++++++++++++------ src/libcollections/btree/search.rs | 31 +++- 3 files changed, 265 insertions(+), 66 deletions(-) diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 513bed4e83435..4b4df47e2f57f 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -114,13 +114,20 @@ impl Clone for BTreeMap { Ok(parent) => parent, Err(_) => break 'main }; - internal_out_node = internal_out_node.ascend().ok().unwrap().into_node(); + internal_out_node = internal_out_node.ascend() + .ok() + .unwrap() + .into_node(); } } } let (k, v) = internal_kv.into_kv(); - internal_out_node.push(k.clone(), v.clone(), create_chain(internal_kv.into_node().height() - 1)); + internal_out_node.push( + k.clone(), + v.clone(), + create_chain(internal_kv.into_node().height() - 1) + ); in_node = first_leaf_edge(internal_kv.right_edge().descend()).into_node(); out_node = first_leaf_edge(internal_out_node.last_edge().descend()).into_node(); @@ -236,7 +243,13 @@ pub struct VacantEntry<'a, K: 'a, V: 'a> { /// An occupied Entry. #[stable(feature = "rust1", since = "1.0.0")] pub struct OccupiedEntry<'a, K: 'a, V: 'a> { - handle: Handle, K, V, marker::Mut, marker::LeafOrInternal>, marker::KV>, + handle: Handle, + K, V, + marker::Mut, + marker::LeafOrInternal + >, marker::KV>, + length: &'a mut usize } @@ -681,7 +694,7 @@ impl IntoIterator for BTreeMap { let root2 = unsafe { ptr::read(&self.root).into_ref() }; let len = self.length; mem::forget(self); - + IntoIter { front: first_leaf_edge(root1), back: last_leaf_edge(root2), @@ -724,7 +737,9 @@ impl Iterator for IntoIter { self.front = kv.right_edge(); return Some((k, v)); }, - Err(last_edge) => unsafe { unwrap_unchecked(last_edge.into_node().deallocate_and_ascend()) } + Err(last_edge) => unsafe { + unwrap_unchecked(last_edge.into_node().deallocate_and_ascend()) + } }; loop { @@ -764,7 +779,9 @@ impl DoubleEndedIterator for IntoIter { self.back = kv.left_edge(); return Some((k, v)); }, - Err(last_edge) => unsafe { unwrap_unchecked(last_edge.into_node().deallocate_and_ascend()) } + Err(last_edge) => unsafe { + unwrap_unchecked(last_edge.into_node().deallocate_and_ascend()) + } }; loop { @@ -1109,7 +1126,12 @@ impl<'a, K: Ord, Q: ?Sized, V> Index<&'a Q> for BTreeMap } } -fn first_leaf_edge(mut node: NodeRef) -> Handle, marker::Edge> { +fn first_leaf_edge( + mut node: NodeRef + ) -> Handle, marker::Edge> { loop { match node.force() { Leaf(leaf) => return leaf.first_edge(), @@ -1120,7 +1142,12 @@ fn first_leaf_edge(mut node: NodeRef(mut node: NodeRef) -> Handle, marker::Edge> { +fn last_leaf_edge( + mut node: NodeRef + ) -> Handle, marker::Edge> { loop { match node.force() { Leaf(leaf) => return leaf.last_edge(), @@ -1434,7 +1461,11 @@ enum UnderflowResult<'a, K, V> { Stole(NodeRef, K, V, marker::Mut, marker::Internal>) } -fn handle_underfull_node<'a, K, V>(node: NodeRef, K, V, marker::Mut, marker::LeafOrInternal>) -> UnderflowResult<'a, K, V> { +fn handle_underfull_node<'a, K, V>(node: NodeRef, + K, V, + marker::Mut, + marker::LeafOrInternal>) + -> UnderflowResult<'a, K, V> { let parent = if let Ok(parent) = node.ascend() { parent } else { @@ -1464,7 +1495,7 @@ fn handle_underfull_node<'a, K, V>(node: NodeRef, K, V, mar let k = mem::replace(handle.reborrow_mut().into_kv_mut().0, k); let v = mem::replace(handle.reborrow_mut().into_kv_mut().1, v); - // TODO: reuse cur_node? + // FIXME: reuse cur_node? if is_left { match handle.reborrow_mut().right_edge().descend().force() { Leaf(mut leaf) => leaf.push_front(k, v), diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs index 891c5c7293eb1..088e425da636b 100644 --- a/src/libcollections/btree/node.rs +++ b/src/libcollections/btree/node.rs @@ -28,7 +28,8 @@ // } // ``` // -// Since Rust doesn't acutally have dependent types and polymorphic recursion, we make do with lots of unsafety. +// Since Rust doesn't acutally have dependent types and polymorphic recursion, +// we make do with lots of unsafety. use alloc::heap; use core::marker::PhantomData; @@ -61,7 +62,8 @@ impl LeafNode { } } -// We use repr(C) so that a pointer to an internal node can be directly used as a pointer to a leaf node +// We use repr(C) so that a pointer to an internal node can be +// directly used as a pointer to a leaf node #[repr(C)] struct InternalNode { data: LeafNode, @@ -105,7 +107,8 @@ impl BoxedNode { } } -/// An owned tree. Note that despite being owned, this does not have a destructor, and must be cleaned up manually. +/// An owned tree. Note that despite being owned, this does not have a destructor, +/// and must be cleaned up manually. pub struct Root { node: BoxedNode, height: usize @@ -122,7 +125,8 @@ impl Root { } } - pub fn as_ref(&self) -> NodeRef { + pub fn as_ref(&self) + -> NodeRef { NodeRef { height: self.height, node: self.node.as_ptr(), @@ -131,7 +135,8 @@ impl Root { } } - pub fn as_mut(&mut self) -> NodeRef { + pub fn as_mut(&mut self) + -> NodeRef { NodeRef { height: self.height, node: self.node.as_ptr(), @@ -140,18 +145,20 @@ impl Root { } } - pub fn into_ref(self) -> NodeRef { + pub fn into_ref(self) + -> NodeRef { NodeRef { height: self.height, node: self.node.as_ptr(), - root: ptr::null_mut(), // TODO: Is there anything better to do here? + root: ptr::null_mut(), // FIXME: Is there anything better to do here? _marker: PhantomData, } } /// Add a new internal node with a single edge, pointing to the previous root, and make that /// new node the root. This increases the height by 1 and is the opposite of `shrink`. - pub fn enlarge(&mut self) -> NodeRef { + pub fn enlarge(&mut self) + -> NodeRef { let mut new_node = Box::new(unsafe { InternalNode::new() }); new_node.edges[0] = unsafe { BoxedNode::from_ptr(self.node.as_ptr()) }; @@ -192,7 +199,11 @@ impl Root { self.as_mut().as_leaf_mut().parent = ptr::null_mut(); unsafe { - heap::deallocate(top, mem::size_of::>(), mem::align_of::>()); + heap::deallocate( + top, + mem::size_of::>(), + mem::align_of::>() + ); } } } @@ -225,11 +236,15 @@ impl<'a, K: 'a, V: 'a, Type> Clone for NodeRef, K, V, marke } } -unsafe impl Sync for NodeRef { } +unsafe impl Sync + for NodeRef { } -unsafe impl<'a, K: Sync + 'a, V: Sync + 'a, Type> Send for NodeRef, K, V, marker::Immut, Type> { } -unsafe impl<'a, K: Send + 'a, V: Send + 'a, Type> Send for NodeRef, K, V, marker::Mut, Type> { } -unsafe impl Send for NodeRef { } +unsafe impl<'a, K: Sync + 'a, V: Sync + 'a, Type> Send + for NodeRef, K, V, marker::Immut, Type> { } +unsafe impl<'a, K: Send + 'a, V: Send + 'a, Type> Send + for NodeRef, K, V, marker::Mut, Type> { } +unsafe impl Send + for NodeRef { } impl NodeRef { fn as_internal(&self) -> &InternalNode { @@ -298,7 +313,18 @@ impl NodeRef self.reborrow().into_slices().1 } - pub fn ascend(self) -> Result, marker::Edge>, Self> { + pub fn ascend(self) -> Result< + Handle< + NodeRef< + Lifetime, + K, V, + Mutability, + marker::Internal + >, + marker::Edge + >, + Self + > { if self.as_leaf().parent.is_null() { Err(self) } else { @@ -328,7 +354,17 @@ impl NodeRef } impl NodeRef { - pub unsafe fn deallocate_and_ascend(mut self) -> Option, marker::Edge>> { + pub unsafe fn deallocate_and_ascend(mut self) -> Option< + Handle< + NodeRef< + marker::Owned, + K, V, + marker::Mut, + marker::Internal + >, + marker::Edge + > + > { let ptr = self.as_leaf_mut() as *mut LeafNode as *mut u8; let ret = self.ascend().ok(); heap::deallocate(ptr, mem::size_of::>(), mem::align_of::>()); @@ -337,16 +373,32 @@ impl NodeRef { } impl NodeRef { - pub unsafe fn deallocate_and_ascend(mut self) -> Option, marker::Edge>> { + pub unsafe fn deallocate_and_ascend(mut self) -> Option< + Handle< + NodeRef< + marker::Owned, + K, V, + marker::Mut, + marker::Internal + >, + marker::Edge + > + > { let ptr = self.as_internal_mut() as *mut InternalNode as *mut u8; let ret = self.ascend().ok(); - heap::deallocate(ptr, mem::size_of::>(), mem::align_of::>()); + heap::deallocate( + ptr, + mem::size_of::>(), + mem::align_of::>() + ); ret } } impl NodeRef { - unsafe fn cast_unchecked(&mut self) -> NodeRef { + unsafe fn cast_unchecked(&mut self) + -> NodeRef { + NodeRef { height: self.height, node: self.node, @@ -474,7 +526,14 @@ impl NodeRef { unsafe { slice_insert(self.keys_mut(), 0, key); slice_insert(self.vals_mut(), 0, val); - slice_insert(slice::from_raw_parts_mut(self.as_internal_mut().edges.as_mut_ptr(), self.len()+1), 0, edge.node); + slice_insert( + slice::from_raw_parts_mut( + self.as_internal_mut().edges.as_mut_ptr(), + self.len()+1 + ), + 0, + edge.node + ); self.as_leaf_mut().len += 1; @@ -523,7 +582,14 @@ impl NodeRef None, ForceResult::Internal(mut internal) => { - let edge = slice_remove(slice::from_raw_parts_mut(internal.as_internal_mut().edges.as_mut_ptr(), old_len+1), 0); + let edge = slice_remove( + slice::from_raw_parts_mut( + internal.as_internal_mut().edges.as_mut_ptr(), + old_len+1 + ), + 0 + ); + let mut new_root = Root { node: edge, height: internal.height - 1 }; new_root.as_mut().as_leaf_mut().parent = ptr::null_mut(); @@ -543,7 +609,10 @@ impl NodeRef NodeRef { - pub fn force(self) -> ForceResult, NodeRef> { + pub fn force(self) -> ForceResult< + NodeRef, + NodeRef + > { if self.height == 0 { ForceResult::Leaf(NodeRef { height: self.height, @@ -599,26 +668,40 @@ impl Handle { } } -impl PartialEq for Handle, HandleType> { +impl PartialEq + for Handle, HandleType> { + fn eq(&self, other: &Self) -> bool { self.node.node == other.node.node && self.idx == other.idx } } -impl Handle, HandleType> { - pub fn reborrow(&self) -> Handle, HandleType> { +impl + Handle, HandleType> { + + pub fn reborrow(&self) + -> Handle, HandleType> { + unsafe { Handle::new(self.node.reborrow(), self.idx) } } } -impl Handle, HandleType> { - pub unsafe fn reborrow_mut(&mut self) -> Handle, HandleType> { +impl + Handle, HandleType> { + + pub unsafe fn reborrow_mut(&mut self) + -> Handle, HandleType> { + Handle::new(self.node.reborrow_mut(), self.idx) } } -impl Handle, marker::Edge> { - pub fn left_kv(self) -> Result, marker::KV>, Self> { +impl + Handle, marker::Edge> { + + pub fn left_kv(self) + -> Result, marker::KV>, Self> { + if self.idx > 0 { unsafe { Ok(Handle::new(self.node, self.idx - 1)) @@ -628,7 +711,9 @@ impl Handle Result, marker::KV>, Self> { + pub fn right_kv(self) + -> Result, marker::KV>, Self> { + if self.idx < self.node.len() { unsafe { Ok(Handle::new(self.node, self.idx)) @@ -649,7 +734,9 @@ impl Handle, self.node.vals_mut().get_unchecked_mut(self.idx) } - pub fn insert(mut self, key: K, val: V) -> (InsertResult, *mut V) { + pub fn insert(mut self, key: K, val: V) + -> (InsertResult, *mut V) { + if self.node.len() < self.node.capacity() { unsafe { let ptr = self.insert_unchecked(key, val); @@ -664,7 +751,10 @@ impl Handle, } } else { unsafe { - Handle::new(right.as_mut().cast_unchecked::(), self.idx - T - 1).insert_unchecked(key, val) + Handle::new( + right.as_mut().cast_unchecked::(), + self.idx - T - 1 + ).insert_unchecked(key, val) } }; (InsertResult::Split(left, k, v, right), ptr) @@ -681,21 +771,32 @@ impl Handle(&mut self) -> Handle, marker::Edge> { + unsafe fn cast_unchecked(&mut self) + -> Handle, marker::Edge> { + Handle::new(self.node.cast_unchecked(), self.idx) } unsafe fn insert_unchecked(&mut self, key: K, val: V, edge: Root) { self.cast_unchecked::().insert_unchecked(key, val); - slice_insert(slice::from_raw_parts_mut(self.node.as_internal_mut().edges.as_mut_ptr(), self.node.len()), self.idx + 1, edge.node); + slice_insert( + slice::from_raw_parts_mut( + self.node.as_internal_mut().edges.as_mut_ptr(), + self.node.len() + ), + self.idx + 1, + edge.node + ); for i in (self.idx+1)..(self.node.len()+1) { Handle::new(self.node.reborrow_mut(), i).correct_parent_link(); } } - pub fn insert(mut self, key: K, val: V, edge: Root) -> InsertResult { + pub fn insert(mut self, key: K, val: V, edge: Root) + -> InsertResult { + // Necessary for correctness, but this is an internal module debug_assert!(edge.height == self.node.height - 1); @@ -713,7 +814,10 @@ impl Handle(), self.idx - T - 1).insert_unchecked(key, val, edge); + Handle::new( + right.as_mut().cast_unchecked::(), + self.idx - T - 1 + ).insert_unchecked(key, val, edge); } } InsertResult::Split(left, k, v, right) @@ -721,7 +825,9 @@ impl Handle Handle, marker::Edge> { +impl + Handle, marker::Edge> { + pub fn descend(self) -> NodeRef { NodeRef { height: self.node.height - 1, @@ -732,7 +838,9 @@ impl Handle Handle, K, V, Mutability, NodeType>, marker::KV> { +impl<'a, K: 'a, V: 'a, Mutability, NodeType> + Handle, K, V, Mutability, NodeType>, marker::KV> { + pub fn into_kv(self) -> (&'a K, &'a V) { let (keys, vals) = self.node.into_slices(); unsafe { @@ -741,7 +849,9 @@ impl<'a, K: 'a, V: 'a, Mutability, NodeType> Handle } } -impl<'a, K: 'a, V: 'a, NodeType> Handle, K, V, marker::Mut, NodeType>, marker::KV> { +impl<'a, K: 'a, V: 'a, NodeType> + Handle, K, V, marker::Mut, NodeType>, marker::KV> { + pub fn into_kv_mut(self) -> (&'a mut K, &'a mut V) { let (mut keys, mut vals) = self.node.into_slices_mut(); unsafe { @@ -760,7 +870,8 @@ impl Handle Handle, marker::KV> { - pub fn split(mut self) -> (NodeRef, K, V, Root) { + pub fn split(mut self) + -> (NodeRef, K, V, Root) { unsafe { let mut new_node = Box::new(LeafNode::new()); @@ -794,7 +905,8 @@ impl Handle, } } - pub fn remove(mut self) -> (Handle, marker::Edge>, K, V) { + pub fn remove(mut self) + -> (Handle, marker::Edge>, K, V) { unsafe { let k = slice_remove(self.node.keys_mut(), self.idx); let v = slice_remove(self.node.vals_mut(), self.idx); @@ -805,7 +917,8 @@ impl Handle, } impl Handle, marker::KV> { - pub fn split(mut self) -> (NodeRef, K, V, Root) { + pub fn split(mut self) + -> (NodeRef, K, V, Root) { unsafe { let mut new_node = Box::new(InternalNode::new()); @@ -838,7 +951,7 @@ impl Handle Handle bool { - self.reborrow().left_edge().descend().len() + self.reborrow().right_edge().descend().len() + 1 <= self.node.capacity() - } - - pub fn merge(mut self) -> Handle, marker::Edge> { + ( + self.reborrow() + .left_edge() + .descend() + .len() + + self.reborrow() + .right_edge() + .descend() + .len() + + 1 + ) <= self.node.capacity() + } + + pub fn merge(mut self) + -> Handle, marker::Edge> { let self1 = unsafe { ptr::read(&self) }; let self2 = unsafe { ptr::read(&self) }; let mut left_node = self1.left_edge().descend(); @@ -867,13 +991,15 @@ impl Handle Handle 1 { ptr::copy_nonoverlapping( right_node.cast_unchecked().as_internal().edges.as_ptr(), - left_node.cast_unchecked().as_internal_mut().edges.as_mut_ptr().offset(left_len as isize + 1), + left_node.cast_unchecked() + .as_internal_mut() + .edges + .as_mut_ptr() + .offset(left_len as isize + 1), right_len + 1 ); @@ -897,9 +1027,17 @@ impl Handle>(), mem::align_of::>()); + heap::deallocate( + *right_node.node as *mut u8, + mem::size_of::>(), + mem::align_of::>() + ); } else { - heap::deallocate(*right_node.node as *mut u8, mem::size_of::>(), mem::align_of::>()); + heap::deallocate( + *right_node.node as *mut u8, + mem::size_of::>(), + mem::align_of::>() + ); } left_node.as_leaf_mut().len += right_len as u16 + 1; @@ -909,8 +1047,13 @@ impl Handle Handle, HandleType> { - pub fn force(self) -> ForceResult, HandleType>, Handle, HandleType>> { +impl + Handle, HandleType> { + + pub fn force(self) -> ForceResult< + Handle, HandleType>, + Handle, HandleType> + > { match self.node.force() { ForceResult::Leaf(node) => ForceResult::Leaf(Handle { node: node, diff --git a/src/libcollections/btree/search.rs b/src/libcollections/btree/search.rs index b4d4e339ab7a5..c515584528b12 100644 --- a/src/libcollections/btree/search.rs +++ b/src/libcollections/btree/search.rs @@ -1,3 +1,13 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + use core::cmp::Ordering; use borrow::Borrow; @@ -12,7 +22,12 @@ pub enum SearchResult { GoDown(Handle, marker::Edge>) } -pub fn search_tree(mut node: NodeRef, key: &Q) -> SearchResult where Q: Ord, K: Borrow { +pub fn search_tree( + mut node: NodeRef, + key: &Q +) -> SearchResult + where Q: Ord, K: Borrow { + loop { match search_node(node, key) { Found(handle) => return Found(handle), @@ -27,7 +42,12 @@ pub fn search_tree(mut node: NodeRef(node: NodeRef, key: &Q) -> SearchResult where Q: Ord, K: Borrow { +pub fn search_node( + node: NodeRef, + key: &Q +) -> SearchResult + where Q: Ord, K: Borrow { + match search_linear(&node, key) { (idx, true) => Found( unsafe { Handle::new(node, idx) } @@ -38,7 +58,12 @@ pub fn search_node(node: NodeRef
  • (node: &NodeRef, key: &Q) -> (usize, bool) where Q: Ord, K: Borrow { +fn search_linear( + node: &NodeRef, + key: &Q +) -> (usize, bool) + where Q: Ord, K: Borrow { + for (i, k) in node.keys().iter().enumerate() { match key.cmp(k.borrow()) { Ordering::Greater => {},