zhdev/oblak
1
0
Fork 0
Code Issues Pull requests Activity

core: Improvements to number arguments (#255)

Browse source
This commit is contained in:
Jason 2021-04-28 15:18:33 -07:00 • committed by Jason
parent 343be0bf67
commit e109e639a1
8 changed files with 579 additions and 289 deletions
Download patch file Download diff file Expand all files Collapse all files

116
cloud-core/src/main/java/cloud/commandframework/arguments/standard/ByteArgument.java
View file

@ -59,7 +59,7 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
}
/**
* Create a new builder
* Create a new {@link Builder}.
*
* @param name Name of the argument
* @param <C> Command sender type
@ -70,7 +70,7 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
}
/**
* Create a new required command argument
* Create a new required {@link ByteArgument}.
*
* @param name Argument name
* @param <C> Command sender type
@ -81,7 +81,7 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
}
/**
* Create a new optional command argument
* Create a new optional {@link ByteArgument}.
*
* @param name Argument name
* @param <C> Command sender type
@ -92,7 +92,7 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
}
/**
* Create a new required command argument with a default value
* Create a new optional {@link ByteArgument} with the specified default value.
*
* @param name Argument name
* @param defaultNum Default num
@ -103,7 +103,7 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
final @NonNull String name,
final byte defaultNum
) {
return ByteArgument.<C>newBuilder(name).asOptionalWithDefault(Byte.toString(defaultNum)).build();
return ByteArgument.<C>newBuilder(name).asOptionalWithDefault(defaultNum).build();
}
/**
@ -126,8 +126,8 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
public static final class Builder<C> extends CommandArgument.Builder<C, Byte> {
private byte min = Byte.MIN_VALUE;
private byte max = Byte.MAX_VALUE;
private byte min = ByteParser.DEFAULT_MINIMUM;
private byte max = ByteParser.DEFAULT_MAXIMUM;
private Builder(final @NonNull String name) {
super(Byte.class, name);
@ -155,6 +155,18 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
return this;
}
/**
* Sets the command argument to be optional, with the specified default value.
*
* @param defaultValue default value
* @return this builder
* @see CommandArgument.Builder#asOptionalWithDefault(String)
* @since 1.5.0
*/
public @NonNull Builder<C> asOptionalWithDefault(final byte defaultValue) {
return (Builder<C>) this.asOptionalWithDefault(Byte.toString(defaultValue));
}
/**
* Builder a new byte argument
*
@ -171,6 +183,20 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
public static final class ByteParser<C> implements ArgumentParser<C, Byte> {
/**
* Constant for the default/unset minimum value.
*
* @since 1.5.0
*/
public static final byte DEFAULT_MINIMUM = Byte.MIN_VALUE;
/**
* Constant for the default/unset maximum value.
*
* @since 1.5.0
*/
public static final byte DEFAULT_MAXIMUM = Byte.MAX_VALUE;
private final byte min;
private final byte max;
@ -192,32 +218,17 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NoInputProvidedException(
ByteParser.class,
commandContext
));
return ArgumentParseResult.failure(new NoInputProvidedException(ByteParser.class, commandContext));
}
try {
final byte value = Byte.parseByte(input);
if (value < this.min || value > this.max) {
return ArgumentParseResult.failure(
new ByteParseException(
input,
this.min,
this.max,
commandContext
));
return ArgumentParseResult.failure(new ByteParseException(input, this, commandContext));
}
inputQueue.remove();
return ArgumentParseResult.success(value);
} catch (final Exception e) {
return ArgumentParseResult.failure(
new ByteParseException(
input,
this.min,
this.max,
commandContext
));
return ArgumentParseResult.failure(new ByteParseException(input, this, commandContext));
}
}
@ -252,6 +263,28 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
return this.min;
}
/**
* Get whether this parser has a maximum set.
* This will compare the parser's maximum to {@link #DEFAULT_MAXIMUM}.
*
* @return whether the parser has a maximum set
* @since 1.5.0
*/
public boolean hasMax() {
return this.max != DEFAULT_MAXIMUM;
}
/**
* Get whether this parser has a minimum set.
* This will compare the parser's minimum to {@link #DEFAULT_MINIMUM}.
*
* @return whether the parser has a maximum set
* @since 1.5.0
*/
public boolean hasMin() {
return this.min != DEFAULT_MINIMUM;
}
}
@ -262,6 +295,8 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
private static final long serialVersionUID = -4724241304872989208L;
private final ByteParser<?> parser;
/**
* Construct a new byte parse exception
*
@ -269,30 +304,43 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
* @param min Minimum value
* @param max Maximum value
* @param context Command context
* @deprecated use {@link #ByteParseException(String, ByteParser, CommandContext)} instead
*/
@Deprecated
public ByteParseException(
final @NonNull String input,
final byte min,
final byte max,
final @NonNull CommandContext<?> context
) {
super(
input,
min,
max,
ByteParser.class,
context
);
this(input, new ByteParser<>(min, max), context);
}
/**
* Create a new {@link ByteParseException}.
*
* @param input input string
* @param parser byte parser
* @param context command context
* @since 1.5.0
*/
public ByteParseException(
final @NonNull String input,
final @NonNull ByteParser<?> parser,
final @NonNull CommandContext<?> context
) {
super(input, parser.min, parser.max, ByteParser.class, context);
this.parser = parser;
}
@Override
public boolean hasMin() {
return this.getMin().byteValue() != Byte.MIN_VALUE;
return this.parser.hasMin();
}
@Override
public boolean hasMax() {
return this.getMax().byteValue() != Byte.MAX_VALUE;
return this.parser.hasMax();
}
@Override

