From b88ec9ac10ee9bce59f3010f20ec40ca8c850c22 Mon Sep 17 00:00:00 2001 From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com> Date: Sat, 13 Nov 2021 14:34:09 +0100 Subject: [PATCH] fix clippy lints --- benches/packed_linked_list.rs | 2 +- src/binary_tree.rs | 2 +- src/linked_list/mod.rs | 42 ++++++++++++++++---------- src/packed_linked_list/mod.rs | 57 ++++++++++++++++++++--------------- 4 files changed, 61 insertions(+), 42 deletions(-) diff --git a/benches/packed_linked_list.rs b/benches/packed_linked_list.rs index f6dc491..cdfebd2 100644 --- a/benches/packed_linked_list.rs +++ b/benches/packed_linked_list.rs @@ -37,7 +37,7 @@ fn create_random_packed_list_128(size: usize) -> PackedLinkedList { fn push_back(c: &mut Criterion) { let mut group = c.benchmark_group("push_back"); - for i in [100, 1_0000_00].iter() { + for i in [100, 1_000_000].iter() { group.bench_with_input(BenchmarkId::new("create_random_list", i), i, |b, i| { b.iter(|| create_random_list(*i)) }); diff --git a/src/binary_tree.rs b/src/binary_tree.rs index 4f68802..c25c317 100644 --- a/src/binary_tree.rs +++ b/src/binary_tree.rs @@ -70,7 +70,7 @@ impl DisplayTree for Node { let mut current_nodes = vec![self]; - while current_nodes.len() > 0 { + while !current_nodes.is_empty() { // display node layer let mut offset = 0; diff --git a/src/linked_list/mod.rs b/src/linked_list/mod.rs index bcc0041..4aa6a2f 100644 --- a/src/linked_list/mod.rs +++ b/src/linked_list/mod.rs @@ -222,6 +222,13 @@ impl LinkedList { self.iter().count() } + /// Checks whether the list is empty + /// + /// See [LinkedList::len] + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + /// Returns an iterator over the items pub fn iter(&self) -> Iter { Iter::new(self) @@ -231,11 +238,6 @@ impl LinkedList { pub fn iter_mut(&mut self) -> IterMut { IterMut::new(self) } - - /// Returns an iterator owning the items - pub fn into_iter(self) -> IntoIter { - IntoIter::new(self) - } } ///// @@ -278,11 +280,20 @@ impl PartialEq for LinkedList { } } +impl IntoIterator for LinkedList { + type Item = T; + type IntoIter = IntoIter; + + /// Returns an iterator owning the items + fn into_iter(self) -> Self::IntoIter { + IntoIter::new(self) + } +} + impl FromIterator for LinkedList { fn from_iter>(iter: I) -> Self { - let mut iter = iter.into_iter(); let mut list = Self::new(); - while let Some(item) = iter.next() { + for item in iter { list.push_back(item) } list @@ -291,8 +302,7 @@ impl FromIterator for LinkedList { impl Extend for LinkedList { fn extend>(&mut self, iter: I) { - let mut iter = iter.into_iter(); - while let Some(item) = iter.next() { + for item in iter { self.push_back(item) } } @@ -339,10 +349,10 @@ impl Node { next: self.next, prev: NonNull::new(self as _), })); - self.next.map(|mut next| { + if let Some(mut next) = self.next { // SAFETY: All pointers should always be valid and created from a box - unsafe { next.as_mut() }.prev = new_node - }); + unsafe { next.as_mut() }.prev = new_node; + } self.next = new_node; } @@ -353,10 +363,10 @@ impl Node { next: NonNull::new(self as _), prev: self.prev, })); - self.prev.map(|mut next| { + if let Some(mut next) = self.prev { // SAFETY: All pointers should always be valid and created from a box - unsafe { next.as_mut() }.next = new_node - }); + unsafe { next.as_mut() }.next = new_node; + } self.prev = new_node; } @@ -449,7 +459,7 @@ impl IntoIter { impl Drop for IntoIter { fn drop(&mut self) { - while let Some(_) = self.next() {} + for _ in self {} } } diff --git a/src/packed_linked_list/mod.rs b/src/packed_linked_list/mod.rs index 244ce73..0e40d8c 100644 --- a/src/packed_linked_list/mod.rs +++ b/src/packed_linked_list/mod.rs @@ -59,6 +59,11 @@ impl PackedLinkedList { self.len } + // Whether the list is empty (O(1)) + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + /// Pushes a new value to the front of the list pub fn push_front(&mut self, element: T) { // SAFETY: All pointers should always point to valid memory, @@ -109,9 +114,11 @@ impl PackedLinkedList { if node.size == 1 { // the last item, deallocate it let mut boxed = Box::from_raw(first.as_ptr()); - boxed.next.as_mut().map(|next| next.as_mut().prev = None); + if let Some(next) = boxed.next.as_mut() { + next.as_mut().prev = None; + } self.first = boxed.next; - if let None = self.first { + if self.first.is_none() { // if this node was the last one, also remove it from the tail pointer self.last = None; } @@ -143,12 +150,11 @@ impl PackedLinkedList { if node.size == 1 { // the last item, deallocate it let mut boxed = Box::from_raw(last.as_ptr()); - boxed - .prev - .as_mut() - .map(|previous| previous.as_mut().next = None); + if let Some(previous) = boxed.prev.as_mut() { + previous.as_mut().next = None; + } self.last = boxed.prev; - if let None = self.last { + if self.last.is_none() { // if this node was the last one, also remove it from the tail pointer self.first = None; } @@ -209,38 +215,42 @@ impl PackedLinkedList { iter::IterMut::new(self) } - pub fn into_iter(self) -> iter::IntoIter { - iter::IntoIter::new(self) - } - fn insert_node_start(&mut self) { let node = Some(allocate_nonnull(Node::new(None, self.first))); - self.first - .as_mut() - .map(|first| unsafe { first.as_mut().prev = node }); + if let Some(first) = self.first.as_mut() { + unsafe { first.as_mut().prev = node }; + } self.first = node; - if let None = self.last { + if self.last.is_none() { self.last = node; } } fn insert_node_end(&mut self) { let node = Some(allocate_nonnull(Node::new(self.last, None))); - self.last - .as_mut() - .map(|last| unsafe { last.as_mut().next = node }); + if let Some(last) = self.last.as_mut() { + unsafe { last.as_mut().next = node }; + } self.last = node; - if let None = self.first { + if self.first.is_none() { self.first = node; } } } +impl IntoIterator for PackedLinkedList { + type Item = T; + type IntoIter = iter::IntoIter; + + fn into_iter(self) -> Self::IntoIter { + iter::IntoIter::new(self) + } +} + impl FromIterator for PackedLinkedList { fn from_iter>(iter: I) -> Self { let mut list = PackedLinkedList::new(); - let mut iter = iter.into_iter(); - while let Some(item) = iter.next() { + for item in iter { list.push_back(item); } list @@ -249,8 +259,7 @@ impl FromIterator for PackedLinkedList { impl Extend for PackedLinkedList { fn extend>(&mut self, iter: I) { - let mut iter = iter.into_iter(); - while let Some(item) = iter.next() { + for item in iter { self.push_back(item); } } @@ -675,7 +684,7 @@ mod iter { impl Drop for IntoIter { fn drop(&mut self) { - while let Some(_) = self.next() {} + for _ in self {} } }