Upstream/Minestom
1
0
Fork 0
mirror of https://github.com/Minestom/Minestom.git synced 2024-06-26 06:24:54 +02:00
Code Issues Projects Releases Wiki Activity

Reduce boilerplate, add missing toString method

Browse Source
This commit is contained in:
Németh Noel 2021-08-10 22:18:11 +02:00
parent f489f95bb7
commit c94344a22e
5 changed files with 70 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
src/main/java/net/minestom/server/command/builder/arguments/number/ArgumentDouble.java
View File

@ -1,60 +1,11 @@
package net.minestom.server.command.builder.arguments.number;
import net.minestom.server.command.builder.NodeMaker;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.binary.BinaryWriter;
import org.jetbrains.annotations.NotNull;
public class ArgumentDouble extends ArgumentNumber<Double> {
public ArgumentDouble(String id) {
super(id);
}
@NotNull
@Override
public Double parse(@NotNull String input) throws ArgumentSyntaxException {
try {
final double value;
{
String parsed = parseValue(input);
int radix = getRadix(input);
if (radix != 10) {
value = (double) Long.parseLong(parsed, radix);
} else {
value = Double.parseDouble(parsed);
}
}
// Check range
if (hasMin && value < min) {
throw new ArgumentSyntaxException("Input is lower than the minimum required value", input, RANGE_ERROR);
}
if (hasMax && value > max) {
throw new ArgumentSyntaxException("Input is higher than the minimum required value", input, RANGE_ERROR);
}
return value;
} catch (NumberFormatException | NullPointerException e) {
throw new ArgumentSyntaxException("Input is not a number/long", input, NOT_NUMBER_ERROR);
}
}
@Override
public void processNodes(@NotNull NodeMaker nodeMaker, boolean executable) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(this, executable, false, false);
argumentNode.parser = "brigadier:double";
argumentNode.properties = BinaryWriter.makeArray(packetWriter -> {
packetWriter.writeByte(getNumberProperties());
if (this.hasMin())
packetWriter.writeDouble(this.getMin());
if (this.hasMax())
packetWriter.writeDouble(this.getMax());
});
nodeMaker.addNodes(new DeclareCommandsPacket.Node[]{argumentNode});
super(id, "brigadier:double", Double::parseDouble, ((s, radix) -> (double) Long.parseLong(s, radix)), BinaryWriter::writeDouble, Double::compare);
}
@Override

51
src/main/java/net/minestom/server/command/builder/arguments/number/ArgumentFloat.java
View File

@ -1,60 +1,11 @@
package net.minestom.server.command.builder.arguments.number;
import net.minestom.server.command.builder.NodeMaker;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.binary.BinaryWriter;
import org.jetbrains.annotations.NotNull;
public class ArgumentFloat extends ArgumentNumber<Float> {
public ArgumentFloat(String id) {
super(id);
}
@NotNull
@Override
public Float parse(@NotNull String input) throws ArgumentSyntaxException {
try {
final float value;
{
String parsed = parseValue(input);
int radix = getRadix(input);
if (radix != 10) {
value = (float) Integer.parseInt(parsed, radix);
} else {
value = Float.parseFloat(parsed);
}
}
// Check range
if (hasMin && value < min) {
throw new ArgumentSyntaxException("Input is lower than the minimum required value", input, RANGE_ERROR);
}
if (hasMax && value > max) {
throw new ArgumentSyntaxException("Input is higher than the minimum required value", input, RANGE_ERROR);
}
return value;
} catch (NumberFormatException | NullPointerException e) {
throw new ArgumentSyntaxException("Input is not a number/long", input, NOT_NUMBER_ERROR);
}
}
@Override
public void processNodes(@NotNull NodeMaker nodeMaker, boolean executable) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(this, executable, false, false);
argumentNode.parser = "brigadier:float";
argumentNode.properties = BinaryWriter.makeArray(packetWriter -> {
packetWriter.writeByte(getNumberProperties());
if (this.hasMin())
packetWriter.writeFloat(this.getMin());
if (this.hasMax())
packetWriter.writeFloat(this.getMax());
});
nodeMaker.addNodes(new DeclareCommandsPacket.Node[]{argumentNode});
super(id, "brigadier:float", Float::parseFloat, (s, radix) -> (float) Integer.parseInt(s, radix), BinaryWriter::writeFloat, Float::compare);
}
@Override

42
src/main/java/net/minestom/server/command/builder/arguments/number/ArgumentInteger.java
View File

@ -1,51 +1,11 @@
package net.minestom.server.command.builder.arguments.number;
import net.minestom.server.command.builder.NodeMaker;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.binary.BinaryWriter;
import org.jetbrains.annotations.NotNull;
public class ArgumentInteger extends ArgumentNumber<Integer> {
public ArgumentInteger(String id) {
super(id);
}
@NotNull
@Override
public Integer parse(@NotNull String input) throws ArgumentSyntaxException {
try {
final int value = Integer.parseInt(parseValue(input), getRadix(input));
// Check range
if (hasMin && value < min) {
throw new ArgumentSyntaxException("Input is lower than the minimum required value", input, RANGE_ERROR);
}
if (hasMax && value > max) {
throw new ArgumentSyntaxException("Input is higher than the minimum required value", input, RANGE_ERROR);
}
return value;
} catch (NumberFormatException | NullPointerException e) {
throw new ArgumentSyntaxException("Input is not a number/long", input, NOT_NUMBER_ERROR);
}
}
@Override
public void processNodes(@NotNull NodeMaker nodeMaker, boolean executable) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(this, executable, false, false);
argumentNode.parser = "brigadier:integer";
argumentNode.properties = BinaryWriter.makeArray(packetWriter -> {
packetWriter.writeByte(getNumberProperties());
if (this.hasMin())
packetWriter.writeInt(this.getMin());
if (this.hasMax())
packetWriter.writeInt(this.getMax());
});
nodeMaker.addNodes(new DeclareCommandsPacket.Node[]{argumentNode});
super(id, "brigadier:integer", Integer::parseInt, Integer::parseInt, BinaryWriter::writeInt, Integer::compare);
}
@Override