114
cloud-core/src/main/java/cloud/commandframework/arguments/standard/DoubleArgument.java
View file

@ -59,7 +59,7 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
}
/**
* Create a new builder
* Create a new {@link Builder}.
*
* @param name Name of the argument
* @param <C> Command sender type
@ -70,7 +70,7 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
}
/**
* Create a new required command argument
* Create a new required {@link DoubleArgument}.
*
* @param name Argument name
* @param <C> Command sender type
@ -81,7 +81,7 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
}
/**
* Create a new optional command argument
* Create a new optional {@link DoubleArgument}.
*
* @param name Argument name
* @param <C> Command sender type
@ -92,7 +92,7 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
}
/**
* Create a new required command argument with a default value
* Create a new optional {@link DoubleArgument} with the specified default value.
*
* @param name Argument name
* @param defaultNum Default num
@ -103,7 +103,7 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
final @NonNull String name,
final double defaultNum
) {
return DoubleArgument.<C>newBuilder(name).asOptionalWithDefault(Double.toString(defaultNum)).build();
return DoubleArgument.<C>newBuilder(name).asOptionalWithDefault(defaultNum).build();
}
/**
@ -126,8 +126,8 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
public static final class Builder<C> extends CommandArgument.Builder<C, Double> {
private double min = Double.NEGATIVE_INFINITY;
private double max = Double.POSITIVE_INFINITY;
private double min = DoubleParser.DEFAULT_MINIMUM;
private double max = DoubleParser.DEFAULT_MAXIMUM;
private Builder(final @NonNull String name) {
super(Double.class, name);
@ -155,6 +155,18 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
return this;
}
/**
* Sets the command argument to be optional, with the specified default value.
*
* @param defaultValue default value
* @return this builder
* @see CommandArgument.Builder#asOptionalWithDefault(String)
* @since 1.5.0
*/
public @NonNull Builder<C> asOptionalWithDefault(final double defaultValue) {
return (Builder<C>) this.asOptionalWithDefault(Double.toString(defaultValue));
}
/**
* Builder a new double argument
*
@ -171,6 +183,20 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
public static final class DoubleParser<C> implements ArgumentParser<C, Double> {
/**
* Constant for the default/unset minimum value.
*
* @since 1.5.0
*/
public static final double DEFAULT_MINIMUM = Double.NEGATIVE_INFINITY;
/**
* Constant for the default/unset maximum value.
*
* @since 1.5.0
*/
public static final double DEFAULT_MAXIMUM = Double.POSITIVE_INFINITY;
private final double min;
private final double max;
@ -192,30 +218,17 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NoInputProvidedException(
DoubleParser.class,
commandContext
));
return ArgumentParseResult.failure(new NoInputProvidedException(DoubleParser.class, commandContext));
}
try {
final double value = Double.parseDouble(input);
if (value < this.min || value > this.max) {
return ArgumentParseResult.failure(new DoubleParseException(
input,
this.min,
this.max,
commandContext
));
return ArgumentParseResult.failure(new DoubleParseException(input, this, commandContext));
}
inputQueue.remove();
return ArgumentParseResult.success(value);
} catch (final Exception e) {
return ArgumentParseResult.failure(new DoubleParseException(
input,
this.min,
this.max,
commandContext
));
return ArgumentParseResult.failure(new DoubleParseException(input, this, commandContext));
}
}
@ -242,6 +255,28 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
return this.min;
}
/**
* Get whether this parser has a maximum set.
* This will compare the parser's maximum to {@link #DEFAULT_MAXIMUM}.
*
* @return whether the parser has a maximum set
* @since 1.5.0
*/
public boolean hasMax() {
return this.max != DEFAULT_MAXIMUM;
}
/**
* Get whether this parser has a minimum set.
* This will compare the parser's minimum to {@link #DEFAULT_MINIMUM}.
*
* @return whether the parser has a maximum set
* @since 1.5.0
*/
public boolean hasMin() {
return this.min != DEFAULT_MINIMUM;
}
}
@ -249,6 +284,8 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
private static final long serialVersionUID = 1764554911581976586L;
private final DoubleParser<?> parser;
/**
* Construct a new double parse exception
*
@ -256,30 +293,43 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
* @param min Minimum value
* @param max Maximum value
* @param commandContext Command context
* @deprecated use {@link #DoubleParseException(String, DoubleParser, CommandContext)} instead
*/
@Deprecated
public DoubleParseException(
final @NonNull String input,
final double min,
final double max,
final @NonNull CommandContext<?> commandContext
) {
super(
input,
min,
max,
DoubleParser.class,
commandContext
);
this(input, new DoubleParser<>(min, max), commandContext);
}
/**
* Create a new {@link DoubleParseException}.
*
* @param input input string
* @param parser double parser
* @param commandContext command context
* @since 1.5.0
*/
public DoubleParseException(
final @NonNull String input,
final @NonNull DoubleParser<?> parser,
final @NonNull CommandContext<?> commandContext
) {
super(input, parser.min, parser.max, DoubleParser.class, commandContext);
this.parser = parser;
}
@Override
public boolean hasMin() {
return this.getMin().doubleValue() != Double.MIN_VALUE;
return this.parser.hasMin();
}
@Override
public boolean hasMax() {
return this.getMax().doubleValue() != Double.MAX_VALUE;
return this.parser.hasMax();
}
@Override

