Reformat code comments for consistency and clarity across all classes

src/main/java/dev/coph/nextusweb/server/ratelimit/RateLimitGate.java

@@ -22,14 +22,22 @@ import java.util.concurrent.TimeUnit;
  */
 public final class RateLimitGate {
 
-    /** Default idle age after which per-key limiter state is eligible for eviction. */
+    /**
+     * Default idle age after which per-key limiter state is eligible for eviction.
+     */
     private static final long DEFAULT_STALE_AFTER_NANOS = 10L * 60 * 1_000_000_000L;
 
-    /** The rule set this gate enforces. */
+    /**
+     * The rule set this gate enforces.
+     */
     private final RateLimitConfig config;
-    /** Idle age (nanoseconds) after which a limiter's per-key state may be evicted. */
+    /**
+     * Idle age (nanoseconds) after which a limiter's per-key state may be evicted.
+     */
     private final long staleAfterNanos;
-    /** Single-threaded scheduler driving periodic cleanup of stale buckets. */
+    /**
+     * Single-threaded scheduler driving periodic cleanup of stale buckets.
+     */
     private final ScheduledExecutorService cleanup;
 
     /**
@@ -62,6 +70,38 @@ public final class RateLimitGate {
         cleanup.scheduleAtFixedRate(this::doCleanup, 5, 5, TimeUnit.MINUTES);
     }
 
+    /**
+     * Periodic cleanup hook invoked by the background scheduler. Asks every configured limiter to
+     * evict per-key state idle for longer than {@link #staleAfterNanos}. A failure cleaning one
+     * limiter must not abort the others or kill the scheduler, so each call is guarded.
+     */
+    private void doCleanup() {
+        for (RateLimiter limiter : config.allLimiters()) {
+            try {
+                limiter.cleanup(staleAfterNanos);
+            } catch (RuntimeException ignored) {
+            }
+        }
+    }
+
+    /**
+     * Writes the standard rate-limit headers ({@code X-RateLimit-Limit},
+     * {@code X-RateLimit-Remaining}, and {@code Retry-After} when denied) onto a response.
+     *
+     * <p>Does nothing when {@code result} is {@code null} (no rule applied). The retry hint is
+     * rounded up to whole seconds as required by the {@code Retry-After} header.</p>
+     *
+     * @param result the limiting result, may be {@code null}
+     * @param res    the response to decorate
+     */
+    public static void applyHeaders(RateLimiter.Result result, Response res) {
+        if (result == null) return;
+        res.header("X-RateLimit-Limit", String.valueOf(result.limit()));
+        res.header("X-RateLimit-Remaining", String.valueOf(Math.max(0, result.remaining())));
+        if (!result.allowed()) {
+            res.header("Retry-After", String.valueOf((result.retryAfterMillis() + 999) / 1000));
+        }
+    }
 
     /**
      * Evaluates all rules applicable to the given path and decides whether the request may
@@ -97,41 +137,10 @@ public final class RateLimitGate {
         return strictest;
     }
 
-    /**
-     * Writes the standard rate-limit headers ({@code X-RateLimit-Limit},
-     * {@code X-RateLimit-Remaining}, and {@code Retry-After} when denied) onto a response.
-     *
-     * <p>Does nothing when {@code result} is {@code null} (no rule applied). The retry hint is
-     * rounded up to whole seconds as required by the {@code Retry-After} header.</p>
-     *
-     * @param result the limiting result, may be {@code null}
-     * @param res    the response to decorate
-     */
-    public static void applyHeaders(RateLimiter.Result result, Response res) {
-        if (result == null) return;
-        res.header("X-RateLimit-Limit", String.valueOf(result.limit()));
-        res.header("X-RateLimit-Remaining", String.valueOf(Math.max(0, result.remaining())));
-        if (!result.allowed()) {
-            res.header("Retry-After", String.valueOf((result.retryAfterMillis() + 999) / 1000));
-        }
-    }
-
-    /**
-     * Periodic cleanup hook invoked by the background scheduler. Asks every configured limiter to
-     * evict per-key state idle for longer than {@link #staleAfterNanos}. A failure cleaning one
-     * limiter must not abort the others or kill the scheduler, so each call is guarded.
-     */
-    private void doCleanup() {
-        for (RateLimiter limiter : config.allLimiters()) {
-            try {
-                limiter.cleanup(staleAfterNanos);
-            } catch (RuntimeException ignored) {
-            }
-        }
-    }
-
     /**
      * Stops the background cleanup scheduler. Should be called when the server shuts down.
      */
-    public void shutdown() { cleanup.shutdown(); }
+    public void shutdown() {
+        cleanup.shutdown();
+    }
 }