Only allow adding modifiers

Author: Yeregorix

src/main/java/org/spongepowered/api/event/entity/DamageCalculationEvent.java

@@ -85,7 +85,7 @@ public interface DamageCalculationEvent extends Event, Cancellable {
     interface Pre extends DamageCalculationEvent {
 
         /**
-         * Gets a mutable list of all modifiers that applies just before the step.
+         * Gets an unmodifiable list of all modifiers that applies just before the step.
          *
          * @param type The step type
          * @return The list of modifiers
@@ -95,15 +95,33 @@ default List<DamageModifier> modifiersBefore(Supplier<DamageStepType> type) {
         }
 
         /**
-         * Gets a mutable list of all modifiers that applies just before the step.
+         * Gets an unmodifiable list of all modifiers that applies just before the step.
          *
          * @param type The step type
          * @return The list of modifiers
          */
         List<DamageModifier> modifiersBefore(DamageStepType type);
 
         /**
-         * Gets a mutable list of all modifiers that applies just after the step.
+         * Adds a modifier that applies just before the step.
+         *
+         * @param type The step type
+         * @param modifier The modifier
+         */
+        default void addModifierBefore(Supplier<DamageStepType> type, DamageModifier modifier) {
+            this.addModifierBefore(type.get(), modifier);
+        }
+
+        /**
+         * Adds a modifier that applies just before the step.
+         *
+         * @param type The step type
+         * @param modifier The modifier
+         */
+        void addModifierBefore(DamageStepType type, DamageModifier modifier);
+
+        /**
+         * Gets an unmodifiable list of all modifiers that applies just after the step.
          *
          * @param type The step type
          * @return The list of modifiers
@@ -113,12 +131,30 @@ default List<DamageModifier> modifiersAfter(Supplier<DamageStepType> type) {
         }
 
         /**
-         * Gets a mutable list of all modifiers that applies just after the step.
+         * Gets an unmodifiable list of all modifiers that applies just after the step.
          *
          * @param type The step type
          * @return The list of modifiers
          */
         List<DamageModifier> modifiersAfter(DamageStepType type);
+
+        /**
+         * Adds a modifier that applies just after the step.
+         *
+         * @param type The step type
+         * @param modifier The modifier
+         */
+        default void addModifierAfter(Supplier<DamageStepType> type, DamageModifier modifier) {
+            this.addModifierAfter(type.get(), modifier);
+        }
+
+        /**
+         * Adds a modifier that applies just after the step.
+         *
+         * @param type The step type
+         * @param modifier The modifier
+         */
+        void addModifierAfter(DamageStepType type, DamageModifier modifier);
     }
 
     /**

src/main/java/org/spongepowered/api/event/impl/entity/AbstractDamageCalculationEventPre.java

@@ -29,6 +29,7 @@
 import org.spongepowered.api.event.entity.DamageCalculationEvent;
 import org.spongepowered.api.event.impl.AbstractEvent;
 
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
@@ -38,13 +39,31 @@ public abstract class AbstractDamageCalculationEventPre extends AbstractEvent im
     private final Map<DamageStepType, List<DamageModifier>> modifiersBeforeMap = new HashMap<>();
     private final Map<DamageStepType, List<DamageModifier>> modifiersAfterMap = new HashMap<>();
 
+    private List<DamageModifier> getModifiersBefore(DamageStepType type) {
+        return this.modifiersBeforeMap.computeIfAbsent(type, k -> new LinkedList<>());
+    }
+
+    private List<DamageModifier> getModifiersAfter(DamageStepType type) {
+        return this.modifiersAfterMap.computeIfAbsent(type, k -> new LinkedList<>());
+    }
+
     @Override
     public List<DamageModifier> modifiersBefore(DamageStepType type) {
-        return this.modifiersBeforeMap.computeIfAbsent(type, k -> new LinkedList<>());
+        return Collections.unmodifiableList(this.getModifiersBefore(type));
     }
 
     @Override
     public List<DamageModifier> modifiersAfter(DamageStepType type) {
-        return this.modifiersAfterMap.computeIfAbsent(type, k -> new LinkedList<>());
+        return Collections.unmodifiableList(this.getModifiersAfter(type));
+    }
+
+    @Override
+    public void addModifierBefore(DamageStepType type, DamageModifier modifier) {
+        this.getModifiersBefore(type).addFirst(modifier);
+    }
+
+    @Override
+    public void addModifierAfter(DamageStepType type, DamageModifier modifier) {
+        this.getModifiersAfter(type).addLast(modifier);
     }
 }