refactor!: renamed gradual calc types

src/mania/gradual_difficulty.rs

@@ -23,12 +23,12 @@ use super::{
 /// be processed and the [`ManiaDifficultyAttributes`] will be updated and returned.
 ///
 /// If you want to calculate performance attributes, use
-/// [`ManiaGradualPerformanceAttributes`](crate::mania::ManiaGradualPerformanceAttributes) instead.
+/// [`ManiaGradualPerformanceAttributes`](crate::mania::ManiaGradualPerformance) instead.
 ///
 /// # Example
 ///
 /// ```
-/// use rosu_pp::{Beatmap, mania::ManiaGradualDifficultyAttributes};
+/// use rosu_pp::{Beatmap, mania::ManiaGradualDifficulty};
 ///
 /// # /*
 /// let map: Beatmap = ...
@@ -36,7 +36,7 @@ use super::{
 /// # let map = Beatmap::default();
 ///
 /// let mods = 64; // DT
-/// let mut iter = ManiaGradualDifficultyAttributes::new(&map, mods);
+/// let mut iter = ManiaGradualDifficulty::new(&map, mods);
 ///
 /// let attrs1 = iter.next(); // the difficulty of the map after the first hit object
 /// let attrs2 = iter.next(); //                           after the second hit object
@@ -47,7 +47,7 @@ use super::{
 /// }
 /// ```
 #[derive(Clone, Debug)]
-pub struct ManiaGradualDifficultyAttributes<'map> {
+pub struct ManiaGradualDifficulty<'map> {
     pub(crate) idx: usize,
     map: Cow<'map, Beatmap>,
     hit_window: f64,
@@ -57,7 +57,7 @@ pub struct ManiaGradualDifficultyAttributes<'map> {
     clock_rate: f64,
 }
 
-impl<'map> ManiaGradualDifficultyAttributes<'map> {
+impl<'map> ManiaGradualDifficulty<'map> {
     /// Create a new difficulty attributes iterator for osu!mania maps.
     pub fn new(map: &'map Beatmap, mods: u32) -> Self {
         let map = map.convert_mode(GameMode::Mania);
@@ -148,7 +148,7 @@ impl<'map> ManiaGradualDifficultyAttributes<'map> {
     }
 }
 
-impl Iterator for ManiaGradualDifficultyAttributes<'_> {
+impl Iterator for ManiaGradualDifficulty<'_> {
     type Item = ManiaDifficultyAttributes;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -206,7 +206,7 @@ impl Iterator for ManiaGradualDifficultyAttributes<'_> {
     }
 }
 
-impl ExactSizeIterator for ManiaGradualDifficultyAttributes<'_> {
+impl ExactSizeIterator for ManiaGradualDifficulty<'_> {
     #[inline]
     fn len(&self) -> usize {
         self.diff_objects.len() + 1 - self.idx

src/mania/gradual_performance.rs

@@ -2,7 +2,7 @@
 
 use crate::{Beatmap, ManiaPP};
 
-use super::{ManiaGradualDifficultyAttributes, ManiaPerformanceAttributes, ManiaScoreState};
+use super::{ManiaGradualDifficulty, ManiaPerformanceAttributes, ManiaScoreState};
 
 /// Gradually calculate the performance attributes of an osu!mania map.
 ///
@@ -15,12 +15,12 @@ use super::{ManiaGradualDifficultyAttributes, ManiaPerformanceAttributes, ManiaS
 /// Be sure the given score is adjusted with respect to mods.
 ///
 /// If you only want to calculate difficulty attributes use
-/// [`ManiaGradualDifficultyAttributes`] instead.
+/// [`ManiaGradualDifficulty`] instead.
 ///
 /// # Example
 ///
 /// ```
-/// use rosu_pp::{Beatmap, mania::{ManiaGradualPerformanceAttributes, ManiaScoreState}};
+/// use rosu_pp::{Beatmap, mania::{ManiaGradualPerformance, ManiaScoreState}};
 ///
 /// # /*
 /// let map: Beatmap = ...
@@ -28,7 +28,7 @@ use super::{ManiaGradualDifficultyAttributes, ManiaPerformanceAttributes, ManiaS
 /// # let map = Beatmap::default();
 ///
 /// let mods = 64; // DT
-/// let mut gradual_perf = ManiaGradualPerformanceAttributes::new(&map, mods);
+/// let mut gradual_perf = ManiaGradualPerformance::new(&map, mods);
 /// let mut state = ManiaScoreState::new(); // empty state, everything is on 0.
 ///
 /// // The first 10 hitresults are 320s
@@ -77,15 +77,15 @@ use super::{ManiaGradualDifficultyAttributes, ManiaPerformanceAttributes, ManiaS
 /// assert!(gradual_perf.next(state).is_none());
 /// ```
 #[derive(Clone, Debug)]
-pub struct ManiaGradualPerformanceAttributes<'map> {
-    difficulty: ManiaGradualDifficultyAttributes<'map>,
+pub struct ManiaGradualPerformance<'map> {
+    difficulty: ManiaGradualDifficulty<'map>,
     performance: ManiaPP<'map>,
 }
 
-impl<'map> ManiaGradualPerformanceAttributes<'map> {
+impl<'map> ManiaGradualPerformance<'map> {
     /// Create a new gradual performance calculator for osu!mania maps.
     pub fn new(map: &'map Beatmap, mods: u32) -> Self {
-        let difficulty = ManiaGradualDifficultyAttributes::new(map, mods);
+        let difficulty = ManiaGradualDifficulty::new(map, mods);
         let performance = ManiaPP::new(map).mods(mods).passed_objects(0);
 
         Self {

src/mania/mod.rs

@@ -17,8 +17,7 @@ pub use self::{mania_object::ManiaObject, pp::*, score_state::ManiaScoreState};
 
 #[cfg(feature = "gradual")]
 pub use self::{
-    gradual_difficulty::ManiaGradualDifficultyAttributes,
-    gradual_performance::ManiaGradualPerformanceAttributes,
+    gradual_difficulty::ManiaGradualDifficulty, gradual_performance::ManiaGradualPerformance,
 };
 
 pub(crate) use self::mania_object::ObjectParameters;
@@ -88,7 +87,7 @@ impl<'map> ManiaStars<'map> {
     ///
     /// If you want to calculate the difficulty after every few objects, instead of
     /// using [`ManiaStars`] multiple times with different `passed_objects`, you should use
-    /// [`ManiaGradualDifficultyAttributes`](crate::mania::ManiaGradualDifficultyAttributes).
+    /// [`ManiaGradualDifficultyAttributes`](crate::mania::ManiaGradualDifficulty).
     #[inline]
     pub fn passed_objects(mut self, passed_objects: usize) -> Self {
         self.passed_objects = Some(passed_objects);

src/mania/pp.rs

@@ -109,7 +109,7 @@ impl<'map> ManiaPP<'map> {
     ///
     /// If you want to calculate the performance after every few objects, instead of
     /// using [`ManiaPP`] multiple times with different `passed_objects`, you should use
-    /// [`ManiaGradualPerformanceAttributes`](crate::mania::ManiaGradualPerformanceAttributes).
+    /// [`ManiaGradualPerformanceAttributes`](crate::mania::ManiaGradualPerformance).
     #[inline]
     pub fn passed_objects(mut self, passed_objects: usize) -> Self {
         self.passed_objects = Some(passed_objects);

src/mania/score_state.rs

@@ -1,6 +1,6 @@
 /// Aggregation for a score's current state i.e. what are the current hitresults.
 ///
-/// This struct is used for [`ManiaGradualPerformanceAttributes`](crate::mania::ManiaGradualPerformanceAttributes).
+/// This struct is used for [`ManiaGradualPerformanceAttributes`](crate::mania::ManiaGradualPerformance).
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct ManiaScoreState {
     /// Amount of current 320s.