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

33
cloud-annotations/src/main/java/cloud/commandframework/annotations/AnnotationParser.java
View file

@ -36,9 +36,9 @@ import cloud.commandframework.meta.CommandMeta;
import cloud.commandframework.meta.SimpleCommandMeta;
import io.leangen.geantyref.TypeToken;
import cloud.commandframework.arguments.parser.ParserParameters;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
@ -75,9 +75,9 @@ public final class AnnotationParser<C> {
* {@link ParserParameter}. Mappers for the
* parser parameters can be registered using {@link #registerAnnotationMapper(Class, Function)}
*/
public AnnotationParser(@Nonnull final CommandManager<C> manager,
@Nonnull final Class<C> commandSenderClass,
@Nonnull final Function<ParserParameters, CommandMeta> metaMapper) {
public AnnotationParser(@NonNull final CommandManager<C> manager,
@NonNull final Class<C> commandSenderClass,
@NonNull final Function<@NonNull ParserParameters, @NonNull CommandMeta> metaMapper) {
this.commandSenderClass = commandSenderClass;
this.manager = manager;
this.metaFactory = new MetaFactory(this, metaMapper);
@ -93,8 +93,9 @@ public final class AnnotationParser<C> {
* @param mapper Mapping function
* @param <A> Annotation type
*/
public <A extends Annotation> void registerAnnotationMapper(@Nonnull final Class<A> annotation,
@Nonnull final Function<A, ParserParameters> mapper) {
public <A extends Annotation> void registerAnnotationMapper(@NonNull final Class<A> annotation,
@NonNull final Function<@NonNull A,
@NonNull ParserParameters> mapper) {
this.annotationMappers.put(annotation, mapper);
}
@ -106,8 +107,7 @@ public final class AnnotationParser<C> {
* @param <T> Type of the instance
* @return Collection of parsed annotations
*/
@Nonnull
public <T> Collection<Command<C>> parse(@Nonnull final T instance) {
public <T> @NonNull Collection<@NonNull Command<C>> parse(@NonNull final T instance) {
final Method[] methods = instance.getClass().getDeclaredMethods();
final Collection<CommandMethodPair> commandMethodPairs = new ArrayList<>();
for (final Method method : methods) {
@ -133,10 +133,10 @@ public final class AnnotationParser<C> {
return commands;
}
@Nonnull
@SuppressWarnings("unchecked")
private Collection<Command<C>> construct(@Nonnull final Object instance,
@Nonnull final Collection<CommandMethodPair> methodPairs) {
private @NonNull Collection<@NonNull Command<C>> construct(
@NonNull final Object instance,
@NonNull final Collection<@NonNull CommandMethodPair> methodPairs) {
final Collection<Command<C>> commands = new ArrayList<>();
for (final CommandMethodPair commandMethodPair : methodPairs) {
final CommandMethod commandMethod = commandMethodPair.getCommandMethod();
@ -239,11 +239,10 @@ public final class AnnotationParser<C> {
return commands;
}
@Nonnull
@SuppressWarnings("unchecked")
private CommandArgument<C, ?> buildArgument(@Nonnull final Method method,
private @NonNull CommandArgument<C, ?> buildArgument(@NonNull final Method method,
@Nullable final SyntaxFragment syntaxFragment,
@Nonnull final ArgumentParameterPair argumentPair) {
@NonNull final ArgumentParameterPair argumentPair) {
final Parameter parameter = argumentPair.getParameter();
final Collection<Annotation> annotations = Arrays.asList(parameter.getAnnotations());
final TypeToken<?> token = TypeToken.get(parameter.getParameterizedType());
@ -291,8 +290,8 @@ public final class AnnotationParser<C> {
return argumentBuilder.manager(this.manager).withParser(parser).build();
}
@Nonnull
Map<Class<? extends Annotation>, Function<? extends Annotation, ParserParameters>> getAnnotationMappers() {
@NonNull Map<@NonNull Class<@NonNull ? extends Annotation>,
@NonNull Function<@NonNull ? extends Annotation, @NonNull ParserParameters>> getAnnotationMappers() {
return this.annotationMappers;
}

7
cloud-annotations/src/main/java/cloud/commandframework/annotations/ArgumentExtractor.java
View file

@ -23,7 +23,8 @@
//
package cloud.commandframework.annotations;
import javax.annotation.Nonnull;
import org.checkerframework.checker.nullness.qual.NonNull;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
@ -34,10 +35,10 @@ import java.util.function.Function;
* Utility that extract {@link Argument arguments} from
* {@link java.lang.reflect.Method method} {@link java.lang.reflect.Parameter parameters}
*/
class ArgumentExtractor implements Function<Method, Collection<ArgumentParameterPair>> {
class ArgumentExtractor implements Function<@NonNull Method, Collection<@NonNull ArgumentParameterPair>> {
@Override
public Collection<ArgumentParameterPair> apply(@Nonnull final Method method) {
public @NonNull Collection<@NonNull ArgumentParameterPair> apply(@NonNull final Method method) {
final Collection<ArgumentParameterPair> arguments = new ArrayList<>();
for (final Parameter parameter : method.getParameters()) {
if (!parameter.isAnnotationPresent(Argument.class)) {

12
cloud-annotations/src/main/java/cloud/commandframework/annotations/ArgumentParameterPair.java
View file

@ -23,7 +23,8 @@
//
package cloud.commandframework.annotations;
import javax.annotation.Nonnull;
import org.checkerframework.checker.nullness.qual.NonNull;
import java.lang.reflect.Parameter;
final class ArgumentParameterPair {
@ -31,18 +32,17 @@ final class ArgumentParameterPair {
private final Parameter parameter;
private final Argument argument;
ArgumentParameterPair(@Nonnull final Parameter parameter, @Nonnull final Argument argument) {
ArgumentParameterPair(@NonNull final Parameter parameter,
@NonNull final Argument argument) {
this.parameter = parameter;
this.argument = argument;
}
@Nonnull
Parameter getParameter() {
@NonNull Parameter getParameter() {
return this.parameter;
}
@Nonnull
Argument getArgument() {
@NonNull Argument getArgument() {
return this.argument;
}

12
cloud-annotations/src/main/java/cloud/commandframework/annotations/CommandMethodPair.java
View file

@ -23,7 +23,8 @@
//
package cloud.commandframework.annotations;
import javax.annotation.Nonnull;
import org.checkerframework.checker.nullness.qual.NonNull;
import java.lang.reflect.Method;
final class CommandMethodPair {
@ -31,18 +32,17 @@ final class CommandMethodPair {
private final Method method;
private final CommandMethod commandMethod;
CommandMethodPair(@Nonnull final Method method, @Nonnull final CommandMethod commandMethod) {
CommandMethodPair(@NonNull final Method method,
@NonNull final CommandMethod commandMethod) {
this.method = method;
this.commandMethod = commandMethod;
}
@Nonnull
Method getMethod() {
@NonNull Method getMethod() {
return this.method;
}
@Nonnull
CommandMethod getCommandMethod() {
@NonNull CommandMethod getCommandMethod() {
return this.commandMethod;
}

10
cloud-annotations/src/main/java/cloud/commandframework/annotations/MetaFactory.java
View file

@ -25,24 +25,24 @@ package cloud.commandframework.annotations;
import cloud.commandframework.arguments.parser.ParserParameters;
import cloud.commandframework.meta.CommandMeta;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.lang.annotation.Annotation;
import java.util.function.Function;
class MetaFactory implements Function<Annotation[], CommandMeta> {
class MetaFactory implements Function<@NonNull Annotation @NonNull [], @NonNull CommandMeta> {
private final AnnotationParser<?> annotationParser;
private final Function<ParserParameters, CommandMeta> metaMapper;
MetaFactory(@Nonnull final AnnotationParser<?> annotationParser,
@Nonnull final Function<ParserParameters, CommandMeta> metaMapper) {
MetaFactory(@NonNull final AnnotationParser<?> annotationParser,
@NonNull final Function<@NonNull ParserParameters, @NonNull CommandMeta> metaMapper) {
this.annotationParser = annotationParser;
this.metaMapper = metaMapper;
}
@Override
public CommandMeta apply(@Nonnull final Annotation[] annotations) {
public @NonNull CommandMeta apply(@NonNull final Annotation @NonNull [] annotations) {
final ParserParameters parameters = ParserParameters.empty();
for (final Annotation annotation : annotations) {
@SuppressWarnings("ALL") final Function function = this.annotationParser.getAnnotationMappers()

11
cloud-annotations/src/main/java/cloud/commandframework/annotations/MethodCommandExecutionHandler.java
View file

@ -26,8 +26,8 @@ package cloud.commandframework.annotations;
import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.context.CommandContext;
import cloud.commandframework.execution.CommandExecutionHandler;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Method;
@ -42,9 +42,10 @@ class MethodCommandExecutionHandler<C> implements CommandExecutionHandler<C> {
private final MethodHandle methodHandle;
private final Map<String, CommandArgument<C, ?>> commandArguments;
MethodCommandExecutionHandler(@Nonnull final Object instance,
@Nonnull final Map<String, CommandArgument<C, ?>> commandArguments,
@Nonnull final Method method) throws Exception {
MethodCommandExecutionHandler(@NonNull final Object instance,
@NonNull final Map<@NonNull String,
@NonNull CommandArgument<@NonNull C, @NonNull ?>> commandArguments,
@NonNull final Method method) throws Exception {
this.commandArguments = commandArguments;
method.setAccessible(true);
this.methodHandle = MethodHandles.lookup().unreflect(method).bindTo(instance);
@ -52,7 +53,7 @@ class MethodCommandExecutionHandler<C> implements CommandExecutionHandler<C> {
}
@Override
public void execute(@Nonnull final CommandContext<C> commandContext) {
public void execute(@NonNull final CommandContext<C> commandContext) {
final List<Object> arguments = new ArrayList<>(this.parameters.length);
/* Bind parameters to context */

4
cloud-annotations/src/main/java/cloud/commandframework/annotations/ProxiedBy.java
View file

@ -24,8 +24,8 @@
package cloud.commandframework.annotations;
import cloud.commandframework.Command;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@ -44,7 +44,7 @@ public @interface ProxiedBy {
*
* @return Proxy syntax
*/
@Nonnull String value();
@NonNull String value();
/**
* Whether or not the proxying command should be {@link Hidden}

18
cloud-annotations/src/main/java/cloud/commandframework/annotations/SyntaxFragment.java
View file

@ -23,7 +23,8 @@
//
package cloud.commandframework.annotations;
import javax.annotation.Nonnull;
import org.checkerframework.checker.nullness.qual.NonNull;
import java.util.List;
final class SyntaxFragment {
@ -32,26 +33,23 @@ final class SyntaxFragment {
private final List<String> minor;
private final ArgumentMode argumentMode;
SyntaxFragment(@Nonnull final String major,
@Nonnull final List<String> minor,
@Nonnull final ArgumentMode argumentMode) {
SyntaxFragment(@NonNull final String major,
@NonNull final List<@NonNull String> minor,
@NonNull final ArgumentMode argumentMode) {
this.major = major;
this.minor = minor;
this.argumentMode = argumentMode;
}
@Nonnull
String getMajor() {
@NonNull String getMajor() {
return this.major;
}
@Nonnull
List<String> getMinor() {
@NonNull List<@NonNull String> getMinor() {
return this.minor;
}
@Nonnull
ArgumentMode getArgumentMode() {
@NonNull ArgumentMode getArgumentMode() {
return this.argumentMode;
}

7
cloud-annotations/src/main/java/cloud/commandframework/annotations/SyntaxParser.java
View file

@ -23,7 +23,8 @@
//
package cloud.commandframework.annotations;
import javax.annotation.Nonnull;
import org.checkerframework.checker.nullness.qual.NonNull;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
@ -36,7 +37,7 @@ import java.util.regex.Pattern;
/**
* Parses command syntax into syntax fragments
*/
final class SyntaxParser implements Function<String, LinkedHashMap<String, SyntaxFragment>> {
final class SyntaxParser implements Function<@NonNull String, @NonNull LinkedHashMap<@NonNull String, @NonNull SyntaxFragment>> {
private static final Predicate<String> PATTERN_ARGUMENT_LITERAL = Pattern.compile("([A-Za-z0-9]+)(|([A-Za-z0-9]+))*")
.asPredicate();
@ -46,7 +47,7 @@ final class SyntaxParser implements Function<String, LinkedHashMap<String, Synta
.asPredicate();
@Override
public LinkedHashMap<String, SyntaxFragment> apply(@Nonnull final String syntax) {
public @NonNull LinkedHashMap<@NonNull String, @NonNull SyntaxFragment> apply(@NonNull final String syntax) {
final StringTokenizer stringTokenizer = new StringTokenizer(syntax, " ");
final LinkedHashMap<String, SyntaxFragment> map = new LinkedHashMap<>();
while (stringTokenizer.hasMoreTokens()) {

5
cloud-annotations/src/test/java/cloud/commandframework/annotations/AnnotationParserTest.java
View file

@ -32,7 +32,6 @@ import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import javax.annotation.Nonnull;
import java.util.Collection;
import java.util.Collections;
import java.util.concurrent.CompletionException;
@ -63,9 +62,9 @@ class AnnotationParserTest {
@ProxiedBy("proxycommand")
@CommandMethod("test|t literal <int> [string]")
public void testCommand(@Nonnull final TestCommandSender sender,
public void testCommand(final TestCommandSender sender,
@Argument("int") @Range(max = "100") final int argument,
@Nonnull @Argument(value = "string", defaultValue = "potato", parserName = "potato")
@Argument(value = "string", defaultValue = "potato", parserName = "potato")
final String string) {
System.out.printf("Received int: %d and string '%s'\n", argument, string);
}

7
cloud-annotations/src/test/java/cloud/commandframework/annotations/TestCommandManager.java
View file

@ -28,23 +28,20 @@ import cloud.commandframework.execution.CommandExecutionCoordinator;
import cloud.commandframework.internal.CommandRegistrationHandler;
import cloud.commandframework.meta.SimpleCommandMeta;
import javax.annotation.Nonnull;
public class TestCommandManager extends CommandManager<TestCommandSender> {
protected TestCommandManager() {
super(CommandExecutionCoordinator.simpleCoordinator(), CommandRegistrationHandler.nullCommandRegistrationHandler());
}
@Nonnull
@Override
public final SimpleCommandMeta createDefaultCommandMeta() {
return SimpleCommandMeta.empty();
}
@Override
public final boolean hasPermission(@Nonnull final TestCommandSender sender,
@Nonnull final String permission) {
public final boolean hasPermission(final TestCommandSender sender,
final String permission) {
return !permission.equalsIgnoreCase("no");
}

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));
}
}

46
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 */
@ -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

46
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,8 +90,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,
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;
}

56
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,8 +94,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,
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;
}
}

48
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,8 +94,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,
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;
}

48
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,8 +94,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,
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";
}

54
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,8 +101,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,
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";
}

51
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,8 +94,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,
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";
}

87
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,8 +105,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> 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();
}
@ -116,14 +114,13 @@ public final class StringArgument<C> extends CommandArgument<C, String> {
* Create a new required command argument with a default value
*
* @param name Argument name
* @param defaultNum Default num
* @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();
}

16
cloud-jline/src/main/java/cloud/commandframework/jline/JLineCommandManager.java
View file

@ -32,6 +32,7 @@ import cloud.commandframework.exceptions.NoSuchCommandException;
import cloud.commandframework.execution.CommandExecutionCoordinator;
import cloud.commandframework.internal.CommandRegistrationHandler;
import cloud.commandframework.meta.SimpleCommandMeta;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.jline.reader.Candidate;
import org.jline.reader.Completer;
import org.jline.reader.LineReader;
@ -40,7 +41,6 @@ import org.jline.reader.ParsedLine;
import org.jline.terminal.Terminal;
import org.jline.terminal.TerminalBuilder;
import javax.annotation.Nonnull;
import java.util.List;
import java.util.function.Function;
@ -54,7 +54,7 @@ public class JLineCommandManager extends CommandManager<JLineCommandSender> impl
*
* @param executionCoordinatorFunction Function producing a new coordinator
*/
public JLineCommandManager(@Nonnull final Function<CommandTree<JLineCommandSender>,
public JLineCommandManager(@NonNull final Function<CommandTree<JLineCommandSender>,
CommandExecutionCoordinator<JLineCommandSender>> executionCoordinatorFunction) {
super(executionCoordinatorFunction, CommandRegistrationHandler.nullCommandRegistrationHandler());
}
@ -138,9 +138,9 @@ public class JLineCommandManager extends CommandManager<JLineCommandSender> impl
}
@Override
public final void complete(@Nonnull final LineReader lineReader,
@Nonnull final ParsedLine parsedLine,
@Nonnull final List<Candidate> list) {
public final void complete(@NonNull final LineReader lineReader,
@NonNull final ParsedLine parsedLine,
@NonNull final List<@NonNull Candidate> list) {
final String line = parsedLine.line();
if (line == null || line.isEmpty() || !line.startsWith("/")) {
System.out.println("Cannot suggest: empty line");
@ -149,14 +149,14 @@ public class JLineCommandManager extends CommandManager<JLineCommandSender> impl
System.out.printf("Trying to complete '%s'\n", line);
}
@Nonnull
@Override
public final SimpleCommandMeta createDefaultCommandMeta() {
public final @NonNull SimpleCommandMeta createDefaultCommandMeta() {
return SimpleCommandMeta.empty();
}
@Override
public final boolean hasPermission(@Nonnull final JLineCommandSender sender, @Nonnull final String permission) {
public final boolean hasPermission(@NonNull final JLineCommandSender sender,
@NonNull final String permission) {
return true;
}

90
cloud-minecraft/cloud-brigadier/src/main/java/cloud/commandframework/brigadier/CloudBrigadierManager.java
View file

@ -57,9 +57,9 @@ import com.mojang.brigadier.suggestion.SuggestionProvider;
import com.mojang.brigadier.suggestion.Suggestions;
import com.mojang.brigadier.suggestion.SuggestionsBuilder;
import com.mojang.brigadier.tree.LiteralCommandNode;
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.HashMap;
import java.util.LinkedList;
@ -94,8 +94,8 @@ public final class CloudBrigadierManager<C, S> {
* @param commandManager Command manager
* @param dummyContextProvider Provider of dummy context for completions
*/
public CloudBrigadierManager(@Nonnull final CommandManager<C> commandManager,
@Nonnull final Supplier<CommandContext<C>>
public CloudBrigadierManager(@NonNull final CommandManager<C> commandManager,
@NonNull final Supplier<@NonNull CommandContext<C>>
dummyContextProvider) {
this.mappers = new HashMap<>();
this.defaultArgumentTypeSuppliers = new HashMap<>();
@ -194,9 +194,9 @@ public final class CloudBrigadierManager<C, S> {
* @param <K> cloud argument type
* @param <O> Brigadier argument type value
*/
public <T, K extends ArgumentParser<C, T>, O> void registerMapping(@Nonnull final TypeToken<K> argumentType,
@Nonnull final Function<? extends K,
? extends ArgumentType<O>> mapper) {
public <T, K extends ArgumentParser<C, T>, O> void registerMapping(@NonNull final TypeToken<K> argumentType,
@NonNull final Function<@NonNull ? extends K,
@NonNull ? extends ArgumentType<O>> mapper) {
this.mappers.put(GenericTypeReflector.erase(argumentType.getType()), mapper);
}
@ -206,17 +206,16 @@ public final class CloudBrigadierManager<C, S> {
* @param clazz Type to map
* @param supplier Supplier that supplies the argument type
*/
public void registerDefaultArgumentTypeSupplier(@Nonnull final Class<?> clazz,
@Nonnull final Supplier<ArgumentType<?>> supplier) {
public void registerDefaultArgumentTypeSupplier(@NonNull final Class<?> clazz,
@NonNull final Supplier<@NonNull ArgumentType<?>> supplier) {
this.defaultArgumentTypeSuppliers.put(clazz, supplier);
}
@Nullable
@SuppressWarnings("all")
private <T, K extends ArgumentParser<?, ?>> Pair<ArgumentType<?>, Boolean> getArgument(
@Nonnull final TypeToken<?> valueType,
@Nonnull final TypeToken<T> argumentType,
@Nonnull final K argument) {
private <T, K extends ArgumentParser<?, ?>> @Nullable Pair<@NonNull ArgumentType<?>, @NonNull Boolean> getArgument(
@NonNull final TypeToken<?> valueType,
@NonNull final TypeToken<T> argumentType,
@NonNull final K argument) {
final ArgumentParser<C, ?> commandArgument = (ArgumentParser<C, ?>) argument;
Function function = this.mappers.get(GenericTypeReflector.erase(argumentType.getType()));
if (function == null) {
@ -225,11 +224,11 @@ public final class CloudBrigadierManager<C, S> {
return new Pair<>((ArgumentType<?>) function.apply(commandArgument), !(argument instanceof StringArgument.StringParser));
}
@Nonnull
private <T, K extends ArgumentParser<C, T>> Pair<ArgumentType<?>, Boolean> createDefaultMapper(
@Nonnull final TypeToken<?> clazz,
@Nonnull final ArgumentParser<C, T> argument) {
final Supplier<ArgumentType<?>> argumentTypeSupplier = this.defaultArgumentTypeSuppliers.get(clazz.getRawType());
private <T, K extends ArgumentParser<C, T>> @NonNull Pair<@NonNull ArgumentType<?>, @NonNull Boolean> createDefaultMapper(
@NonNull final TypeToken<?> clazz,
@NonNull final ArgumentParser<C, T> argument) {
final Supplier<ArgumentType<?>> argumentTypeSupplier = this.defaultArgumentTypeSuppliers
.get(GenericTypeReflector.erase(clazz.getType()));
if (argumentTypeSupplier != null) {
return new Pair<>(argumentTypeSupplier.get(), true);
}
@ -245,10 +244,11 @@ public final class CloudBrigadierManager<C, S> {
* @param executor Command executor
* @return Literal command node
*/
public LiteralCommandNode<S> createLiteralCommandNode(@Nonnull final String label,
@Nonnull final Command<C> cloudCommand,
@Nonnull final BiPredicate<S, CommandPermission> permissionChecker,
@Nonnull final com.mojang.brigadier.Command<S> executor) {
public @NonNull LiteralCommandNode<S> createLiteralCommandNode(@NonNull final String label,
@NonNull final Command<C> cloudCommand,
@NonNull final BiPredicate<@NonNull S,
@NonNull CommandPermission> permissionChecker,
final com.mojang.brigadier.@NonNull Command<S> executor) {
final CommandTree.Node<CommandArgument<C, ?>> node = this.commandManager
.getCommandTree().getNamedNode(cloudCommand.getArguments().get(0).getName());
final SuggestionProvider<S> provider = (context, builder) -> this.buildSuggestions(node.getValue(), context, builder);
@ -275,12 +275,12 @@ public final class CloudBrigadierManager<C, S> {
* @param permissionChecker Permission checker
* @return Constructed literal command node
*/
@Nonnull
public LiteralCommandNode<S> createLiteralCommandNode(@Nonnull final CommandTree.Node<CommandArgument<C, ?>> cloudCommand,
@Nonnull final LiteralCommandNode<S> root,
@Nonnull final SuggestionProvider<S> suggestionProvider,
@Nonnull final com.mojang.brigadier.Command<S> executor,
@Nonnull final BiPredicate<S, CommandPermission> permissionChecker) {
public @NonNull LiteralCommandNode<S> createLiteralCommandNode(
final CommandTree.@NonNull Node<@NonNull CommandArgument<C, ?>> cloudCommand,
@NonNull final LiteralCommandNode<S> root,
@NonNull final SuggestionProvider<S> suggestionProvider,
final com.mojang.brigadier.@NonNull Command<S> executor,
@NonNull final BiPredicate<@NonNull S, @NonNull CommandPermission> permissionChecker) {
final LiteralArgumentBuilder<S> literalArgumentBuilder = LiteralArgumentBuilder.<S>literal(root.getLiteral())
.requires(sender -> permissionChecker.test(sender, (CommandPermission) cloudCommand.getNodeMeta()
.getOrDefault("permission", Permission.empty())));
@ -295,11 +295,12 @@ public final class CloudBrigadierManager<C, S> {
return constructedRoot;
}
private ArgumentBuilder<S, ?> constructCommandNode(final boolean forceExecutor,
@Nonnull final CommandTree.Node<CommandArgument<C, ?>> root,
@Nonnull final BiPredicate<S, CommandPermission> permissionChecker,
@Nonnull final com.mojang.brigadier.Command<S> executor,
@Nonnull final SuggestionProvider<S> suggestionProvider) {
private @NonNull ArgumentBuilder<S, ?> constructCommandNode(
final boolean forceExecutor,
final CommandTree.@NonNull Node<CommandArgument<C, ?>> root,
@NonNull final BiPredicate<@NonNull S, @NonNull CommandPermission> permissionChecker,
final com.mojang.brigadier.@NonNull Command<S> executor,
final SuggestionProvider<S> suggestionProvider) {
if (root.getValue() instanceof CompoundArgument) {
@SuppressWarnings("unchecked")
final CompoundArgument<?, C, ?> compoundArgument = (CompoundArgument<?, C, ?>) root.getValue();
@ -313,8 +314,8 @@ public final class CloudBrigadierManager<C, S> {
for (int i = parsers.length - 1; i >= 0; i--) {
@SuppressWarnings("unchecked")
final ArgumentParser<C, ?> parser = (ArgumentParser<C, ?>) parsers[i];
final Pair<ArgumentType<?>, Boolean> pair = this.getArgument(TypeToken.of((Class<?>) types[i]),
TypeToken.of(parser.getClass()),
final Pair<ArgumentType<?>, Boolean> pair = this.getArgument(TypeToken.get((Class<?>) types[i]),
TypeToken.get(parser.getClass()),
parser);
final SuggestionProvider<S> provider = pair.getRight() ? null : suggestionProvider;
final ArgumentBuilder<S, ?> fragmentBuilder = RequiredArgumentBuilder
@ -369,10 +370,10 @@ public final class CloudBrigadierManager<C, S> {
return argumentBuilder;
}
@Nonnull
private CompletableFuture<Suggestions> buildSuggestions(@Nonnull final CommandArgument<C, ?> argument,
@Nonnull final com.mojang.brigadier.context.CommandContext<S> s,
@Nonnull final SuggestionsBuilder builder) {
private @NonNull CompletableFuture<Suggestions> buildSuggestions(
@NonNull final CommandArgument<C, ?> argument,
final com.mojang.brigadier.context.@NonNull CommandContext<S> s,
@NonNull final SuggestionsBuilder builder) {
final CommandContext<C> commandContext = this.dummyContextProvider.get();
final LinkedList<String> inputQueue = new LinkedList<>(Collections.singletonList(builder.getInput()));
final CommandPreprocessingContext<C> commandPreprocessingContext =
@ -416,18 +417,17 @@ public final class CloudBrigadierManager<C, S> {
private final L left;
private final R right;
private Pair(@Nonnull final L left, @Nonnull final R right) {
private Pair(@NonNull final L left,
@NonNull final R right) {
this.left = left;
this.right = right;
}
@Nonnull
private L getLeft() {
private @NonNull L getLeft() {
return this.left;
}
@Nonnull
private R getRight() {
private @NonNull R getRight() {
return this.right;
}

12
cloud-minecraft/cloud-bukkit/src/main/java/cloud/commandframework/bukkit/BukkitCommand.java
View file

@ -34,8 +34,8 @@ import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import org.bukkit.command.PluginIdentifiableCommand;
import org.bukkit.plugin.Plugin;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.util.List;
import java.util.concurrent.CompletionException;
@ -51,11 +51,11 @@ final class BukkitCommand<C> extends org.bukkit.command.Command implements Plugi
private final Command<C> cloudCommand;
@SuppressWarnings("unchecked")
BukkitCommand(@Nonnull final String label,
@Nonnull final List<String> aliases,
@Nonnull final Command<C> cloudCommand,
@Nonnull final CommandArgument<C, ?> command,
@Nonnull final BukkitCommandManager<C> manager) {
BukkitCommand(@NonNull final String label,
@NonNull final List<@NonNull String> aliases,
@NonNull final Command<C> cloudCommand,
@NonNull final CommandArgument<C, ?> command,
@NonNull final BukkitCommandManager<C> manager) {
super(label,
cloudCommand.getCommandMeta().getOrDefault("description", ""),
"",

37
cloud-minecraft/cloud-bukkit/src/main/java/cloud/commandframework/bukkit/BukkitCommandManager.java
View file

@ -34,8 +34,8 @@ import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.plugin.Plugin;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.util.EnumSet;
import java.util.Set;
import java.util.function.Function;
@ -71,11 +71,11 @@ public class BukkitCommandManager<C> extends CommandManager<C> {
* @param backwardsCommandSenderMapper Function that maps the command sender type to {@link CommandSender}
* @throws Exception If the construction of the manager fails
*/
public BukkitCommandManager(@Nonnull final Plugin owningPlugin,
@Nonnull final Function<CommandTree<C>,
CommandExecutionCoordinator<C>> commandExecutionCoordinator,
@Nonnull final Function<CommandSender, C> commandSenderMapper,
@Nonnull final Function<C, CommandSender> backwardsCommandSenderMapper)
public BukkitCommandManager(@NonNull final Plugin owningPlugin,
@NonNull final Function<@NonNull CommandTree<C>,
@NonNull CommandExecutionCoordinator<C>> commandExecutionCoordinator,
@NonNull final Function<@NonNull CommandSender, @NonNull C> commandSenderMapper,
@NonNull final Function<@NonNull C, @NonNull CommandSender> backwardsCommandSenderMapper)
throws Exception {
super(commandExecutionCoordinator, new BukkitPluginRegistrationHandler<>());
((BukkitPluginRegistrationHandler<C>) this.getCommandRegistrationHandler()).initialize(this);
@ -117,8 +117,7 @@ public class BukkitCommandManager<C> extends CommandManager<C> {
*
* @return Owning plugin
*/
@Nonnull
public Plugin getOwningPlugin() {
public @NonNull Plugin getOwningPlugin() {
return this.owningPlugin;
}
@ -127,9 +126,8 @@ public class BukkitCommandManager<C> extends CommandManager<C> {
*
* @return Meta data
*/
@Nonnull
@Override
public BukkitCommandMeta createDefaultCommandMeta() {
public @NonNull BukkitCommandMeta createDefaultCommandMeta() {
return BukkitCommandMetaBuilder.builder().withDescription("").build();
}
@ -138,13 +136,12 @@ public class BukkitCommandManager<C> extends CommandManager<C> {
*
* @return Command sender mapper
*/
@Nonnull
public final Function<CommandSender, C> getCommandSenderMapper() {
public final @NonNull Function<@NonNull CommandSender, @NonNull C> getCommandSenderMapper() {
return this.commandSenderMapper;
}
@Override
public final boolean hasPermission(@Nonnull final C sender, @Nonnull final String permission) {
public final boolean hasPermission(@NonNull final C sender, @NonNull final String permission) {
if (permission.isEmpty()) {
return true;
}
@ -172,7 +169,7 @@ public class BukkitCommandManager<C> extends CommandManager<C> {
* @param capability Capability
* @return {@code true} if the manager has the given capability, else {@code false}
*/
public final boolean queryCapability(@Nonnull final CloudBukkitCapabilities capability) {
public final boolean queryCapability(@NonNull final CloudBukkitCapabilities capability) {
return this.queryCapabilities().contains(capability);
}
@ -181,7 +178,7 @@ public class BukkitCommandManager<C> extends CommandManager<C> {
*
* @return A set containing all capabilities of the instance
*/
public final Set<CloudBukkitCapabilities> queryCapabilities() {
public final @NonNull Set<@NonNull CloudBukkitCapabilities> queryCapabilities() {
if (this.paper) {
if (this.minecraftVersion >= BRIGADIER_MINIMAL_VERSION) {
if (this.minecraftVersion >= PAPER_BRIGADIER_VERSION) {
@ -226,8 +223,7 @@ public class BukkitCommandManager<C> extends CommandManager<C> {
*
* @return The backwards command sender mapper
*/
@Nonnull
public final Function<C, CommandSender> getBackwardsCommandSenderMapper() {
public final @NonNull Function<@NonNull C, @NonNull CommandSender> getBackwardsCommandSenderMapper() {
return this.backwardsCommandSenderMapper;
}
@ -248,7 +244,7 @@ public class BukkitCommandManager<C> extends CommandManager<C> {
*
* @param reason Reason
*/
public BrigadierFailureException(@Nonnull final BrigadierFailureReason reason) {
public BrigadierFailureException(@NonNull final BrigadierFailureReason reason) {
this.reason = reason;
}
@ -258,7 +254,7 @@ public class BukkitCommandManager<C> extends CommandManager<C> {
* @param reason Reason
* @param cause Cause
*/
public BrigadierFailureException(@Nonnull final BrigadierFailureReason reason, @Nonnull final Throwable cause) {
public BrigadierFailureException(@NonNull final BrigadierFailureReason reason, @NonNull final Throwable cause) {
super(cause);
this.reason = reason;
}
@ -268,8 +264,7 @@ public class BukkitCommandManager<C> extends CommandManager<C> {
*
* @return Reason
*/
@Nonnull
public BrigadierFailureReason getReason() {
public @NonNull BrigadierFailureReason getReason() {
return this.reason;
}

22
cloud-minecraft/cloud-bukkit/src/main/java/cloud/commandframework/bukkit/BukkitCommandSender.java
View file

@ -25,8 +25,7 @@ package cloud.commandframework.bukkit;
import com.google.common.base.Objects;
import org.bukkit.entity.Player;
import javax.annotation.Nonnull;
import org.checkerframework.checker.nullness.qual.NonNull;
/**
* Command sender that proxies {@link org.bukkit.command.CommandSender}
@ -41,7 +40,7 @@ public abstract class BukkitCommandSender {
*
* @param internalSender Bukkit command sender
*/
public BukkitCommandSender(@Nonnull final org.bukkit.command.CommandSender internalSender) {
public BukkitCommandSender(final org.bukkit.command.@NonNull CommandSender internalSender) {
this.internalSender = internalSender;
}
@ -51,8 +50,7 @@ public abstract class BukkitCommandSender {
* @param player Player instance
* @return Constructed command sender
*/
@Nonnull
public static BukkitCommandSender player(@Nonnull final Player player) {
public static @NonNull BukkitCommandSender player(@NonNull final Player player) {
return new BukkitPlayerSender(player);
}
@ -61,8 +59,7 @@ public abstract class BukkitCommandSender {
*
* @return Constructed command sender
*/
@Nonnull
public static BukkitCommandSender console() {
public static @NonNull BukkitCommandSender console() {
return new BukkitConsoleSender();
}
@ -72,8 +69,7 @@ public abstract class BukkitCommandSender {
* @param sender Bukkit command sender
* @return Constructed command sender
*/
@Nonnull
public static BukkitCommandSender of(@Nonnull final org.bukkit.command.CommandSender sender) {
public static @NonNull BukkitCommandSender of(final org.bukkit.command.@NonNull CommandSender sender) {
if (sender instanceof Player) {
return player((Player) sender);
}
@ -102,8 +98,7 @@ public abstract class BukkitCommandSender {
*
* @return Proxied command sneder
*/
@Nonnull
public org.bukkit.command.CommandSender getInternalSender() {
public org.bukkit.command.@NonNull CommandSender getInternalSender() {
return this.internalSender;
}
@ -120,15 +115,14 @@ public abstract class BukkitCommandSender {
*
* @return Player object
*/
@Nonnull
public abstract Player asPlayer();
public abstract @NonNull Player asPlayer();
/**
* Send a message to the command sender
*
* @param message Message to send
*/
public void sendMessage(@Nonnull final String message) {
public void sendMessage(@NonNull final String message) {
this.internalSender.sendMessage(message);
}

8
cloud-minecraft/cloud-bukkit/src/main/java/cloud/commandframework/bukkit/BukkitPlayerSender.java
View file

@ -24,12 +24,11 @@
package cloud.commandframework.bukkit;
import org.bukkit.entity.Player;
import javax.annotation.Nonnull;
import org.checkerframework.checker.nullness.qual.NonNull;
final class BukkitPlayerSender extends BukkitCommandSender {
BukkitPlayerSender(@Nonnull final Player player) {
BukkitPlayerSender(@NonNull final Player player) {
super(player);
}
@ -38,9 +37,8 @@ final class BukkitPlayerSender extends BukkitCommandSender {
return true;
}
@Nonnull
@Override
public Player asPlayer() {
public @NonNull Player asPlayer() {
return (Player) this.getInternalSender();
}
}

8
cloud-minecraft/cloud-bungee/src/main/java/cloud/commandframework/bungee/BungeeCommand.java
View file

@ -35,8 +35,8 @@ import net.md_5.bungee.api.CommandSender;
import net.md_5.bungee.api.chat.ComponentBuilder;
import net.md_5.bungee.api.plugin.Command;
import net.md_5.bungee.api.plugin.TabExecutor;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.util.concurrent.CompletionException;
public final class BungeeCommand<C> extends Command implements TabExecutor {
@ -51,9 +51,9 @@ public final class BungeeCommand<C> extends Command implements TabExecutor {
private final cloud.commandframework.Command<C> cloudCommand;
@SuppressWarnings("unchecked")
BungeeCommand(@Nonnull final cloud.commandframework.Command<C> cloudCommand,
@Nonnull final CommandArgument<C, ?> command,
@Nonnull final BungeeCommandManager<C> manager) {
BungeeCommand(final cloud.commandframework.@NonNull Command<C> cloudCommand,
@NonNull final CommandArgument<C, ?> command,
@NonNull final BungeeCommandManager<C> manager) {
super(command.getName(),
cloudCommand.getCommandPermission().toString(),
((StaticArgument<C>) command).getAlternativeAliases().toArray(new String[0]));

25
cloud-minecraft/cloud-bungee/src/main/java/cloud/commandframework/bungee/BungeeCommandManager.java
View file

@ -29,8 +29,8 @@ import cloud.commandframework.execution.CommandExecutionCoordinator;
import cloud.commandframework.meta.SimpleCommandMeta;
import net.md_5.bungee.api.CommandSender;
import net.md_5.bungee.api.plugin.Plugin;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.util.function.Function;
public class BungeeCommandManager<C> extends CommandManager<C> {
@ -48,11 +48,11 @@ public class BungeeCommandManager<C> extends CommandManager<C> {
* @param backwardsCommandSenderMapper Function that maps the command sender type to {@link CommandSender}
* @throws Exception If the construction of the manager fails
*/
public BungeeCommandManager(@Nonnull final Plugin owningPlugin,
@Nonnull final Function<CommandTree<C>,
CommandExecutionCoordinator<C>> commandExecutionCoordinator,
@Nonnull final Function<CommandSender, C> commandSenderMapper,
@Nonnull final Function<C, CommandSender> backwardsCommandSenderMapper)
public BungeeCommandManager(@NonNull final Plugin owningPlugin,
@NonNull final Function<@NonNull CommandTree<C>,
@NonNull CommandExecutionCoordinator<C>> commandExecutionCoordinator,
@NonNull final Function<@NonNull CommandSender, @NonNull C> commandSenderMapper,
@NonNull final Function<@NonNull C, @NonNull CommandSender> backwardsCommandSenderMapper)
throws Exception {
super(commandExecutionCoordinator, new BungeePluginRegistrationHandler<>());
((BungeePluginRegistrationHandler<C>) this.getCommandRegistrationHandler()).initialize(this);
@ -62,22 +62,20 @@ public class BungeeCommandManager<C> extends CommandManager<C> {
}
@Override
public final boolean hasPermission(@Nonnull final C sender,
@Nonnull final String permission) {
public final boolean hasPermission(@NonNull final C sender,
@NonNull final String permission) {
if (permission.isEmpty()) {
return true;
}
return this.backwardsCommandSenderMapper.apply(sender).hasPermission(permission);
}
@Nonnull
@Override
public final SimpleCommandMeta createDefaultCommandMeta() {
public final @NonNull SimpleCommandMeta createDefaultCommandMeta() {
return SimpleCommandMeta.empty();
}
@Nonnull
final Function<CommandSender, C> getCommandSenderMapper() {
final @NonNull Function<@NonNull CommandSender, @NonNull C> getCommandSenderMapper() {
return this.commandSenderMapper;
}
@ -86,8 +84,7 @@ public class BungeeCommandManager<C> extends CommandManager<C> {
*
* @return Owning plugin
*/
@Nonnull
public Plugin getOwningPlugin() {
public @NonNull Plugin getOwningPlugin() {
return this.owningPlugin;
}

6
cloud-minecraft/cloud-bungee/src/main/java/cloud/commandframework/bungee/BungeePluginRegistrationHandler.java
View file

@ -26,8 +26,8 @@ package cloud.commandframework.bungee;
import cloud.commandframework.Command;
import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.internal.CommandRegistrationHandler;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.util.HashMap;
import java.util.Map;
@ -40,12 +40,12 @@ final class BungeePluginRegistrationHandler<C> implements CommandRegistrationHan
BungeePluginRegistrationHandler() {
}
void initialize(@Nonnull final BungeeCommandManager<C> bungeeCommandManager) {
void initialize(@NonNull final BungeeCommandManager<C> bungeeCommandManager) {
this.bungeeCommandManager = bungeeCommandManager;
}
@Override
public boolean registerCommand(@Nonnull final Command<?> command) {
public boolean registerCommand(@NonNull final Command<?> command) {
/* We only care about the root command argument */
final CommandArgument<?, ?> commandArgument = command.getArguments().get(0);
if (this.registeredCommands.containsKey(commandArgument)) {

6
cloud-minecraft/cloud-cloudburst-test/src/main/java/cloud/commandframework/cloudburst/CloudCloudburstTest.java
View file

@ -29,11 +29,11 @@ import cloud.commandframework.annotations.CommandMethod;
import cloud.commandframework.annotations.specifier.Range;
import cloud.commandframework.execution.CommandExecutionCoordinator;
import cloud.commandframework.meta.SimpleCommandMeta;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.cloudburstmc.server.command.CommandSender;
import org.cloudburstmc.server.plugin.PluginBase;
import org.cloudburstmc.server.utils.TextFormat;
import javax.annotation.Nonnull;
import java.util.function.Function;
/**
@ -61,8 +61,8 @@ public final class CloudCloudburstTest extends PluginBase {
}
@CommandMethod("test <num> [str]")
private void testCommand(@Nonnull @Argument(value = "str", defaultValue = "potato") final String string,
@Nonnull final CommandSender source,
private void testCommand(@NonNull @Argument(value = "str", defaultValue = "potato") final String string,
@NonNull final CommandSender source,
@Argument("num") @Range(min = "10", max = "33") final int num) {
source.sendMessage(TextFormat.RED + "You said: "
+ TextFormat.GOLD + string

16
cloud-minecraft/cloud-cloudburst/src/main/java/cloud/commandframework/cloudburst/CloudburstCommand.java
View file

@ -24,18 +24,18 @@
package cloud.commandframework.cloudburst;
import cloud.commandframework.Command;
import cloud.commandframework.exceptions.InvalidSyntaxException;
import cloud.commandframework.exceptions.NoPermissionException;
import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.exceptions.ArgumentParseException;
import cloud.commandframework.exceptions.InvalidCommandSenderException;
import cloud.commandframework.exceptions.InvalidSyntaxException;
import cloud.commandframework.exceptions.NoPermissionException;
import cloud.commandframework.exceptions.NoSuchCommandException;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.cloudburstmc.server.command.CommandSender;
import org.cloudburstmc.server.command.PluginCommand;
import org.cloudburstmc.server.command.data.CommandData;
import org.cloudburstmc.server.plugin.Plugin;
import javax.annotation.Nonnull;
import java.util.List;
import java.util.concurrent.CompletionException;
@ -50,11 +50,11 @@ final class CloudburstCommand<C> extends PluginCommand<Plugin> {
private final CloudburstCommandManager<C> manager;
private final Command<C> cloudCommand;
CloudburstCommand(@Nonnull final String label,
@Nonnull final List<String> aliases,
@Nonnull final Command<C> cloudCommand,
@Nonnull final CommandArgument<C, ?> command,
@Nonnull final CloudburstCommandManager<C> manager) {
CloudburstCommand(@NonNull final String label,
@NonNull final List<@NonNull String> aliases,
@NonNull final Command<C> cloudCommand,
@NonNull final CommandArgument<C, ?> command,
@NonNull final CloudburstCommandManager<C> manager) {
super(manager.getOwningPlugin(), CommandData.builder(label)
.addAliases(aliases.toArray(new String[0]))
.addPermission(cloudCommand.getCommandPermission().toString())

25
cloud-minecraft/cloud-cloudburst/src/main/java/cloud/commandframework/cloudburst/CloudburstCommandManager.java
View file

@ -28,10 +28,10 @@ import cloud.commandframework.CommandTree;
import cloud.commandframework.execution.CommandExecutionCoordinator;
import cloud.commandframework.meta.CommandMeta;
import cloud.commandframework.meta.SimpleCommandMeta;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.cloudburstmc.server.command.CommandSender;
import org.cloudburstmc.server.plugin.Plugin;
import javax.annotation.Nonnull;
import java.util.function.Function;
/**
@ -54,11 +54,11 @@ public class CloudburstCommandManager<C> extends CommandManager<C> {
* @param commandSenderMapper Function that maps {@link CommandSender} to the command sender type
* @param backwardsCommandSenderMapper Function that maps the command sender type to {@link CommandSender}
*/
public CloudburstCommandManager(@Nonnull final Plugin owningPlugin,
@Nonnull final Function<CommandTree<C>,
CommandExecutionCoordinator<C>> commandExecutionCoordinator,
@Nonnull final Function<CommandSender, C> commandSenderMapper,
@Nonnull final Function<C, CommandSender> backwardsCommandSenderMapper) {
public CloudburstCommandManager(@NonNull final Plugin owningPlugin,
@NonNull final Function<@NonNull CommandTree<C>,
@NonNull CommandExecutionCoordinator<C>> commandExecutionCoordinator,
@NonNull final Function<@NonNull CommandSender, @NonNull C> commandSenderMapper,
@NonNull final Function<@NonNull C, @NonNull CommandSender> backwardsCommandSenderMapper) {
super(commandExecutionCoordinator, new CloudburstPluginRegistrationHandler<>());
((CloudburstPluginRegistrationHandler<C>) this.getCommandRegistrationHandler()).initialize(this);
this.commandSenderMapper = commandSenderMapper;
@ -67,19 +67,17 @@ public class CloudburstCommandManager<C> extends CommandManager<C> {
}
@Override
public final boolean hasPermission(@Nonnull final C sender,
@Nonnull final String permission) {
public final boolean hasPermission(@NonNull final C sender,
@NonNull final String permission) {
return this.backwardsCommandSenderMapper.apply(sender).hasPermission(permission);
}
@Nonnull
@Override
public final CommandMeta createDefaultCommandMeta() {
public final @NonNull CommandMeta createDefaultCommandMeta() {
return SimpleCommandMeta.builder().build();
}
@Nonnull
final Function<CommandSender, C> getCommandSenderMapper() {
final @NonNull Function<@NonNull CommandSender, @NonNull C> getCommandSenderMapper() {
return this.commandSenderMapper;
}
@ -88,8 +86,7 @@ public class CloudburstCommandManager<C> extends CommandManager<C> {
*
* @return Owning plugin
*/
@Nonnull
public final Plugin getOwningPlugin() {
public final @NonNull Plugin getOwningPlugin() {
return this.owningPlugin;
}

8
cloud-minecraft/cloud-cloudburst/src/main/java/cloud/commandframework/cloudburst/CloudburstPluginRegistrationHandler.java
View file

@ -23,14 +23,14 @@
//
package cloud.commandframework.cloudburst;
import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.Command;
import cloud.commandframework.arguments.CommandArgument;
import cloud.commandframework.arguments.StaticArgument;
import cloud.commandframework.internal.CommandRegistrationHandler;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.cloudburstmc.server.Server;
import org.cloudburstmc.server.plugin.Plugin;
import javax.annotation.Nonnull;
import java.util.HashMap;
import java.util.Map;
@ -43,12 +43,12 @@ class CloudburstPluginRegistrationHandler<C> implements CommandRegistrationHandl
CloudburstPluginRegistrationHandler() {
}
void initialize(@Nonnull final CloudburstCommandManager<C> cloudburstCommandManager) {
void initialize(@NonNull final CloudburstCommandManager<C> cloudburstCommandManager) {
this.cloudburstCommandManager = cloudburstCommandManager;
}
@Override
public final boolean registerCommand(@Nonnull final Command<?> command) {
public final boolean registerCommand(@NonNull final Command<?> command) {
/* We only care about the root command argument */
final CommandArgument<?, ?> commandArgument = command.getArguments().get(0);
if (this.registeredCommands.containsKey(commandArgument)) {

7
cloud-minecraft/cloud-minecraft-extras/src/main/java/cloud/commandframework/AudienceProvider.java
View file

@ -24,8 +24,8 @@
package cloud.commandframework;
import net.kyori.adventure.audience.Audience;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.util.function.Function;
/**
@ -34,7 +34,7 @@ import java.util.function.Function;
* @param <C> Command sender type
*/
@FunctionalInterface
public interface AudienceProvider<C> extends Function<C, Audience> {
public interface AudienceProvider<C> extends Function<@NonNull C, @NonNull Audience> {
/**
* Convert a command sender to an {@link Audience}
@ -43,7 +43,6 @@ public interface AudienceProvider<C> extends Function<C, Audience> {
* @return Mapped audience
*/
@Override
@Nonnull
Audience apply(@Nonnull C sender);
@NonNull Audience apply(@NonNull C sender);
}

39
cloud-minecraft/cloud-minecraft-extras/src/main/java/cloud/commandframework/MinecraftHelp.java
View file

@ -28,8 +28,8 @@ import cloud.commandframework.arguments.StaticArgument;
import net.kyori.adventure.audience.Audience;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.Template;
import org.checkerframework.checker.nullness.qual.NonNull;
import javax.annotation.Nonnull;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
@ -73,9 +73,9 @@ public final class MinecraftHelp<C> {
* @param audienceProvider Provider that maps the command sender type to {@link Audience}
* @param commandManager Command manager instance
*/
public MinecraftHelp(@Nonnull final String commandPrefix,
@Nonnull final AudienceProvider<C> audienceProvider,
@Nonnull final CommandManager<C> commandManager) {
public MinecraftHelp(@NonNull final String commandPrefix,
@NonNull final AudienceProvider<C> audienceProvider,
@NonNull final CommandManager<C> commandManager) {
this.commandPrefix = commandPrefix;
this.audienceProvider = audienceProvider;
this.commandManager = commandManager;
@ -109,8 +109,7 @@ public final class MinecraftHelp<C> {
*
* @return Command manager
*/
@Nonnull
public CommandManager<C> getCommandManager() {
public @NonNull CommandManager<C> getCommandManager() {
return this.commandManager;
}
@ -119,8 +118,7 @@ public final class MinecraftHelp<C> {
*
* @return Audience provider
*/
@Nonnull
public AudienceProvider<C> getAudienceProvider() {
public @NonNull AudienceProvider<C> getAudienceProvider() {
return this.audienceProvider;
}
@ -130,8 +128,7 @@ public final class MinecraftHelp<C> {
* @param sender Sender to map
* @return Mapped audience
*/
@Nonnull
public Audience getAudience(@Nonnull final C sender) {
public @NonNull Audience getAudience(@NonNull final C sender) {
return this.audienceProvider.apply(sender);
}
@ -141,7 +138,8 @@ public final class MinecraftHelp<C> {
* @param key Message key
* @param message Message
*/
public void setMessage(@Nonnull final String key, @Nonnull final String message) {
public void setMessage(@NonNull final String key,
@NonNull final String message) {
this.messageMap.put(key, message);
}
@ -151,17 +149,17 @@ public final class MinecraftHelp<C> {
* @param query Command query (without leading '/')
* @param recipient Recipient
*/
public void queryCommands(@Nonnull final String query,
@Nonnull final C recipient) {
public void queryCommands(@NonNull final String query,
@NonNull final C recipient) {
final Audience audience = this.getAudience(recipient);
audience.sendMessage(this.miniMessage.parse(this.messageMap.get(MESSAGE_HELP_HEADER)));
this.printTopic(recipient, query, this.commandManager.getCommandHelpHandler().queryHelp(query));
audience.sendMessage(this.miniMessage.parse(this.messageMap.get(MESSAGE_HELP_FOOTER)));
}
private void printTopic(@Nonnull final C sender,
@Nonnull final String query,
@Nonnull final CommandHelpHandler.HelpTopic<C> helpTopic) {
private void printTopic(@NonNull final C sender,
@NonNull final String query,
final CommandHelpHandler.@NonNull HelpTopic<C> helpTopic) {
this.getAudience(sender).sendMessage(this.miniMessage.parse(this.messageMap.get(MESSAGE_QUERY_QUERY),
Template.of("query", query)));
if (helpTopic instanceof CommandHelpHandler.IndexHelpTopic) {
@ -175,7 +173,8 @@ public final class MinecraftHelp<C> {
}
}
private void printIndexHelpTopic(@Nonnull final C sender, @Nonnull final CommandHelpHandler.IndexHelpTopic<C> helpTopic) {
private void printIndexHelpTopic(@NonNull final C sender,
final CommandHelpHandler.@NonNull IndexHelpTopic<C> helpTopic) {
final Audience audience = this.getAudience(sender);
audience.sendMessage(this.miniMessage.parse(this.messageMap.get(MESSAGE_QUERY_AVAILABLE_COMMANDS)));
final Iterator<CommandHelpHandler.VerboseHelpEntry<C>> iterator = helpTopic.getEntries().iterator();
@ -202,7 +201,8 @@ public final class MinecraftHelp<C> {
}
}
private void printMultiHelpTopic(@Nonnull final C sender, @Nonnull final CommandHelpHandler.MultiHelpTopic<C> helpTopic) {
private void printMultiHelpTopic(@NonNull final C sender,
final CommandHelpHandler.@NonNull MultiHelpTopic<C> helpTopic) {
final Audience audience = this.getAudience(sender);
audience.sendMessage(this.miniMessage.parse(this.messageMap.get(MESSAGE_QUERY_LONGEST_PATH),
Template.of("command", helpTopic.getLongestPath())));
@ -236,7 +236,8 @@ public final class MinecraftHelp<C> {
}
}
private void printVerboseHelpTopic(@Nonnull final C sender, @Nonnull final CommandHelpHandler.VerboseHelpTopic<C> helpTopic) {
private void printVerboseHelpTopic(@NonNull final C sender,
final CommandHelpHandler.@NonNull VerboseHelpTopic<C> helpTopic) {
final Audience audience = this.getAudience(sender);
final String command = this.commandManager.getCommandSyntaxFormatter()
.apply(helpTopic.getCommand().getArguments(), null);