42
src/main/java/net/minestom/server/command/builder/arguments/number/ArgumentLong.java
View File

@ -1,51 +1,15 @@
package net.minestom.server.command.builder.arguments.number;
import net.minestom.server.command.builder.NodeMaker;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.binary.BinaryWriter;
import org.jetbrains.annotations.NotNull;
public class ArgumentLong extends ArgumentNumber<Long> {
public ArgumentLong(String id) {
super(id);
}
@NotNull
@Override
public Long parse(@NotNull String input) throws ArgumentSyntaxException {
try {
final long value = Long.parseLong(parseValue(input), getRadix(input));
// Check range
if (hasMin && value < min) {
throw new ArgumentSyntaxException("Input is lower than the minimum required value", input, RANGE_ERROR);
}
if (hasMax && value > max) {
throw new ArgumentSyntaxException("Input is higher than the minimum required value", input, RANGE_ERROR);
}
return value;
} catch (NumberFormatException | NullPointerException e) {
throw new ArgumentSyntaxException("Input is not a number/long", input, NOT_NUMBER_ERROR);
}
super(id, "brigadier:long", Long::parseLong, Long::parseLong, BinaryWriter::writeLong, Long::compare);
}
@Override
public void processNodes(@NotNull NodeMaker nodeMaker, boolean executable) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(this, executable, false, false);
argumentNode.parser = "brigadier:long";
argumentNode.properties = BinaryWriter.makeArray(packetWriter -> {
packetWriter.writeByte(getNumberProperties());
if (this.hasMin())
packetWriter.writeLong(this.getMin());
if (this.hasMax())
packetWriter.writeLong(this.getMax());
});
nodeMaker.addNodes(new DeclareCommandsPacket.Node[]{argumentNode});
public String toString() {
return String.format("Long<%s>", getId());
}
}

66
src/main/java/net/minestom/server/command/builder/arguments/number/ArgumentNumber.java
View File

@ -1,13 +1,21 @@
package net.minestom.server.command.builder.arguments.number;
import net.minestom.server.command.builder.NodeMaker;
import net.minestom.server.command.builder.arguments.Argument;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.binary.BinaryWriter;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.math.BigDecimal;
import java.util.Comparator;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.regex.Pattern;
public abstract class ArgumentNumber<T extends Number> extends Argument<T> {
public class ArgumentNumber<T extends Number> extends Argument<T> {
public static final int NOT_NUMBER_ERROR = 1;
public static final int RANGE_ERROR = 2;
@ -15,8 +23,62 @@ public abstract class ArgumentNumber<T extends Number> extends Argument<T> {
protected boolean hasMin, hasMax;
protected T min, max;
public ArgumentNumber(String id) {
protected final String parserName;
protected final BiFunction<String, Integer, T> radixParser;
protected final Function<String, T> parser;
protected final BiConsumer<BinaryWriter, T> propertiesWriter;
protected final Comparator<T> comparator;
ArgumentNumber(@NotNull String id, String parserName, Function<String, T> parser,
BiFunction<String, Integer, T> radixParser, BiConsumer<BinaryWriter, T> propertiesWriter,
Comparator<T> comparator) {
super(id);
this.parserName = parserName;
this.radixParser = radixParser;
this.parser = parser;
this.propertiesWriter = propertiesWriter;
this.comparator = comparator;
}
@Override
public @NotNull T parse(@NotNull String input) throws ArgumentSyntaxException {
try {
final T value;
final int radix = getRadix(input);
if (radix == 10) {
value = parser.apply(parseValue(input));
} else {
value = radixParser.apply(parseValue(input), radix);
}
// Check range
if (hasMin && comparator.compare(value, min) < 0) {
throw new ArgumentSyntaxException("Input is lower than the minimum required value", input, RANGE_ERROR);
}
if (hasMax && comparator.compare(value, max) > 0) {
throw new ArgumentSyntaxException("Input is higher than the minimum required value", input, RANGE_ERROR);
}
return value;
} catch (NumberFormatException | NullPointerException e) {
throw new ArgumentSyntaxException("Input is not a number/long", input, NOT_NUMBER_ERROR);
}
}
@Override
public void processNodes(@NotNull NodeMaker nodeMaker, boolean executable) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(this, executable, false, false);
argumentNode.parser = parserName;
argumentNode.properties = BinaryWriter.makeArray(packetWriter -> {
packetWriter.writeByte(getNumberProperties());
if (this.hasMin())
propertiesWriter.accept(packetWriter, getMin());
if (this.hasMax())
propertiesWriter.accept(packetWriter, getMax());
});
nodeMaker.addNodes(new DeclareCommandsPacket.Node[]{argumentNode});
}
@NotNull