removed Copy from score states but added Eq + PartiqlEq

src/taiko/gradual_performance.rs

@@ -2,12 +2,11 @@ use crate::{Beatmap, TaikoPP};
 
 use super::{TaikoGradualDifficultyAttributes, TaikoPerformanceAttributes};
 
-// TODO: Benchmark if Copy is faster than Clone
 /// Aggregation for a score's current state i.e. what was the
 /// maximum combo so far and what are the current hitresults.
 ///
 /// This struct is used for [`TaikoGradualPerformanceAttributes`].
-#[derive(Copy, Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct TaikoScoreState {
     /// Maximum combo that the score has had so far.
     /// **Not** the maximum possible combo of the map so far.
@@ -61,10 +60,10 @@ impl TaikoScoreState {
 ///     state.max_combo += 1;
 ///
 ///     # /*
-///     let performance = gradual_perf.process_next_object(state).unwrap();
+///     let performance = gradual_perf.process_next_object(state.clone()).unwrap();
 ///     println!("PP: {}", performance.pp);
 ///     # */
-///     # let _ = gradual_perf.process_next_object(state);
+///     # let _ = gradual_perf.process_next_object(state.clone());
 /// }
 ///
 /// // Then comes a miss.
@@ -72,29 +71,29 @@ impl TaikoScoreState {
 /// // the next few objects because the combo is reset.
 /// state.misses += 1;
 /// # /*
-/// let performance = gradual_perf.process_next_object(state).unwrap();
+/// let performance = gradual_perf.process_next_object(state.clone()).unwrap();
 /// println!("PP: {}", performance.pp);
 /// # */
-/// # let _ = gradual_perf.process_next_object(state);
+/// # let _ = gradual_perf.process_next_object(state.clone());
 ///
 /// // The next 10 objects will be a mixture of 300s and 100s.
 /// // Notice how all 10 objects will be processed in one go.
 /// state.n300 += 3;
 /// state.n100 += 7;
 /// # /*
-/// let performance = gradual_perf.process_next_n_objects(state, 10).unwrap();
+/// let performance = gradual_perf.process_next_n_objects(state.clone(), 10).unwrap();
 /// println!("PP: {}", performance.pp);
 /// # */
-/// # let _ = gradual_perf.process_next_n_objects(state, 10);
+/// # let _ = gradual_perf.process_next_n_objects(state.clone(), 10);
 ///
 /// // Now comes another 300. Note that the max combo gets incremented again.
 /// state.n300 += 1;
 /// state.max_combo += 1;
 /// # /*
-/// let performance = gradual_perf.process_next_object(state).unwrap();
+/// let performance = gradual_perf.process_next_object(state.clone()).unwrap();
 /// println!("PP: {}", performance.pp);
 /// # */
-/// # let _ = gradual_perf.process_next_object(state);
+/// # let _ = gradual_perf.process_next_object(state.clone());
 ///
 /// // Skip to the end
 /// # /*
@@ -102,10 +101,10 @@ impl TaikoScoreState {
 /// state.n300 = ...
 /// state.n100 = ...
 /// state.misses = ...
-/// let final_performance = gradual_perf.process_next_n_objects(state, usize::MAX).unwrap();
+/// let final_performance = gradual_perf.process_next_n_objects(state.clone(), usize::MAX).unwrap();
 /// println!("PP: {}", performance.pp);
 /// # */
-/// # let _ = gradual_perf.process_next_n_objects(state, usize::MAX);
+/// # let _ = gradual_perf.process_next_n_objects(state.clone(), usize::MAX);
 ///
 /// // Once the final performance was calculated,
 /// // attempting to process further objects will return `None`.
@@ -178,7 +177,9 @@ mod tests {
         let mut gradual = TaikoGradualPerformanceAttributes::new(&map, mods);
         let state = TaikoScoreState::default();
 
-        assert!(gradual.process_next_n_objects(state, usize::MAX).is_some());
+        assert!(gradual
+            .process_next_n_objects(state.clone(), usize::MAX)
+            .is_some());
         assert!(gradual.process_next_object(state).is_none());
     }
 
@@ -193,14 +194,14 @@ mod tests {
         let mut gradual2 = TaikoGradualPerformanceAttributes::new(&map, mods);
 
         for _ in 0..50 {
-            let _ = gradual1.process_next_object(state);
-            let _ = gradual2.process_next_object(state);
+            let _ = gradual1.process_next_object(state.clone());
+            let _ = gradual2.process_next_object(state.clone());
         }
 
         let n = 200;
 
         for _ in 1..n {
-            let _ = gradual1.process_next_object(state);
+            let _ = gradual1.process_next_object(state.clone());
         }
 
         let state = TaikoScoreState {
@@ -210,7 +211,7 @@ mod tests {
             misses: 6,
         };
 
-        let next = gradual1.process_next_object(state);
+        let next = gradual1.process_next_object(state.clone());
         let next_n = gradual2.process_next_n_objects(state, n);
 
         assert_eq!(next_n, next);