Package studio.mevera.imperat.command.arguments.type

Interface ArgumentTypeHandler<S extends CommandSource>

Type Parameters:

S - the source type

All Superinterfaces:

Prioritizable

All Known Implementing Classes:

ArrayArgumentTypeHandler, CollectionArgumentTypeHandler, CompletableFutureArgumentTypeHandler, EitherArgumentTypeHandler, EnumArgumentTypeHandler, MapArgumentTypeHandler, NumericArgumentTypeHandler, OptionalArgumentTypeHandler, SimpleTypeResolver

public interface ArgumentTypeHandler<S extends CommandSource>
extends Prioritizable

Handler for resolving ArgumentType instances for complex or specialized types.

Implementations of this interface form a chain of responsibility for type resolution. Each handler declares what types it can handle via canHandle(Type, TypeWrap), and when applicable, resolves an ArgumentType via resolve(Type, TypeWrap, ArgumentTypeLookup).

Handlers are ordered by Priority - handlers with higher priority are checked first. This allows for specific handlers to override more general ones.

Method Summary

Modifier and Type	Method	Description
boolean	canHandle(@NotNull Type type, @NotNull TypeWrap<?> wrap)	Determines if this handler can resolve the given type.
default <T> void	onRegisteringResolver(@NotNull SimpleTypeResolver<S,T> resolver)
<T> @Nullable ArgumentType<S,T>	resolve(@NotNull Type type, @NotNull TypeWrap<?> wrap, @NotNull ArgumentTypeLookup<S> lookup)	Resolves an ArgumentType for the given type.

Methods inherited from interface studio.mevera.imperat.util.priority.Prioritizable

getPriority

Method Details

canHandle

boolean canHandle(@NotNull
 @NotNull Type type,
 @NotNull
 @NotNull TypeWrap<?> wrap)

Determines if this handler can resolve the given type.

Parameters:

type - the raw type to check

wrap - the wrapped type for convenience, providing additional type introspection

Returns:

true if this handler can handle the type

resolve

@Nullable
<T> @Nullable ArgumentType<S,T> resolve(@NotNull
 @NotNull Type type,
 @NotNull
 @NotNull TypeWrap<?> wrap,
 @NotNull
 @NotNull ArgumentTypeLookup<S> lookup)

Resolves an ArgumentType for the given type.

This method is called only if canHandle(Type, TypeWrap) returns true. The provided ArgumentTypeLookup can be used to recursively resolve component types for generic types (e.g., the element type of a collection).

Type Parameters:

T - the resolved type

Parameters:

type - the type to resolve

wrap - the wrapped type for convenience

lookup - the lookup function for resolving nested/component types

Returns:

the resolved ArgumentType, or null if resolution fails despite canHandle returning true

onRegisteringResolver

default <T> void onRegisteringResolver(@NotNull
 @NotNull SimpleTypeResolver<S,T> resolver)