org.codehaus.plexus.util.introspection
public class MethodMap extends Object
Version: $Id: MethodMap.java 5958 2007-02-28 10:29:55Z olamy $
Nested Class Summary | |
---|---|
static class | MethodMap.AmbiguousException
simple distinguishable exception, used when
we run across ambiguous overloading |
Field Summary | |
---|---|
static int | INCOMPARABLE |
static int | LESS_SPECIFIC |
Map | methodByNameMap
Keep track of all methods with the same name. |
static int | MORE_SPECIFIC |
Method Summary | |
---|---|
void | add(Method method)
Add a method to a list of methods by name.
|
Method | find(String methodName, Object[] args) Find a method. |
List | get(String key)
Return a list of methods with the same name.
|
static LinkedList | getApplicables(List methods, Class[] classes)
Returns all methods that are applicable to actual argument types. |
static Method | getMostSpecific(List methods, Class[] classes) |
static boolean | isApplicable(Method method, Class[] classes)
Returns true if the supplied method is applicable to actual
argument types. |
static boolean | isMethodInvocationConvertible(Class formal, Class actual)
Determines whether a type represented by a class object is
convertible to another type represented by a class object using a
method invocation conversion, treating object types of primitive
types as if they were primitive types (that is, a Boolean actual
parameter type matches boolean primitive formal type). |
static boolean | isStrictMethodInvocationConvertible(Class formal, Class actual)
Determines whether a type represented by a class object is
convertible to another type represented by a class object using a
method invocation conversion, without matching object and primitive
types. |
static int | moreSpecific(Class[] c1, Class[] c2)
Determines which method signature (represented by a class array) is more
specific. |
Find a method. Attempts to find the most specific applicable method using the algorithm described in the JLS section 15.12.2 (with the exception that it can't distinguish a primitive type argument from an object type argument, since in reflection primitive type arguments are represented by their object counterparts, so for an argument of type (say) java.lang.Integer, it will not be able to decide between a method that takes int and a method that takes java.lang.Integer as a parameter.
This turns out to be a relatively rare case where this is needed - however, functionality like this is needed.
Parameters: methodName name of method args the actual arguments with which the method is called
Returns: the most specific applicable method, or null if no method is applicable.
Throws: AmbiguousException if there is more than one maximally specific applicable method
Parameters: String key
Returns: List list of methods
Parameters: methods list of all candidate methods classes the actual types of the arguments
Returns: a list that contains only applicable methods (number of formal and actual arguments matches, and argument types are assignable to formal types through a method invocation conversion).
Parameters: formal the formal parameter type to which the actual parameter type should be convertible actual the actual parameter type.
Returns: true if either formal type is assignable from actual type, or formal is a primitive type and actual is its corresponding object type or an object type of a primitive type that can be converted to the formal type.
Parameters: formal the formal parameter type to which the actual parameter type should be convertible actual the actual parameter type.
Returns: true if either formal type is assignable from actual type, or formal and actual are both primitive types and actual can be subject to widening conversion to formal.
Parameters: c1 first signature to compare c2 second signature to compare
Returns: MORE_SPECIFIC if c1 is more specific than c2, LESS_SPECIFIC if c1 is less specific than c2, INCOMPARABLE if they are incomparable.