cleanup events

Author: Lulu13022002

paper-api/src/main/java/com/destroystokyo/paper/event/player/PlayerSetSpawnEvent.java

@@ -109,7 +109,7 @@ public void setNotifyPlayer(final boolean notifyPlayer) {
 
     /**
      * Gets the notification message that will be sent to the player
-     * if {@link #willNotifyPlayer()} returns true.
+     * if {@link #willNotifyPlayer()} returns {@code true}.
      *
      * @return {@code null} if no notification
      */

paper-api/src/main/java/org/bukkit/World.java

@@ -69,7 +69,7 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
     void setVoidDamageEnabled(boolean enabled);
 
     /**
-     * Gets the damage applied to the player when they are in the void in this world.
+     * Gets the damage applied to the entities when they are in the void in this world.
      * Check {@link #isVoidDamageEnabled()} to see if void damage is enabled.
      *
      * @return amount of damage to apply
@@ -78,7 +78,7 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
     float getVoidDamageAmount();
 
     /**
-     * Sets the damage applied to the player when they are in the void in this world.
+     * Sets the damage applied to the entities when they are in the void in this world.
      * Check {@link #isVoidDamageEnabled()} to see if void damage is enabled.
      *
      * @param voidDamageAmount amount of damage to apply

paper-api/src/main/java/org/bukkit/entity/Entity.java

@@ -529,6 +529,7 @@ final class Holder {
      * @param event a {@link EntityDamageEvent}
      * @deprecated method is for internal use only and will be removed
      */
+    @ApiStatus.Internal
     @Deprecated(since = "1.20.4", forRemoval = true)
     public void setLastDamageCause(@Nullable EntityDamageEvent event);
 

paper-api/src/main/java/org/bukkit/entity/PigZombie.java

@@ -1,19 +1,21 @@
 package org.bukkit.entity;
 
+import org.jetbrains.annotations.Contract;
+
 /**
- * Represents a Pig Zombie.
+ * Represents a Zombified piglin.
  */
 public interface PigZombie extends Zombie {
 
     /**
-     * Get the pig zombie's current anger level.
+     * Get the zombified piglin's current anger level.
      *
      * @return The anger level.
      */
     int getAnger();
 
     /**
-     * Set the pig zombie's current anger level.
+     * Set the zombified piglin's current anger level.
      *
      * @param level The anger level. Higher levels of anger take longer to
      *     wear off.
@@ -23,29 +25,31 @@ public interface PigZombie extends Zombie {
     /**
      * Shorthand; sets to either 0 or the default level.
      *
-     * @param angry Whether the zombie should be angry.
+     * @param angry Whether the piglin should be angry.
      */
     void setAngry(boolean angry);
 
     /**
-     * Shorthand; gets whether the zombie is angry.
+     * Shorthand; gets whether the piglin is angry.
      *
-     * @return True if the zombie is angry, otherwise false.
+     * @return True if the piglin is angry, otherwise false.
      */
     boolean isAngry();
 
     /**
      * <b>Not applicable to this entity</b>
      *
-     * @return false
+     * @return {@code false}
      */
     @Override
+    @Contract("-> false")
     public boolean isConverting();
 
     /**
      * <b>Not applicable to this entity</b>
      */
     @Override
+    @Contract("-> fail")
     public int getConversionTime();
 
     /**
@@ -54,5 +58,6 @@ public interface PigZombie extends Zombie {
      * @param time unused
      */
     @Override
+    @Contract("_ -> fail")
     public void setConversionTime(int time);
 }

paper-api/src/main/java/org/bukkit/event/Cancellable.java

@@ -9,15 +9,15 @@ public interface Cancellable {
      * Gets the cancellation state of this event. A cancelled event will not
      * be executed in the server, but will still pass to other plugins
      *
-     * @return true if this event is cancelled
+     * @return {@code true} if this event is cancelled
      */
-    public boolean isCancelled();
+    boolean isCancelled();
 
     /**
      * Sets the cancellation state of this event. A cancelled event will not
      * be executed in the server, but will still pass to other plugins.
      *
-     * @param cancel true if you wish to cancel this event
+     * @param cancel {@code true} if you wish to cancel this event
      */
-    public void setCancelled(boolean cancel);
+    void setCancelled(boolean cancel);
 }

paper-api/src/main/java/org/bukkit/event/Event.java

@@ -1,20 +1,22 @@
 package org.bukkit.event;
 
+import org.bukkit.Bukkit;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.PluginManager;
 import org.jetbrains.annotations.NotNull;
 
 /**
  * Represents an event.
- *
+ * <br>
  * All events require a static method named getHandlerList() which returns the same {@link HandlerList} as {@link #getHandlers()}.
  *
  * @see PluginManager#callEvent(Event)
  * @see PluginManager#registerEvents(Listener,Plugin)
  */
 public abstract class Event {
+
     private String name;
-    private final boolean async;
+    private final boolean isAsync;
 
     /**
      * The default constructor is defined for cleaner code. This constructor
@@ -28,28 +30,26 @@ public Event() {
      * This constructor is used to explicitly declare an event as synchronous
      * or asynchronous.
      *
-     * @param isAsync true indicates the event will fire asynchronously, false
+     * @param isAsync {@code true} indicates the event will fire asynchronously, {@code false}
      *     by default from default constructor
      */
     public Event(boolean isAsync) {
-        this.async = isAsync;
+        this.isAsync = isAsync;
     }
 
-    // Paper start
     /**
      * Calls the event and tests if cancelled.
      *
-     * @return false if event was cancelled, if cancellable. otherwise true.
+     * @return {@code false} if event was cancelled, if cancellable. otherwise {@code true}.
      */
     public boolean callEvent() {
-        org.bukkit.Bukkit.getPluginManager().callEvent(this);
+        Bukkit.getPluginManager().callEvent(this);
         if (this instanceof Cancellable) {
             return !((Cancellable) this).isCancelled();
         } else {
             return true;
         }
     }
-    // Paper end
 
     /**
      * Convenience method for providing a user-friendly identifier. By
@@ -60,23 +60,23 @@ public boolean callEvent() {
      */
     @NotNull
     public String getEventName() {
-        if (name == null) {
-            name = getClass().getSimpleName();
+        if (this.name == null) {
+            this.name = this.getClass().getSimpleName();
         }
-        return name;
+        return this.name;
     }
 
     @NotNull
     public abstract HandlerList getHandlers();
 
     /**
-     * Any custom event that should not by synchronized with other events must
+     * Any custom event that should not be synchronized with other events must
      * use the specific constructor. These are the caveats of using an
      * asynchronous event:
      * <ul>
      * <li>The event is never fired from inside code triggered by a
      *     synchronous event. Attempting to do so results in an {@link
-     *     java.lang.IllegalStateException}.
+     *     IllegalStateException}.
      * <li>However, asynchronous event handlers may fire synchronous or
      *     asynchronous events
      * <li>The event may be fired multiple times simultaneously and in any
@@ -89,10 +89,10 @@ public String getEventName() {
      * <li>Asynchronous calls are not calculated in the plugin timing system.
      * </ul>
      *
-     * @return false by default, true if the event fires asynchronously
+     * @return {@code false} by default, {@code true} if the event fires asynchronously
      */
     public final boolean isAsynchronous() {
-        return async;
+        return this.isAsync;
     }
 
     public enum Result {
@@ -113,6 +113,6 @@ public enum Result {
          * take place if possible, even if the server would not normally allow
          * the action. Some actions may not be allowed.
          */
-        ALLOW;
+        ALLOW
     }
 }

paper-api/src/main/java/org/bukkit/event/EventException.java

@@ -44,7 +44,7 @@ public EventException(String message) {
     /**
      * If applicable, returns the Exception that triggered this Exception
      *
-     * @return Inner exception, or null if one does not exist
+     * @return Inner exception, or {@code null} if one does not exist
      */
     @Override
     public Throwable getCause() {

paper-api/src/main/java/org/bukkit/event/EventHandler.java

@@ -32,7 +32,7 @@
     /**
      * Define if the handler ignores a cancelled event.
      * <p>
-     * If ignoreCancelled is true and the event is cancelled, the method is
+     * If ignoreCancelled is {@code true} and the event is cancelled, the method is
      * not called. Otherwise, the method is always called.
      *
      * @return whether cancelled events should be ignored

paper-api/src/main/java/org/bukkit/event/EventPriority.java

@@ -43,7 +43,7 @@ public enum EventPriority {
 
     private final int slot;
 
-    private EventPriority(int slot) {
+    EventPriority(int slot) {
         this.slot = slot;
     }
 

paper-api/src/main/java/org/bukkit/event/HandlerList.java

@@ -31,14 +31,12 @@ public class HandlerList {
     /**
      * List of all HandlerLists which have been created, for use in bakeAll()
      */
-    private static ArrayList<HandlerList> allLists = new ArrayList<HandlerList>();
+    private static final ArrayList<HandlerList> allLists = new ArrayList<>();
 
-    // Paper start
     /**
      * Event types which have instantiated a {@link HandlerList}.
      */
     private static final java.util.Set<String> EVENT_TYPES = java.util.concurrent.ConcurrentHashMap.newKeySet();
-    // Paper end
 
     /**
      * Bake all handler lists. Best used just after all normal event
@@ -101,15 +99,14 @@ public static void unregisterAll(@NotNull Listener listener) {
      * The HandlerList is then added to meta-list for use in bakeAll()
      */
     public HandlerList() {
-        // Paper start
         java.lang.StackWalker.getInstance(java.util.EnumSet.of(java.lang.StackWalker.Option.RETAIN_CLASS_REFERENCE), 4)
             .walk(s -> s.filter(f -> Event.class.isAssignableFrom(f.getDeclaringClass())).findFirst())
             .map(f -> f.getDeclaringClass().getName())
             .ifPresent(EVENT_TYPES::add);
-        // Paper end
-        handlerslots = new EnumMap<EventPriority, ArrayList<RegisteredListener>>(EventPriority.class);
+
+        handlerslots = new EnumMap<>(EventPriority.class);
         for (EventPriority o : EventPriority.values()) {
-            handlerslots.put(o, new ArrayList<RegisteredListener>());
+            handlerslots.put(o, new ArrayList<>());
         }
         synchronized (allLists) {
             allLists.add(this);
@@ -191,7 +188,7 @@ public synchronized void unregister(@NotNull Listener listener) {
      */
     public synchronized void bake() {
         if (handlers != null) return; // don't re-bake when still valid
-        List<RegisteredListener> entries = new ArrayList<RegisteredListener>();
+        List<RegisteredListener> entries = new ArrayList<>();
         for (Entry<EventPriority, ArrayList<RegisteredListener>> entry : handlerslots.entrySet()) {
             entries.addAll(entry.getValue());
         }

paper-api/src/main/java/org/bukkit/event/block/BellResonateEvent.java

@@ -4,6 +4,7 @@
 import org.bukkit.block.Block;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 /**
@@ -12,16 +13,18 @@
  */
 public class BellResonateEvent extends BlockEvent {
 
-    private static final HandlerList handlers = new HandlerList();
+    private static final HandlerList HANDLER_LIST = new HandlerList();
+
     private final List<LivingEntity> resonatedEntities;
 
+    @ApiStatus.Internal
     public BellResonateEvent(@NotNull Block bell, @NotNull List<LivingEntity> resonatedEntities) {
         super(bell);
         this.resonatedEntities = resonatedEntities;
     }
 
     /**
-     * Get a mutable list of all {@link LivingEntity LivingEntities} to be
+     * Get a mutable list of all {@link LivingEntity entities} to be
      * highlighted by the bell's resonating. This list can be added to or
      * removed from to change which entities are highlighted, and may be empty
      * if no entities were resonated as a result of this event.
@@ -34,17 +37,17 @@ public BellResonateEvent(@NotNull Block bell, @NotNull List<LivingEntity> resona
      */
     @NotNull
     public List<LivingEntity> getResonatedEntities() {
-        return resonatedEntities;
+        return this.resonatedEntities;
     }
 
     @NotNull
     @Override
     public HandlerList getHandlers() {
-        return handlers;
+        return HANDLER_LIST;
     }
 
     @NotNull
     public static HandlerList getHandlerList() {
-        return handlers;
+        return HANDLER_LIST;
     }
 }

paper-api/src/main/java/org/bukkit/event/block/BellRingEvent.java

@@ -5,6 +5,7 @@
 import org.bukkit.entity.Entity;
 import org.bukkit.event.Cancellable;
 import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -13,11 +14,14 @@
  */
 public class BellRingEvent extends BlockEvent implements Cancellable {
 
-    private static final HandlerList handlers = new HandlerList();
+    private static final HandlerList HANDLER_LIST = new HandlerList();
+
     private final BlockFace direction;
     private final Entity entity;
+
     private boolean cancelled;
 
+    @ApiStatus.Internal
     public BellRingEvent(@NotNull Block block, @NotNull BlockFace direction, @Nullable Entity entity) {
         super(block);
         this.direction = direction;
@@ -57,11 +61,11 @@ public boolean isCancelled() {
     @NotNull
     @Override
     public HandlerList getHandlers() {
-        return handlers;
+        return HANDLER_LIST;
     }
 
     @NotNull
     public static HandlerList getHandlerList() {
-        return handlers;
+        return HANDLER_LIST;
     }
 }