revxrsal.commands

Class Lamp<A extends CommandActor>

java.lang.Object

revxrsal.commands.Lamp<A>

Type Parameters:

A - The actor type

public final class Lamp<A extends CommandActor>
extends java.lang.Object

The main entrypoint to command registration. Instances should be created with builder().

Lamp instances are expensive to create. They are immutable so they are safe to re-use and share across threads.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Lamp.Builder<A extends CommandActor>

Constructor Summary

Constructors

Constructor and Description
Lamp(Lamp.Builder<A> builder)

Method Summary

Modifier and Type	Method and Description
@NotNull Lamp<A>	accept(@NotNull LampVisitor<A> visitor) Accepts the given visitor by calling LampVisitor.visit(Lamp) on this Lamp instance
@Unmodifiable @NotNull java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.util.Set<AnnotationReplacer<?>>>	annotationReplacers() Returns an immutable map of the annotation replacers registered in this Lamp instance
@NotNull AutoCompleter<A>	autoCompleter() Returns the AutoCompleter of this Lamp instance
static <A extends CommandActor> @NotNull Lamp.Builder<A>	builder() Creates a new Lamp Lamp.Builder
@Unmodifiable @NotNull java.util.List<CommandCondition<? super A>>	commandConditions() Returns an immutable list of the command conditions registered in this Lamp instance
@NotNull CommandPermission<A>	createPermission(AnnotationList annotations) Creates a new CommandPermission for the given list of annotations.
<T> T	dependency(@NotNull java.lang.Class<T> type) Returns the dependency that corresponds to the given type, otherwise throws an IllegalStateException
void	dispatch(A actor, java.lang.String input) Executes the given input on the behalf of the specified actor.
void	dispatch(A actor, StringStream input) Executes the given input on the behalf of the specified actor.
@NotNull DispatcherSettings<A>	dispatcherSettings() Returns the DispatcherSettings that are used by Lamp under the hood to customize the dispatcher settings.
@NotNull MessageSender<? super A,java.lang.String>	errorSender() Returns the MessageSender responsible for sending messages using CommandActor.error(String)
<T> @NotNull ParameterResolver<A,T>	findNextResolver(@NotNull java.lang.reflect.Type type, @NotNull AnnotationList annotations, @NotNull ParameterFactory skipPast) Returns the first ParameterType that comes after the skipPast factory.
SuggestionProvider<A>	findNextSuggestionProvider(java.lang.reflect.Type type, AnnotationList annotations, SuggestionProvider.Factory<? super A> skipPast, Lamp<A> lamp) Returns the first SuggestionProvider that comes after the skipPast factory.
void	handleException(@NotNull java.lang.Throwable throwable, @NotNull ErrorContext<A> errorContext) Handles the given exception in the given context.
@NotNull Hooks<A>	hooks() Returns the hooks registry
@NotNull MessageSender<? super A,java.lang.String>	messageSender() Returns the MessageSender responsible for sending messages using CommandActor.reply(String)
@NotNull ParameterNamingStrategy	parameterNamingStrategy() Returns the parameter naming strategy for this Lamp instance
@NotNull ParameterTypes<A>	parameterTypes() Returns the parameter type registry
@Unmodifiable @NotNull java.util.List<ParameterValidator<A,java.lang.Object>>	parameterValidators() Returns an immutable list of the parameter resolvers registered in this Lamp instance
@NotNull @Unmodifiable java.util.List<ExecutableCommand<A>>	register(java.lang.Object... instances) Registers the given instance to the command handler.
@NotNull CommandRegistry<A>	registry() Returns the command registry.
<T> @NotNull ParameterResolver<A,T>	resolver(@NotNull CommandParameter parameter) Returns the first ParameterType that can parse the given parameter.
<T> @NotNull ParameterResolver<A,T>	resolver(@NotNull java.lang.reflect.Type type) Returns the first ParameterType that can parse the given type.
<T> @NotNull ParameterResolver<A,T>	resolver(@NotNull java.lang.reflect.Type type, @NotNull AnnotationList annotations) Returns the first ParameterType that can parse the given type and annotations.
<T> @NotNull ResponseHandler<A,T>	responseHandler(@NotNull java.lang.reflect.Type type, @NotNull AnnotationList annotations) Returns the first ResponseHandler that can handle the given type and annotation list.
@Unmodifiable @NotNull java.util.List<SenderResolver<? super A>>	senderResolvers() Returns an immutable list of the sender resolvers registered in this Lamp instance
@NotNull SuggestionProvider<A>	suggestionProvider(CommandParameter parameter) Returns the first SuggestionProvider that can create suggestions for the given parameter.
@NotNull SuggestionProvider<A>	suggestionProvider(java.lang.reflect.Type type) Returns the first SuggestionProvider that can create suggestions for the given type and annotations.
@NotNull SuggestionProvider<A>	suggestionProvider(java.lang.reflect.Type type, AnnotationList annotations) Returns the first SuggestionProvider that can create suggestions for the given type and annotations.
@NotNull SuggestionProviders<A>	suggestionProviders() Returns the suggestion provider registry
void	unregister(@NotNull ExecutableCommand<A> execution) Unregisters the given executable command
void	unregisterAllCommands() Unregisters all the commands in this Lamp instance
void	unregisterIf(@NotNull java.util.function.Predicate<ExecutableCommand<A>> commandPredicate) Unregisters all the commands in this Lamp instance that match the given predicate
<T> void	validate(A actor, T value, ParameterNode<A,T> parameter) Validates a parameter by passing it into the registered ParameterValidators

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Lamp

