MethodSelector.java

package com.github.dakusui.pcond.core.refl;

import com.github.dakusui.pcond.internals.InternalChecks;
import com.github.dakusui.pcond.internals.InternalUtils;

import java.lang.reflect.Method;
import java.util.*;
import java.util.stream.IntStream;

import static com.github.dakusui.pcond.core.refl.MethodSelector.Utils.isAssignableWithBoxingFrom;
import static com.github.dakusui.pcond.internals.InternalChecks.requireArgument;
import static java.lang.String.format;
import static java.util.Objects.requireNonNull;
import static java.util.stream.Collectors.toList;

/**
 * //@formater:off
 * An interface representing an object that selects {@link Method}s from given ones.
 *
 * This interface is used to choose methods that are appropriate to invoke with
 * given arguments.
 * //@formater:on
 */
public interface MethodSelector extends Formattable {
  /**
   * Selects methods that can be invoked with given {@code args}.
   *
   * @param methods Methods from which returned methods are selected.
   * @param args    Arguments to be passed to selected methods.
   * @return Selected methods.
   */
  List<Method> select(List<Method> methods, Object[] args);

  /**
   * Returns a string that describes this object.
   *
   * @return A description of this object
   */
  String describe();

  /**
   * Returns a composed {@link MethodSelector} that first applies this and
   * then applies {@code another}.
   *
   * @param another The method selector to apply after this.
   * @return The composed method selector
   */
  default MethodSelector andThen(MethodSelector another) {
    return new MethodSelector() {
      @Override
      public List<Method> select(List<Method> methods, Object[] args) {
        return another.select(MethodSelector.this.select(methods, args), args);
      }

      @Override
      public String describe() {
        return format("%s&&%s", MethodSelector.this.describe(), another.describe());
      }
    };
  }

  /**
   * Formats this object using the {@link MethodSelector#describe()} method.
   */
  @Override
  default void formatTo(Formatter formatter, int flags, int width, int precision) {
    formatter.format("%s", this.describe());
  }

  class Default implements MethodSelector {
    @Override
    public List<Method> select(List<Method> methods, Object[] args) {
      return methods
          .stream()
          .filter(m -> areArgsCompatible(m.getParameterTypes(), args))
          .collect(toList());
    }

    @Override
    public String describe() {
      return "default";
    }

    private static boolean areArgsCompatible(Class<?>[] formalParameters, Object[] args) {
      if (formalParameters.length != args.length)
        return false;
      for (int i = 0; i < args.length; i++) {
        if (args[i] == null)
          if (formalParameters[i].isPrimitive())
            return false;
          else
            continue;
        if (!isAssignableWithBoxingFrom(formalParameters[i], Utils.toClass(args[i])))
          return false;
      }
      return true;
    }
  }

  /**
   * A method selector that selects "narrower" methods over "wider" ones.
   */
  class PreferNarrower implements MethodSelector {
    @Override
    public List<Method> select(List<Method> methods, Object[] args) {
      if (methods.size() < 2)
        return methods;
      List<Method> ret = new LinkedList<>();
      for (Method i : methods) {
        if (methods.stream().filter(j -> j != i).noneMatch(j -> compareNarrowness(j, i) > 0))
          ret.add(i);
      }
      return ret;
    }

    @Override
    public String describe() {
      return "preferNarrower";
    }

    /**
     * If {@code a} is 'narrower' than {@code b}, positive integer will be returned.
     * If {@code b} is 'narrower' than {@code a}, negative integer will be returned.
     * Otherwise {@code zero}.
     *
     * 'Narrower' means that every parameter of {@code a} is assignable to corresponding
     * one of {@code b}, but any of {@code b} cannot be assigned to {@code a}'s
     * corresponding parameter.
     *
     * @param a A method.
     * @param b A method to be compared with {@code a}.
     * @return a negative integer, zero, or a positive integer as method {@code a}
     * is less compatible than, as compatible as, or more compatible than
     * the method {@code b} object.
     */
    private static int compareNarrowness(Method a, Method b) {
      if (isCompatibleWith(a, b) && isCompatibleWith(b, a))
        return 0;
      if (!isCompatibleWith(a, b) && !isCompatibleWith(b, a))
        return 0;
      return isCompatibleWith(a, b)
          ? -1
          : 1;
    }