113
cloud-core/src/main/java/cloud/commandframework/arguments/standard/FloatArgument.java
View file

@ -59,7 +59,7 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
}
/**
* Create a new builder
* Create a new {@link Builder}.
*
* @param name Name of the argument
* @param <C> Command sender type
@ -70,7 +70,7 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
}
/**
* Create a new required command argument
* Create a new required {@link FloatArgument}.
*
* @param name Argument name
* @param <C> Command sender type
@ -81,7 +81,7 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
}
/**
* Create a new optional command argument
* Create a new optional {@link FloatArgument}.
*
* @param name Argument name
* @param <C> Command sender type
@ -92,7 +92,7 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
}
/**
* Create a new required command argument with a default value
* Create a new optional {@link FloatArgument} with the specified default value.
*
* @param name Argument name
* @param defaultNum Default num
@ -103,7 +103,7 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
final @NonNull String name,
final float defaultNum
) {
return FloatArgument.<C>newBuilder(name).asOptionalWithDefault(Float.toString(defaultNum)).build();
return FloatArgument.<C>newBuilder(name).asOptionalWithDefault(defaultNum).build();
}
/**
@ -126,8 +126,8 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
public static final class Builder<C> extends CommandArgument.Builder<C, Float> {
private float min = Float.NEGATIVE_INFINITY;
private float max = Float.POSITIVE_INFINITY;
private float min = FloatParser.DEFAULT_MINIMUM;
private float max = FloatParser.DEFAULT_MAXIMUM;
private Builder(final @NonNull String name) {
super(Float.class, name);
@ -156,10 +156,17 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
}
/**
* Builder a new float argument
* Sets the command argument to be optional, with the specified default value.
*
* @return Constructed argument
* @param defaultValue default value
* @return this builder
* @see CommandArgument.Builder#asOptionalWithDefault(String)
* @since 1.5.0
*/
public @NonNull Builder<C> asOptionalWithDefault(final float defaultValue) {
return (Builder<C>) this.asOptionalWithDefault(Float.toString(defaultValue));
}
@Override
public @NonNull FloatArgument<C> build() {
return new FloatArgument<>(this.isRequired(), this.getName(), this.min, this.max,
@ -171,6 +178,20 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
public static final class FloatParser<C> implements ArgumentParser<C, Float> {
/**
* Constant for the default/unset minimum value.
*
* @since 1.5.0
*/
public static final float DEFAULT_MINIMUM = Float.NEGATIVE_INFINITY;
/**
* Constant for the default/unset maximum value.
*
* @since 1.5.0
*/
public static final float DEFAULT_MAXIMUM = Float.POSITIVE_INFINITY;
private final float min;
private final float max;
@ -192,30 +213,17 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NoInputProvidedException(
FloatParser.class,
commandContext
));
return ArgumentParseResult.failure(new NoInputProvidedException(FloatParser.class, commandContext));
}
try {
final float value = Float.parseFloat(input);
if (value < this.min || value > this.max) {
return ArgumentParseResult.failure(new FloatParseException(
input,
this.min,
this.max,
commandContext
));
return ArgumentParseResult.failure(new FloatParseException(input, this, commandContext));
}
inputQueue.remove();
return ArgumentParseResult.success(value);
} catch (final Exception e) {
return ArgumentParseResult.failure(new FloatParseException(
input,
this.min,
this.max,
commandContext
));
return ArgumentParseResult.failure(new FloatParseException(input, this, commandContext));
}
}
@ -242,6 +250,28 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
return this.min;
}
/**
* Get whether this parser has a maximum set.
* This will compare the parser's maximum to {@link #DEFAULT_MAXIMUM}.
*
* @return whether the parser has a maximum set
* @since 1.5.0
*/
public boolean hasMax() {
return this.max != DEFAULT_MAXIMUM;
}
/**
* Get whether this parser has a minimum set.
* This will compare the parser's minimum to {@link #DEFAULT_MINIMUM}.
*
* @return whether the parser has a maximum set
* @since 1.5.0
*/
public boolean hasMin() {
return this.min != DEFAULT_MINIMUM;
}
}
@ -249,6 +279,8 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
private static final long serialVersionUID = -1162983846751812292L;
private final FloatParser<?> parser;
/**
* Construct a new float parse exception
*
@ -256,30 +288,43 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
* @param min Minimum value
* @param max Maximum value
* @param commandContext Command context
* @deprecated use {@link #FloatParseException(String, FloatParser, CommandContext)} instead
*/
@Deprecated
public FloatParseException(
final @NonNull String input,
final float min,
final float max,
final @NonNull CommandContext<?> commandContext
) {
super(
input,
min,
max,
FloatParser.class,
commandContext
);
this(input, new FloatParser<>(min, max), commandContext);
}
/**
* Create a new {@link FloatParseException}.
*
* @param input input string
* @param parser float parser
* @param commandContext command context
* @since 1.5.0
*/
public FloatParseException(
final @NonNull String input,
final @NonNull FloatParser<?> parser,
final @NonNull CommandContext<?> commandContext
) {
super(input, parser.min, parser.max, FloatParser.class, commandContext);
this.parser = parser;
}
@Override
public boolean hasMin() {
return this.getMin().floatValue() != Float.MIN_VALUE;
return this.parser.hasMin();
}
@Override
public boolean hasMax() {
return this.getMax().floatValue() != Float.MAX_VALUE;
return this.parser.hasMax();
}
@Override

