From 5b280ab336942aee140fde4853a981ac50c962ea Mon Sep 17 00:00:00 2001
From: Sebastian Klose <mail@sklose.com>
Date: Fri, 14 Apr 2023 22:07:10 -0400
Subject: [PATCH] minor cleanup

---
 .gitignore              |  3 ++-
 benches/u64_channels.rs |  4 ++--
 src/prelude.rs          | 11 +++++++----
 src/ringbuffer.rs       |  8 ++++----
 src/utils.rs            |  5 +++--
 src/wait.rs             | 11 +++++++----
 6 files changed, 25 insertions(+), 17 deletions(-)

diff --git a/.gitignore b/.gitignore
index f0e3bca..ebdff5a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 /target
-**/*.rs.bk
\ No newline at end of file
+**/*.rs.bk
+/.idea
diff --git a/benches/u64_channels.rs b/benches/u64_channels.rs
index d56f60e..3e1ca53 100644
--- a/benches/u64_channels.rs
+++ b/benches/u64_channels.rs
@@ -31,7 +31,7 @@ fn disrustor_channel<S: Sequencer, F: FnOnce(&RingBuffer<i64>) -> S>(n: u64, b:
     let gating_sequence = vec![sequencer.get_cursor()];
     let barrier = sequencer.create_barrier(&gating_sequence);
     let processor = BatchEventProcessor::create(move |data, sequence, _| {
-        assert!(*data == sequence);
+        assert_eq!(*data, sequence);
     });
 
     sequencer.add_gating_sequence(&processor.get_cursor());
@@ -57,7 +57,7 @@ fn disrustor_channel<S: Sequencer, F: FnOnce(&RingBuffer<i64>) -> S>(n: u64, b:
 
     sequencer.drain();
     handle.join();
-    assert!(counter == n);
+    assert_eq!(counter, n);
 }
 
 fn criterion_benchmark(c: &mut Criterion) {
diff --git a/src/prelude.rs b/src/prelude.rs
index 22d7974..1a5ed2d 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -1,6 +1,9 @@
-use std::sync::{
-    atomic::{AtomicI64, Ordering},
-    Arc,
+use std::{
+    borrow::Borrow,
+    sync::{
+        atomic::{AtomicI64, Ordering},
+        Arc,
+    },
 };
 
 pub type Sequence = i64;
@@ -68,7 +71,7 @@ pub trait Sequencer {
 
 pub trait WaitStrategy: Send + Sync {
     fn new() -> Self;
-    fn wait_for<F: Fn() -> bool, S: AsRef<AtomicSequence>>(
+    fn wait_for<F: Fn() -> bool, S: Borrow<AtomicSequence>>(
         &self,
         sequence: Sequence,
         dependencies: &[S],
diff --git a/src/ringbuffer.rs b/src/ringbuffer.rs
index b4fbd8b..2c58147 100644
--- a/src/ringbuffer.rs
+++ b/src/ringbuffer.rs
@@ -28,6 +28,10 @@ impl<T: Default> RingBuffer<T> {
 }
 
 impl<T: Send + Sync> DataProvider<T> for RingBuffer<T> {
+    fn buffer_size(&self) -> usize {
+        self.capacity
+    }
+
     unsafe fn get_mut(&self, sequence: Sequence) -> &mut T {
         let index = sequence as usize & self.mask;
         let cell = self.data.get_unchecked(index);
@@ -39,10 +43,6 @@ impl<T: Send + Sync> DataProvider<T> for RingBuffer<T> {
         let cell = self.data.get_unchecked(index);
         &*cell.get()
     }
-
-    fn buffer_size(&self) -> usize {
-        self.capacity
-    }
 }
 
 unsafe impl<T: Send> Send for RingBuffer<T> {}
diff --git a/src/utils.rs b/src/utils.rs
index 3fcef42..b710142 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,13 +1,14 @@
 use crate::prelude::*;
 use std::{
+    borrow::Borrow,
     iter::*,
     sync::atomic::{AtomicU64, Ordering},
 };
 
-pub fn min_cursor_sequence<S: AsRef<AtomicSequence>>(sequences: &[S]) -> Sequence {
+pub fn min_cursor_sequence<S: Borrow<AtomicSequence>>(sequences: &[S]) -> Sequence {
     sequences
         .iter()
-        .map(|s| s.as_ref().get())
+        .map(|s| s.borrow().get())
         .min()
         .unwrap_or_default()
 }
diff --git a/src/wait.rs b/src/wait.rs
index 1d53c19..3125400 100644
--- a/src/wait.rs
+++ b/src/wait.rs
@@ -1,6 +1,9 @@
 use crate::prelude::*;
 use crate::utils::*;
-use std::sync::{Condvar, Mutex};
+use std::{
+    borrow::Borrow,
+    sync::{Condvar, Mutex},
+};
 
 pub struct SpinLoopWaitStrategy;
 
@@ -14,7 +17,7 @@ impl WaitStrategy for SpinLoopWaitStrategy {
         SpinLoopWaitStrategy {}
     }
 
-    fn wait_for<F: Fn() -> bool, S: AsRef<AtomicSequence>>(
+    fn wait_for<F: Fn() -> bool, S: Borrow<AtomicSequence>>(
         &self,
         sequence: Sequence,
         dependencies: &[S],
@@ -36,13 +39,13 @@ impl WaitStrategy for SpinLoopWaitStrategy {
 
 impl WaitStrategy for BlockingWaitStrategy {
     fn new() -> Self {
-        BlockingWaitStrategy {
+        Self {
             cvar: Condvar::new(),
             guard: Mutex::new(()),
         }
     }
 
-    fn wait_for<F: Fn() -> bool, S: AsRef<AtomicSequence>>(
+    fn wait_for<F: Fn() -> bool, S: Borrow<AtomicSequence>>(
         &self,
         sequence: Sequence,
         dependencies: &[S],