From 31a08518881778cddb422532b1a5f0c48aa89adc Mon Sep 17 00:00:00 2001 From: Doc Date: Sat, 8 Nov 2025 19:29:36 -0300 Subject: [PATCH 01/14] Add MorePreconditions for float checks --- .../papermc/paper/util/MorePreconditions.java | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 paper-api/src/main/java/io/papermc/paper/util/MorePreconditions.java diff --git a/paper-api/src/main/java/io/papermc/paper/util/MorePreconditions.java b/paper-api/src/main/java/io/papermc/paper/util/MorePreconditions.java new file mode 100644 index 000000000000..22ec45d3e705 --- /dev/null +++ b/paper-api/src/main/java/io/papermc/paper/util/MorePreconditions.java @@ -0,0 +1,48 @@ +package io.papermc.paper.util; + +import org.jetbrains.annotations.ApiStatus; +import org.jspecify.annotations.NullMarked; +import java.util.function.Function; + +@NullMarked +@ApiStatus.Internal +public final class MorePreconditions { + private MorePreconditions() { + } + + public static void validateFloatNonNegative(final float value, final String valueName) { + validateFloatRangeMinInclusive(value, 0.0F, Float.MAX_VALUE, _float -> String.format("%s value %.2f must be non-negative", valueName, value)); + } + + public static void validateFloatPositive(final float value, final String valueName) { + validateFloatRangeMinExclusive(value, 0.0F, Float.MAX_VALUE, _float -> String.format("%s value %.2f must be positive", valueName, value)); + } + + public static void validateFloatRangeMinInclusive(final float value, final float min, final float max, final String valueName) { + validateFloatRangeMinInclusive(value, min, max, _float -> String.format("%s value %.2f is out of range [%.2f, %.2f]", valueName, value, min, max)); + } + + private static void validateFloatRangeMinInclusive(final float value, final float min, final float max, Function errorMessage) { + if (!(Float.compare(value, min) >= 0 && Float.compare(value, max) <= 0)) { + throw new IllegalArgumentException(errorMessage.apply(value)); + } + } + + public static void validateFloatRangeMinExclusive(final float value, final float min, final float max, final String valueName) { + validateFloatRangeMinExclusive(value, min, max, _float -> String.format("%s value %.2f is out of range [%.2f, %.2f)", valueName, value, min, max)); + } + + private static void validateFloatRangeMinExclusive(final float value, final float min, final float max, Function errorMessage) { + if (!(Float.compare(value, min) > 0 && Float.compare(value, max) <= 0)) { + throw new IllegalArgumentException(errorMessage.apply(value)); + } + } + + public static void validateDoubleRange(final double value, final double min, final double max, final String valueName) { + if (Double.compare(value, min) < 0 || Double.compare(value, max) > 0) { + throw new IllegalArgumentException( + String.format("%s value %.2f is out of range [%.2f, %.2f]", valueName, value, min, max) + ); + } + } +} From 6d94b786c31bcf34def275c58fda43af63a4717f Mon Sep 17 00:00:00 2001 From: Doc Date: Sat, 8 Nov 2025 19:30:33 -0300 Subject: [PATCH 02/14] Use MorePreconditions in PaperBlocksAttacks --- .../paper/datacomponent/item/PaperBlocksAttacks.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperBlocksAttacks.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperBlocksAttacks.java index 4e78722f80d4..1b9fefbc2619 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperBlocksAttacks.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperBlocksAttacks.java @@ -1,6 +1,5 @@ package io.papermc.paper.datacomponent.item; -import com.google.common.base.Preconditions; import io.papermc.paper.adventure.PaperAdventure; import io.papermc.paper.datacomponent.item.blocksattacks.DamageReduction; import io.papermc.paper.datacomponent.item.blocksattacks.ItemDamageFunction; @@ -10,6 +9,7 @@ import io.papermc.paper.registry.tag.TagKey; import java.util.List; import java.util.Optional; +import io.papermc.paper.util.MorePreconditions; import it.unimi.dsi.fastutil.objects.ObjectArrayList; import net.kyori.adventure.key.Key; import org.bukkit.craftbukkit.util.Handleable; @@ -73,14 +73,14 @@ static final class BuilderImpl implements Builder { @Override public Builder blockDelaySeconds(final float delay) { - Preconditions.checkArgument(delay >= 0, "delay must be non-negative, was %s", delay); + MorePreconditions.validateFloatNonNegative(delay, "delay"); this.blockDelaySeconds = delay; return this; } @Override public Builder disableCooldownScale(final float scale) { - Preconditions.checkArgument(scale >= 0, "scale must be non-negative, was %s", scale); + MorePreconditions.validateFloatNonNegative(scale, "scale"); this.disableCooldownScale = scale; return this; } From 6f3bed61e793429a5006b9734bb7ff4a876b29fa Mon Sep 17 00:00:00 2001 From: Doc Date: Sat, 8 Nov 2025 19:35:24 -0300 Subject: [PATCH 03/14] Change error message --- .../io/papermc/paper/util/MorePreconditions.java | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/paper-api/src/main/java/io/papermc/paper/util/MorePreconditions.java b/paper-api/src/main/java/io/papermc/paper/util/MorePreconditions.java index 22ec45d3e705..c2af2943cf31 100644 --- a/paper-api/src/main/java/io/papermc/paper/util/MorePreconditions.java +++ b/paper-api/src/main/java/io/papermc/paper/util/MorePreconditions.java @@ -19,7 +19,7 @@ public static void validateFloatPositive(final float value, final String valueNa } public static void validateFloatRangeMinInclusive(final float value, final float min, final float max, final String valueName) { - validateFloatRangeMinInclusive(value, min, max, _float -> String.format("%s value %.2f is out of range [%.2f, %.2f]", valueName, value, min, max)); + validateFloatRangeMinInclusive(value, min, max, _float -> String.format("%s value %.2f is out of range (%.2f, %.2f]", valueName, value, min, max)); } private static void validateFloatRangeMinInclusive(final float value, final float min, final float max, Function errorMessage) { @@ -29,7 +29,7 @@ private static void validateFloatRangeMinInclusive(final float value, final floa } public static void validateFloatRangeMinExclusive(final float value, final float min, final float max, final String valueName) { - validateFloatRangeMinExclusive(value, min, max, _float -> String.format("%s value %.2f is out of range [%.2f, %.2f)", valueName, value, min, max)); + validateFloatRangeMinExclusive(value, min, max, _float -> String.format("%s value %.2f is out of range [%.2f, %.2f]", valueName, value, min, max)); } private static void validateFloatRangeMinExclusive(final float value, final float min, final float max, Function errorMessage) { @@ -37,12 +37,4 @@ private static void validateFloatRangeMinExclusive(final float value, final floa throw new IllegalArgumentException(errorMessage.apply(value)); } } - - public static void validateDoubleRange(final double value, final double min, final double max, final String valueName) { - if (Double.compare(value, min) < 0 || Double.compare(value, max) > 0) { - throw new IllegalArgumentException( - String.format("%s value %.2f is out of range [%.2f, %.2f]", valueName, value, min, max) - ); - } - } } From b40bc9c9b76c9b76ee89031cb03ad1458360a7ea Mon Sep 17 00:00:00 2001 From: Doc Date: Sat, 8 Nov 2025 22:16:05 -0300 Subject: [PATCH 04/14] Move logic to checks --- .../papermc/paper/util/MorePreconditions.java | 40 ------------------ .../paper/registry/data/util/Checks.java | 42 ++++++++++++++++++- 2 files changed, 40 insertions(+), 42 deletions(-) delete mode 100644 paper-api/src/main/java/io/papermc/paper/util/MorePreconditions.java diff --git a/paper-api/src/main/java/io/papermc/paper/util/MorePreconditions.java b/paper-api/src/main/java/io/papermc/paper/util/MorePreconditions.java deleted file mode 100644 index c2af2943cf31..000000000000 --- a/paper-api/src/main/java/io/papermc/paper/util/MorePreconditions.java +++ /dev/null @@ -1,40 +0,0 @@ -package io.papermc.paper.util; - -import org.jetbrains.annotations.ApiStatus; -import org.jspecify.annotations.NullMarked; -import java.util.function.Function; - -@NullMarked -@ApiStatus.Internal -public final class MorePreconditions { - private MorePreconditions() { - } - - public static void validateFloatNonNegative(final float value, final String valueName) { - validateFloatRangeMinInclusive(value, 0.0F, Float.MAX_VALUE, _float -> String.format("%s value %.2f must be non-negative", valueName, value)); - } - - public static void validateFloatPositive(final float value, final String valueName) { - validateFloatRangeMinExclusive(value, 0.0F, Float.MAX_VALUE, _float -> String.format("%s value %.2f must be positive", valueName, value)); - } - - public static void validateFloatRangeMinInclusive(final float value, final float min, final float max, final String valueName) { - validateFloatRangeMinInclusive(value, min, max, _float -> String.format("%s value %.2f is out of range (%.2f, %.2f]", valueName, value, min, max)); - } - - private static void validateFloatRangeMinInclusive(final float value, final float min, final float max, Function errorMessage) { - if (!(Float.compare(value, min) >= 0 && Float.compare(value, max) <= 0)) { - throw new IllegalArgumentException(errorMessage.apply(value)); - } - } - - public static void validateFloatRangeMinExclusive(final float value, final float min, final float max, final String valueName) { - validateFloatRangeMinExclusive(value, min, max, _float -> String.format("%s value %.2f is out of range [%.2f, %.2f]", valueName, value, min, max)); - } - - private static void validateFloatRangeMinExclusive(final float value, final float min, final float max, Function errorMessage) { - if (!(Float.compare(value, min) > 0 && Float.compare(value, max) <= 0)) { - throw new IllegalArgumentException(errorMessage.apply(value)); - } - } -} diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java b/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java index 24067e244502..049319939401 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java @@ -1,8 +1,10 @@ package io.papermc.paper.registry.data.util; import java.util.OptionalInt; +import org.jspecify.annotations.NullMarked; import org.jspecify.annotations.Nullable; +@NullMarked public final class Checks { public static T asConfigured(final @Nullable T value, final String field) { @@ -12,6 +14,7 @@ public static T asConfigured(final @Nullable T value, final String field) { return value; } + @SuppressWarnings("OptionalUsedAsFieldOrParameterType") public static int asConfigured(final OptionalInt value, final String field) { if (value.isEmpty()) { throw new IllegalStateException(field + " has not been configured"); @@ -40,9 +43,44 @@ public static int asArgumentMin(final int value, final String field, final int m return value; } + public static int asArgumentNonNegative(final int value, final String field) { + if (value < 0) { + throw new IllegalArgumentException("argument " + field + " must be non-negative"); + } + return value; + } + + public static int asArgumentPositive(final int value, final String field) { + if (value < 1) { + throw new IllegalArgumentException("argument " + field + " must be positive"); + } + return value; + } + + public static float asArgumentNonNegative(final float value, final String field) { + if (!(Float.compare(value, 0.0F) > 0 && Float.compare(value, Float.MAX_VALUE) <= 0)) { + throw new IllegalArgumentException("argument " + field + " must be non-negative"); + } + return value; + } + + public static float asArgumentPositive(final float value, final String field) { + if (!(Float.compare(value, 0.0F) >= 0 && Float.compare(value, Float.MAX_VALUE) <= 0)) { + throw new IllegalArgumentException("argument " + field + " must be positive"); + } + return value; + } + public static float asArgumentMinExclusive(final float value, final String field, final float min) { - if (value <= min) { - throw new IllegalArgumentException("argument " + field + " must be (" + min + ",+inf)"); + if (!(Float.compare(value, min) > 0)) { + throw new IllegalArgumentException("argument " + field + " must be (" + min + ",+inf]"); + } + return value; + } + + public static float asArgumentMinExclusive(final float value, final String field, final float min, final float max) { + if (!(Float.compare(value, min) > 0 && Float.compare(value, max) <= 0)) { + throw new IllegalArgumentException("argument " + field + " must be (" + min + "," + max +"]"); } return value; } From b6cfe242544923499a168d5d4a35df32a01422c1 Mon Sep 17 00:00:00 2001 From: Doc Date: Sat, 8 Nov 2025 22:16:40 -0300 Subject: [PATCH 05/14] Replace a few Preconditions with Checks --- .../paper/datacomponent/item/PaperBlocksAttacks.java | 9 ++++----- .../paper/datacomponent/item/PaperConsumable.java | 6 +++--- .../papermc/paper/datacomponent/item/PaperItemTool.java | 5 +++-- .../paper/datacomponent/item/PaperUseCooldown.java | 4 +++- .../io/papermc/paper/datacomponent/item/PaperWeapon.java | 9 ++++----- .../item/blocksattacks/PaperDamageReduction.java | 6 +++--- .../item/blocksattacks/PaperItemDamageFunction.java | 6 +++--- 7 files changed, 23 insertions(+), 22 deletions(-) diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperBlocksAttacks.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperBlocksAttacks.java index 1b9fefbc2619..dc3e7b70b54e 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperBlocksAttacks.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperBlocksAttacks.java @@ -9,13 +9,14 @@ import io.papermc.paper.registry.tag.TagKey; import java.util.List; import java.util.Optional; -import io.papermc.paper.util.MorePreconditions; import it.unimi.dsi.fastutil.objects.ObjectArrayList; import net.kyori.adventure.key.Key; import org.bukkit.craftbukkit.util.Handleable; import org.bukkit.damage.DamageType; import org.jspecify.annotations.Nullable; +import static io.papermc.paper.registry.data.util.Checks.asArgumentNonNegative; + public record PaperBlocksAttacks( net.minecraft.world.item.component.BlocksAttacks impl ) implements BlocksAttacks, Handleable { @@ -73,15 +74,13 @@ static final class BuilderImpl implements Builder { @Override public Builder blockDelaySeconds(final float delay) { - MorePreconditions.validateFloatNonNegative(delay, "delay"); - this.blockDelaySeconds = delay; + this.blockDelaySeconds = asArgumentNonNegative(delay, "delay"); return this; } @Override public Builder disableCooldownScale(final float scale) { - MorePreconditions.validateFloatNonNegative(scale, "scale"); - this.disableCooldownScale = scale; + this.disableCooldownScale = asArgumentNonNegative(scale, "scale"); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperConsumable.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperConsumable.java index d9043ba4caa1..ed7f1c284e41 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperConsumable.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperConsumable.java @@ -1,6 +1,5 @@ package io.papermc.paper.datacomponent.item; -import com.google.common.base.Preconditions; import io.papermc.paper.adventure.PaperAdventure; import io.papermc.paper.datacomponent.item.consumable.ConsumeEffect; import io.papermc.paper.datacomponent.item.consumable.ItemUseAnimation; @@ -16,6 +15,8 @@ import org.checkerframework.checker.index.qual.NonNegative; import org.jetbrains.annotations.Unmodifiable; +import static io.papermc.paper.registry.data.util.Checks.asArgumentNonNegative; + public record PaperConsumable( net.minecraft.world.item.component.Consumable impl ) implements Consumable, Handleable { @@ -73,8 +74,7 @@ static final class BuilderImpl implements Builder { @Override public Builder consumeSeconds(final @NonNegative float consumeSeconds) { - Preconditions.checkArgument(consumeSeconds >= 0, "consumeSeconds must be non-negative, was %s", consumeSeconds); - this.consumeSeconds = consumeSeconds; + this.consumeSeconds = asArgumentNonNegative(consumeSeconds, "consumeSeconds"); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperItemTool.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperItemTool.java index 2bb8166347e5..d45142ff9b2a 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperItemTool.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperItemTool.java @@ -17,6 +17,8 @@ import org.jetbrains.annotations.Unmodifiable; import org.jspecify.annotations.Nullable; +import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; + public record PaperItemTool( net.minecraft.world.item.component.Tool impl ) implements Tool, Handleable { @@ -57,8 +59,7 @@ public boolean canDestroyBlocksInCreative() { record PaperRule(RegistryKeySet blocks, @Nullable Float speed, TriState correctForDrops) implements Rule { public static PaperRule fromUnsafe(final RegistryKeySet blocks, final @Nullable Float speed, final TriState correctForDrops) { - Preconditions.checkArgument(speed == null || speed > 0, "speed must be positive"); - return new PaperRule(blocks, speed, correctForDrops); + return new PaperRule(blocks, (speed == null) ? null : asArgumentPositive(speed, "speed"), correctForDrops); } } diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperUseCooldown.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperUseCooldown.java index b5e2e7387431..1ce507eb50e7 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperUseCooldown.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperUseCooldown.java @@ -7,6 +7,8 @@ import org.bukkit.craftbukkit.util.Handleable; import org.jspecify.annotations.Nullable; +import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; + public record PaperUseCooldown( net.minecraft.world.item.component.UseCooldown impl ) implements UseCooldown, Handleable { @@ -34,7 +36,7 @@ static final class BuilderImpl implements Builder { private Optional cooldownGroup = Optional.empty(); BuilderImpl(final float seconds) { - this.seconds = seconds; + this.seconds = asArgumentPositive(seconds, "seconds"); } @Override diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperWeapon.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperWeapon.java index 0d3fb7aa0c99..3ae98854112c 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperWeapon.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperWeapon.java @@ -1,8 +1,9 @@ package io.papermc.paper.datacomponent.item; -import com.google.common.base.Preconditions; import org.bukkit.craftbukkit.util.Handleable; +import static io.papermc.paper.registry.data.util.Checks.asArgumentNonNegative; + public record PaperWeapon( net.minecraft.world.item.component.Weapon impl ) implements Weapon, Handleable { @@ -29,15 +30,13 @@ static final class BuilderImpl implements Builder { @Override public Builder itemDamagePerAttack(final int damage) { - Preconditions.checkArgument(damage >= 0, "damage must be non-negative, was %s", damage); - this.itemDamagePerAttack = damage; + this.itemDamagePerAttack = asArgumentNonNegative(damage, "damage"); return this; } @Override public Builder disableBlockingForSeconds(final float seconds) { - Preconditions.checkArgument(seconds >= 0, "seconds must be non-negative, was %s", seconds); - this.disableBlockingForSeconds = seconds; + this.disableBlockingForSeconds = asArgumentNonNegative(seconds, "seconds"); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperDamageReduction.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperDamageReduction.java index c34461d083c0..f4ff4d0fe369 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperDamageReduction.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperDamageReduction.java @@ -1,6 +1,5 @@ package io.papermc.paper.datacomponent.item.blocksattacks; -import com.google.common.base.Preconditions; import io.papermc.paper.registry.RegistryKey; import io.papermc.paper.registry.data.util.Conversions; import io.papermc.paper.registry.set.PaperRegistrySets; @@ -12,6 +11,8 @@ import org.checkerframework.checker.index.qual.Positive; import org.jspecify.annotations.Nullable; +import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; + public record PaperDamageReduction( net.minecraft.world.item.component.BlocksAttacks.DamageReduction internal ) implements DamageReduction { @@ -52,8 +53,7 @@ public Builder type(final @Nullable RegistryKeySet type) { @Override public Builder horizontalBlockingAngle(final @Positive float horizontalBlockingAngle) { - Preconditions.checkArgument(horizontalBlockingAngle > 0, "horizontalBlockingAngle must be positive and not zero, was %s", horizontalBlockingAngle); - this.horizontalBlockingAngle = horizontalBlockingAngle; + this.horizontalBlockingAngle = asArgumentPositive(horizontalBlockingAngle, "horizontalBlockingAngle"); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperItemDamageFunction.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperItemDamageFunction.java index 5982a7d3ede6..1543baff59b2 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperItemDamageFunction.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperItemDamageFunction.java @@ -1,9 +1,10 @@ package io.papermc.paper.datacomponent.item.blocksattacks; -import com.google.common.base.Preconditions; import net.minecraft.world.item.component.BlocksAttacks; import org.checkerframework.checker.index.qual.NonNegative; +import static io.papermc.paper.registry.data.util.Checks.asArgumentNonNegative; + public record PaperItemDamageFunction( net.minecraft.world.item.component.BlocksAttacks.ItemDamageFunction internal ) implements ItemDamageFunction { @@ -36,8 +37,7 @@ static final class BuilderImpl implements Builder { @Override public Builder threshold(final @NonNegative float threshold) { - Preconditions.checkArgument(threshold >= 0, "threshold must be non-negative, was %s", threshold); - this.threshold = threshold; + this.threshold = asArgumentNonNegative(threshold, "threshold"); return this; } From 64d9a2f9bbaad0171e4c4b01dc74e8fc4b29c6c6 Mon Sep 17 00:00:00 2001 From: Doc Date: Sat, 8 Nov 2025 22:16:51 -0300 Subject: [PATCH 06/14] Missing annotation for positive --- .../java/io/papermc/paper/datacomponent/item/UseCooldown.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/paper-api/src/main/java/io/papermc/paper/datacomponent/item/UseCooldown.java b/paper-api/src/main/java/io/papermc/paper/datacomponent/item/UseCooldown.java index 57fc55ad1def..72b2071da445 100644 --- a/paper-api/src/main/java/io/papermc/paper/datacomponent/item/UseCooldown.java +++ b/paper-api/src/main/java/io/papermc/paper/datacomponent/item/UseCooldown.java @@ -2,6 +2,7 @@ import io.papermc.paper.datacomponent.DataComponentBuilder; import net.kyori.adventure.key.Key; +import org.checkerframework.checker.index.qual.Positive; import org.jetbrains.annotations.ApiStatus; import org.jetbrains.annotations.Contract; import org.jspecify.annotations.NullMarked; @@ -23,7 +24,7 @@ public interface UseCooldown { * @return builder */ @Contract(value = "_ -> new", pure = true) - static UseCooldown.Builder useCooldown(final float seconds) { + static UseCooldown.Builder useCooldown(@Positive final float seconds) { return ItemComponentTypesBridge.bridge().useCooldown(seconds); } @@ -33,6 +34,7 @@ static UseCooldown.Builder useCooldown(final float seconds) { * @return cooldown seconds */ @Contract(pure = true) + @Positive float seconds(); /** From c3f0f0beda63c4ce41f9672b77885afabc64714b Mon Sep 17 00:00:00 2001 From: Doc Date: Sat, 8 Nov 2025 22:30:20 -0300 Subject: [PATCH 07/14] positive over min --- .../paper/registry/data/PaperInstrumentRegistryEntry.java | 6 +++--- .../paper/registry/data/PaperJukeboxSongRegistryEntry.java | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperInstrumentRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperInstrumentRegistryEntry.java index e8a43e93bb4d..c2f8ade560fb 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperInstrumentRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperInstrumentRegistryEntry.java @@ -19,7 +19,7 @@ import org.jspecify.annotations.Nullable; import static io.papermc.paper.registry.data.util.Checks.asArgument; -import static io.papermc.paper.registry.data.util.Checks.asArgumentMinExclusive; +import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperInstrumentRegistryEntry implements InstrumentRegistryEntry { @@ -89,13 +89,13 @@ public Builder soundEvent(final RegistryHolder s @Override public Builder duration(final @Positive float duration) { - this.useDuration = asArgumentMinExclusive(duration, "useDuration", 0); + this.useDuration = asArgumentPositive(duration, "useDuration"); return this; } @Override public Builder range(final @Positive float range) { - this.range = asArgumentMinExclusive(range, "range", 0); + this.range = asArgumentPositive(range, "range"); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperJukeboxSongRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperJukeboxSongRegistryEntry.java index 50a286fd2f1e..8b026658caa5 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperJukeboxSongRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperJukeboxSongRegistryEntry.java @@ -21,7 +21,7 @@ import org.jspecify.annotations.Nullable; import static io.papermc.paper.registry.data.util.Checks.asArgument; -import static io.papermc.paper.registry.data.util.Checks.asArgumentMinExclusive; +import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; import static io.papermc.paper.registry.data.util.Checks.asArgumentRange; import static io.papermc.paper.registry.data.util.Checks.asConfigured; @@ -98,7 +98,7 @@ public JukeboxSongRegistryEntry.Builder description(final net.kyori.adventure.te @Override public JukeboxSongRegistryEntry.Builder lengthInSeconds(final @Positive float lengthInSeconds) { - this.lengthInSeconds = asArgumentMinExclusive(lengthInSeconds, "lengthInSeconds", 0); + this.lengthInSeconds = asArgumentPositive(lengthInSeconds, "lengthInSeconds"); return this; } From d801d4c916d9c138305525292951dd8238a64686 Mon Sep 17 00:00:00 2001 From: Doc Date: Sat, 8 Nov 2025 22:41:00 -0300 Subject: [PATCH 08/14] alias for range float --- .../main/java/io/papermc/paper/registry/data/util/Checks.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java b/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java index 049319939401..d26796c65899 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java @@ -71,6 +71,10 @@ public static float asArgumentPositive(final float value, final String field) { return value; } + public static float asArgumentRange(final float value, final String field, final float min, final float max) { + return asArgumentMinExclusive(value, field, min, max); + } + public static float asArgumentMinExclusive(final float value, final String field, final float min) { if (!(Float.compare(value, min) > 0)) { throw new IllegalArgumentException("argument " + field + " must be (" + min + ",+inf]"); From a13f1e111acd22fae682fa68422338dd2e7a698a Mon Sep 17 00:00:00 2001 From: Doc Date: Sat, 8 Nov 2025 22:41:21 -0300 Subject: [PATCH 09/14] move preconditions to checks in NumberRangeDialogInputImpl --- .../dialog/input/NumberRangeDialogInputImpl.java | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/input/NumberRangeDialogInputImpl.java b/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/input/NumberRangeDialogInputImpl.java index b611d73fbbfb..2f353e3fc7ce 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/input/NumberRangeDialogInputImpl.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/input/NumberRangeDialogInputImpl.java @@ -6,6 +6,9 @@ import net.minecraft.server.dialog.body.PlainMessage; import org.jspecify.annotations.Nullable; +import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; +import static io.papermc.paper.registry.data.util.Checks.asArgumentRange; + public record NumberRangeDialogInputImpl( String key, int width, @@ -38,8 +41,7 @@ public BuilderImpl(final String key, final Component label, final float start, f @Override public BuilderImpl width(final int width) { - Preconditions.checkArgument(width >= 1 && width <= 1024, "width must be between 1 and 1024"); - this.width = width; + this.width = asArgumentRange(width, "width", 1, 1024); return this; } @@ -51,17 +53,13 @@ public BuilderImpl labelFormat(final String labelFormat) { @Override public BuilderImpl initial(final @Nullable Float initial) { - if (initial != null) { - Preconditions.checkArgument(initial >= this.start && initial <= this.end, "initial must be within the range"); - } - this.initial = initial; + this.initial = (initial == null ? null : asArgumentRange(initial, "initial", this.start, this.end)); return this; } @Override public BuilderImpl step(final @Nullable Float step) { - Preconditions.checkArgument(step == null || step > 0, "step must be null or greater than 0"); - this.step = step; + this.step = (step == null ? null : asArgumentPositive(step, "step")); return this; } From 94fd5a9e3ddd140dc6d842e67712b6243412f949 Mon Sep 17 00:00:00 2001 From: Doc Date: Sun, 9 Nov 2025 09:55:00 -0300 Subject: [PATCH 10/14] Cleanup for Checks --- .../paper/registry/data/util/Checks.java | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java b/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java index d26796c65899..38d3691423d2 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java @@ -58,35 +58,35 @@ public static int asArgumentPositive(final int value, final String field) { } public static float asArgumentNonNegative(final float value, final String field) { - if (!(Float.compare(value, 0.0F) > 0 && Float.compare(value, Float.MAX_VALUE) <= 0)) { - throw new IllegalArgumentException("argument " + field + " must be non-negative"); + if (Float.compare(value, 0.0F) > 0 && Float.compare(value, Float.MAX_VALUE) <= 0) { + return value; } - return value; + throw new IllegalArgumentException("argument " + field + " must be non-negative"); } public static float asArgumentPositive(final float value, final String field) { - if (!(Float.compare(value, 0.0F) >= 0 && Float.compare(value, Float.MAX_VALUE) <= 0)) { - throw new IllegalArgumentException("argument " + field + " must be positive"); + if (Float.compare(value, 0.0F) >= 0 && Float.compare(value, Float.MAX_VALUE) <= 0) { + return value; } - return value; + throw new IllegalArgumentException("argument " + field + " must be positive"); } public static float asArgumentRange(final float value, final String field, final float min, final float max) { return asArgumentMinExclusive(value, field, min, max); } - public static float asArgumentMinExclusive(final float value, final String field, final float min) { - if (!(Float.compare(value, min) > 0)) { - throw new IllegalArgumentException("argument " + field + " must be (" + min + ",+inf]"); + public static float asArgumentMinExclusive(final float value, final String field, final float min, final float max) { + if (Float.compare(value, min) > 0 && Float.compare(value, max) <= 0) { + return value; } - return value; + throw new IllegalArgumentException("argument " + field + " must be (" + min + "," + max +"]"); } - public static float asArgumentMinExclusive(final float value, final String field, final float min, final float max) { - if (!(Float.compare(value, min) > 0 && Float.compare(value, max) <= 0)) { - throw new IllegalArgumentException("argument " + field + " must be (" + min + "," + max +"]"); + public static float asArgumentMinInclusive(final float value, final String field, final float min, final float max) { + if (Float.compare(value, min) >= 0 && Float.compare(value, max) <= 0) { + return value; } - return value; + throw new IllegalArgumentException("argument " + field + " must be (" + min + "," + max +"]"); } private Checks() { From d748bda12139015c5ce150de79eab39ac9ef6e84 Mon Sep 17 00:00:00 2001 From: Doc Date: Sun, 9 Nov 2025 09:55:29 -0300 Subject: [PATCH 11/14] use Checks in ConsumableTypesBridgeImpl --- .../item/consumable/ConsumableTypesBridgeImpl.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/consumable/ConsumableTypesBridgeImpl.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/consumable/ConsumableTypesBridgeImpl.java index ab4d3d094789..c7bb5ce755ef 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/consumable/ConsumableTypesBridgeImpl.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/consumable/ConsumableTypesBridgeImpl.java @@ -1,6 +1,5 @@ package io.papermc.paper.datacomponent.item.consumable; -import com.google.common.base.Preconditions; import com.google.common.collect.Lists; import io.papermc.paper.adventure.PaperAdventure; import io.papermc.paper.registry.data.util.Conversions; @@ -15,16 +14,18 @@ import org.bukkit.potion.PotionEffectType; import org.jspecify.annotations.NullMarked; +import static io.papermc.paper.registry.data.util.Checks.asArgumentMinInclusive; +import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; + @NullMarked public class ConsumableTypesBridgeImpl implements ConsumableTypesBridge { @Override public ConsumeEffect.ApplyStatusEffects applyStatusEffects(final List effectList, final float probability) { - Preconditions.checkArgument(0 <= probability && probability <= 1, "probability must be between 0-1, was %s", probability); return new PaperApplyStatusEffects( new net.minecraft.world.item.consume_effects.ApplyStatusEffectsConsumeEffect( new ArrayList<>(Lists.transform(effectList, CraftPotionUtil::fromBukkit)), - probability + asArgumentMinInclusive(probability, "probability", 0.0F, 1.0F) ) ); } @@ -52,9 +53,8 @@ public ConsumeEffect.PlaySound playSoundEffect(final Key sound) { @Override public ConsumeEffect.TeleportRandomly teleportRandomlyEffect(final float diameter) { - Preconditions.checkArgument(diameter > 0, "diameter must be positive, was %s", diameter); return new PaperTeleportRandomly( - new net.minecraft.world.item.consume_effects.TeleportRandomlyConsumeEffect(diameter) + new net.minecraft.world.item.consume_effects.TeleportRandomlyConsumeEffect(asArgumentPositive(diameter, "diameter")) ); } } From 9aa0d2e196c57a305bb7536f0d71c7931c184d5f Mon Sep 17 00:00:00 2001 From: Doc Date: Sun, 9 Nov 2025 09:55:57 -0300 Subject: [PATCH 12/14] Change call of check for NumberRangeDialogInputImpl initial --- .../registry/data/dialog/input/NumberRangeDialogInputImpl.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/input/NumberRangeDialogInputImpl.java b/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/input/NumberRangeDialogInputImpl.java index 2f353e3fc7ce..769da3790053 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/input/NumberRangeDialogInputImpl.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/input/NumberRangeDialogInputImpl.java @@ -6,6 +6,7 @@ import net.minecraft.server.dialog.body.PlainMessage; import org.jspecify.annotations.Nullable; +import static io.papermc.paper.registry.data.util.Checks.asArgumentMinInclusive; import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; import static io.papermc.paper.registry.data.util.Checks.asArgumentRange; @@ -53,7 +54,7 @@ public BuilderImpl labelFormat(final String labelFormat) { @Override public BuilderImpl initial(final @Nullable Float initial) { - this.initial = (initial == null ? null : asArgumentRange(initial, "initial", this.start, this.end)); + this.initial = (initial == null ? null : asArgumentMinInclusive(initial, "initial", this.start, this.end)); return this; } From 5af3de2f757e2e425ee19c25c7da80a09e8e1744 Mon Sep 17 00:00:00 2001 From: Doc Date: Sun, 9 Nov 2025 09:56:14 -0300 Subject: [PATCH 13/14] use Checks for PaperItemTool --- .../io/papermc/paper/datacomponent/item/PaperItemTool.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperItemTool.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperItemTool.java index d45142ff9b2a..f03aceebc691 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperItemTool.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperItemTool.java @@ -1,6 +1,5 @@ package io.papermc.paper.datacomponent.item; -import com.google.common.base.Preconditions; import io.papermc.paper.registry.RegistryKey; import io.papermc.paper.registry.data.util.Conversions; import io.papermc.paper.registry.set.PaperRegistrySets; @@ -17,6 +16,7 @@ import org.jetbrains.annotations.Unmodifiable; import org.jspecify.annotations.Nullable; +import static io.papermc.paper.registry.data.util.Checks.asArgumentNonNegative; import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; public record PaperItemTool( @@ -72,8 +72,7 @@ static final class BuilderImpl implements Builder { @Override public Builder damagePerBlock(final int damage) { - Preconditions.checkArgument(damage >= 0, "damage must be non-negative, was %s", damage); - this.damage = damage; + this.damage = asArgumentNonNegative(damage, "damage"); return this; } From c643f5ecb2a9036f0fdd1cf6fd0a2e67ef584557 Mon Sep 17 00:00:00 2001 From: Doc Date: Thu, 13 Nov 2025 11:17:43 -0300 Subject: [PATCH 14/14] Rename the lynx --- .../item/PaperBlocksAttacks.java | 6 ++--- .../datacomponent/item/PaperConsumable.java | 4 ++-- .../datacomponent/item/PaperItemTool.java | 9 ++++---- .../datacomponent/item/PaperUseCooldown.java | 4 ++-- .../paper/datacomponent/item/PaperWeapon.java | 7 +++--- .../blocksattacks/PaperDamageReduction.java | 4 ++-- .../PaperItemDamageFunction.java | 4 ++-- .../consumable/ConsumableTypesBridgeImpl.java | 8 +++---- .../data/PaperBannerPatternRegistryEntry.java | 4 ++-- .../data/PaperCatTypeRegistryEntry.java | 4 ++-- .../PaperChickenVariantRegistryEntry.java | 6 ++--- .../data/PaperCowVariantRegistryEntry.java | 6 ++--- .../data/PaperDamageTypeRegistryEntry.java | 10 ++++----- .../data/PaperEnchantmentRegistryEntry.java | 22 +++++++++---------- .../data/PaperFrogVariantRegistryEntry.java | 4 ++-- .../data/PaperGameEventRegistryEntry.java | 4 ++-- .../data/PaperInstrumentRegistryEntry.java | 14 ++++++------ .../data/PaperJukeboxSongRegistryEntry.java | 17 +++++++------- .../PaperPaintingVariantRegistryEntry.java | 11 +++++----- .../data/PaperPigVariantRegistryEntry.java | 6 ++--- .../data/PaperSoundEventRegistryEntry.java | 4 ++-- .../data/PaperWolfVariantRegistryEntry.java | 8 +++---- .../data/dialog/PaperDialogRegistryEntry.java | 6 ++--- .../input/NumberRangeDialogInputImpl.java | 13 ++++++----- .../paper/registry/data/util/Checks.java | 22 +++++++++---------- 25 files changed, 106 insertions(+), 101 deletions(-) diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperBlocksAttacks.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperBlocksAttacks.java index dc3e7b70b54e..9ae04b0b4019 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperBlocksAttacks.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperBlocksAttacks.java @@ -15,7 +15,7 @@ import org.bukkit.damage.DamageType; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgumentNonNegative; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentNonNegative; public record PaperBlocksAttacks( net.minecraft.world.item.component.BlocksAttacks impl @@ -74,13 +74,13 @@ static final class BuilderImpl implements Builder { @Override public Builder blockDelaySeconds(final float delay) { - this.blockDelaySeconds = asArgumentNonNegative(delay, "delay"); + this.blockDelaySeconds = requireArgumentNonNegative(delay, "delay"); return this; } @Override public Builder disableCooldownScale(final float scale) { - this.disableCooldownScale = asArgumentNonNegative(scale, "scale"); + this.disableCooldownScale = requireArgumentNonNegative(scale, "scale"); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperConsumable.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperConsumable.java index ed7f1c284e41..5fa2574fd6a1 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperConsumable.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperConsumable.java @@ -15,7 +15,7 @@ import org.checkerframework.checker.index.qual.NonNegative; import org.jetbrains.annotations.Unmodifiable; -import static io.papermc.paper.registry.data.util.Checks.asArgumentNonNegative; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentNonNegative; public record PaperConsumable( net.minecraft.world.item.component.Consumable impl @@ -74,7 +74,7 @@ static final class BuilderImpl implements Builder { @Override public Builder consumeSeconds(final @NonNegative float consumeSeconds) { - this.consumeSeconds = asArgumentNonNegative(consumeSeconds, "consumeSeconds"); + this.consumeSeconds = requireArgumentNonNegative(consumeSeconds, "consumeSeconds"); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperItemTool.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperItemTool.java index f03aceebc691..6517b776ebe5 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperItemTool.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperItemTool.java @@ -1,6 +1,7 @@ package io.papermc.paper.datacomponent.item; import io.papermc.paper.registry.RegistryKey; +import io.papermc.paper.registry.data.util.Checks; import io.papermc.paper.registry.data.util.Conversions; import io.papermc.paper.registry.set.PaperRegistrySets; import io.papermc.paper.registry.set.RegistryKeySet; @@ -16,8 +17,8 @@ import org.jetbrains.annotations.Unmodifiable; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgumentNonNegative; -import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentNonNegative; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentPositive; public record PaperItemTool( net.minecraft.world.item.component.Tool impl @@ -59,7 +60,7 @@ public boolean canDestroyBlocksInCreative() { record PaperRule(RegistryKeySet blocks, @Nullable Float speed, TriState correctForDrops) implements Rule { public static PaperRule fromUnsafe(final RegistryKeySet blocks, final @Nullable Float speed, final TriState correctForDrops) { - return new PaperRule(blocks, (speed == null) ? null : asArgumentPositive(speed, "speed"), correctForDrops); + return new PaperRule(blocks, (speed == null) ? null : requireArgumentPositive(speed, "speed"), correctForDrops); } } @@ -72,7 +73,7 @@ static final class BuilderImpl implements Builder { @Override public Builder damagePerBlock(final int damage) { - this.damage = asArgumentNonNegative(damage, "damage"); + this.damage = Checks.requireArgumentNonNegative(damage, "damage"); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperUseCooldown.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperUseCooldown.java index 1ce507eb50e7..e7f306060c3e 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperUseCooldown.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperUseCooldown.java @@ -7,7 +7,7 @@ import org.bukkit.craftbukkit.util.Handleable; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentPositive; public record PaperUseCooldown( net.minecraft.world.item.component.UseCooldown impl @@ -36,7 +36,7 @@ static final class BuilderImpl implements Builder { private Optional cooldownGroup = Optional.empty(); BuilderImpl(final float seconds) { - this.seconds = asArgumentPositive(seconds, "seconds"); + this.seconds = requireArgumentPositive(seconds, "seconds"); } @Override diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperWeapon.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperWeapon.java index 3ae98854112c..c35e214184dd 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperWeapon.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/PaperWeapon.java @@ -1,8 +1,9 @@ package io.papermc.paper.datacomponent.item; +import io.papermc.paper.registry.data.util.Checks; import org.bukkit.craftbukkit.util.Handleable; -import static io.papermc.paper.registry.data.util.Checks.asArgumentNonNegative; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentNonNegative; public record PaperWeapon( net.minecraft.world.item.component.Weapon impl @@ -30,13 +31,13 @@ static final class BuilderImpl implements Builder { @Override public Builder itemDamagePerAttack(final int damage) { - this.itemDamagePerAttack = asArgumentNonNegative(damage, "damage"); + this.itemDamagePerAttack = Checks.requireArgumentNonNegative(damage, "damage"); return this; } @Override public Builder disableBlockingForSeconds(final float seconds) { - this.disableBlockingForSeconds = asArgumentNonNegative(seconds, "seconds"); + this.disableBlockingForSeconds = requireArgumentNonNegative(seconds, "seconds"); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperDamageReduction.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperDamageReduction.java index f4ff4d0fe369..0b508d024a1c 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperDamageReduction.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperDamageReduction.java @@ -11,7 +11,7 @@ import org.checkerframework.checker.index.qual.Positive; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentPositive; public record PaperDamageReduction( net.minecraft.world.item.component.BlocksAttacks.DamageReduction internal @@ -53,7 +53,7 @@ public Builder type(final @Nullable RegistryKeySet type) { @Override public Builder horizontalBlockingAngle(final @Positive float horizontalBlockingAngle) { - this.horizontalBlockingAngle = asArgumentPositive(horizontalBlockingAngle, "horizontalBlockingAngle"); + this.horizontalBlockingAngle = requireArgumentPositive(horizontalBlockingAngle, "horizontalBlockingAngle"); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperItemDamageFunction.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperItemDamageFunction.java index 1543baff59b2..98b45fe56a78 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperItemDamageFunction.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/blocksattacks/PaperItemDamageFunction.java @@ -3,7 +3,7 @@ import net.minecraft.world.item.component.BlocksAttacks; import org.checkerframework.checker.index.qual.NonNegative; -import static io.papermc.paper.registry.data.util.Checks.asArgumentNonNegative; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentNonNegative; public record PaperItemDamageFunction( net.minecraft.world.item.component.BlocksAttacks.ItemDamageFunction internal @@ -37,7 +37,7 @@ static final class BuilderImpl implements Builder { @Override public Builder threshold(final @NonNegative float threshold) { - this.threshold = asArgumentNonNegative(threshold, "threshold"); + this.threshold = requireArgumentNonNegative(threshold, "threshold"); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/consumable/ConsumableTypesBridgeImpl.java b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/consumable/ConsumableTypesBridgeImpl.java index c7bb5ce755ef..29ae37f76eff 100644 --- a/paper-server/src/main/java/io/papermc/paper/datacomponent/item/consumable/ConsumableTypesBridgeImpl.java +++ b/paper-server/src/main/java/io/papermc/paper/datacomponent/item/consumable/ConsumableTypesBridgeImpl.java @@ -14,8 +14,8 @@ import org.bukkit.potion.PotionEffectType; import org.jspecify.annotations.NullMarked; -import static io.papermc.paper.registry.data.util.Checks.asArgumentMinInclusive; -import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentMinInclusive; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentPositive; @NullMarked public class ConsumableTypesBridgeImpl implements ConsumableTypesBridge { @@ -25,7 +25,7 @@ public ConsumeEffect.ApplyStatusEffects applyStatusEffects(final List(Lists.transform(effectList, CraftPotionUtil::fromBukkit)), - asArgumentMinInclusive(probability, "probability", 0.0F, 1.0F) + requireArgumentMinInclusive(probability, "probability", 0.0F, 1.0F) ) ); } @@ -54,7 +54,7 @@ public ConsumeEffect.PlaySound playSoundEffect(final Key sound) { @Override public ConsumeEffect.TeleportRandomly teleportRandomlyEffect(final float diameter) { return new PaperTeleportRandomly( - new net.minecraft.world.item.consume_effects.TeleportRandomlyConsumeEffect(asArgumentPositive(diameter, "diameter")) + new net.minecraft.world.item.consume_effects.TeleportRandomlyConsumeEffect(requireArgumentPositive(diameter, "diameter")) ); } } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperBannerPatternRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperBannerPatternRegistryEntry.java index 70d226a14a8d..d078beab0d70 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperBannerPatternRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperBannerPatternRegistryEntry.java @@ -44,13 +44,13 @@ public PaperBuilder(final Conversions conversions, final @Nullable BannerPattern @Override public Builder assetId(final Key assetId) { - this.assetId = PaperAdventure.asVanilla(asArgument(assetId, "assetId")); + this.assetId = PaperAdventure.asVanilla(requireArgument(assetId, "assetId")); return this; } @Override public Builder translationKey(final String translationKey) { - this.translationKey = asArgument(translationKey, "translationKey"); + this.translationKey = requireArgument(translationKey, "translationKey"); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperCatTypeRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperCatTypeRegistryEntry.java index 68fadaf8aa98..a6b6794736eb 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperCatTypeRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperCatTypeRegistryEntry.java @@ -9,7 +9,7 @@ import org.bukkit.entity.Cat; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgument; +import static io.papermc.paper.registry.data.util.Checks.requireArgument; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperCatTypeRegistryEntry implements CatTypeRegistryEntry { @@ -46,7 +46,7 @@ public PaperBuilder(final Conversions conversions, final @Nullable CatVariant in @Override public Builder clientTextureAsset(final ClientTextureAsset clientTextureAsset) { - this.clientTextureAsset = this.conversions.asVanilla(asArgument(clientTextureAsset, "clientTextureAsset")); + this.clientTextureAsset = this.conversions.asVanilla(requireArgument(clientTextureAsset, "clientTextureAsset")); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperChickenVariantRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperChickenVariantRegistryEntry.java index 000127f3b6b4..7a239ac35cde 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperChickenVariantRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperChickenVariantRegistryEntry.java @@ -10,7 +10,7 @@ import org.bukkit.entity.Chicken; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgument; +import static io.papermc.paper.registry.data.util.Checks.requireArgument; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperChickenVariantRegistryEntry implements ChickenVariantRegistryEntry { @@ -57,13 +57,13 @@ public PaperBuilder(final Conversions conversions, final @Nullable ChickenVarian @Override public Builder clientTextureAsset(final ClientTextureAsset clientTextureAsset) { - this.clientTextureAsset = this.conversions.asVanilla(asArgument(clientTextureAsset, "clientTextureAsset")); + this.clientTextureAsset = this.conversions.asVanilla(requireArgument(clientTextureAsset, "clientTextureAsset")); return this; } @Override public Builder model(final Model model) { - this.model = switch (asArgument(model, "model")) { + this.model = switch (requireArgument(model, "model")) { case NORMAL -> ChickenVariant.ModelType.NORMAL; case COLD -> ChickenVariant.ModelType.COLD; }; diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperCowVariantRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperCowVariantRegistryEntry.java index c168150e2c75..748a0b72319b 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperCowVariantRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperCowVariantRegistryEntry.java @@ -10,7 +10,7 @@ import org.bukkit.entity.Cow; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgument; +import static io.papermc.paper.registry.data.util.Checks.requireArgument; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperCowVariantRegistryEntry implements CowVariantRegistryEntry { @@ -58,13 +58,13 @@ public PaperBuilder(final Conversions conversions, final @Nullable CowVariant in @Override public Builder clientTextureAsset(final ClientTextureAsset clientTextureAsset) { - this.clientTextureAsset = this.conversions.asVanilla(asArgument(clientTextureAsset, "clientTextureAsset")); + this.clientTextureAsset = this.conversions.asVanilla(requireArgument(clientTextureAsset, "clientTextureAsset")); return this; } @Override public Builder model(final Model model) { - this.model = switch (asArgument(model, "model")) { + this.model = switch (requireArgument(model, "model")) { case NORMAL -> CowVariant.ModelType.NORMAL; case COLD -> CowVariant.ModelType.COLD; case WARM -> CowVariant.ModelType.WARM; diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperDamageTypeRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperDamageTypeRegistryEntry.java index 519b66de023c..8324b874bd20 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperDamageTypeRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperDamageTypeRegistryEntry.java @@ -11,7 +11,7 @@ import org.bukkit.damage.DamageEffect; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgument; +import static io.papermc.paper.registry.data.util.Checks.requireArgument; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperDamageTypeRegistryEntry implements DamageTypeRegistryEntry { @@ -71,13 +71,13 @@ public PaperBuilder(final Conversions conversions, final @Nullable DamageType in @Override public Builder messageId(final String messageId) { - this.messageId = asArgument(messageId, "messageId"); + this.messageId = requireArgument(messageId, "messageId"); return this; } @Override public Builder damageScaling(final org.bukkit.damage.DamageScaling scaling) { - this.scaling = CraftDamageType.damageScalingToNMS(asArgument(scaling, "scaling")); + this.scaling = CraftDamageType.damageScalingToNMS(requireArgument(scaling, "scaling")); return this; } @@ -89,13 +89,13 @@ public Builder exhaustion(final float exhaustion) { @Override public Builder damageEffect(final DamageEffect effect) { - this.effects = ((CraftDamageEffect) asArgument(effect, "effects")).getHandle(); + this.effects = ((CraftDamageEffect) requireArgument(effect, "effects")).getHandle(); return this; } @Override public Builder deathMessageType(final org.bukkit.damage.DeathMessageType deathMessageType) { - this.deathMessageType = CraftDamageType.deathMessageTypeToNMS(asArgument(deathMessageType, "deathMessageType")); + this.deathMessageType = CraftDamageType.deathMessageTypeToNMS(requireArgument(deathMessageType, "deathMessageType")); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperEnchantmentRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperEnchantmentRegistryEntry.java index 5b05108c5729..24b840e064a1 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperEnchantmentRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperEnchantmentRegistryEntry.java @@ -24,8 +24,8 @@ import org.jetbrains.annotations.Range; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgument; -import static io.papermc.paper.registry.data.util.Checks.asArgumentMin; +import static io.papermc.paper.registry.data.util.Checks.requireArgument; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentMin; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperEnchantmentRegistryEntry implements EnchantmentRegistryEntry { @@ -143,13 +143,13 @@ public PaperBuilder(final Conversions conversions, final @Nullable Enchantment i @Override public Builder description(final net.kyori.adventure.text.Component description) { - this.description = this.conversions.asVanilla(asArgument(description, "description")); + this.description = this.conversions.asVanilla(requireArgument(description, "description")); return this; } @Override public Builder supportedItems(final RegistryKeySet supportedItems) { - this.supportedItems = PaperRegistrySets.convertToNms(Registries.ITEM, this.conversions.lookup(), asArgument(supportedItems, "supportedItems")); + this.supportedItems = PaperRegistrySets.convertToNms(Registries.ITEM, this.conversions.lookup(), requireArgument(supportedItems, "supportedItems")); return this; } @@ -161,45 +161,45 @@ public Builder primaryItems(final @Nullable RegistryKeySet primaryItem @Override public Builder weight(final @Range(from = 1, to = 1024) int weight) { - this.weight = OptionalInt.of(Checks.asArgumentRange(weight, "weight", 1, 1024)); + this.weight = OptionalInt.of(Checks.requireArgumentRange(weight, "weight", 1, 1024)); return this; } @Override public Builder maxLevel(final @Range(from = 1, to = 255) int maxLevel) { - this.maxLevel = OptionalInt.of(Checks.asArgumentRange(maxLevel, "maxLevel", 1, 255)); + this.maxLevel = OptionalInt.of(Checks.requireArgumentRange(maxLevel, "maxLevel", 1, 255)); return this; } @Override public Builder minimumCost(final EnchantmentCost minimumCost) { - final EnchantmentCost validCost = asArgument(minimumCost, "minimumCost"); + final EnchantmentCost validCost = requireArgument(minimumCost, "minimumCost"); this.minimumCost = Enchantment.dynamicCost(validCost.baseCost(), validCost.additionalPerLevelCost()); return this; } @Override public Builder maximumCost(final EnchantmentCost maximumCost) { - final EnchantmentCost validCost = asArgument(maximumCost, "maximumCost"); + final EnchantmentCost validCost = requireArgument(maximumCost, "maximumCost"); this.maximumCost = Enchantment.dynamicCost(validCost.baseCost(), validCost.additionalPerLevelCost()); return this; } @Override public Builder anvilCost(final @Range(from = 0, to = Integer.MAX_VALUE) int anvilCost) { - this.anvilCost = OptionalInt.of(asArgumentMin(anvilCost, "anvilCost", 0)); + this.anvilCost = OptionalInt.of(requireArgumentMin(anvilCost, "anvilCost", 0)); return this; } @Override public Builder activeSlots(final Iterable activeSlots) { - this.activeSlots = Lists.newArrayList(Iterables.transform(asArgument(activeSlots, "activeSlots"), CraftEquipmentSlot::getNMSGroup)); + this.activeSlots = Lists.newArrayList(Iterables.transform(requireArgument(activeSlots, "activeSlots"), CraftEquipmentSlot::getNMSGroup)); return this; } @Override public Builder exclusiveWith(final RegistryKeySet exclusiveWith) { - this.exclusiveWith = PaperRegistrySets.convertToNms(Registries.ENCHANTMENT, this.conversions.lookup(), asArgument(exclusiveWith, "exclusiveWith")); + this.exclusiveWith = PaperRegistrySets.convertToNms(Registries.ENCHANTMENT, this.conversions.lookup(), requireArgument(exclusiveWith, "exclusiveWith")); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperFrogVariantRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperFrogVariantRegistryEntry.java index bd6a9b51c169..680f5991a328 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperFrogVariantRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperFrogVariantRegistryEntry.java @@ -9,7 +9,7 @@ import org.bukkit.entity.Frog; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgument; +import static io.papermc.paper.registry.data.util.Checks.requireArgument; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperFrogVariantRegistryEntry implements FrogVariantRegistryEntry { @@ -46,7 +46,7 @@ public PaperBuilder(final Conversions conversions, final @Nullable FrogVariant i @Override public Builder clientTextureAsset(final ClientTextureAsset clientTextureAsset) { - this.clientTextureAsset = this.conversions.asVanilla(asArgument(clientTextureAsset, "clientTextureAsset")); + this.clientTextureAsset = this.conversions.asVanilla(requireArgument(clientTextureAsset, "clientTextureAsset")); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperGameEventRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperGameEventRegistryEntry.java index 249c1b0dd4f1..615e2a25fa1c 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperGameEventRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperGameEventRegistryEntry.java @@ -7,7 +7,7 @@ import org.jetbrains.annotations.Range; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgumentMin; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentMin; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperGameEventRegistryEntry implements GameEventRegistryEntry { @@ -40,7 +40,7 @@ public PaperBuilder( @Override public GameEventRegistryEntry.Builder range(final @Range(from = 0, to = Integer.MAX_VALUE) int range) { - this.range = OptionalInt.of(asArgumentMin(range, "range", 0)); + this.range = OptionalInt.of(requireArgumentMin(range, "range", 0)); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperInstrumentRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperInstrumentRegistryEntry.java index c2f8ade560fb..2180a510f342 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperInstrumentRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperInstrumentRegistryEntry.java @@ -18,8 +18,8 @@ import org.checkerframework.checker.index.qual.Positive; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgument; -import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; +import static io.papermc.paper.registry.data.util.Checks.requireArgument; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentPositive; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperInstrumentRegistryEntry implements InstrumentRegistryEntry { @@ -71,13 +71,13 @@ public PaperBuilder(final Conversions conversions, final @Nullable Instrument in @Override public Builder soundEvent(final TypedKey soundEvent) { - this.soundEvent = this.conversions.getReferenceHolder(PaperRegistries.toNms(asArgument(soundEvent, "soundEvent"))); + this.soundEvent = this.conversions.getReferenceHolder(PaperRegistries.toNms(requireArgument(soundEvent, "soundEvent"))); return this; } @Override public Builder soundEvent(final Consumer> soundEvent) { - this.soundEvent = this.conversions.createHolderFromBuilder(RegistryKey.SOUND_EVENT, asArgument(soundEvent, "soundEvent")); + this.soundEvent = this.conversions.createHolderFromBuilder(RegistryKey.SOUND_EVENT, requireArgument(soundEvent, "soundEvent")); return this; } @@ -89,19 +89,19 @@ public Builder soundEvent(final RegistryHolder s @Override public Builder duration(final @Positive float duration) { - this.useDuration = asArgumentPositive(duration, "useDuration"); + this.useDuration = requireArgumentPositive(duration, "useDuration"); return this; } @Override public Builder range(final @Positive float range) { - this.range = asArgumentPositive(range, "range"); + this.range = requireArgumentPositive(range, "range"); return this; } @Override public Builder description(final net.kyori.adventure.text.Component description) { - this.description = this.conversions.asVanilla(asArgument(description, "description")); + this.description = this.conversions.asVanilla(requireArgument(description, "description")); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperJukeboxSongRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperJukeboxSongRegistryEntry.java index 8b026658caa5..325e26cb5414 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperJukeboxSongRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperJukeboxSongRegistryEntry.java @@ -5,6 +5,7 @@ import io.papermc.paper.registry.RegistryBuilderFactory; import io.papermc.paper.registry.RegistryKey; import io.papermc.paper.registry.TypedKey; +import io.papermc.paper.registry.data.util.Checks; import io.papermc.paper.registry.data.util.Conversions; import io.papermc.paper.registry.holder.PaperRegistryHolders; import io.papermc.paper.registry.holder.RegistryHolder; @@ -20,9 +21,9 @@ import org.jetbrains.annotations.Range; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgument; -import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; -import static io.papermc.paper.registry.data.util.Checks.asArgumentRange; +import static io.papermc.paper.registry.data.util.Checks.requireArgument; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentPositive; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentRange; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperJukeboxSongRegistryEntry implements JukeboxSongRegistryEntry { @@ -74,13 +75,13 @@ public PaperBuilder(final Conversions conversions, final @Nullable JukeboxSong i @Override public JukeboxSongRegistryEntry.Builder soundEvent(final TypedKey soundEvent) { - this.soundEvent = this.conversions.getReferenceHolder(PaperRegistries.toNms(asArgument(soundEvent, "soundEvent"))); + this.soundEvent = this.conversions.getReferenceHolder(PaperRegistries.toNms(requireArgument(soundEvent, "soundEvent"))); return this; } @Override public JukeboxSongRegistryEntry.Builder soundEvent(final Consumer> soundEvent) { - this.soundEvent = this.conversions.createHolderFromBuilder(RegistryKey.SOUND_EVENT, asArgument(soundEvent, "soundEvent")); + this.soundEvent = this.conversions.createHolderFromBuilder(RegistryKey.SOUND_EVENT, requireArgument(soundEvent, "soundEvent")); return this; } @@ -92,19 +93,19 @@ public Builder soundEvent(final RegistryHolder s @Override public JukeboxSongRegistryEntry.Builder description(final net.kyori.adventure.text.Component description) { - this.description = this.conversions.asVanilla(asArgument(description, "description")); + this.description = this.conversions.asVanilla(requireArgument(description, "description")); return this; } @Override public JukeboxSongRegistryEntry.Builder lengthInSeconds(final @Positive float lengthInSeconds) { - this.lengthInSeconds = asArgumentPositive(lengthInSeconds, "lengthInSeconds"); + this.lengthInSeconds = requireArgumentPositive(lengthInSeconds, "lengthInSeconds"); return this; } @Override public JukeboxSongRegistryEntry.Builder comparatorOutput(final @Range(from = 0, to = 15) int comparatorOutput) { - this.comparatorOutput = OptionalInt.of(asArgumentRange(comparatorOutput, "comparatorOutput", Redstone.SIGNAL_MIN, Redstone.SIGNAL_MAX)); + this.comparatorOutput = OptionalInt.of(Checks.requireArgumentRange(comparatorOutput, "comparatorOutput", Redstone.SIGNAL_MIN, Redstone.SIGNAL_MAX)); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperPaintingVariantRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperPaintingVariantRegistryEntry.java index 31430bfbec5b..3724ac37cc79 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperPaintingVariantRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperPaintingVariantRegistryEntry.java @@ -2,6 +2,7 @@ import io.papermc.paper.adventure.PaperAdventure; import io.papermc.paper.registry.PaperRegistryBuilder; +import io.papermc.paper.registry.data.util.Checks; import io.papermc.paper.registry.data.util.Conversions; import java.util.Optional; import java.util.OptionalInt; @@ -13,8 +14,8 @@ import org.jetbrains.annotations.Range; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgument; -import static io.papermc.paper.registry.data.util.Checks.asArgumentRange; +import static io.papermc.paper.registry.data.util.Checks.requireArgument; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentRange; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperPaintingVariantRegistryEntry implements PaintingVariantRegistryEntry { @@ -74,13 +75,13 @@ public PaperBuilder(final Conversions conversions, final @Nullable PaintingVaria @Override public Builder width(final @Range(from = 1, to = 16) int width) { - this.width = OptionalInt.of(asArgumentRange(width, "width", 1, 16)); + this.width = OptionalInt.of(Checks.requireArgumentRange(width, "width", 1, 16)); return this; } @Override public Builder height(final @Range(from = 1, to = 16) int height) { - this.height = OptionalInt.of(asArgumentRange(height, "height", 1, 16)); + this.height = OptionalInt.of(Checks.requireArgumentRange(height, "height", 1, 16)); return this; } @@ -98,7 +99,7 @@ public Builder author(final net.kyori.adventure.text.@Nullable Component author) @Override public Builder assetId(final Key assetId) { - this.assetId = PaperAdventure.asVanilla(asArgument(assetId, "assetId")); + this.assetId = PaperAdventure.asVanilla(requireArgument(assetId, "assetId")); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperPigVariantRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperPigVariantRegistryEntry.java index b43dcd08180d..2872564d5e58 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperPigVariantRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperPigVariantRegistryEntry.java @@ -10,7 +10,7 @@ import org.bukkit.entity.Pig; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgument; +import static io.papermc.paper.registry.data.util.Checks.requireArgument; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperPigVariantRegistryEntry implements PigVariantRegistryEntry { @@ -57,13 +57,13 @@ public PaperBuilder(final Conversions conversions, final @Nullable PigVariant in @Override public Builder clientTextureAsset(final ClientTextureAsset clientTextureAsset) { - this.clientTextureAsset = this.conversions.asVanilla(asArgument(clientTextureAsset, "clientTextureAsset")); + this.clientTextureAsset = this.conversions.asVanilla(requireArgument(clientTextureAsset, "clientTextureAsset")); return this; } @Override public Builder model(final Model model) { - this.model = switch (asArgument(model, "model")) { + this.model = switch (requireArgument(model, "model")) { case NORMAL -> PigVariant.ModelType.NORMAL; case COLD -> PigVariant.ModelType.COLD; }; diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperSoundEventRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperSoundEventRegistryEntry.java index 9590faa0c6c1..eb68b0f6a27b 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperSoundEventRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperSoundEventRegistryEntry.java @@ -10,7 +10,7 @@ import org.bukkit.Sound; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgument; +import static io.papermc.paper.registry.data.util.Checks.requireArgument; import static io.papermc.paper.registry.data.util.Checks.asConfigured; /** @@ -51,7 +51,7 @@ public PaperBuilder(final Conversions conversions, final @Nullable SoundEvent so @Override public SoundEventRegistryEntry.Builder location(final Key location) { - this.location = PaperAdventure.asVanilla(asArgument(location, "location")); + this.location = PaperAdventure.asVanilla(requireArgument(location, "location")); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperWolfVariantRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperWolfVariantRegistryEntry.java index cb7a976b4ad1..cb4c613603c0 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/PaperWolfVariantRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/PaperWolfVariantRegistryEntry.java @@ -9,7 +9,7 @@ import org.bukkit.entity.Wolf; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgument; +import static io.papermc.paper.registry.data.util.Checks.requireArgument; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperWolfVariantRegistryEntry implements WolfVariantRegistryEntry { @@ -60,19 +60,19 @@ public PaperBuilder(final Conversions conversions, final @Nullable WolfVariant i @Override public Builder angryClientTextureAsset(final ClientTextureAsset angryClientTextureAsset) { - this.angryClientTextureAsset = this.conversions.asVanilla(asArgument(angryClientTextureAsset, "angryClientTextureAsset")); + this.angryClientTextureAsset = this.conversions.asVanilla(requireArgument(angryClientTextureAsset, "angryClientTextureAsset")); return this; } @Override public Builder wildClientTextureAsset(final ClientTextureAsset wildClientTextureAsset) { - this.wildClientTextureAsset = this.conversions.asVanilla(asArgument(wildClientTextureAsset, "wildClientTextureAsset")); + this.wildClientTextureAsset = this.conversions.asVanilla(requireArgument(wildClientTextureAsset, "wildClientTextureAsset")); return this; } @Override public Builder tameClientTextureAsset(final ClientTextureAsset tameClientTextureAsset) { - this.tameClientTextureAsset = this.conversions.asVanilla(asArgument(tameClientTextureAsset, "tameClientTextureAsset")); + this.tameClientTextureAsset = this.conversions.asVanilla(requireArgument(tameClientTextureAsset, "tameClientTextureAsset")); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/PaperDialogRegistryEntry.java b/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/PaperDialogRegistryEntry.java index d0160cf7fa73..e042016b8098 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/PaperDialogRegistryEntry.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/PaperDialogRegistryEntry.java @@ -10,7 +10,7 @@ import net.minecraft.server.dialog.Dialog; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgument; +import static io.papermc.paper.registry.data.util.Checks.requireArgument; import static io.papermc.paper.registry.data.util.Checks.asConfigured; public class PaperDialogRegistryEntry implements DialogRegistryEntry { @@ -56,13 +56,13 @@ public RegistryValueSetBuilder registry @Override public Builder base(final DialogBase dialogBase) { - this.dialogBase = asArgument(dialogBase, "dialogBase"); + this.dialogBase = requireArgument(dialogBase, "dialogBase"); return this; } @Override public Builder type(final DialogType dialogType) { - this.dialogType = asArgument(dialogType, "dialogType"); + this.dialogType = requireArgument(dialogType, "dialogType"); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/input/NumberRangeDialogInputImpl.java b/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/input/NumberRangeDialogInputImpl.java index 769da3790053..e0daa6b8c8ba 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/input/NumberRangeDialogInputImpl.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/dialog/input/NumberRangeDialogInputImpl.java @@ -1,14 +1,15 @@ package io.papermc.paper.registry.data.dialog.input; import com.google.common.base.Preconditions; +import io.papermc.paper.registry.data.util.Checks; import net.kyori.adventure.text.Component; import net.minecraft.commands.functions.StringTemplate; import net.minecraft.server.dialog.body.PlainMessage; import org.jspecify.annotations.Nullable; -import static io.papermc.paper.registry.data.util.Checks.asArgumentMinInclusive; -import static io.papermc.paper.registry.data.util.Checks.asArgumentPositive; -import static io.papermc.paper.registry.data.util.Checks.asArgumentRange; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentMinInclusive; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentPositive; +import static io.papermc.paper.registry.data.util.Checks.requireArgumentRange; public record NumberRangeDialogInputImpl( String key, @@ -42,7 +43,7 @@ public BuilderImpl(final String key, final Component label, final float start, f @Override public BuilderImpl width(final int width) { - this.width = asArgumentRange(width, "width", 1, 1024); + this.width = Checks.requireArgumentRange(width, "width", 1, 1024); return this; } @@ -54,13 +55,13 @@ public BuilderImpl labelFormat(final String labelFormat) { @Override public BuilderImpl initial(final @Nullable Float initial) { - this.initial = (initial == null ? null : asArgumentMinInclusive(initial, "initial", this.start, this.end)); + this.initial = (initial == null ? null : requireArgumentMinInclusive(initial, "initial", this.start, this.end)); return this; } @Override public BuilderImpl step(final @Nullable Float step) { - this.step = (step == null ? null : asArgumentPositive(step, "step")); + this.step = (step == null ? null : requireArgumentPositive(step, "step")); return this; } diff --git a/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java b/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java index 38d3691423d2..0ba066dea2df 100644 --- a/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java +++ b/paper-server/src/main/java/io/papermc/paper/registry/data/util/Checks.java @@ -22,67 +22,67 @@ public static int asConfigured(final OptionalInt value, final String field) { return value.getAsInt(); } - public static T asArgument(final @Nullable T value, final String field) { + public static T requireArgument(final @Nullable T value, final String field) { if (value == null) { throw new IllegalArgumentException("argument " + field + " cannot be null"); } return value; } - public static int asArgumentRange(final int value, final String field, final int min, final int max) { + public static int requireArgumentRange(final int value, final String field, final int min, final int max) { if (value < min || value > max) { throw new IllegalArgumentException("argument " + field + " must be [" + min + ", " + max + "]"); } return value; } - public static int asArgumentMin(final int value, final String field, final int min) { + public static int requireArgumentMin(final int value, final String field, final int min) { if (value < min) { throw new IllegalArgumentException("argument " + field + " must be [" + min + ",+inf)"); } return value; } - public static int asArgumentNonNegative(final int value, final String field) { + public static int requireArgumentNonNegative(final int value, final String field) { if (value < 0) { throw new IllegalArgumentException("argument " + field + " must be non-negative"); } return value; } - public static int asArgumentPositive(final int value, final String field) { + public static int requireArgumentPositive(final int value, final String field) { if (value < 1) { throw new IllegalArgumentException("argument " + field + " must be positive"); } return value; } - public static float asArgumentNonNegative(final float value, final String field) { + public static float requireArgumentNonNegative(final float value, final String field) { if (Float.compare(value, 0.0F) > 0 && Float.compare(value, Float.MAX_VALUE) <= 0) { return value; } throw new IllegalArgumentException("argument " + field + " must be non-negative"); } - public static float asArgumentPositive(final float value, final String field) { + public static float requireArgumentPositive(final float value, final String field) { if (Float.compare(value, 0.0F) >= 0 && Float.compare(value, Float.MAX_VALUE) <= 0) { return value; } throw new IllegalArgumentException("argument " + field + " must be positive"); } - public static float asArgumentRange(final float value, final String field, final float min, final float max) { - return asArgumentMinExclusive(value, field, min, max); + public static float requireArgumentRange(final float value, final String field, final float min, final float max) { + return requireArgumentMinExclusive(value, field, min, max); } - public static float asArgumentMinExclusive(final float value, final String field, final float min, final float max) { + public static float requireArgumentMinExclusive(final float value, final String field, final float min, final float max) { if (Float.compare(value, min) > 0 && Float.compare(value, max) <= 0) { return value; } throw new IllegalArgumentException("argument " + field + " must be (" + min + "," + max +"]"); } - public static float asArgumentMinInclusive(final float value, final String field, final float min, final float max) { + public static float requireArgumentMinInclusive(final float value, final String field, final float min, final float max) { if (Float.compare(value, min) >= 0 && Float.compare(value, max) <= 0) { return value; }