doc: fix intra-doc links (#30)

src/catch/mod.rs

@@ -81,9 +81,12 @@ impl<'map> CatchStars<'map> {
 
     /// Amount of passed objects for partial plays, e.g. a fail.
     ///
-    /// If you want to calculate the difficulty after every few objects, instead of
+    #[cfg_attr(
-    /// using [`CatchStars`] multiple times with different `passed_objects`, you should use
+        feature = "gradual",
-    /// [`CatchGradualDifficultyAttributes`](crate::catch::CatchGradualDifficulty).
+        doc = "If you want to calculate the difficulty after every few objects, instead of
+        using [`CatchStars`] multiple times with different `passed_objects`, you should use
+        [`CatchGradualDifficultyAttributes`](crate::catch::CatchGradualDifficulty)."
+    )]
     #[inline]
     pub fn passed_objects(mut self, passed_objects: usize) -> Self {
         self.passed_objects = Some(passed_objects);

src/catch/pp.rs

@@ -143,9 +143,12 @@ impl<'map> CatchPP<'map> {
 
     /// Amount of passed objects for partial plays, e.g. a fail.
     ///
-    /// If you want to calculate the performance after every few objects, instead of
+    #[cfg_attr(
-    /// using [`CatchPP`] multiple times with different `passed_objects`, you should use
+        feature = "gradual",
-    /// [`CatchGradualPerformanceAttributes`](crate::catch::CatchGradualPerformance).
+        doc = "If you want to calculate the performance after every few objects, instead of
+        using [`CatchPP`] multiple times with different `passed_objects`, you should use
+        [`CatchGradualPerformanceAttributes`](crate::catch::CatchGradualPerformance)."
+    )]
     #[inline]
     pub fn passed_objects(mut self, passed_objects: usize) -> Self {
         self.passed_objects = Some(passed_objects);

src/mania/mod.rs

@@ -86,9 +86,12 @@ impl<'map> ManiaStars<'map> {
 
     /// Amount of passed objects for partial plays, e.g. a fail.
     ///
-    /// If you want to calculate the difficulty after every few objects, instead of
+    #[cfg_attr(
-    /// using [`ManiaStars`] multiple times with different `passed_objects`, you should use
+        feature = "gradual",
-    /// [`ManiaGradualDifficultyAttributes`](crate::mania::ManiaGradualDifficulty).
+        doc = "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::ManiaGradualDifficulty)."
+    )]
     #[inline]
     pub fn passed_objects(mut self, passed_objects: usize) -> Self {
         self.passed_objects = Some(passed_objects);

src/mania/pp.rs

@@ -106,9 +106,12 @@ impl<'map> ManiaPP<'map> {
 
     /// Amount of passed objects for partial plays, e.g. a fail.
     ///
-    /// If you want to calculate the performance after every few objects, instead of
+    #[cfg_attr(
-    /// using [`ManiaPP`] multiple times with different `passed_objects`, you should use
+        feature = "gradual",
-    /// [`ManiaGradualPerformanceAttributes`](crate::mania::ManiaGradualPerformance).
+        doc = "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::ManiaGradualPerformance)."
+    )]
     #[inline]
     pub fn passed_objects(mut self, passed_objects: usize) -> Self {
         self.passed_objects = Some(passed_objects);

src/osu/mod.rs

@@ -100,9 +100,12 @@ impl<'map> OsuStars<'map> {
 
     /// Amount of passed objects for partial plays, e.g. a fail.
     ///
-    /// If you want to calculate the difficulty after every few objects, instead of
+    #[cfg_attr(
-    /// using [`OsuStars`] multiple times with different `passed_objects`, you should use
+        feature = "gradual",
-    /// [`OsuGradualDifficulty`].
+        doc = "If you want to calculate the difficulty after every few objects, instead of
+        using [`OsuStars`] multiple times with different `passed_objects`, you should use
+        [`OsuGradualDifficulty`]."
+    )]
     #[inline]
     pub fn passed_objects(mut self, passed_objects: usize) -> Self {
         self.passed_objects = Some(passed_objects);

src/osu/pp.rs

@@ -162,9 +162,12 @@ impl<'map> OsuPP<'map> {
 
     /// Amount of passed objects for partial plays, e.g. a fail.
     ///
-    /// If you want to calculate the performance after every few objects, instead of
+    #[cfg_attr(
-    /// using [`OsuPP`] multiple times with different `passed_objects`, you should use
+        feature = "gradual",
-    /// [`OsuGradualPerformanceAttributes`](crate::osu::OsuGradualPerformance).
+        doc = "If you want to calculate the performance after every few objects, instead of
+        using [`OsuPP`] multiple times with different `passed_objects`, you should use
+        [`OsuGradualPerformanceAttributes`](crate::osu::OsuGradualPerformance)."
+    )]
     #[inline]
     pub fn passed_objects(mut self, passed_objects: usize) -> Self {
         self.passed_objects = Some(passed_objects);

src/pp.rs

@@ -123,9 +123,12 @@ impl<'map> AnyPP<'map> {
 
     /// Amount of passed objects for partial plays, e.g. a fail.
     ///
-    /// If you want to calculate the performance after every few objects, instead of
+    #[cfg_attr(
-    /// using [`AnyPP`] multiple times with different `passed_objects`, you should use
+        feature = "gradual",
-    /// [`GradualPerformanceAttributes`](crate::GradualPerformance).
+        doc = "If you want to calculate the performance after every few objects, instead of
+        using [`AnyPP`] multiple times with different `passed_objects`, you should use
+        [`GradualPerformanceAttributes`](crate::GradualPerformance)."
+    )]
     #[inline]
     pub fn passed_objects(self, passed_objects: usize) -> Self {
         match self {

src/score_state.rs

@@ -6,8 +6,6 @@ use crate::{
 /// Aggregation for a score's current state i.e. what is
 /// the maximum combo so far, what are the current
 /// hitresults and what is the current score.
-///
-/// This struct is used for [`GradualPerformance`](crate::GradualPerformance).
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct ScoreState {
     /// Maximum combo that the score has had so far.

src/stars.rs

@@ -73,9 +73,12 @@ impl<'map> AnyStars<'map> {
 
     /// Amount of passed objects for partial plays, e.g. a fail.
     ///
-    /// If you want to calculate the performance after every few objects, instead of
+    #[cfg_attr(
-    /// using [`AnyStars`] multiple times with different `passed_objects`, you should use
+        feature = "gradual",
-    /// [`GradualDifficultyAttributes`](crate::GradualDifficulty).
+        doc = "If you want to calculate the performance after every few objects, instead of
+        using [`AnyStars`] multiple times with different `passed_objects`, you should use
+        [`GradualDifficultyAttributes`](crate::GradualDifficulty)."
+    )]
     #[inline]
     pub fn passed_objects(self, passed_objects: usize) -> Self {
         match self {

src/taiko/mod.rs

@@ -90,9 +90,12 @@ impl<'map> TaikoStars<'map> {
 
     /// Amount of passed objects for partial plays, e.g. a fail.
     ///
-    /// If you want to calculate the difficulty after every few objects, instead of
+    #[cfg_attr(
-    /// using [`TaikoStars`] multiple times with different `passed_objects`, you should use
+        feature = "gradual",
-    /// [`TaikoGradualDifficultyAttributes`](crate::taiko::TaikoGradualDifficulty).
+        doc = "If you want to calculate the difficulty after every few objects, instead of
+        using [`TaikoStars`] multiple times with different `passed_objects`, you should use
+        [`TaikoGradualDifficultyAttributes`](crate::taiko::TaikoGradualDifficulty)."
+    )]
     #[inline]
     pub fn passed_objects(mut self, passed_objects: usize) -> Self {
         self.passed_objects = Some(passed_objects);

src/taiko/pp.rs

@@ -148,9 +148,12 @@ impl<'map> TaikoPP<'map> {
 
     /// Amount of passed objects for partial plays, e.g. a fail.
     ///
-    /// If you want to calculate the performance after every few objects, instead of
+    #[cfg_attr(
-    /// using [`TaikoPP`] multiple times with different `passed_objects`, you should use
+        feature = "gradual",
-    /// [`TaikoGradualPerformanceAttributes`](crate::taiko::TaikoGradualPerformance).
+        doc = "If you want to calculate the performance after every few objects, instead of
+        using [`TaikoPP`] multiple times with different `passed_objects`, you should use
+        [`TaikoGradualPerformanceAttributes`](crate::taiko::TaikoGradualPerformance)."
+    )]
     #[inline]
     pub fn passed_objects(mut self, passed_objects: usize) -> Self {
         self.passed_objects = Some(passed_objects);