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

🚚 More removal of javax annotations

Browse source
This commit is contained in:
Alexander Söderberg 2020-09-28 22:26:37 +02:00 • committed by Alexander Söderberg
parent 4556b392b0
commit 26f11e3a7e
47 changed files with 594 additions and 691 deletions
Download patch file Download diff file Expand all files Collapse all files

52
cloud-core/src/main/java/cloud/commandframework/Command.java
View file

@ -34,7 +34,7 @@ import cloud.commandframework.permission.CommandPermission;
import cloud.commandframework.permission.Permission;
import cloud.commandframework.types.tuples.Pair;
import cloud.commandframework.types.tuples.Triplet;
import com.google.common.reflect.TypeToken;
import io.leangen.geantyref.TypeToken;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
@ -391,11 +391,10 @@ public class Command<C> {
* @param <V> Second type
* @return Builder instance with the argument inserted
*/
@Nonnull
public <U, V> Builder<C> argumentPair(@Nonnull final String name,
@Nonnull final Pair<String, String> names,
@Nonnull final Pair<Class<U>, Class<V>> parserPair,
@Nonnull final Description description) {
public <U, V> @NonNull Builder<C> argumentPair(@NonNull final String name,
@NonNull final Pair<@NonNull String, @NonNull String> names,
@NonNull final Pair<@NonNull Class<U>, @NonNull Class<V>> parserPair,
@NonNull final Description description) {
if (this.commandManager == null) {
throw new IllegalStateException("This cannot be called from a command that has no command manager attached");
}
@ -422,13 +421,13 @@ public class Command<C> {
* @param <O> Output type
* @return Builder instance with the argument inserted
*/
@Nonnull
public <U, V, O> Builder<C> argumentPair(@Nonnull final String name,
@Nonnull final TypeToken<O> outputType,
@Nonnull final Pair<String, String> names,
@Nonnull final Pair<Class<U>, Class<V>> parserPair,
@Nonnull final Function<Pair<U, V>, O> mapper,
@Nonnull final Description description) {
public <U, V, O> @NonNull Builder<C> argumentPair(@NonNull final String name,
@NonNull final TypeToken<O> outputType,
@NonNull final Pair<@NonNull String, @NonNull String> names,
@NonNull final Pair<@NonNull Class<U>, @NonNull Class<V>> parserPair,
@NonNull final Function<Pair<@NonNull U, @NonNull V>,
@NonNull O> mapper,
@NonNull final Description description) {
if (this.commandManager == null) {
throw new IllegalStateException("This cannot be called from a command that has no command manager attached");
}
@ -455,11 +454,12 @@ public class Command<C> {
* @param <W> Third type
* @return Builder instance with the argument inserted
*/
@Nonnull
public <U, V, W> Builder<C> argumentTriplet(@Nonnull final String name,
@Nonnull final Triplet<String, String, String> names,
@Nonnull final Triplet<Class<U>, Class<V>, Class<W>> parserTriplet,
@Nonnull final Description description) {
public <U, V, W> @NonNull Builder<C> argumentTriplet(@NonNull final String name,
@NonNull final Triplet<@NonNull String,
@NonNull String, @NonNull String> names,
@NonNull final Triplet<@NonNull Class<U>,
@NonNull Class<V>, @NonNull Class<W>> parserTriplet,
@NonNull final Description description) {
if (this.commandManager == null) {
throw new IllegalStateException("This cannot be called from a command that has no command manager attached");
}
@ -487,13 +487,15 @@ public class Command<C> {
* @param <O> Output type
* @return Builder instance with the argument inserted
*/
@Nonnull
public <U, V, W, O> Builder<C> argumentTriplet(@Nonnull final String name,
@Nonnull final TypeToken<O> outputType,
@Nonnull final Triplet<String, String, String> names,
@Nonnull final Triplet<Class<U>, Class<V>, Class<W>> parserTriplet,
@Nonnull final Function<Triplet<U, V, W>, O> mapper,
@Nonnull final Description description) {
public <U, V, W, O> @NonNull Builder<C> argumentTriplet(@NonNull final String name,
@NonNull final TypeToken<O> outputType,
@NonNull final Triplet<@NonNull String,
@NonNull String, @NonNull String> names,
@NonNull final Triplet<@NonNull Class<U>,
@NonNull Class<V>, @NonNull Class<W>> parserTriplet,
@NonNull final Function<@NonNull Triplet<@NonNull U,
@NonNull V, @NonNull W>, @NonNull O> mapper,
@NonNull final Description description) {
if (this.commandManager == null) {
throw new IllegalStateException("This cannot be called from a command that has no command manager attached");
}

24
cloud-core/src/main/java/cloud/commandframework/arguments/CommandArgument.java
View file

@ -125,12 +125,13 @@ public class CommandArgument<C, T> implements Comparable<CommandArgument<?, ?>>
* @param suggestionsProvider Suggestions provider
*/
public CommandArgument(final boolean required,
@Nonnull final String name,
@Nonnull final ArgumentParser<C, T> parser,
@Nonnull final String defaultValue,
@Nonnull final Class<T> valueType,
@Nullable final BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider) {
this(required, name, parser, defaultValue, TypeToken.of(valueType), suggestionsProvider);
@NonNull final String name,
@NonNull final ArgumentParser<C, T> parser,
@NonNull final String defaultValue,
@NonNull final Class<T> valueType,
@Nullable final BiFunction<@NonNull CommandContext<C>,
@NonNull String, @NonNull List<@NonNull String>> suggestionsProvider) {
this(required, name, parser, defaultValue, TypeToken.get(valueType), suggestionsProvider);
}
/**
@ -162,9 +163,8 @@ public class CommandArgument<C, T> implements Comparable<CommandArgument<?, ?>>
* @param <T> Argument Type. Used to make the compiler happy.
* @return Argument builder
*/
@Nonnull
public static <C, T> CommandArgument.Builder<C, T> ofType(@Nonnull final TypeToken<T> clazz,
@Nonnull final String name) {
public static <C, T> CommandArgument.@NonNull Builder<C, T> ofType(@NonNull final TypeToken<T> clazz,
@NonNull final String name) {
return new Builder<>(clazz, name);
}
@ -352,9 +352,9 @@ public class CommandArgument<C, T> implements Comparable<CommandArgument<?, ?>>
this.name = name;
}
protected Builder(@Nonnull final Class<T> valueType,
@Nonnull final String name) {
this(TypeToken.of(valueType), name);
protected Builder(@NonNull final Class<T> valueType,
@NonNull final String name) {
this(TypeToken.get(valueType), name);
}
/**

57
cloud-core/src/main/java/cloud/commandframework/arguments/compound/ArgumentPair.java
View file

@ -23,14 +23,14 @@
//
package cloud.commandframework.arguments.compound;
import com.google.common.reflect.TypeToken;
import cloud.commandframework.CommandManager;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.arguments.parser.ParserParameters;
import cloud.commandframework.arguments.parser.ParserRegistry;
import cloud.commandframework.types.tuples.Pair;
import io.leangen.geantyref.TypeToken;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.util.function.Function;
/**
@ -55,12 +55,12 @@ public class ArgumentPair<C, U, V, O> extends CompoundArgument<Pair<U, V>, C, O>
* @param valueType The output type
*/
protected ArgumentPair(final boolean required,
@Nonnull final String name,
@Nonnull final Pair<String, String> names,
@Nonnull final Pair<Class<U>, Class<V>> types,
@Nonnull final Pair<ArgumentParser<C, U>, ArgumentParser<C, V>> parserPair,
@Nonnull final Function<Pair<U, V>, O> mapper,
@Nonnull final TypeToken<O> valueType) {
@NonNull final String name,
@NonNull final Pair<@NonNull String, @NonNull String> names,
@NonNull final Pair<@NonNull Class<U>, @NonNull Class<V>> types,
@NonNull final Pair<@NonNull ArgumentParser<C, U>, @NonNull ArgumentParser<C, V>> parserPair,
@NonNull final Function<@NonNull Pair<@NonNull U, @NonNull V>, @NonNull O> mapper,
@NonNull final TypeToken<O> valueType) {
super(required, name, names, parserPair, types, mapper, o -> Pair.of((U) o[0], (V) o[1]), valueType);
}
@ -78,17 +78,18 @@ public class ArgumentPair<C, U, V, O> extends CompoundArgument<Pair<U, V>, C, O>
* @param <V> Second parsed type
* @return Intermediary builder
*/
@Nonnull
public static <C, U, V> ArgumentPairIntermediaryBuilder<C, U, V> required(@Nonnull final CommandManager<C> manager,
@Nonnull final String name,
@Nonnull final Pair<String, String> names,
@Nonnull final Pair<Class<U>, Class<V>> types) {
public static <C, U, V> @NonNull ArgumentPairIntermediaryBuilder<C, U, V> required(@NonNull final CommandManager<C> manager,
@NonNull final String name,
@NonNull final Pair<@NonNull String,
@NonNull String> names,
@NonNull final Pair<@NonNull Class<U>,
@NonNull Class<V>> types) {
final ParserRegistry<C> parserRegistry = manager.getParserRegistry();
final ArgumentParser<C, U> firstParser = parserRegistry.createParser(TypeToken.of(types.getFirst()),
final ArgumentParser<C, U> firstParser = parserRegistry.createParser(TypeToken.get(types.getFirst()),
ParserParameters.empty()).orElseThrow(() ->
new IllegalArgumentException(
"Could not create parser for primary type"));
final ArgumentParser<C, V> secondaryParser = parserRegistry.createParser(TypeToken.of(types.getSecond()),
final ArgumentParser<C, V> secondaryParser = parserRegistry.createParser(TypeToken.get(types.getSecond()),
ParserParameters.empty()).orElseThrow(() ->
new IllegalArgumentException(
"Could not create parser for secondary type"));
@ -105,10 +106,11 @@ public class ArgumentPair<C, U, V, O> extends CompoundArgument<Pair<U, V>, C, O>
private final Pair<Class<U>, Class<V>> types;
private ArgumentPairIntermediaryBuilder(final boolean required,
@Nonnull final String name,
@Nonnull final Pair<String, String> names,
@Nonnull final Pair<ArgumentParser<C, U>, ArgumentParser<C, V>> parserPair,
@Nonnull final Pair<Class<U>, Class<V>> types) {
@NonNull final String name,
@NonNull final Pair<@NonNull String, @NonNull String> names,
@NonNull final Pair<@NonNull ArgumentParser<@NonNull C, @NonNull U>,
@NonNull ArgumentParser<@NonNull C, @NonNull V>> parserPair,
@NonNull final Pair<@NonNull Class<U>, @NonNull Class<V>> types) {
this.required = required;
this.name = name;
this.names = names;
@ -121,8 +123,7 @@ public class ArgumentPair<C, U, V, O> extends CompoundArgument<Pair<U, V>, C, O>
*
* @return Argument pair
*/
@Nonnull
public ArgumentPair<C, U, V, Pair<U, V>> simple() {
public @NonNull ArgumentPair<@NonNull C, @NonNull U, @NonNull V, @NonNull Pair<@NonNull U, @NonNull V>> simple() {
return new ArgumentPair<C, U, V, Pair<U, V>>(this.required,
this.name,
this.names,
@ -141,9 +142,9 @@ public class ArgumentPair<C, U, V, O> extends CompoundArgument<Pair<U, V>, C, O>
* @param <O> Output type
* @return Created pair
*/
@Nonnull
public <O> ArgumentPair<C, U, V, O> withMapper(@Nonnull final TypeToken<O> clazz,
@Nonnull final Function<Pair<U, V>, O> mapper) {
public <O> @NonNull ArgumentPair<C, U, V, O> withMapper(@NonNull final TypeToken<O> clazz,
@NonNull final Function<@NonNull Pair<@NonNull U,
@NonNull V>, @NonNull O> mapper) {
return new ArgumentPair<C, U, V, O>(this.required, this.name, this.names, this.types, this.parserPair, mapper, clazz);
}
@ -155,10 +156,10 @@ public class ArgumentPair<C, U, V, O> extends CompoundArgument<Pair<U, V>, C, O>
* @param <O> Output type
* @return Created pair
*/
@Nonnull
public <O> ArgumentPair<C, U, V, O> withMapper(@Nonnull final Class<O> clazz,
@Nonnull final Function<Pair<U, V>, O> mapper) {
return this.withMapper(TypeToken.of(clazz), mapper);
public <O> @NonNull ArgumentPair<@NonNull C, @NonNull U, @NonNull V, @NonNull O> withMapper(
@NonNull final Class<O> clazz,
@NonNull final Function<@NonNull Pair<@NonNull U, @NonNull V>, @NonNull O> mapper) {
return this.withMapper(TypeToken.get(clazz), mapper);
}
}

67
cloud-core/src/main/java/cloud/commandframework/arguments/compound/ArgumentTriplet.java
View file

@ -28,9 +28,9 @@ import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.arguments.parser.ParserParameters;
import cloud.commandframework.arguments.parser.ParserRegistry;
import cloud.commandframework.types.tuples.Triplet;
import com.google.common.reflect.TypeToken;
import io.leangen.geantyref.TypeToken;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.util.function.Function;
/**
@ -56,13 +56,13 @@ public class ArgumentTriplet<C, U, V, W, O> extends CompoundArgument<Triplet<U,
* @param valueType The output type
*/
protected ArgumentTriplet(final boolean required,
@Nonnull final String name,
@Nonnull final Triplet<String, String, String> names,
@Nonnull final Triplet<Class<U>, Class<V>, Class<W>> types,
@Nonnull final Triplet<ArgumentParser<C, U>, ArgumentParser<C, V>,
ArgumentParser<C, W>> parserTriplet,
@Nonnull final Function<Triplet<U, V, W>, O> mapper,
@Nonnull final TypeToken<O> valueType) {
@NonNull final String name,
@NonNull final Triplet<@NonNull String, @NonNull String, @NonNull String> names,
@NonNull final Triplet<@NonNull Class<U>, @NonNull Class<V>, @NonNull Class<W>> types,
@NonNull final Triplet<@NonNull ArgumentParser<C, U>, @NonNull ArgumentParser<C, V>,
@NonNull ArgumentParser<C, W>> parserTriplet,
@NonNull final Function<@NonNull Triplet<U, @NonNull V, @NonNull W>, @NonNull O> mapper,
@NonNull final TypeToken<O> valueType) {
super(required, name, names, parserTriplet, types, mapper, o -> Triplet.of((U) o[0], (V) o[1], (W) o[2]), valueType);
}
@ -81,22 +81,21 @@ public class ArgumentTriplet<C, U, V, W, O> extends CompoundArgument<Triplet<U,
* @param <W> Third type
* @return Intermediary builder
*/
@Nonnull
public static <C, U, V, W> ArgumentTripletIntermediaryBuilder<C, U, V, W>
required(@Nonnull final CommandManager<C> manager,
@Nonnull final String name,
@Nonnull final Triplet<String, String, String> names,
@Nonnull final Triplet<Class<U>, Class<V>, Class<W>> types) {
public static <C, U, V, W> @NonNull ArgumentTripletIntermediaryBuilder<@NonNull C, @NonNull U, @NonNull V, @NonNull W>
required(@NonNull final CommandManager<C> manager,
@NonNull final String name,
@NonNull final Triplet<@NonNull String, @NonNull String, @NonNull String> names,
@NonNull final Triplet<@NonNull Class<U>, @NonNull Class<V>, @NonNull Class<W>> types) {
final ParserRegistry<C> parserRegistry = manager.getParserRegistry();
final ArgumentParser<C, U> firstParser = parserRegistry.createParser(TypeToken.of(types.getFirst()),
final ArgumentParser<C, U> firstParser = parserRegistry.createParser(TypeToken.get(types.getFirst()),
ParserParameters.empty()).orElseThrow(() ->
new IllegalArgumentException(
"Could not create parser for primary type"));
final ArgumentParser<C, V> secondaryParser = parserRegistry.createParser(TypeToken.of(types.getSecond()),
final ArgumentParser<C, V> secondaryParser = parserRegistry.createParser(TypeToken.get(types.getSecond()),
ParserParameters.empty()).orElseThrow(() ->
new IllegalArgumentException(
"Could not create parser for secondary type"));
final ArgumentParser<C, W> tertiaryParser = parserRegistry.createParser(TypeToken.of(types.getThird()),
final ArgumentParser<C, W> tertiaryParser = parserRegistry.createParser(TypeToken.get(types.getThird()),
ParserParameters.empty()).orElseThrow(() ->
new IllegalArgumentException(
"Could not create parser for tertiary type"));
@ -114,11 +113,14 @@ public class ArgumentTriplet<C, U, V, W, O> extends CompoundArgument<Triplet<U,
private final Triplet<Class<U>, Class<V>, Class<W>> types;
private ArgumentTripletIntermediaryBuilder(final boolean required,
@Nonnull final String name,
@Nonnull final Triplet<String, String, String> names,
@Nonnull final Triplet<ArgumentParser<C, U>,
ArgumentParser<C, V>, ArgumentParser<C, W>> parserTriplet,
@Nonnull final Triplet<Class<U>, Class<V>, Class<W>> types) {
@NonNull final String name,
@NonNull final Triplet<@NonNull String, @NonNull String,
@NonNull String> names,
@NonNull final Triplet<@NonNull ArgumentParser<C, U>,
@NonNull ArgumentParser<C, V>,
@NonNull ArgumentParser<C, W>> parserTriplet,
@NonNull final Triplet<@NonNull Class<U>,
@NonNull Class<V>, @NonNull Class<W>> types) {
this.required = required;
this.name = name;
this.names = names;
@ -131,8 +133,8 @@ public class ArgumentTriplet<C, U, V, W, O> extends CompoundArgument<Triplet<U,
*
* @return Argument triplet
*/
@Nonnull
public ArgumentTriplet<C, U, V, W, Triplet<U, V, W>> simple() {
public @NonNull ArgumentTriplet<@NonNull C, @NonNull U, @NonNull V,
@NonNull W, Triplet<@NonNull U, @NonNull V, @NonNull W>> simple() {
return new ArgumentTriplet<>(this.required,
this.name,
this.names,
@ -151,9 +153,10 @@ public class ArgumentTriplet<C, U, V, W, O> extends CompoundArgument<Triplet<U,
* @param <O> Output type
* @return Created triplet
*/
@Nonnull
public <O> ArgumentTriplet<C, U, V, W, O> withMapper(@Nonnull final TypeToken<O> clazz,
@Nonnull final Function<Triplet<U, V, W>, O> mapper) {
public <O> @NonNull ArgumentTriplet<@NonNull C, @NonNull U, @NonNull V,
@NonNull W, @NonNull O> withMapper(@NonNull final TypeToken<O> clazz,
@NonNull final Function<@NonNull Triplet<@NonNull U,
@NonNull V, @NonNull W>, @NonNull O> mapper) {
return new ArgumentTriplet<>(this.required, this.name, this.names, this.types, this.parserTriplet, mapper, clazz);
}
@ -165,11 +168,11 @@ public class ArgumentTriplet<C, U, V, W, O> extends CompoundArgument<Triplet<U,
* @param <O> Output type
* @return Created triplet
*/
@Nonnull
public <O> ArgumentTriplet<C, U, V, W, O> withMapper(@Nonnull final Class<O> clazz,
@Nonnull final Function<Triplet<U, V, W>, O> mapper) {
public <O> @NonNull ArgumentTriplet<C, U, V, W, O> withMapper(@NonNull final Class<O> clazz,
@NonNull final Function<@NonNull Triplet<@NonNull U,
@NonNull V, @NonNull W>, @NonNull O> mapper) {
return new ArgumentTriplet<>(this.required, this.name, this.names, this.types,
this.parserTriplet, mapper, TypeToken.of(clazz));
this.parserTriplet, mapper, TypeToken.get(clazz));
}
}

50
cloud-core/src/main/java/cloud/commandframework/arguments/compound/CompoundArgument.java
View file

@ -28,9 +28,9 @@ import cloud.commandframework.arguments.parser.ArgumentParseResult;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.context.CommandContext;
import cloud.commandframework.types.tuples.Tuple;
import com.google.common.reflect.TypeToken;
import io.leangen.geantyref.TypeToken;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.util.List;
import java.util.Queue;
import java.util.function.Function;
@ -49,13 +49,13 @@ public class CompoundArgument<T extends Tuple, C, O> extends CommandArgument<C,
private final Tuple parserTuple;
CompoundArgument(final boolean required,
@Nonnull final String name,
@Nonnull final Tuple names,
@Nonnull final Tuple parserTuple,
@Nonnull final Tuple types,
@Nonnull final Function<T, O> mapper,
@Nonnull final Function<Object[], T> tupleFactory,
@Nonnull final TypeToken<O> valueType) {
@NonNull final String name,
@NonNull final Tuple names,
@NonNull final Tuple parserTuple,
@NonNull final Tuple types,
@NonNull final Function<@NonNull T, @NonNull O> mapper,
@NonNull final Function<@NonNull Object[], @NonNull T> tupleFactory,
@NonNull final TypeToken<O> valueType) {
super(required,
name,
new CompoundParser<>(parserTuple, mapper, tupleFactory),
@ -72,8 +72,7 @@ public class CompoundArgument<T extends Tuple, C, O> extends CommandArgument<C,
*
* @return Internal parsers
*/
@Nonnull
public Tuple getParserTuple() {
public @NonNull Tuple getParserTuple() {
return this.parserTuple;
}
@ -82,8 +81,7 @@ public class CompoundArgument<T extends Tuple, C, O> extends CommandArgument<C,
*
* @return Argument names
*/
@Nonnull
public Tuple getNames() {
public @NonNull Tuple getNames() {
return this.names;
}
@ -92,8 +90,7 @@ public class CompoundArgument<T extends Tuple, C, O> extends CommandArgument<C,
*
* @return Parser types
*/
@Nonnull
public Tuple getTypes() {
public @NonNull Tuple getTypes() {
return this.types;
}
@ -104,22 +101,20 @@ public class CompoundArgument<T extends Tuple, C, O> extends CommandArgument<C,
private final Function<T, O> mapper;
private final Function<Object[], T> tupleFactory;
private CompoundParser(@Nonnull final Tuple parserTuple,
@Nonnull final Function<T, O> mapper,
@Nonnull final Function<Object[], T> tupleFactory) {
private CompoundParser(@NonNull final Tuple parserTuple,
@NonNull final Function<@NonNull T, @NonNull O> mapper,
@NonNull final Function<@NonNull Object[], @NonNull T> tupleFactory) {
this.parsers = parserTuple.toArray();
this.mapper = mapper;
this.tupleFactory = tupleFactory;
}
@Nonnull
@Override
public ArgumentParseResult<O> parse(@Nonnull final CommandContext<C> commandContext,
@Nonnull final Queue<String> inputQueue) {
public @NonNull ArgumentParseResult<O> parse(@NonNull final CommandContext<C> commandContext,
@NonNull final Queue<@NonNull String> inputQueue) {
final Object[] output = new Object[this.parsers.length];
for (int i = 0; i < this.parsers.length; i++) {
@SuppressWarnings("unchecked")
final ArgumentParser<C, ?> parser = (ArgumentParser<C, ?>) this.parsers[i];
@SuppressWarnings("unchecked") final ArgumentParser<C, ?> parser = (ArgumentParser<C, ?>) this.parsers[i];
final ArgumentParseResult<?> result = parser.parse(commandContext, inputQueue);
if (result.getFailure().isPresent()) {
/* Return the failure */
@ -129,8 +124,8 @@ public class CompoundArgument<T extends Tuple, C, O> extends CommandArgument<C,
output[i] = result.getParsedValue().orElse(null);
}
/*
* We now know that we have complete output, as none of the parsers returned a failure.
* Now check if the mapper threw any exceptions
* We now know that we have complete output, as none of the parsers returned a failure.
* Now check if the mapper threw any exceptions
*/
try {
return ArgumentParseResult.success(this.mapper.apply(this.tupleFactory.apply(output)));
@ -139,10 +134,9 @@ public class CompoundArgument<T extends Tuple, C, O> extends CommandArgument<C,
}
}
@Nonnull
@Override
public List<String> suggestions(@Nonnull final CommandContext<C> commandContext,
@Nonnull final String input) {
public @NonNull List<@NonNull String> suggestions(@NonNull final CommandContext<C> commandContext,
@NonNull final String input) {
/*
This method will be called n times, each time for each of the internal types.
The problem is that we need to then know which of the parsers to forward the

48
cloud-core/src/main/java/cloud/commandframework/arguments/standard/BooleanArgument.java
View file

@ -27,9 +27,9 @@ import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.arguments.parser.ArgumentParseResult;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.context.CommandContext;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.Arrays;
import java.util.List;
import java.util.Queue;
@ -39,9 +39,12 @@ import java.util.function.BiFunction;
public final class BooleanArgument<C> extends CommandArgument<C, Boolean> {
private final boolean liberal;
private BooleanArgument(final boolean required, @Nonnull final String name,
final boolean liberal, @Nonnull final String defaultValue,
@Nullable final BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider) {
private BooleanArgument(final boolean required,
@NonNull final String name,
final boolean liberal,
@NonNull final String defaultValue,
@Nullable final BiFunction<@NonNull CommandContext<C>, @NonNull String,
@NonNull List<@NonNull String>> suggestionsProvider) {
super(required, name, new BooleanParser<>(liberal), defaultValue, Boolean.class, suggestionsProvider);
this.liberal = liberal;
}
@ -53,8 +56,7 @@ public final class BooleanArgument<C> extends CommandArgument<C, Boolean> {
* @param <C> Command sender type
* @return Created builder
*/
@Nonnull
public static <C> Builder<C> newBuilder(@Nonnull final String name) {
public static <C> @NonNull Builder<C> newBuilder(@NonNull final String name) {
return new Builder<>(name);
}
@ -65,8 +67,7 @@ public final class BooleanArgument<C> extends CommandArgument<C, Boolean> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Boolean> required(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Boolean> required(@NonNull final String name) {
return BooleanArgument.<C>newBuilder(name).asRequired().build();
}
@ -77,8 +78,7 @@ public final class BooleanArgument<C> extends CommandArgument<C, Boolean> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Boolean> optional(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Boolean> optional(@NonNull final String name) {
return BooleanArgument.<C>newBuilder(name).asOptional().build();
}
@ -90,9 +90,8 @@ public final class BooleanArgument<C> extends CommandArgument<C, Boolean> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Boolean> optional(@Nonnull final String name,
final boolean defaultBoolean) {
public static <C> @NonNull CommandArgument<C, Boolean> optional(@NonNull final String name,
final boolean defaultBoolean) {
return BooleanArgument.<C>newBuilder(name).asOptionalWithDefault(Boolean.toString(defaultBoolean)).build();
}
@ -109,7 +108,7 @@ public final class BooleanArgument<C> extends CommandArgument<C, Boolean> {
private boolean liberal = false;
protected Builder(@Nonnull final String name) {
protected Builder(@NonNull final String name) {
super(Boolean.class, name);
}
@ -119,8 +118,7 @@ public final class BooleanArgument<C> extends CommandArgument<C, Boolean> {
* @param liberal liberal value
* @return Builder instance
*/
@Nonnull
public Builder<C> withLiberal(final boolean liberal) {
public @NonNull Builder<C> withLiberal(final boolean liberal) {
this.liberal = liberal;
return this;
}
@ -130,9 +128,8 @@ public final class BooleanArgument<C> extends CommandArgument<C, Boolean> {
*
* @return Constructed argument
*/
@Nonnull
@Override
public BooleanArgument<C> build() {
public @NonNull BooleanArgument<C> build() {
return new BooleanArgument<>(this.isRequired(), this.getName(), this.liberal,
this.getDefaultValue(), this.getSuggestionsProvider());
}
@ -156,10 +153,9 @@ public final class BooleanArgument<C> extends CommandArgument<C, Boolean> {
this.liberal = liberal;
}
@Nonnull
@Override
public ArgumentParseResult<Boolean> parse(@Nonnull final CommandContext<C> commandContext,
@Nonnull final Queue<String> inputQueue) {
public @NonNull ArgumentParseResult<Boolean> parse(@NonNull final CommandContext<C> commandContext,
@NonNull final Queue<@NonNull String> inputQueue) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NullPointerException("No input was provided"));
@ -191,10 +187,9 @@ public final class BooleanArgument<C> extends CommandArgument<C, Boolean> {
return ArgumentParseResult.failure(new BooleanParseException(input, true));
}
@Nonnull
@Override
public List<String> suggestions(@Nonnull final CommandContext<C> commandContext,
@Nonnull final String input) {
public @NonNull List<@NonNull String> suggestions(@NonNull final CommandContext<C> commandContext,
@NonNull final String input) {
if (!liberal) {
return Arrays.asList("TRUE", "FALSE");
}
@ -223,7 +218,8 @@ public final class BooleanArgument<C> extends CommandArgument<C, Boolean> {
* @param input String input
* @param liberal Liberal value
*/
public BooleanParseException(@Nonnull final String input, final boolean liberal) {
public BooleanParseException(@NonNull final String input,
final boolean liberal) {
this.input = input;
this.liberal = liberal;
}

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

@ -23,14 +23,14 @@
//
package cloud.commandframework.arguments.standard;
import cloud.commandframework.exceptions.parsing.NumberParseException;
import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.arguments.parser.ArgumentParseResult;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.context.CommandContext;
import cloud.commandframework.exceptions.parsing.NumberParseException;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.List;
import java.util.Queue;
import java.util.function.BiFunction;
@ -41,9 +41,13 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
private final byte min;
private final byte max;
private ByteArgument(final boolean required, @Nonnull final String name, final byte min,
final byte max, final String defaultValue,
@Nullable final BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider) {
private ByteArgument(final boolean required,
@NonNull final String name,
final byte min,
final byte max,
@NonNull final String defaultValue,
@Nullable final BiFunction<@NonNull CommandContext<C>, @NonNull String,
@NonNull List<@NonNull String>> suggestionsProvider) {
super(required, name, new ByteParser<>(min, max), defaultValue, Byte.class, suggestionsProvider);
this.min = min;
this.max = max;
@ -56,8 +60,7 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
* @param <C> Command sender type
* @return Created builder
*/
@Nonnull
public static <C> Builder<C> newBuilder(@Nonnull final String name) {
public static <C> @NonNull Builder<C> newBuilder(@NonNull final String name) {
return new Builder<>(name);
}
@ -68,8 +71,7 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Byte> required(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Byte> required(@NonNull final String name) {
return ByteArgument.<C>newBuilder(name).asRequired().build();
}
@ -80,8 +82,7 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Byte> optional(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Byte> optional(@NonNull final String name) {
return ByteArgument.<C>newBuilder(name).asOptional().build();
}
@ -93,9 +94,8 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Byte> optional(@Nonnull final String name,
final byte defaultNum) {
public static <C> @NonNull CommandArgument<C, Byte> optional(@NonNull final String name,
final byte defaultNum) {
return ByteArgument.<C>newBuilder(name).asOptionalWithDefault(Byte.toString(defaultNum)).build();
}
@ -122,7 +122,7 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
private byte min = Byte.MIN_VALUE;
private byte max = Byte.MAX_VALUE;
protected Builder(@Nonnull final String name) {
protected Builder(@NonNull final String name) {
super(Byte.class, name);
}
@ -132,8 +132,7 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
* @param min Minimum value
* @return Builder instance
*/
@Nonnull
public Builder<C> withMin(final byte min) {
public @NonNull Builder<C> withMin(final byte min) {
this.min = min;
return this;
}
@ -144,8 +143,7 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
* @param max Maximum value
* @return Builder instance
*/
@Nonnull
public Builder<C> withMax(final byte max) {
public @NonNull Builder<C> withMax(final byte max) {
this.max = max;
return this;
}
@ -155,9 +153,8 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
*
* @return Constructed argument
*/
@Nonnull
@Override
public ByteArgument<C> build() {
public @NonNull ByteArgument<C> build() {
return new ByteArgument<>(this.isRequired(), this.getName(), this.min, this.max,
this.getDefaultValue(), this.getSuggestionsProvider());
}
@ -180,11 +177,10 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
this.max = max;
}
@Nonnull
@Override
public ArgumentParseResult<Byte> parse(
@Nonnull final CommandContext<C> commandContext,
@Nonnull final Queue<String> inputQueue) {
public @NonNull ArgumentParseResult<Byte> parse(
@NonNull final CommandContext<C> commandContext,
@NonNull final Queue<@NonNull String> inputQueue) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NullPointerException("No input was provided"));
@ -211,10 +207,9 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
return true;
}
@Nonnull
@Override
public List<String> suggestions(@Nonnull final CommandContext<C> commandContext,
@Nonnull final String input) {
public @NonNull List<@NonNull String> suggestions(@NonNull final CommandContext<C> commandContext,
@NonNull final String input) {
return IntegerArgument.IntegerParser.getSuggestions(this.min, this.max, input);
}
@ -251,7 +246,7 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
* @param min Minimum value
* @param max Maximum value
*/
public ByteParseException(@Nonnull final String input, final byte min, final byte max) {
public ByteParseException(@NonNull final String input, final byte min, final byte max) {
super(input, min, max);
}
@ -266,8 +261,7 @@ public final class ByteArgument<C> extends CommandArgument<C, Byte> {
}
@Override
@Nonnull
public String getNumberType() {
public @NonNull String getNumberType() {
return "byte";
}

42
cloud-core/src/main/java/cloud/commandframework/arguments/standard/CharArgument.java
View file

@ -24,12 +24,12 @@
package cloud.commandframework.arguments.standard;
import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.arguments.parser.ArgumentParseResult;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.context.CommandContext;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.List;
import java.util.Queue;
import java.util.function.BiFunction;
@ -37,9 +37,11 @@ import java.util.function.BiFunction;
@SuppressWarnings("unused")
public final class CharArgument<C> extends CommandArgument<C, Character> {
private CharArgument(final boolean required, @Nonnull final String name,
@Nonnull final String defaultValue, @Nullable
final BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider) {
private CharArgument(final boolean required,
@NonNull final String name,
@NonNull final String defaultValue,
@Nullable final BiFunction<@NonNull CommandContext<C>,
@NonNull String, @NonNull List<@NonNull String>> suggestionsProvider) {
super(required, name, new CharacterParser<>(), defaultValue, Character.class, suggestionsProvider);
}
@ -50,8 +52,7 @@ public final class CharArgument<C> extends CommandArgument<C, Character> {
* @param <C> Command sender type
* @return Created builder
*/
@Nonnull
public static <C> CharArgument.Builder<C> newBuilder(@Nonnull final String name) {
public static <C> CharArgument.@NonNull Builder<C> newBuilder(@NonNull final String name) {
return new CharArgument.Builder<>(name);
}
@ -62,8 +63,7 @@ public final class CharArgument<C> extends CommandArgument<C, Character> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Character> required(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Character> required(@NonNull final String name) {
return CharArgument.<C>newBuilder(name).asRequired().build();
}
@ -74,8 +74,7 @@ public final class CharArgument<C> extends CommandArgument<C, Character> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Character> optional(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Character> optional(@NonNull final String name) {
return CharArgument.<C>newBuilder(name).asOptional().build();
}
@ -87,16 +86,15 @@ public final class CharArgument<C> extends CommandArgument<C, Character> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Character> optional(@Nonnull final String name,
final String defaultNum) {
public static <C> @NonNull CommandArgument<C, Character> optional(@NonNull final String name,
@NonNull final String defaultNum) {
return CharArgument.<C>newBuilder(name).asOptionalWithDefault(defaultNum).build();
}
public static final class Builder<C> extends CommandArgument.Builder<C, Character> {
protected Builder(@Nonnull final String name) {
protected Builder(@NonNull final String name) {
super(Character.class, name);
}
@ -105,9 +103,8 @@ public final class CharArgument<C> extends CommandArgument<C, Character> {
*
* @return Constructed argument
*/
@Nonnull
@Override
public CharArgument<C> build() {
public @NonNull CharArgument<C> build() {
return new CharArgument<>(this.isRequired(), this.getName(),
this.getDefaultValue(), this.getSuggestionsProvider());
}
@ -117,10 +114,9 @@ public final class CharArgument<C> extends CommandArgument<C, Character> {
public static final class CharacterParser<C> implements ArgumentParser<C, Character> {
@Nonnull
@Override
public ArgumentParseResult<Character> parse(@Nonnull final CommandContext<C> commandContext,
@Nonnull final Queue<String> inputQueue) {
public @NonNull ArgumentParseResult<Character> parse(@NonNull final CommandContext<C> commandContext,
@NonNull final Queue<@NonNull String> inputQueue) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NullPointerException("No input was provided"));
@ -153,7 +149,7 @@ public final class CharArgument<C> extends CommandArgument<C, Character> {
*
* @param input String input
*/
public CharParseException(final String input) {
public CharParseException(@NonNull final String input) {
this.input = input;
}
@ -162,7 +158,7 @@ public final class CharArgument<C> extends CommandArgument<C, Character> {
*
* @return Input value
*/
public String getInput() {
public @NonNull String getInput() {
return input;
}
}

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

@ -24,13 +24,13 @@
package cloud.commandframework.arguments.standard;
import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.exceptions.parsing.NumberParseException;
import cloud.commandframework.arguments.parser.ArgumentParseResult;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.context.CommandContext;
import cloud.commandframework.exceptions.parsing.NumberParseException;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.List;
import java.util.Queue;
import java.util.function.BiFunction;
@ -42,11 +42,12 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
private final double max;
private DoubleArgument(final boolean required,
@Nonnull final String name,
@NonNull final String name,
final double min,
final double max,
final String defaultValue,
@Nullable final BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider) {
@Nullable final BiFunction<@NonNull CommandContext<C>, @NonNull String,
@NonNull List<@NonNull String>> suggestionsProvider) {
super(required, name, new DoubleParser<>(min, max), defaultValue, Double.class, suggestionsProvider);
this.min = min;
this.max = max;
@ -59,8 +60,7 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
* @param <C> Command sender type
* @return Created builder
*/
@Nonnull
public static <C> Builder<C> newBuilder(@Nonnull final String name) {
public static <C> @NonNull Builder<C> newBuilder(@NonNull final String name) {
return new Builder<>(name);
}
@ -71,8 +71,7 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Double> required(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Double> required(@NonNull final String name) {
return DoubleArgument.<C>newBuilder(name).asRequired().build();
}
@ -83,8 +82,7 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Double> optional(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Double> optional(@NonNull final String name) {
return DoubleArgument.<C>newBuilder(name).asOptional().build();
}
@ -96,9 +94,8 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Double> optional(@Nonnull final String name,
final double defaultNum) {
public static <C> @NonNull CommandArgument<C, Double> optional(@NonNull final String name,
final double defaultNum) {
return DoubleArgument.<C>newBuilder(name).asOptionalWithDefault(Double.toString(defaultNum)).build();
}
@ -125,7 +122,7 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
private double min = Double.MIN_VALUE;
private double max = Double.MAX_VALUE;
protected Builder(@Nonnull final String name) {
protected Builder(@NonNull final String name) {
super(Double.class, name);
}
@ -135,8 +132,7 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
* @param min Minimum value
* @return Builder instance
*/
@Nonnull
public Builder<C> withMin(final int min) {
public @NonNull Builder<C> withMin(final int min) {
this.min = min;
return this;
}
@ -147,8 +143,7 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
* @param max Maximum value
* @return Builder instance
*/
@Nonnull
public Builder<C> withMax(final int max) {
public @NonNull Builder<C> withMax(final int max) {
this.max = max;
return this;
}
@ -158,9 +153,8 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
*
* @return Constructed argument
*/
@Nonnull
@Override
public DoubleArgument<C> build() {
public @NonNull DoubleArgument<C> build() {
return new DoubleArgument<>(this.isRequired(), this.getName(), this.min, this.max,
this.getDefaultValue(), this.getSuggestionsProvider());
}
@ -183,11 +177,10 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
this.max = max;
}
@Nonnull
@Override
public ArgumentParseResult<Double> parse(
@Nonnull final CommandContext<C> commandContext,
@Nonnull final Queue<String> inputQueue) {
public @NonNull ArgumentParseResult<Double> parse(
@NonNull final CommandContext<C> commandContext,
@NonNull final Queue<@NonNull String> inputQueue) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NullPointerException("No input was provided"));
@ -239,7 +232,7 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
* @param min Minimum value
* @param max Maximum value
*/
public DoubleParseException(@Nonnull final String input, final double min, final double max) {
public DoubleParseException(@NonNull final String input, final double min, final double max) {
super(input, min, max);
}
@ -254,8 +247,7 @@ public final class DoubleArgument<C> extends CommandArgument<C, Double> {
}
@Override
@Nonnull
public String getNumberType() {
public @NonNull String getNumberType() {
return "double";
}

65
cloud-core/src/main/java/cloud/commandframework/arguments/standard/EnumArgument.java
View file

@ -27,9 +27,9 @@ import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.arguments.parser.ArgumentParseResult;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.context.CommandContext;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.EnumSet;
import java.util.List;
import java.util.Queue;
@ -45,11 +45,12 @@ import java.util.stream.Collectors;
@SuppressWarnings("unused")
public class EnumArgument<C, E extends Enum<E>> extends CommandArgument<C, E> {
protected EnumArgument(@Nonnull final Class<E> enumClass,
protected EnumArgument(@NonNull final Class<E> enumClass,
final boolean required,
@Nonnull final String name,
@Nonnull final String defaultValue,
@Nullable final BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider) {
@NonNull final String name,
@NonNull final String defaultValue,
@Nullable final BiFunction<@NonNull CommandContext<C>, @NonNull String,
@NonNull List<@NonNull String>> suggestionsProvider) {
super(required, name, new EnumParser<>(enumClass), defaultValue, enumClass, suggestionsProvider);
}
@ -62,9 +63,9 @@ public class EnumArgument<C, E extends Enum<E>> extends CommandArgument<C, E> {
* @param <E> Enum type
* @return Created builder
*/
@Nonnull
public static <C, E extends Enum<E>> EnumArgument.Builder<C, E> newBuilder(
@Nonnull final Class<E> enumClass, @Nonnull final String name) {
public static <C, E extends Enum<E>> EnumArgument.@NonNull Builder<C, E> newBuilder(
@NonNull final Class<E> enumClass,
@NonNull final String name) {
return new EnumArgument.Builder<>(name, enumClass);
}
@ -77,9 +78,9 @@ public class EnumArgument<C, E extends Enum<E>> extends CommandArgument<C, E> {
* @param <E> Enum type
* @return Created argument
*/
@Nonnull
public static <C, E extends Enum<E>> CommandArgument<C, E> required(
@Nonnull final Class<E> enumClass, @Nonnull final String name) {
public static <C, E extends Enum<E>> @NonNull CommandArgument<C, E> required(
@NonNull final Class<E> enumClass,
@NonNull final String name) {
return EnumArgument.<C, E>newBuilder(enumClass, name).asRequired().build();
}
@ -92,9 +93,9 @@ public class EnumArgument<C, E extends Enum<E>> extends CommandArgument<C, E> {
* @param <E> Enum type
* @return Created argument
*/
@Nonnull
public static <C, E extends Enum<E>> CommandArgument<C, E> optional(
@Nonnull final Class<E> enumClass, @Nonnull final String name) {
public static <C, E extends Enum<E>> @NonNull CommandArgument<C, E> optional(
@NonNull final Class<E> enumClass,
@NonNull final String name) {
return EnumArgument.<C, E>newBuilder(enumClass, name).asOptional().build();
}
@ -108,9 +109,10 @@ public class EnumArgument<C, E extends Enum<E>> extends CommandArgument<C, E> {
* @param <E> Enum type
* @return Created argument
*/
@Nonnull
public static <C, E extends Enum<E>> CommandArgument<C, E> optional(
@Nonnull final Class<E> enumClass, @Nonnull final String name, @Nonnull final E defaultValue) {
public static <C, E extends Enum<E>> @NonNull CommandArgument<C, E> optional(
@NonNull final Class<E> enumClass,
@NonNull final String name,
@NonNull final E defaultValue) {
return EnumArgument.<C, E>newBuilder(enumClass, name).asOptionalWithDefault(defaultValue.name().toLowerCase()).build();
}
@ -119,14 +121,13 @@ public class EnumArgument<C, E extends Enum<E>> extends CommandArgument<C, E> {
private final Class<E> enumClass;
protected Builder(@Nonnull final String name, @Nonnull final Class<E> enumClass) {
protected Builder(@NonNull final String name, @NonNull final Class<E> enumClass) {
super(enumClass, name);
this.enumClass = enumClass;
}
@Nonnull
@Override
public CommandArgument<C, E> build() {
public @NonNull CommandArgument<C, E> build() {
return new EnumArgument<>(this.enumClass, this.isRequired(), this.getName(),
this.getDefaultValue(), this.getSuggestionsProvider());
}
@ -143,15 +144,14 @@ public class EnumArgument<C, E extends Enum<E>> extends CommandArgument<C, E> {
*
* @param enumClass Enum class
*/
public EnumParser(@Nonnull final Class<E> enumClass) {
public EnumParser(@NonNull final Class<E> enumClass) {
this.enumClass = enumClass;
this.allowedValues = EnumSet.allOf(enumClass);
}
@Nonnull
@Override
public ArgumentParseResult<E> parse(@Nonnull final CommandContext<C> commandContext,
@Nonnull final Queue<String> inputQueue) {
public @NonNull ArgumentParseResult<E> parse(@NonNull final CommandContext<C> commandContext,
@NonNull final Queue<@NonNull String> inputQueue) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NullPointerException("No input was provided"));
@ -167,9 +167,9 @@ public class EnumArgument<C, E extends Enum<E>> extends CommandArgument<C, E> {
return ArgumentParseResult.failure(new EnumParseException(input, this.enumClass));
}
@Nonnull
@Override
public List<String> suggestions(@Nonnull final CommandContext<C> commandContext, @Nonnull final String input) {
public @NonNull List<@NonNull String> suggestions(@NonNull final CommandContext<C> commandContext,
@NonNull final String input) {
return EnumSet.allOf(this.enumClass).stream().map(e -> e.name().toLowerCase()).collect(Collectors.toList());
}
@ -191,14 +191,14 @@ public class EnumArgument<C, E extends Enum<E>> extends CommandArgument<C, E> {
* @param input Input
* @param enumClass Enum class
*/
public EnumParseException(@Nonnull final String input, @Nonnull final Class<? extends Enum<?>> enumClass) {
public EnumParseException(@NonNull final String input,
@NonNull final Class<? extends Enum<?>> enumClass) {
this.input = input;
this.enumClass = enumClass;
}
@Nonnull
@SuppressWarnings("all")
private static String join(@Nonnull final Class<? extends Enum> clazz) {
private static @NonNull String join(@NonNull final Class<? extends Enum> clazz) {
final EnumSet<?> enumSet = EnumSet.allOf(clazz);
return enumSet.stream()
.map(e -> e.toString().toLowerCase())
@ -210,8 +210,7 @@ public class EnumArgument<C, E extends Enum<E>> extends CommandArgument<C, E> {
*
* @return Input
*/
@Nonnull
public String getInput() {
public @NonNull String getInput() {
return this.input;
}
@ -220,7 +219,7 @@ public class EnumArgument<C, E extends Enum<E>> extends CommandArgument<C, E> {
*
* @return Enum class
*/
public Class<? extends Enum<?>> getEnumClass() {
public @NonNull Class<? extends Enum<?>> getEnumClass() {
return this.enumClass;
}

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

@ -23,14 +23,14 @@
//
package cloud.commandframework.arguments.standard;
import cloud.commandframework.exceptions.parsing.NumberParseException;
import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.arguments.parser.ArgumentParseResult;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.context.CommandContext;
import cloud.commandframework.exceptions.parsing.NumberParseException;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.List;
import java.util.Queue;
import java.util.function.BiFunction;
@ -42,11 +42,12 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
private final float max;
private FloatArgument(final boolean required,
@Nonnull final String name,
@NonNull final String name,
final float min,
final float max,
final String defaultValue,
@Nullable final BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider) {
@NonNull final String defaultValue,
@Nullable final BiFunction<@NonNull CommandContext<C>,
@NonNull String, @NonNull List<@NonNull String>> suggestionsProvider) {
super(required, name, new FloatParser<>(min, max), defaultValue, Float.class, suggestionsProvider);
this.min = min;
this.max = max;
@ -59,8 +60,7 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
* @param <C> Command sender type
* @return Created builder
*/
@Nonnull
public static <C> Builder<C> newBuilder(@Nonnull final String name) {
public static <C> @NonNull Builder<C> newBuilder(@NonNull final String name) {
return new Builder<>(name);
}
@ -71,8 +71,7 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Float> required(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Float> required(@NonNull final String name) {
return FloatArgument.<C>newBuilder(name).asRequired().build();
}
@ -83,8 +82,7 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Float> optional(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Float> optional(@NonNull final String name) {
return FloatArgument.<C>newBuilder(name).asOptional().build();
}
@ -96,9 +94,8 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Float> optional(@Nonnull final String name,
final float defaultNum) {
public static <C> @NonNull CommandArgument<C, Float> optional(@NonNull final String name,
final float defaultNum) {
return FloatArgument.<C>newBuilder(name).asOptionalWithDefault(Float.toString(defaultNum)).build();
}
@ -125,7 +122,7 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
private float min = Float.MIN_VALUE;
private float max = Float.MAX_VALUE;
protected Builder(@Nonnull final String name) {
protected Builder(@NonNull final String name) {
super(Float.class, name);
}
@ -135,8 +132,7 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
* @param min Minimum value
* @return Builder instance
*/
@Nonnull
public Builder<C> withMin(final int min) {
public @NonNull Builder<C> withMin(final int min) {
this.min = min;
return this;
}
@ -147,8 +143,7 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
* @param max Maximum value
* @return Builder instance
*/
@Nonnull
public Builder<C> withMax(final int max) {
public @NonNull Builder<C> withMax(final int max) {
this.max = max;
return this;
}
@ -158,9 +153,8 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
*
* @return Constructed argument
*/
@Nonnull
@Override
public FloatArgument<C> build() {
public @NonNull FloatArgument<C> build() {
return new FloatArgument<>(this.isRequired(), this.getName(), this.min, this.max,
this.getDefaultValue(), this.getSuggestionsProvider());
}
@ -183,11 +177,10 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
this.max = max;
}
@Nonnull
@Override
public ArgumentParseResult<Float> parse(
@Nonnull final CommandContext<C> commandContext,
@Nonnull final Queue<String> inputQueue) {
public @NonNull ArgumentParseResult<Float> parse(
@NonNull final CommandContext<C> commandContext,
@NonNull final Queue<String> inputQueue) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NullPointerException("No input was provided"));
@ -239,7 +232,7 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
* @param min Minimum value
* @param max Maximum value
*/
public FloatParseException(@Nonnull final String input, final float min, final float max) {
public FloatParseException(@NonNull final String input, final float min, final float max) {
super(input, min, max);
}
@ -254,8 +247,7 @@ public final class FloatArgument<C> extends CommandArgument<C, Float> {
}
@Override
@Nonnull
public String getNumberType() {
public @NonNull String getNumberType() {
return "float";
}

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

@ -23,14 +23,14 @@
//
package cloud.commandframework.arguments.standard;
import cloud.commandframework.exceptions.parsing.NumberParseException;
import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.arguments.parser.ArgumentParseResult;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.context.CommandContext;
import cloud.commandframework.exceptions.parsing.NumberParseException;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
@ -49,11 +49,12 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
private final int max;
private IntegerArgument(final boolean required,
@Nonnull final String name,
@NonNull final String name,
final int min,
final int max,
final String defaultValue,
@Nullable final BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider) {
@Nullable final BiFunction<@NonNull CommandContext<C>, @NonNull String,
@NonNull List<@NonNull String>> suggestionsProvider) {
super(required, name, new IntegerParser<>(min, max), defaultValue, Integer.class, suggestionsProvider);
this.min = min;
this.max = max;
@ -66,8 +67,7 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
* @param <C> Command sender type
* @return Created builder
*/
@Nonnull
public static <C> Builder<C> newBuilder(@Nonnull final String name) {
public static <C> @NonNull Builder<C> newBuilder(@NonNull final String name) {
return new Builder<>(name);
}
@ -78,8 +78,7 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Integer> required(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Integer> required(@NonNull final String name) {
return IntegerArgument.<C>newBuilder(name).asRequired().build();
}
@ -90,8 +89,7 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Integer> optional(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Integer> optional(@NonNull final String name) {
return IntegerArgument.<C>newBuilder(name).asOptional().build();
}
@ -103,9 +101,8 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Integer> optional(@Nonnull final String name,
final int defaultNum) {
public static <C> @NonNull CommandArgument<C, Integer> optional(@NonNull final String name,
final int defaultNum) {
return IntegerArgument.<C>newBuilder(name).asOptionalWithDefault(Integer.toString(defaultNum)).build();
}
@ -132,7 +129,7 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
private int min = Integer.MIN_VALUE;
private int max = Integer.MAX_VALUE;
protected Builder(@Nonnull final String name) {
protected Builder(@NonNull final String name) {
super(Integer.class, name);
}
@ -142,8 +139,7 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
* @param min Minimum value
* @return Builder instance
*/
@Nonnull
public Builder<C> withMin(final int min) {
public @NonNull Builder<C> withMin(final int min) {
this.min = min;
return this;
}
@ -154,8 +150,7 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
* @param max Maximum value
* @return Builder instance
*/
@Nonnull
public Builder<C> withMax(final int max) {
public @NonNull Builder<C> withMax(final int max) {
this.max = max;
return this;
}
@ -165,9 +160,8 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
*
* @return Constructed argument
*/
@Nonnull
@Override
public IntegerArgument<C> build() {
public @NonNull IntegerArgument<C> build() {
return new IntegerArgument<>(this.isRequired(), this.getName(), this.min, this.max,
this.getDefaultValue(), this.getSuggestionsProvider());
}
@ -190,8 +184,7 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
this.max = max;
}
@Nonnull
static List<String> getSuggestions(final long min, final long max, @Nonnull final String input) {
static @NonNull List<@NonNull String> getSuggestions(final long min, final long max, @NonNull final String input) {
if (input.isEmpty()) {
return IntStream.range(0, MAX_SUGGESTIONS_INCREMENT).mapToObj(Integer::toString).collect(Collectors.toList());
}
@ -213,11 +206,10 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
}
}
@Nonnull
@Override
public ArgumentParseResult<Integer> parse(
@Nonnull final CommandContext<C> commandContext,
@Nonnull final Queue<String> inputQueue) {
public @NonNull ArgumentParseResult<Integer> parse(
@NonNull final CommandContext<C> commandContext,
@NonNull final Queue<@NonNull String> inputQueue) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NullPointerException("No input was provided"));
@ -257,10 +249,9 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
return true;
}
@Nonnull
@Override
public List<String> suggestions(@Nonnull final CommandContext<C> commandContext,
@Nonnull final String input) {
public @NonNull List<@NonNull String> suggestions(@NonNull final CommandContext<C> commandContext,
@NonNull final String input) {
return getSuggestions(this.min, this.max, input);
}
@ -276,7 +267,7 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
* @param min Minimum value
* @param max Maximum value
*/
public IntegerParseException(@Nonnull final String input, final int min, final int max) {
public IntegerParseException(@NonNull final String input, final int min, final int max) {
super(input, min, max);
}
@ -291,8 +282,7 @@ public final class IntegerArgument<C> extends CommandArgument<C, Integer> {
}
@Override
@Nonnull
public String getNumberType() {
public @NonNull String getNumberType() {
return "integer";
}

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

@ -23,14 +23,14 @@
//
package cloud.commandframework.arguments.standard;
import cloud.commandframework.exceptions.parsing.NumberParseException;
import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.arguments.parser.ArgumentParseResult;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.context.CommandContext;
import cloud.commandframework.exceptions.parsing.NumberParseException;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.List;
import java.util.Queue;
import java.util.function.BiFunction;
@ -42,11 +42,12 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
private final long max;
private LongArgument(final boolean required,
@Nonnull final String name,
@NonNull final String name,
final long min,
final long max,
final String defaultValue,
@Nullable final BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider) {
@Nullable final BiFunction<@NonNull CommandContext<C>, @NonNull String,
@NonNull List<@NonNull String>> suggestionsProvider) {
super(required, name, new LongParser<>(min, max), defaultValue, Long.class, suggestionsProvider);
this.min = min;
this.max = max;
@ -59,8 +60,7 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
* @param <C> Command sender type
* @return Created builder
*/
@Nonnull
public static <C> LongArgument.Builder<C> newBuilder(@Nonnull final String name) {
public static <C> LongArgument.@NonNull Builder<C> newBuilder(@NonNull final String name) {
return new Builder<>(name);
}
@ -71,8 +71,7 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Long> required(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Long> required(@NonNull final String name) {
return LongArgument.<C>newBuilder(name).asRequired().build();
}
@ -83,8 +82,7 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Long> optional(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, Long> optional(@NonNull final String name) {
return LongArgument.<C>newBuilder(name).asOptional().build();
}
@ -96,9 +94,8 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, Long> optional(@Nonnull final String name,
final long defaultNum) {
public static <C> @NonNull CommandArgument<C, Long> optional(@NonNull final String name,
final long defaultNum) {
return LongArgument.<C>newBuilder(name).asOptionalWithDefault(Long.toString(defaultNum)).build();
}
@ -125,7 +122,7 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
private long min = Long.MIN_VALUE;
private long max = Long.MAX_VALUE;
protected Builder(@Nonnull final String name) {
protected Builder(@NonNull final String name) {
super(Long.class, name);
}
@ -135,8 +132,7 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
* @param min Minimum value
* @return Builder instance
*/
@Nonnull
public Builder<C> withMin(final long min) {
public @NonNull Builder<C> withMin(final long min) {
this.min = min;
return this;
}
@ -147,8 +143,7 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
* @param max Maximum value
* @return Builder instance
*/
@Nonnull
public Builder<C> withMax(final long max) {
public @NonNull Builder<C> withMax(final long max) {
this.max = max;
return this;
}
@ -158,9 +153,8 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
*
* @return Constructed argument
*/
@Nonnull
@Override
public LongArgument<C> build() {
public @NonNull LongArgument<C> build() {
return new LongArgument<>(this.isRequired(), this.getName(), this.min,
this.max, this.getDefaultValue(), this.getSuggestionsProvider());
}
@ -177,11 +171,10 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
this.max = max;
}
@Nonnull
@Override
public ArgumentParseResult<Long> parse(
@Nonnull final CommandContext<C> commandContext,
@Nonnull final Queue<String> inputQueue) {
public @NonNull ArgumentParseResult<Long> parse(
@NonNull final CommandContext<C> commandContext,
@NonNull final Queue<@NonNull String> inputQueue) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NullPointerException("No input was provided"));
@ -203,10 +196,9 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
return true;
}
@Nonnull
@Override
public List<String> suggestions(@Nonnull final CommandContext<C> commandContext,
@Nonnull final String input) {
public @NonNull List<@NonNull String> suggestions(@NonNull final CommandContext<C> commandContext,
@NonNull final String input) {
return IntegerArgument.IntegerParser.getSuggestions(this.min, this.max, input);
}
@ -222,7 +214,7 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
* @param min Minimum value
* @param max Maximum value
*/
public LongParseException(@Nonnull final String input, final long min, final long max) {
public LongParseException(@NonNull final String input, final long min, final long max) {
super(input, min, max);
}
@ -237,8 +229,7 @@ public final class LongArgument<C> extends CommandArgument<C, Long> {
}
@Override
@Nonnull
public String getNumberType() {
public @NonNull String getNumberType() {
return "long";
}

91
cloud-core/src/main/java/cloud/commandframework/arguments/standard/StringArgument.java
View file

@ -27,8 +27,8 @@ import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.arguments.parser.ArgumentParseResult;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.context.CommandContext;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.util.Collections;
import java.util.List;
import java.util.Queue;
@ -41,10 +41,11 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
private final StringMode stringMode;
private StringArgument(final boolean required,
@Nonnull final String name,
@Nonnull final StringMode stringMode,
@Nonnull final String defaultValue,
@Nonnull final BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider) {
@NonNull final String name,
@NonNull final StringMode stringMode,
@NonNull final String defaultValue,
@NonNull final BiFunction<@NonNull CommandContext<C>, @NonNull String,
@NonNull List<@NonNull String>> suggestionsProvider) {
super(required, name, new StringParser<>(stringMode, suggestionsProvider),
defaultValue, String.class, suggestionsProvider);
this.stringMode = stringMode;
@ -57,8 +58,7 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
* @param <C> Command sender type
* @return Created builder
*/
@Nonnull
public static <C> StringArgument.Builder<C> newBuilder(@Nonnull final String name) {
public static <C> StringArgument.@NonNull Builder<C> newBuilder(@NonNull final String name) {
return new StringArgument.Builder<>(name);
}
@ -69,8 +69,7 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, String> required(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, String> required(@NonNull final String name) {
return StringArgument.<C>newBuilder(name).single().asRequired().build();
}
@ -82,8 +81,8 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, String> required(@Nonnull final String name, @Nonnull final StringMode stringMode) {
public static <C> @NonNull CommandArgument<C, String> required(@NonNull final String name,
@NonNull final StringMode stringMode) {
return StringArgument.<C>newBuilder(name).withMode(stringMode).asRequired().build();
}
@ -94,8 +93,7 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, String> optional(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, String> optional(@NonNull final String name) {
return StringArgument.<C>newBuilder(name).single().asOptional().build();
}
@ -107,23 +105,22 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, String> optional(@Nonnull final String name, @Nonnull final StringMode stringMode) {
public static <C> @NonNull CommandArgument<C, String> optional(@NonNull final String name,
@NonNull final StringMode stringMode) {
return StringArgument.<C>newBuilder(name).withMode(stringMode).asOptional().build();
}
/**
* Create a new required command argument with a default value
*
* @param name Argument name
* @param defaultNum Default num
* @param <C> Command sender type
* @param name Argument name
* @param defaultString Default string
* @param <C> Command sender type
* @return Created argument
*/
@Nonnull
public static <C> CommandArgument<C, String> optional(@Nonnull final String name,
final String defaultNum) {
return StringArgument.<C>newBuilder(name).asOptionalWithDefault(defaultNum).build();
public static <C> @NonNull CommandArgument<C, String> optional(@NonNull final String name,
@NonNull String defaultString) {
return StringArgument.<C>newBuilder(name).asOptionalWithDefault(defaultString).build();
}
/**
@ -131,8 +128,7 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
*
* @return String mode
*/
@Nonnull
public StringMode getStringMode() {
public @NonNull StringMode getStringMode() {
return this.stringMode;
}
@ -149,12 +145,11 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
private StringMode stringMode = StringMode.SINGLE;
private BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider = (v1, v2) -> Collections.emptyList();
protected Builder(@Nonnull final String name) {
protected Builder(@NonNull final String name) {
super(String.class, name);
}
@Nonnull
private Builder<C> withMode(@Nonnull final StringMode stringMode) {
private @NonNull Builder<C> withMode(@NonNull final StringMode stringMode) {
this.stringMode = stringMode;
return this;
}
@ -164,8 +159,7 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
*
* @return Builder instance
*/
@Nonnull
public Builder<C> greedy() {
public @NonNull Builder<C> greedy() {
this.stringMode = StringMode.GREEDY;
return this;
}
@ -175,8 +169,7 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
*
* @return Builder instance
*/
@Nonnull
public Builder<C> single() {
public @NonNull Builder<C> single() {
this.stringMode = StringMode.SINGLE;
return this;
}
@ -186,8 +179,7 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
*
* @return Builder instance
*/
@Nonnull
public Builder<C> quoted() {
public @NonNull Builder<C> quoted() {
this.stringMode = StringMode.QUOTED;
return this;
}
@ -198,9 +190,8 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
* @param suggestionsProvider Suggestions provider
* @return Builder instance
*/
@Nonnull
public Builder<C> withSuggestionsProvider(@Nonnull final BiFunction<CommandContext<C>,
String, List<String>> suggestionsProvider) {
public @NonNull Builder<C> withSuggestionsProvider(@NonNull final BiFunction<@NonNull CommandContext<C>,
@NonNull String, @NonNull List<@NonNull String>> suggestionsProvider) {
this.suggestionsProvider = suggestionsProvider;
return this;
}
@ -210,9 +201,8 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
*
* @return Constructed argument
*/
@Nonnull
@Override
public StringArgument<C> build() {
public @NonNull StringArgument<C> build() {
return new StringArgument<>(this.isRequired(), this.getName(), this.stringMode,
this.getDefaultValue(), this.suggestionsProvider);
}
@ -231,16 +221,16 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
* @param stringMode String parsing mode
* @param suggestionsProvider Suggestions provider
*/
public StringParser(@Nonnull final StringMode stringMode,
@Nonnull final BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider) {
public StringParser(@NonNull final StringMode stringMode,
@NonNull final BiFunction<@NonNull CommandContext<C>, @NonNull String,
@NonNull List<@NonNull String>> suggestionsProvider) {
this.stringMode = stringMode;
this.suggestionsProvider = suggestionsProvider;
}
@Nonnull
@Override
public ArgumentParseResult<String> parse(@Nonnull final CommandContext<C> commandContext,
@Nonnull final Queue<String> inputQueue) {
public @NonNull ArgumentParseResult<String> parse(@NonNull final CommandContext<C> commandContext,
@NonNull final Queue<@NonNull String> inputQueue) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NullPointerException("No input was provided"));
@ -303,9 +293,9 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
return ArgumentParseResult.success(sj.toString());
}
@Nonnull
@Override
public List<String> suggestions(@Nonnull final CommandContext<C> commandContext, @Nonnull final String input) {
public @NonNull List<@NonNull String> suggestions(@NonNull final CommandContext<C> commandContext,
@NonNull final String input) {
return this.suggestionsProvider.apply(commandContext, input);
}
@ -319,8 +309,7 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
*
* @return String mode
*/
@Nonnull
public StringMode getStringMode() {
public @NonNull StringMode getStringMode() {
return this.stringMode;
}
}
@ -337,7 +326,7 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
* @param input Input
* @param stringMode String mode
*/
public StringParseException(@Nonnull final String input, @Nonnull final StringMode stringMode) {
public StringParseException(@NonNull final String input, @NonNull final StringMode stringMode) {
this.input = input;
this.stringMode = stringMode;
}
@ -348,8 +337,7 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
*
* @return Input
*/
@Nonnull
public String getInput() {
public @NonNull String getInput() {
return this.input;
}
@ -358,8 +346,7 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
*
* @return String mode
*/
@Nonnull
public StringMode getStringMode() {
public @NonNull StringMode getStringMode() {
return this.stringMode;
}

39
cloud-core/src/main/java/cloud/commandframework/arguments/standard/UUIDArgument.java
View file

@ -27,9 +27,9 @@ import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.arguments.parser.ArgumentParseResult;
import cloud.commandframework.arguments.parser.ArgumentParser;
import cloud.commandframework.context.CommandContext;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.List;
import java.util.Queue;
import java.util.UUID;
@ -39,9 +39,10 @@ import java.util.function.BiFunction;
public final class UUIDArgument<C> extends CommandArgument<C, UUID> {
private UUIDArgument(final boolean required,
@Nonnull final String name,
@Nonnull final String defaultValue,
@Nullable final BiFunction<CommandContext<C>, String, List<String>> suggestionsProvider) {
@NonNull final String name,
@NonNull final String defaultValue,
@Nullable final BiFunction<@NonNull CommandContext<C>,
@NonNull String, @NonNull List<@NonNull String>> suggestionsProvider) {
super(required, name, new UUIDParser<>(), defaultValue, UUID.class, suggestionsProvider);
}
@ -52,8 +53,7 @@ public final class UUIDArgument<C> extends CommandArgument<C, UUID> {
* @param <C> Command sender type
* @return Created builder
*/
@Nonnull
public static <C> Builder<C> newBuilder(@Nonnull final String name) {
public static <C> @NonNull Builder<C> newBuilder(@NonNull final String name) {
return new Builder<>(name);
}
@ -64,8 +64,7 @@ public final class UUIDArgument<C> extends CommandArgument<C, UUID> {
* @param <C> Command sender type
* @return Created component
*/
@Nonnull
public static <C> CommandArgument<C, UUID> required(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, UUID> required(@NonNull final String name) {
return UUIDArgument.<C>newBuilder(name).asRequired().build();
}
@ -76,8 +75,7 @@ public final class UUIDArgument<C> extends CommandArgument<C, UUID> {
* @param <C> Command sender type
* @return Created component
*/
@Nonnull
public static <C> CommandArgument<C, UUID> optional(@Nonnull final String name) {
public static <C> @NonNull CommandArgument<C, UUID> optional(@NonNull final String name) {
return UUIDArgument.<C>newBuilder(name).asOptional().build();
}
@ -89,16 +87,15 @@ public final class UUIDArgument<C> extends CommandArgument<C, UUID> {
* @param <C> Command sender type
* @return Created component
*/
@Nonnull
public static <C> CommandArgument<C, UUID> optional(@Nonnull final String name,
final UUID defaultUUID) {
public static <C> @NonNull CommandArgument<C, UUID> optional(@NonNull final String name,
@NonNull final UUID defaultUUID) {
return UUIDArgument.<C>newBuilder(name).asOptionalWithDefault(defaultUUID.toString()).build();
}
public static final class Builder<C> extends CommandArgument.Builder<C, UUID> {
protected Builder(@Nonnull final String name) {
protected Builder(@NonNull final String name) {
super(UUID.class, name);
}
@ -107,9 +104,8 @@ public final class UUIDArgument<C> extends CommandArgument<C, UUID> {
*
* @return Constructed component
*/
@Nonnull
@Override
public UUIDArgument<C> build() {
public @NonNull UUIDArgument<C> build() {
return new UUIDArgument<>(this.isRequired(), this.getName(), this.getDefaultValue(), this.getSuggestionsProvider());
}
@ -118,11 +114,10 @@ public final class UUIDArgument<C> extends CommandArgument<C, UUID> {
private static final class UUIDParser<C> implements ArgumentParser<C, UUID> {
@Nonnull
@Override
public ArgumentParseResult<UUID> parse(
@Nonnull final CommandContext<C> commandContext,
@Nonnull final Queue<String> inputQueue) {
public @NonNull ArgumentParseResult<UUID> parse(
@NonNull final CommandContext<C> commandContext,
@NonNull final Queue<@NonNull String> inputQueue) {
final String input = inputQueue.peek();
if (input == null) {
return ArgumentParseResult.failure(new NullPointerException("No input was provided"));
@ -151,7 +146,7 @@ public final class UUIDArgument<C> extends CommandArgument<C, UUID> {
*
* @param input String input
*/
public UUIDParseException(@Nonnull final String input) {
public UUIDParseException(@NonNull final String input) {
super(input);
}

5
cloud-core/src/main/java/cloud/commandframework/types/tuples/Pair.java
View file

@ -101,12 +101,11 @@ public class Pair<U, V> implements Tuple {
@Override
public final int getSize() {
return Tuples.SIZE_PAIR;
return 2;
}
@Nonnull
@Override
public final Object[] toArray() {
public final @NonNull Object @NonNull [] toArray() {
final Object[] array = new Object[2];
array[0] = this.first;
array[1] = this.second;

5
cloud-core/src/main/java/cloud/commandframework/types/tuples/Quartet.java
View file

@ -135,12 +135,11 @@ public class Quartet<U, V, W, X> implements Tuple {
@Override
public final int getSize() {
return Tuples.SIZE_QUARTET;
return 4;
}
@Nonnull
@Override
public final Object[] toArray() {
public final @NonNull Object @NonNull [] toArray() {
final Object[] array = new Object[4];
array[0] = this.first;
array[1] = this.second;

5
cloud-core/src/main/java/cloud/commandframework/types/tuples/Quintet.java
View file

@ -153,12 +153,11 @@ public class Quintet<U, V, W, X, Y> implements Tuple {
@Override
public final int getSize() {
return Tuples.SIZE_QUINTET;
return 5;
}
@Nonnull
@Override
public final Object[] toArray() {
public final @NonNull Object @NonNull [] toArray() {
final Object[] array = new Object[5];
array[0] = this.first;
array[1] = this.second;

5
cloud-core/src/main/java/cloud/commandframework/types/tuples/Sextet.java
View file

@ -171,12 +171,11 @@ public class Sextet<U, V, W, X, Y, Z> implements Tuple {
@Override
public final int getSize() {
return Tuples.SIZE_SEXTET;
return 6;
}
@Nonnull
@Override
public final Object[] toArray() {
public @NonNull final Object @NonNull [] toArray() {
final Object[] array = new Object[6];
array[0] = this.first;
array[1] = this.second;

5
cloud-core/src/main/java/cloud/commandframework/types/tuples/Triplet.java
View file

@ -118,12 +118,11 @@ public class Triplet<U, V, W> implements Tuple {
@Override
public final int getSize() {
return Tuples.SIZE_TRIPLET;
return 3;
}
@Nonnull
@Override
public final Object[] toArray() {
public final @NonNull Object @NonNull [] toArray() {
final Object[] array = new Object[3];
array[0] = this.first;
array[1] = this.second;

5
cloud-core/src/main/java/cloud/commandframework/types/tuples/Tuple.java
View file

@ -23,7 +23,7 @@
//
package cloud.commandframework.types.tuples;
import javax.annotation.Nonnull;
import org.checkerframework.checker.nullness.qual.NonNull;
/**
* Tuple type
@ -42,7 +42,6 @@ public interface Tuple {
*
* @return Created array
*/
@Nonnull
Object[] toArray();
@NonNull Object @NonNull [] toArray();
}