public Lamp(Lamp.Builder<A> builder)

Method Detail

builder

@NotNull
public static <A extends CommandActor> @NotNull Lamp.Builder<A> builder()

Creates a new Lamp Lamp.Builder

Type Parameters:

A - The actor type

Returns:

The newly created builder

resolver

@NotNull
public <T> @NotNull ParameterResolver<A,T> resolver(@NotNull
                                                             @NotNull CommandParameter parameter)

Returns the first ParameterType that can parse the given parameter.

Note that this method will never return null. In cases where no suitable factory is found, it will throw IllegalArgumentException.

Parameters:

parameter - The parameter to create a resolver for

Returns:

The parameter type

Throws:

java.lang.IllegalStateException - if no suitable parameter type was found

resolver

@NotNull
public <T> @NotNull ParameterResolver<A,T> resolver(@NotNull
                                                             @NotNull java.lang.reflect.Type type)

Returns the first ParameterType that can parse the given type. This method can be used to create more complex parameter types for composite types (such as T[]).

Note that this method assumes the type has no annotations.

Note that this method will never return null. In cases where no suitable factory is found, it will throw IllegalArgumentException.

Parameters:

type - The type to create for

Returns:

The parameter type

Throws:

java.lang.IllegalStateException - if no suitable parameter type was found

resolver

@NotNull
public <T> @NotNull ParameterResolver<A,T> resolver(@NotNull
                                                             @NotNull java.lang.reflect.Type type,
                                                             @NotNull
                                                             @NotNull AnnotationList annotations)

Returns the first ParameterType that can parse the given type and annotations. This method can be used to create more complex parameter types for composite types (such as T[])

Note that this method will never return null. In cases where no suitable factory is found, it will throw IllegalArgumentException.

Parameters:

type - The type to create for

annotations - The annotations to pass to factories

Returns:

The parameter type

Throws:

java.lang.IllegalStateException - if no suitable parameter type was found

findNextResolver

@NotNull
public <T> @NotNull ParameterResolver<A,T> findNextResolver(@NotNull
                                                                     @NotNull java.lang.reflect.Type type,
                                                                     @NotNull
                                                                     @NotNull AnnotationList annotations,
                                                                     @NotNull
                                                                     @NotNull ParameterFactory skipPast)

Returns the first ParameterType that comes after the skipPast factory. This is useful for adding behavior on top of existing factory.

Parameters:

type - The type to create for

annotations - The annotations to pass to factories

skipPast - The factory to skip past. In most cases, this will be the caller factory, i.e. this.

Returns:

The parameter type

Throws:

java.lang.IllegalStateException - if no suitable parameter type was found

suggestionProvider

@NotNull
public @NotNull SuggestionProvider<A> suggestionProvider(java.lang.reflect.Type type)

Returns the first SuggestionProvider that can create suggestions for the given type and annotations. This method can be used to create more complex suggestion providers for composite types (such as T[])

Note that this method assumes the type has no annotations.