    private static boolean isCompatibleWith(Method a, Method b) {
      requireSameParameterCounts(a, b);
      if (Objects.equals(a, b))
        return true;
      return IntStream
          .range(0, a.getParameterCount())
          .allMatch(i -> isAssignableWithBoxingFrom(a.getParameterTypes()[i], b.getParameterTypes()[i]));
    }

    private static void requireSameParameterCounts(Method a, Method b) {
      requireArgument(
          requireNonNull(a),
          (Method v) -> v.getParameterCount() == requireNonNull(b).getParameterCount(),
          () -> format("Parameter counts are different: a: %s, b: %s", a, b));
    }
  }

  class PreferExact implements MethodSelector {
    @Override
    public List<Method> select(List<Method> methods, Object[] args) {
      if (methods.size() < 2)
        return methods;
      List<Method> work = methods;
      for (Object ignored : args) {
        List<Method> tmp = new ArrayList<>(work);
        if (!tmp.isEmpty()) {
          work = tmp;
          break;
        }
      }
      return work;
    }

    @Override
    public String describe() {
      return "preferExact";
    }
  }

  enum Utils {
    ;

    static boolean isAssignableWithBoxingFrom(Class<?> a, Class<?> b) {
      if (a.isAssignableFrom(b))
        return true;
      if (InternalChecks.isPrimitiveWrapperClassOrPrimitive(a) && InternalChecks.isPrimitiveWrapperClassOrPrimitive(b))
        return InternalChecks.isWiderThanOrEqualTo(toWrapperIfPrimitive(a), toWrapperIfPrimitive(b));
      return false;
    }

    private static Class<?> toWrapperIfPrimitive(Class<?> in) {
      if (in.isPrimitive())
        return InternalUtils.wrapperClassOf(in);
      return in;
    }

    private static Class<?> toClass(Object value) {
      return value.getClass();
    }
  }
}














































Active mutators

CONDITIONALS_BOUNDARY
EMPTY_RETURNS
FALSE_RETURNS
INCREMENTS
INVERT_NEGS
MATH
NEGATE_CONDITIONALS
NULL_RETURNS
PRIMITIVE_RETURNS
TRUE_RETURNS
VOID_METHOD_CALLS

Tests examined

