revxrsal.commands.exception.context

Interface ErrorContext<A extends CommandActor>

Type Parameters:

A - The actor type

All Known Subinterfaces:

ErrorContext.ExecutingFunction<A>, ErrorContext.ParsingLiteral<A>, ErrorContext.ParsingParameter<A>, ErrorContext.UnknownCommand<A>, ErrorContext.UnknownParameter<A>

public interface ErrorContext<A extends CommandActor>

Represents the context in which the error has 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.

If, however, it occurred during executing the command function, this will be an ErrorContext.ExecutingFunction context.

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	ErrorContext.ExecutingFunction<A extends CommandActor> Represents the context for an error that occurred during executing a command function
static interface	ErrorContext.ParsingLiteral<A extends CommandActor> Represents the context for an error that occurred during parsing a literal node
static interface	ErrorContext.ParsingParameter<A extends CommandActor> Represents the context for an error that occurred during parsing a parameter node
static interface	ErrorContext.UnknownCommand<A extends CommandActor> Represents the context for an error due to an unknown command.
static interface	ErrorContext.UnknownParameter<A extends CommandActor> Represents the context for an error due to an unknown parameter.

Method Summary

Modifier and Type	Method and Description
A	actor() Returns the actor
ExecutionContext<A>	context() Returns the ExecutionContext in this context.
static <A extends CommandActor> @NotNull ErrorContext.ExecutingFunction<A>	executingFunction(@NotNull ExecutionContext<A> context) Creates an ErrorContext.ExecutingFunction error context
default boolean	hasExecutionContext() Tests whether this context has a ExecutionContext or not.
default boolean	isExecutingFunction() Tests whether the error occurred during executing a function
default boolean	isParsingLiteral() Tests whether the error occurred during parsing a literal
default boolean	isParsingParameter() Tests whether the error occurred during parsing a parameter
@NotNull Lamp<A>	lamp() Returns the Lamp instance
static <A extends CommandActor> @NotNull ErrorContext.ParsingLiteral<A>	parsingLiteral(@NotNull ExecutionContext<A> context, @NotNull LiteralNode<A> node) Creates a ErrorContext.ParsingLiteral context for the given literal node
static <A extends CommandActor> @NotNull ErrorContext.ParsingParameter<A>	parsingParameter(@NotNull ExecutionContext<A> context, @NotNull ParameterNode<A,?> node, @NotNull StringStream input) Creates a ErrorContext.ParsingParameter context for the given parameter node
static <A extends CommandActor> @NotNull ErrorContext.UnknownCommand<A>	unknownCommand(A actor) Creates an ErrorContext.UnknownCommand error context
static <A extends CommandActor> @NotNull ErrorContext.UnknownParameter<A>	unknownParameter(@NotNull ExecutionContext<A> context) Creates an ErrorContext.UnknownParameter error context

Method Detail

parsingLiteral

@NotNull
static <A extends CommandActor> @NotNull ErrorContext.ParsingLiteral<A> parsingLiteral(@NotNull
                                                                                                @NotNull ExecutionContext<A> context,
                                                                                                @NotNull
                                                                                                @NotNull LiteralNode<A> node)

Creates a ErrorContext.ParsingLiteral context for the given literal node

Type Parameters:

A - The actor type

Parameters:

node - The literal node

Returns:

The context

parsingParameter

@NotNull
static <A extends CommandActor> @NotNull ErrorContext.ParsingParameter<A> parsingParameter(@NotNull
                                                                                                    @NotNull ExecutionContext<A> context,
                                                                                                    @NotNull
                                                                                                    @NotNull ParameterNode<A,?> node,
                                                                                                    @NotNull
                                                                                                    @NotNull StringStream input)

Creates a ErrorContext.ParsingParameter context for the given parameter node

Type Parameters:

A - The actor type

Parameters:

node - The parameter node

input - The problematic input

Returns:

The context

executingFunction

@NotNull
static <A extends CommandActor> @NotNull ErrorContext.ExecutingFunction<A> executingFunction(@NotNull
                                                                                                      @NotNull ExecutionContext<A> context)

Creates an ErrorContext.ExecutingFunction error context

Type Parameters:

A - The actor type

Returns:

The context

unknownCommand

@NotNull
static <A extends CommandActor> @NotNull ErrorContext.UnknownCommand<A> unknownCommand(@NotNull
                                                                                                A actor)

Creates an ErrorContext.UnknownCommand error context

Type Parameters:

A - The actor type

Returns:

The context

unknownParameter

@NotNull
static <A extends CommandActor> @NotNull ErrorContext.UnknownParameter<A> unknownParameter(@NotNull
                                                                                                    @NotNull ExecutionContext<A> context)

Creates an ErrorContext.UnknownParameter error context

Type Parameters:

A - The actor type

Returns:

The context

hasExecutionContext

default boolean hasExecutionContext()

Tests whether this context has a ExecutionContext or not.

All error contexts have an ExecutionContext except ErrorContext.UnknownCommand, which has no command to wrap (it's unknown)

Returns:

if this context has an ExecutionContext

context

ExecutionContext<A> context()

Returns the ExecutionContext in this context.

All error contexts have an ExecutionContext except ErrorContext.UnknownCommand, which has no command to wrap (it's unknown)

Returns:

the ExecutionContext or null if there's none

actor

@NotNull
A actor()

Returns the actor

Returns:

The actor

lamp

@NotNull
@NotNull Lamp<A> lamp()

Returns the Lamp instance

Returns:

The Lamp instance

isParsingLiteral

default boolean isParsingLiteral()

Tests whether the error occurred during parsing a literal

Returns:

whether the error occurred during parsing a literal

isParsingParameter

default boolean isParsingParameter()

Tests whether the error occurred during parsing a parameter

Returns:

whether the error occurred during parsing a parameter

isExecutingFunction

default boolean isExecutingFunction()

Tests whether the error occurred during executing a function

Returns:

whether the error occurred during executing a function