/** * Compares the relative fitness of two Methods in terms of how well they * match a set of runtime parameter types, such that a list ordered * by the results of the comparison would return the best match first * (least). * * @param left the "left" Method * @param right the "right" Method * @param actual the runtime parameter types to match against * {@code left}/{@code right} * @return int consistent with {@code compare} semantics * @since 3.5 */ static int compareMethodFit(final Method left, final Method right, final Class<?>[] actual) { return compareParameterTypes(Executable.of(left), Executable.of(right), actual); }
/** * Compares the relative fitness of two Constructors in terms of how well they * match a set of runtime parameter types, such that a list ordered * by the results of the comparison would return the best match first * (least). * * @param left the "left" Constructor * @param right the "right" Constructor * @param actual the runtime parameter types to match against * {@code left}/{@code right} * @return int consistent with {@code compare} semantics * @since 3.5 */ static int compareConstructorFit(final Constructor<?> left, final Constructor<?> right, final Class<?>[] actual) { return compareParameterTypes(Executable.of(left), Executable.of(right), actual); }
/** * Compares the relative fitness of two Constructors in terms of how well they * match a set of runtime parameter types, such that a list ordered * by the results of the comparison would return the best match first * (least). * * @param left the "left" Constructor * @param right the "right" Constructor * @param actual the runtime parameter types to match against * {@code left}/{@code right} * @return int consistent with {@code compare} semantics * @since 3.5 */ static int compareConstructorFit(final Constructor<?> left, final Constructor<?> right, final Class<?>[] actual) { return compareParameterTypes(Executable.of(left), Executable.of(right), actual); }
/** * Compares the relative fitness of two Methods in terms of how well they * match a set of runtime parameter types, such that a list ordered * by the results of the comparison would return the best match first * (least). * * @param left the "left" Method * @param right the "right" Method * @param actual the runtime parameter types to match against * {@code left}/{@code right} * @return int consistent with {@code compare} semantics * @since 3.5 */ static int compareMethodFit(final Method left, final Method right, final Class<?>[] actual) { return compareParameterTypes(Executable.of(left), Executable.of(right), actual); }
/** * Compares the relative fitness of two Methods in terms of how well they * match a set of runtime parameter types, such that a list ordered * by the results of the comparison would return the best match first * (least). * * @param left the "left" Method * @param right the "right" Method * @param actual the runtime parameter types to match against * {@code left}/{@code right} * @return int consistent with {@code compare} semantics * @since 3.5 */ static int compareMethodFit(final Method left, final Method right, final Class<?>[] actual) { return compareParameterTypes(Executable.of(left), Executable.of(right), actual); }
/** * Compares the relative fitness of two Constructors in terms of how well they * match a set of runtime parameter types, such that a list ordered * by the results of the comparison would return the best match first * (least). * * @param left the "left" Constructor * @param right the "right" Constructor * @param actual the runtime parameter types to match against * {@code left}/{@code right} * @return int consistent with {@code compare} semantics * @since 3.5 */ static int compareConstructorFit(final Constructor<?> left, final Constructor<?> right, final Class<?>[] actual) { return compareParameterTypes(Executable.of(left), Executable.of(right), actual); }
/** * Compares the relative fitness of two Constructors in terms of how well they * match a set of runtime parameter types, such that a list ordered * by the results of the comparison would return the best match first * (least). * * @param left the "left" Constructor * @param right the "right" Constructor * @param actual the runtime parameter types to match against * {@code left}/{@code right} * @return int consistent with {@code compare} semantics * @since 3.5 */ static int compareConstructorFit(final Constructor<?> left, final Constructor<?> right, final Class<?>[] actual) { return compareParameterTypes(Executable.of(left), Executable.of(right), actual); }
/** * Compares the relative fitness of two Methods in terms of how well they * match a set of runtime parameter types, such that a list ordered * by the results of the comparison would return the best match first * (least). * * @param left the "left" Method * @param right the "right" Method * @param actual the runtime parameter types to match against * {@code left}/{@code right} * @return int consistent with {@code compare} semantics * @since 3.5 */ static int compareMethodFit(final Method left, final Method right, final Class<?>[] actual) { return compareParameterTypes(Executable.of(left), Executable.of(right), actual); }