Class HandlerInspector.MethodHandlerMatcher<M>

java.lang.Object

io.fluxzero.common.handling.HandlerInspector.MethodHandlerMatcher<M>

All Implemented Interfaces:

HandlerMatcher<Object,M>

Enclosing class:

HandlerInspector

public static class HandlerInspector.MethodHandlerMatcher<M>
extends Object
implements HandlerMatcher<Object,M>

A matcher that encapsulates metadata and resolution logic for a single handler method or constructor.

Resolves parameter values using ParameterResolvers and builds a HandlerInvoker for invoking the method on a given target instance.

This matcher supports prioritization, specificity analysis, and filtering based on annotations and parameters.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
protected class	HandlerInspector.MethodHandlerMatcher.MethodHandlerInvoker
protected static final record	HandlerInspector.MethodHandlerMatcher.Specificity

Field Summary

Fields

Modifier and Type	Field	Description
protected static final Comparator<HandlerInspector.MethodHandlerMatcher<?>>	comparator

Constructor Summary

Constructors

Constructor	Description
MethodHandlerMatcher(Executable executable, Class<?> targetClass, List<ParameterResolver<? super M>> parameterResolvers, @NonNull HandlerConfiguration<? super M> config)

Method Summary

Modifier and Type	Method	Description
boolean	canHandle(M message)	Returns whether the given message can be handled by a handler instance of type T.
protected static int	compare(int leftPriority, HandlerInspector.MethodHandlerMatcher.Specificity leftSpecificity, int leftParameterCount, int leftMethodIndex, int rightPriority, HandlerInspector.MethodHandlerMatcher.Specificity rightSpecificity, int rightParameterCount, int rightMethodIndex)
protected int	compareForMessage(HandlerInspector.MethodHandlerMatcher<M> other, M message)
protected Class<?>	computeClassForSpecificity()
protected HandlerInspector.MethodHandlerMatcher.Specificity	computeSpecificity(M message)
Optional<HandlerInvoker>	getInvoker(Object target, M m)	Attempts to resolve a HandlerInvoker for the given target instance and message.
protected int	getPriority(Annotation annotation)
protected boolean	isPassive(Annotation annotation)
Stream<Executable>	matchingMethods(M message)	Returns a stream of methods from the target class that match the given message.
protected int	methodIndex(Method instanceMethod, Class<?> instanceType)
protected Optional<Function<Object, HandlerInvoker>>	prepareInvoker(M m)

Methods inherited from class Object

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

Methods inherited from interface HandlerMatcher

or

Field Details

comparator

protected static final Comparator<HandlerInspector.MethodHandlerMatcher<?>> comparator

Constructor Details

MethodHandlerMatcher

public MethodHandlerMatcher(Executable executable,
 Class<?> targetClass,
 List<ParameterResolver<? super M>> parameterResolvers,
 @NonNull
 @NonNull HandlerConfiguration<? super M> config)

Method Details

canHandle

public boolean canHandle(M message)

Description copied from interface: HandlerMatcher

Returns whether the given message can be handled by a handler instance of type T. This is a lightweight check and may be used for fast filtering or diagnostics.

Specified by:

canHandle in interface HandlerMatcher<Object,M>

Parameters:

message - the message to check

Returns:

true if the matcher may be able to produce an invoker for the given message

matchingMethods

public Stream<Executable> matchingMethods(M message)

Description copied from interface: HandlerMatcher

Returns a stream of methods from the target class that match the given message. Typically used for diagnostics or documentation tools.

Specified by:

matchingMethods in interface HandlerMatcher<Object,M>

Parameters:

message - the message to match against

Returns:

a stream of matching Executable handler methods

prepareInvoker

protected Optional<Function<Object, HandlerInvoker>> prepareInvoker(M m)

getInvoker

public Optional<HandlerInvoker> getInvoker(Object target,
 M m)

Description copied from interface: HandlerMatcher

Attempts to resolve a HandlerInvoker for the given target instance and message.

Specified by:

getInvoker in interface HandlerMatcher<Object,M>

Parameters:

target - the handler object

m - the message to be handled

Returns:

an optional invoker if the message is supported by the target; empty otherwise

computeClassForSpecificity

protected Class<?> computeClassForSpecificity()

computeSpecificity

protected HandlerInspector.MethodHandlerMatcher.Specificity computeSpecificity(M message)

compareForMessage

protected int compareForMessage(HandlerInspector.MethodHandlerMatcher<M> other,
 M message)

methodIndex

protected int methodIndex(Method instanceMethod,
 Class<?> instanceType)

getPriority

protected int getPriority(Annotation annotation)

isPassive

protected boolean isPassive(Annotation annotation)

compare

protected static int compare(int leftPriority,
 HandlerInspector.MethodHandlerMatcher.Specificity leftSpecificity,
 int leftParameterCount,
 int leftMethodIndex,
 int rightPriority,
 HandlerInspector.MethodHandlerMatcher.Specificity rightSpecificity,
 int rightParameterCount,
 int rightMethodIndex)