Note that this method will never return null. In cases where no suitable provider is found, it will return SuggestionProvider.empty().

Parameters:

type - The type to create for

Returns:

The suggestion provider, or SuggestionProvider.empty().

suggestionProvider

@NotNull
public @NotNull SuggestionProvider<A> suggestionProvider(java.lang.reflect.Type type,
                                                                  AnnotationList annotations)

Returns the first SuggestionProvider that can create suggestions for the given type and annotations. This method can be used to create more complex suggestion providers for composite types (such as T[])

Note that this method will never return null. In cases where no suitable provider is found, it will return SuggestionProvider.empty().

Parameters:

type - The type to create for

annotations - The annotations to pass to factories

Returns:

The suggestion provider, or SuggestionProvider.empty().

suggestionProvider

@NotNull
public @NotNull SuggestionProvider<A> suggestionProvider(CommandParameter parameter)

Returns the first SuggestionProvider that can create suggestions for the given parameter.

Note that this method will never return null. In cases where no suitable provider is found, it will return SuggestionProvider.empty().

Parameters:

parameter - The parameter to create for

Returns:

The suggestion provider, or SuggestionProvider.empty().

findNextSuggestionProvider

public SuggestionProvider<A> findNextSuggestionProvider(java.lang.reflect.Type type,
                                                        AnnotationList annotations,
                                                        SuggestionProvider.Factory<? super A> skipPast,
                                                        Lamp<A> lamp)

Returns the first SuggestionProvider that comes after the skipPast factory. This is useful for adding behavior on top of existing providers.

Parameters:

type - The type to create for

annotations - The annotations to pass to factories

skipPast - The factory to skip past. In most cases, this will be the caller factory, i.e. this.

lamp - The Lamp instance to pass to factories

Returns:

The suggestion provider, or SuggestionProvider.empty().

responseHandler

@NotNull
public <T> @NotNull ResponseHandler<A,T> responseHandler(@NotNull
                                                                  @NotNull java.lang.reflect.Type type,
                                                                  @NotNull
                                                                  @NotNull AnnotationList annotations)

Returns the first ResponseHandler that can handle the given type and annotation list.

Note that this method will never return null. In cases where no suitable provider is found, it will return ResponseHandler.noOp().

Parameters:

type - The type to create for

annotations - The annotations to pass to factories

Returns:

The suggestion provider, or SuggestionProvider.empty().

register

@NotNull
public @NotNull @Unmodifiable java.util.List<ExecutableCommand<A>> register(java.lang.Object... instances)

Registers the given instance to the command handler. This can deal with orphan commands as well as Class objects.

Parameters:

instances - The instance to register

Returns:

The newly registered commands (as an immutable list).

unregister

public void unregister(@NotNull
                       @NotNull ExecutableCommand<A> execution)

Unregisters the given executable command

Parameters:

execution - The command to unregister.

unregisterAllCommands

public void unregisterAllCommands()

Unregisters all the commands in this Lamp instance

unregisterIf

public void unregisterIf(@NotNull
                         @NotNull java.util.function.Predicate<ExecutableCommand<A>> commandPredicate)

Unregisters all the commands in this Lamp instance that match the given predicate

dispatch

public void dispatch(@NotNull
                     A actor,
                     java.lang.String input)

Executes the given input on the behalf of the specified actor.

Parameters:

actor - The actor to send for

input - The input to execute with

dispatch

public void dispatch(@NotNull
                     A actor,
                     StringStream input)

Executes the given input on the behalf of the specified actor.

Parameters:

actor - The actor to send for

input - The input to execute with

registry

@NotNull
public @NotNull CommandRegistry<A> registry()

Returns the command registry.

Returns:

The command registry

annotationReplacers

@NotNull
public @Unmodifiable @NotNull java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.util.Set<AnnotationReplacer<?>>> annotationReplacers()

Returns an immutable map of the annotation replacers registered in this Lamp instance

Returns:

The annotation replacers

See Also:

Lamp.Builder.annotationReplacer(Class, AnnotationReplacer)

commandConditions

@NotNull
public @Unmodifiable @NotNull java.util.List<CommandCondition<? super A>> commandConditions()

Returns an immutable list of the command conditions registered in this Lamp instance

Returns:

The command conditions

See Also:

Lamp.Builder.commandCondition(CommandCondition)