132
cloud-core/src/main/java/cloud/commandframework/arguments/standard/IntegerArgument.java
View file

@ -55,18 +55,26 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
final @NonNull String name,
final int min,
final int max,
final String defaultValue,
final @NonNull String defaultValue,
final @Nullable BiFunction<@NonNull CommandContext<C>, @NonNull String,
@NonNull List<@NonNull String>> suggestionsProvider,
final @NonNull ArgumentDescription defaultDescription
) {
super(required, name, new IntegerParser<>(min, max), defaultValue, Integer.class, suggestionsProvider, defaultDescription);
super(
required,
name,
new IntegerParser<>(min, max),
defaultValue,
Integer.class,
suggestionsProvider,
defaultDescription
);
this.min = min;
this.max = max;
}
/**
* Create a new builder
* Create a new {@link Builder}.
*
* @param name Name of the argument
* @param <C> Command sender type
@ -77,7 +85,7 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
}
/**
* Create a new required command argument
* Create a new required {@link IntegerArgument}.
*
* @param name Argument name
* @param <C> Command sender type
@ -88,7 +96,7 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
}
/**
* Create a new optional command argument
* Create a new optional {@link IntegerArgument}.
*
* @param name Argument name
* @param <C> Command sender type
@ -99,18 +107,15 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
}
/**
* Create a new required command argument with a default value
* Create a new required {@link IntegerArgument} with the specified default value.
*
* @param name Argument name
* @param defaultNum Default num
* @param defaultNum Default value
* @param <C> Command sender type
* @return Created argument
*/
public static <C> @NonNull CommandArgument<C, Integer> optional(
final @NonNull String name,
final int defaultNum
) {
return IntegerArgument.<C>newBuilder(name).asOptionalWithDefault(Integer.toString(defaultNum)).build();
public static <C> @NonNull CommandArgument<C, Integer> optional(final @NonNull String name, final int defaultNum) {
return IntegerArgument.<C>newBuilder(name).asOptionalWithDefault(defaultNum).build();
}
/**
@ -133,8 +138,8 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
public static final class Builder<C> extends CommandArgument.Builder<C, Integer> {
private int min = Integer.MIN_VALUE;
private int max = Integer.MAX_VALUE;
private int min = IntegerParser.DEFAULT_MINIMUM;
private int max = IntegerParser.DEFAULT_MAXIMUM;
private Builder(final @NonNull String name) {
super(Integer.class, name);
@ -163,10 +168,17 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
}
/**
* Builder a new integer argument
* Sets the command argument to be optional, with the specified default value.
*
* @return Constructed argument
* @param defaultValue default value
* @return this builder
* @see CommandArgument.Builder#asOptionalWithDefault(String)
* @since 1.5.0
*/
public @NonNull Builder<C> asOptionalWithDefault(final int defaultValue) {
return (Builder<C>) this.asOptionalWithDefault(Integer.toString(defaultValue));
}
@Override
public @NonNull IntegerArgument<C> build() {
return new IntegerArgument<>(this.isRequired(), this.getName(), this.min, this.max,
@ -178,6 +190,20 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
public static final class IntegerParser<C> implements ArgumentParser<C, Integer> {
/**
* Constant for the default/unset minimum value.
*
* @since 1.5.0
*/
public static final int DEFAULT_MINIMUM = Integer.MIN_VALUE;
/**
* Constant for the default/unset maximum value.
*
* @since 1.5.0
*/
public static final int DEFAULT_MAXIMUM = Integer.MAX_VALUE;
private final int min;
private final int max;
@ -242,30 +268,17 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NoInputProvidedException(
IntegerParser.class,
commandContext
));
return ArgumentParseResult.failure(new NoInputProvidedException(IntegerParser.class, commandContext));
}
try {
final int value = Integer.parseInt(input);
if (value < this.min || value > this.max) {
return ArgumentParseResult.failure(new IntegerParseException(
input,
this.min,
this.max,
commandContext
));
return ArgumentParseResult.failure(new IntegerParseException(input, this, commandContext));
}
inputQueue.remove();
return ArgumentParseResult.success(value);
} catch (final Exception e) {
return ArgumentParseResult.failure(new IntegerParseException(
input,
this.min,
this.max,
commandContext
));
return ArgumentParseResult.failure(new IntegerParseException(input, this, commandContext));
}
}
@ -287,6 +300,28 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
return this.max;
}
/**
* Get whether this parser has a maximum set.
* This will compare the parser's maximum to {@link #DEFAULT_MAXIMUM}.
*
* @return whether the parser has a maximum set
* @since 1.5.0
*/
public boolean hasMax() {
return this.max != DEFAULT_MAXIMUM;
}
/**
* Get whether this parser has a minimum set.
* This will compare the parser's minimum to {@link #DEFAULT_MINIMUM}.
*
* @return whether the parser has a maximum set
* @since 1.5.0
*/
public boolean hasMin() {
return this.min != DEFAULT_MINIMUM;
}
@Override
public boolean isContextFree() {
return true;
@ -307,6 +342,8 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
private static final long serialVersionUID = -6933923056628373853L;
private final IntegerParser<?> parser;
/**
* Construct a new integer parse exception
*
@ -314,30 +351,43 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
* @param min Minimum value
* @param max Maximum value
* @param commandContext Command context
* @deprecated use {@link #IntegerParseException(String, IntegerParser, CommandContext)} instead
*/
@Deprecated
public IntegerParseException(
final @NonNull String input,
final int min,
final int max,
final @NonNull CommandContext<?> commandContext
) {
super(
input,
min,
max,
IntegerParser.class,
commandContext
);
this(input, new IntegerParser<>(min, max), commandContext);
}
/**
* Create a new {@link IntegerParseException}.
*
* @param input input string
* @param parser integer parser
* @param commandContext command context
* @since 1.5.0
*/
public IntegerParseException(
final @NonNull String input,
final @NonNull IntegerParser<?> parser,
final @NonNull CommandContext<?> commandContext
) {
super(input, parser.min, parser.max, IntegerParser.class, commandContext);
this.parser = parser;
}
@Override
public boolean hasMin() {
return this.getMin().intValue() != Integer.MIN_VALUE;
return this.parser.hasMin();
}
@Override
public boolean hasMax() {
return this.getMax().intValue() != Integer.MAX_VALUE;
return this.parser.hasMax();
}
@Override

131
cloud-core/src/main/java/cloud/commandframework/arguments/standard/LongArgument.java
View file

@ -59,7 +59,7 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
}
/**
* Create a new builder
* Create a new {@link Builder}.
*
* @param name Name of the argument
* @param <C> Command sender type
@ -70,7 +70,7 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
}
/**
* Create a new required command argument
* Create a new required {@link LongArgument}.
*
* @param name Argument name
* @param <C> Command sender type
@ -81,7 +81,7 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
}
/**
* Create a new optional command argument
* Create a new optional {@link LongArgument}.
*
* @param name Argument name
* @param <C> Command sender type
@ -92,7 +92,7 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
}
/**
* Create a new required command argument with a default value
* Create a new optional {@link LongArgument} with the specified default value.
*
* @param name Argument name
* @param defaultNum Default num
@ -103,7 +103,7 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
final @NonNull String name,
final long defaultNum
) {
return LongArgument.<C>newBuilder(name).asOptionalWithDefault(Long.toString(defaultNum)).build();
return LongArgument.<C>newBuilder(name).asOptionalWithDefault(defaultNum).build();
}
/**
@ -126,8 +126,8 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
public static final class Builder<C> extends CommandArgument.Builder<C, Long> {
private long min = Long.MIN_VALUE;
private long max = Long.MAX_VALUE;
private long min = LongParser.DEFAULT_MINIMUM;
private long max = LongParser.DEFAULT_MAXIMUM;
private Builder(final @NonNull String name) {
super(Long.class, name);
@ -156,10 +156,17 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
}
/**
* Builder a new long argument
* Sets the command argument to be optional, with the specified default value.
*
* @return Constructed argument
* @param defaultValue default value
* @return this builder
* @see CommandArgument.Builder#asOptionalWithDefault(String)
* @since 1.5.0
*/
public @NonNull Builder<C> asOptionalWithDefault(final long defaultValue) {
return (Builder<C>) this.asOptionalWithDefault(Long.toString(defaultValue));
}
@Override
public @NonNull LongArgument<C> build() {
return new LongArgument<>(this.isRequired(), this.getName(), this.min,
@ -171,6 +178,20 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
public static final class LongParser<C> implements ArgumentParser<C, Long> {
/**
* Constant for the default/unset minimum value.
*
* @since 1.5.0
*/
public static final long DEFAULT_MINIMUM = Long.MIN_VALUE;
/**
* Constant for the default/unset maximum value.
*
* @since 1.5.0
*/
public static final long DEFAULT_MAXIMUM = Long.MAX_VALUE;
private final long min;
private final long max;
@ -192,33 +213,60 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NoInputProvidedException(
LongParser.class,
commandContext
));
return ArgumentParseResult.failure(new NoInputProvidedException(LongParser.class, commandContext));
}
try {
final long value = Long.parseLong(input);
if (value < this.min || value > this.max) {
return ArgumentParseResult.failure(new LongParseException(
input,
this.min,
this.max,
commandContext
));
return ArgumentParseResult.failure(new LongParseException(input, this, commandContext));
}
inputQueue.remove();
return ArgumentParseResult.success(value);
} catch (final Exception e) {
return ArgumentParseResult.failure(new LongParseException(
input,
this.min,
this.max,
commandContext
));
return ArgumentParseResult.failure(new LongParseException(input, this, commandContext));
}
}
/**
* Get the minimum value accepted by this parser
*
* @return Min value
*/
public long getMin() {
return this.min;
}
/**
* Get the maximum value accepted by this parser
*
* @return Max value
*/
public long getMax() {
return this.max;
}
/**
* Get whether this parser has a maximum set.
* This will compare the parser's maximum to {@link #DEFAULT_MAXIMUM}.
*
* @return whether the parser has a maximum set
* @since 1.5.0
*/
public boolean hasMax() {
return this.max != DEFAULT_MAXIMUM;
}
/**
* Get whether this parser has a minimum set.
* This will compare the parser's minimum to {@link #DEFAULT_MINIMUM}.
*
* @return whether the parser has a maximum set
* @since 1.5.0
*/
public boolean hasMin() {
return this.min != DEFAULT_MINIMUM;
}
@Override
public boolean isContextFree() {
return true;
@ -239,6 +287,8 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
private static final long serialVersionUID = 4366856282301198232L;
private final LongParser<?> parser;
/**
* Construct a new long parse exception
*
@ -246,30 +296,43 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
* @param min Minimum value
* @param max Maximum value
* @param commandContext Command context
* @deprecated use {@link #LongParseException(String, LongParser, CommandContext)} instead
*/
@Deprecated
public LongParseException(
final @NonNull String input,
final long min,
final long max,
final @NonNull CommandContext<?> commandContext
) {
super(
input,
min,
max,
LongParser.class,
commandContext
);
this(input, new LongParser<>(min, max), commandContext);
}
/**
* Create a new {@link LongParseException}.
*
* @param input input string
* @param parser long parser
* @param commandContext command context
* @since 1.5.0
*/
public LongParseException(
final @NonNull String input,
final @NonNull LongParser<?> parser,
final @NonNull CommandContext<?> commandContext
) {
super(input, parser.min, parser.max, LongParser.class, commandContext);
this.parser = parser;
}
@Override
public boolean hasMin() {
return this.getMin().longValue() != Long.MIN_VALUE;
return this.parser.hasMin();
}
@Override
public boolean hasMax() {
return this.getMax().longValue() != Long.MAX_VALUE;
return this.parser.hasMax();
}
@Override

120
cloud-core/src/main/java/cloud/commandframework/arguments/standard/ShortArgument.java
View file

@ -59,7 +59,7 @@ public final class ShortArgument<C> extends CommandArgument<C, Short> {
}
/**
* Create a new builder
* Create a new {@link Builder}.
*
* @param name Name of the argument
* @param <C> Command sender type
@ -70,7 +70,7 @@ public final class ShortArgument<C> extends CommandArgument<C, Short> {
}
/**
* Create a new required command argument
* Create a new required {@link ShortArgument}.
*
* @param name Argument name
* @param <C> Command sender type
@ -81,7 +81,7 @@ public final class ShortArgument<C> extends CommandArgument<C, Short> {
}
/**
* Create a new optional command argument
* Create a new optional {@link ShortArgument}.
*
* @param name Argument name
* @param <C> Command sender type
@ -92,18 +92,15 @@ public final class ShortArgument<C> extends CommandArgument<C, Short> {
}
/**
* Create a new required command argument with a default value
* Create a new required {@link ShortArgument} with the specified default value.
*
* @param name Argument name
* @param defaultNum Default num
* @param defaultNum Default value
* @param <C> Command sender type
* @return Created argument
*/
public static <C> @NonNull CommandArgument<C, Short> optional(
final @NonNull String name,
final short defaultNum
) {
return ShortArgument.<C>newBuilder(name).asOptionalWithDefault(Short.toString(defaultNum)).build();
public static <C> @NonNull CommandArgument<C, Short> optional(final @NonNull String name, final short defaultNum) {
return ShortArgument.<C>newBuilder(name).asOptionalWithDefault(defaultNum).build();
}
/**
@ -126,8 +123,8 @@ public final class ShortArgument<C> extends CommandArgument<C, Short> {
public static final class Builder<C> extends CommandArgument.Builder<C, Short> {
private short min = Short.MIN_VALUE;
private short max = Short.MAX_VALUE;
private short min = ShortParser.DEFAULT_MINIMUM;
private short max = ShortParser.DEFAULT_MAXIMUM;
private Builder(final @NonNull String name) {
super(Short.class, name);
@ -156,10 +153,17 @@ public final class ShortArgument<C> extends CommandArgument<C, Short> {
}
/**
* Builder a new short argument
* Sets the command argument to be optional, with the specified default value.
*
* @return Constructed argument
* @param defaultValue default value
* @return this builder
* @see CommandArgument.Builder#asOptionalWithDefault(String)
* @since 1.5.0
*/
public @NonNull Builder<C> asOptionalWithDefault(final short defaultValue) {
return (Builder<C>) this.asOptionalWithDefault(Short.toString(defaultValue));
}
@Override
public @NonNull ShortArgument<C> build() {
return new ShortArgument<>(this.isRequired(), this.getName(), this.min, this.max,
@ -171,6 +175,20 @@ public final class ShortArgument<C> extends CommandArgument<C, Short> {
public static final class ShortParser<C> implements ArgumentParser<C, Short> {
/**
* Constant for the default/unset minimum value.
*
* @since 1.5.0
*/
public static final short DEFAULT_MINIMUM = Short.MIN_VALUE;
/**
* Constant for the default/unset maximum value.
*
* @since 1.5.0
*/
public static final short DEFAULT_MAXIMUM = Short.MAX_VALUE;
private final short min;
private final short max;
@ -192,30 +210,17 @@ public final class ShortArgument<C> extends CommandArgument<C, Short> {
) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NoInputProvidedException(
ShortParser.class,
commandContext
));
return ArgumentParseResult.failure(new NoInputProvidedException(ShortParser.class, commandContext));
}
try {
final short value = Short.parseShort(input);
if (value < this.min || value > this.max) {
return ArgumentParseResult.failure(new ShortParseException(
input,
this.min,
this.max,
commandContext
));
return ArgumentParseResult.failure(new ShortParseException(input, this, commandContext));
}
inputQueue.remove();
return ArgumentParseResult.success(value);
} catch (final Exception e) {
return ArgumentParseResult.failure(new ShortParseException(
input,
this.min,
this.max,
commandContext
));
return ArgumentParseResult.failure(new ShortParseException(input, this, commandContext));
}
}
@ -250,6 +255,28 @@ public final class ShortArgument<C> extends CommandArgument<C, Short> {
return this.min;
}
/**
* Get whether this parser has a maximum set.
* This will compare the parser's maximum to {@link #DEFAULT_MAXIMUM}.
*
* @return whether the parser has a maximum set
* @since 1.5.0
*/
public boolean hasMax() {
return this.max != DEFAULT_MAXIMUM;
}
/**
* Get whether this parser has a minimum set.
* This will compare the parser's minimum to {@link #DEFAULT_MINIMUM}.
*
* @return whether the parser has a maximum set
* @since 1.5.0
*/
public boolean hasMin() {
return this.min != DEFAULT_MINIMUM;
}
}
@ -257,6 +284,8 @@ public final class ShortArgument<C> extends CommandArgument<C, Short> {
private static final long serialVersionUID = -478674263339091032L;
private final ShortParser<?> parser;
/**
* Construct a new short parse exception
*
@ -264,30 +293,43 @@ public final class ShortArgument<C> extends CommandArgument<C, Short> {
* @param min Minimum value
* @param max Maximum value
* @param commandContext Command context
* @deprecated use {@link #ShortParseException(String, ShortParser, CommandContext)} instead
*/
@Deprecated
public ShortParseException(
final @NonNull String input,
final short min,
final short max,
final @NonNull CommandContext<?> commandContext
) {
super(
input,
min,
max,
ShortParser.class,
commandContext
);
this(input, new ShortParser<>(min, max), commandContext);
}
/**
* Create a new {@link ShortParseException}.
*
* @param input input string
* @param parser short parser
* @param commandContext command context
* @since 1.5.0
*/
public ShortParseException(
final @NonNull String input,
final @NonNull ShortParser<?> parser,
final @NonNull CommandContext<?> commandContext
) {
super(input, parser.min, parser.max, ShortParser.class, commandContext);
this.parser = parser;
}
@Override
public boolean hasMin() {
return this.getMin().shortValue() != Short.MIN_VALUE;
return this.parser.hasMin();
}
@Override
public boolean hasMax() {
return this.getMax().shortValue() != Short.MAX_VALUE;
return this.parser.hasMax();
}
@Override