revxrsal.commands.parameter

Interface ParameterType<A extends CommandActor,T>

Type Parameters:

A - The actor type

T - The parameter type

All Superinterfaces:

BaseParameterType

All Known Implementing Classes:

BooleanParameterType, ByteParameterType, CharParameterType, DoubleParameterType, FloatParameterType, IntParameterType, LongParameterType, ShortParameterType, StringParameterType, UUIDParameterType

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface ParameterType<A extends CommandActor,T>
extends BaseParameterType

Represents a parameter type that produces values from the user input MutableStringStream.

A parameter type is allowed to consume as much of the MutableStringStream as needed, however, it may not consume parts of strings. If it needs to consume a single string, it must consume it entirely.

Note that Lamp will automatically register resolvers for the following types:

• List<T> for any parameter type T
• Set<T> for any parameter type T
• T[] for any parameter type T
• Enum types
• Primitive types (ints, doubles, booleans, chars, etc.)
• String type

A parameter may request to be parsed with a specific parameter type using the @ParseWith annotation.

See Also:

ParameterTypes, @ParseWith

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	ParameterType.Factory<A extends CommandActor> Represents a factory that constructs ParameterTypes dynamically

Method Summary

Modifier and Type	Method and Description
default @NotNull SuggestionProvider<A>	defaultSuggestions() Returns the default suggestions.
default boolean	isGreedy() Returns whether this parameter is greedy or not.
T	parse(@NotNull MutableStringStream input, @NotNull ExecutionContext<A> context) Reads input from the given MutableStringStream, parses the object, or throws exceptions if needed.
default @NotNull PrioritySpec	parsePriority() The priority for an argument of this type over other candidate arguments.

Method Detail

parse

T parse(@NotNull
        @NotNull MutableStringStream input,
        @NotNull
        @NotNull ExecutionContext<A> context)

Reads input from the given MutableStringStream, parses the object, or throws exceptions if needed.

Note: Lamp makes no guarantees about the times it may invoke this method. It may be called repeatedly for execution, tab completion, finding execution candidates, etc.

As such, it's important to implement the parse method with the following in mind:

• Avoid expensive computations
• Avoid "expensive computations"
• Avoid sending the actor any feedback inside this method. Any feedback should only be sent using exceptions (see CommandErrorException)
• Avoid any side-effects in general. Ideally, this method should be pure.

Parameters:

input - The input stream. This argument type is free to consume as much as it needs

context - The command execution context, as well as arguments that have been resolved

Returns:

The parsed object. This should never be null.

defaultSuggestions

@NotNull
default @NotNull SuggestionProvider<A> defaultSuggestions()

Returns the default suggestions. These will be sent if the containing ParameterNode does not supply any custom suggestions.

Returns:

The default type suggestions

parsePriority

@NotNull
default @NotNull PrioritySpec parsePriority()

The priority for an argument of this type over other candidate arguments.

An example of this, is when a command has the following signatures:

• /foo [integer]
• /foo [string]

Because an integer parameter can only accept a certain type of input (i.e. numbers), it will have higher priority over a string parameter, and as such, if the user inputs /foo 10, the integer will be tested first, before moving on to the string.

For more details on the priority API, see PrioritySpec

Returns:

the parse priority for this parameter

See Also:

PrioritySpec

isGreedy

default boolean isGreedy()

Returns whether this parameter is greedy or not. Greedy parameters are treated slightly differently:

• They must come at the end of the command
• They can provide tab completes indefinitely

Returns:

if this parameter is greedy or not