parameterNamingStrategy

@NotNull
public @NotNull ParameterNamingStrategy parameterNamingStrategy()

Returns the parameter naming strategy for this Lamp instance

Returns:

The parameter naming strategy

See Also:

Lamp.Builder.parameterNamingStrategy(ParameterNamingStrategy)

parameterTypes

@NotNull
public @NotNull ParameterTypes<A> parameterTypes()

Returns the parameter type registry

Returns:

The parameter type registry

See Also:

Lamp.Builder.parameterTypes()

suggestionProviders

@NotNull
public @NotNull SuggestionProviders<A> suggestionProviders()

Returns the suggestion provider registry

Returns:

The suggestion provider registry

See Also:

Lamp.Builder.suggestionProviders()

hooks

@NotNull
public @NotNull Hooks<A> hooks()

Returns the hooks registry

Returns:

The hooks registry

See Also:

Lamp.Builder.hooks()

senderResolvers

@NotNull
public @Unmodifiable @NotNull java.util.List<SenderResolver<? super A>> senderResolvers()

Returns an immutable list of the sender resolvers registered in this Lamp instance

Returns:

The sender resolvers

See Also:

Lamp.Builder.senderResolver(SenderResolver)

parameterValidators

@NotNull
public @Unmodifiable @NotNull java.util.List<ParameterValidator<A,java.lang.Object>> parameterValidators()

Returns an immutable list of the parameter resolvers registered in this Lamp instance

Returns:

The parameter resolvers

See Also:

Lamp.Builder.parameterValidator(Class, ParameterValidator)

dependency

@NotNull
public <T> T dependency(@NotNull
                                 @NotNull java.lang.Class<T> type)

Returns the dependency that corresponds to the given type, otherwise throws an IllegalStateException

Type Parameters:

T - The dependency type

Parameters:

type - The dependency type

Returns:

The dependency

Throws:

java.lang.IllegalStateException - if no suitable dependency was found

validate

@ApiStatus.Internal
public <T> void validate(A actor,
                                             T value,
                                             ParameterNode<A,T> parameter)

Validates a parameter by passing it into the registered ParameterValidators

Parameters:

actor - The actor to validate for

value - The value to validate

parameter - The parameter to validate for

autoCompleter

@NotNull
public @NotNull AutoCompleter<A> autoCompleter()

Returns the AutoCompleter of this Lamp instance

Returns:

The auto-complete

handleException

public void handleException(@NotNull
                            @NotNull java.lang.Throwable throwable,
                            @NotNull
                            @NotNull ErrorContext<A> errorContext)

Handles the given exception in the given context. This will pass the exception to the exceptionHandler

Parameters:

throwable - The exception to handle

errorContext - The context in which the error occurred. For example, if the error was because a parameter was invalid, this will be a ErrorContext.ParsingParameter context, which contains information about the parameter being parsed.

See Also:

Lamp.Builder.exceptionHandler(CommandExceptionHandler)

createPermission

@NotNull
public @NotNull CommandPermission<A> createPermission(AnnotationList annotations)

Creates a new CommandPermission for the given list of annotations. Note that this will never return null. If no suitable permission factory was found, it will return CommandPermission.alwaysTrue().

Parameters:

annotations - Annotations to check for

Returns:

The command permission.

messageSender

@NotNull
public @NotNull MessageSender<? super A,java.lang.String> messageSender()

Returns the MessageSender responsible for sending messages using CommandActor.reply(String)

Returns:

The message sender

errorSender

@NotNull
public @NotNull MessageSender<? super A,java.lang.String> errorSender()

Returns the MessageSender responsible for sending messages using CommandActor.error(String)

Returns:

The error sender

dispatcherSettings

@NotNull
public @NotNull DispatcherSettings<A> dispatcherSettings()

Returns the DispatcherSettings that are used by Lamp under the hood to customize the dispatcher settings.

Returns:

The dispatcher settings

See Also:

DispatcherSettings

accept

@Contract(value="_ -> this")
 @NotNull
public @NotNull Lamp<A> accept(@NotNull
                                                                      @NotNull LampVisitor<A> visitor)

Accepts the given visitor by calling LampVisitor.visit(Lamp) on this Lamp instance

Parameters:

visitor - Visitor to accept

Returns:

This Lamp instance