com.github.dakusui.pcond.CallTest.nullReturningFunctionAsPredicate(com.github.dakusui.pcond.CallTest) (4 ms)
com.github.dakusui.pcond.CallTest.methodAmbiguous_primitiveBoxed(com.github.dakusui.pcond.CallTest) (61 ms)
com.github.dakusui.pcond.CallTest.classMethodCaBeCalled(com.github.dakusui.pcond.CallTest) (5 ms)
com.github.dakusui.pcond.bugfixes.Issue42Test.givenPrivateClassOverridingPublicMethod$whenPublicMethodIsCalled$thenCallSucceeds(com.github.dakusui.pcond.bugfixes.Issue42Test) (5 ms)
com.github.dakusui.pcond.CallTest.exceptionThrowingMethod(com.github.dakusui.pcond.CallTest) (3 ms)
com.github.dakusui.ut.valid8j.ut.ValidatesTest.testX(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (2 ms)
com.github.dakusui.pcond.CallTest.methodAmbiguous_primitiveBoxed_negated(com.github.dakusui.pcond.CallTest) (11 ms)
com.github.dakusui.pcond.ut.MethodSelectorTest.givenPreferNarrowerSelector$whenSelectWithNullArgument$thenReturned(com.github.dakusui.pcond.ut.MethodSelectorTest) (0 ms)
com.github.dakusui.pcond.CallTest.narrowerMethodIsChosen(com.github.dakusui.pcond.CallTest) (2 ms)
com.github.dakusui.ut.thincrest.examples.JUnitBasedExamplesTest.testExampleUT(com.github.dakusui.ut.thincrest.examples.JUnitBasedExamplesTest) (20 ms)
com.github.dakusui.pcond.CallTest.methodIncompatible(com.github.dakusui.pcond.CallTest) (2 ms)
com.github.dakusui.pcond.ut.MethodSelectorTest.givenPreferNarrowerSelector$whenIncompatibleMethodsArePassed$thenIllegalArgument(com.github.dakusui.pcond.ut.MethodSelectorTest) (1 ms)
com.github.dakusui.pcond.CallTest.parameterUnmatchedWhileNameMatching(com.github.dakusui.pcond.CallTest) (1 ms)
com.github.dakusui.pcond.CallTest.instanceMethodCanBeCalled(com.github.dakusui.pcond.CallTest) (0 ms)
com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (1 ms)
com.github.dakusui.pcond.CallTest.instanceMethodCanBeCreatedOnSpecifiedObject(com.github.dakusui.pcond.CallTest) (0 ms)
com.github.dakusui.pcond.ut.MethodSelectorTest.givenPreferNarrowerSelector$whenIdenticalMethodsArePassed$thenBothAreReturned(com.github.dakusui.pcond.ut.MethodSelectorTest) (0 ms)
com.github.dakusui.pcond.ut.MethodSelectorTest.checkDescriptionOfDefaultMethodSelector(com.github.dakusui.pcond.ut.MethodSelectorTest) (0 ms)
com.github.dakusui.pcond.CallTest.cannotCallPrimitiveParameterMethodWithNull(com.github.dakusui.pcond.CallTest) (25 ms)
com.github.dakusui.pcond.ut.MethodSelectorTest.checkDescriptionOChainedMethodSelector(com.github.dakusui.pcond.ut.MethodSelectorTest) (0 ms)
com.github.dakusui.pcond.CallTest.covariantOverridingMethodCanBeInvokedCorrectly(com.github.dakusui.pcond.CallTest) (3 ms)
com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat_usingFluentStyle(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (1 ms)
com.github.dakusui.pcond.CallTest.methodAmbiguous(com.github.dakusui.pcond.CallTest) (9 ms)
com.github.dakusui.pcond.CallTest.nullCanMatch(com.github.dakusui.pcond.CallTest) (3 ms)
com.github.dakusui.pcond.CallTest.functionsCanBeChained(com.github.dakusui.pcond.CallTest) (1 ms)
com.github.dakusui.pcond.CallTest.methodNotFound(com.github.dakusui.pcond.CallTest) (3 ms)
com.github.dakusui.pcond.CallTest.functionCanBeCreatedFromInstanceMethod(com.github.dakusui.pcond.CallTest) (1 ms)

Report generated by PIT 1.7.3

1		package com.github.dakusui.pcond.core.refl;
2
3		import com.github.dakusui.pcond.internals.InternalChecks;
4		import com.github.dakusui.pcond.internals.InternalUtils;
5
6		import java.lang.reflect.Method;
7		import java.util.*;
8		import java.util.stream.IntStream;
9
10		import static com.github.dakusui.pcond.core.refl.MethodSelector.Utils.isAssignableWithBoxingFrom;
11		import static com.github.dakusui.pcond.internals.InternalChecks.requireArgument;
12		import static java.lang.String.format;
13		import static java.util.Objects.requireNonNull;
14		import static java.util.stream.Collectors.toList;
15
16		/**
17		* //@formater:off
18		* An interface representing an object that selects {@link Method}s from given ones.
19		*
20		* This interface is used to choose methods that are appropriate to invoke with
21		* given arguments.
22		* //@formater:on
23		*/
24		public interface MethodSelector extends Formattable {
25		/**
26		* Selects methods that can be invoked with given {@code args}.
27		*
28		* @param methods Methods from which returned methods are selected.
29		* @param args Arguments to be passed to selected methods.
30		* @return Selected methods.
31		*/
32		List<Method> select(List<Method> methods, Object[] args);
33
34		/**
35		* Returns a string that describes this object.
36		*
37		* @return A description of this object
38		*/
39		String describe();
40

MethodSelector.java

Mutations

Active mutators

Tests examined