private Class<?> getInputClass(Class<?> functionalClass) { return toFunctionalMethod(functionalClass).getParameterTypes()[0]; } private Class<?> getOutputClas(Class<?> functionClass) {
.filter(c -> { boolean isFunctional = isFunctionalInterface(c); boolean canAssignInput = inputType==null || canAssignInputType(c, inputType); boolean canAssignReturn = returnType==null ||canAssignReturnType(c, returnType); boolean matchesSignature = isFunctional && canAssignInput && canAssignReturn; return matchesSignature; .flatMap(c -> Arrays.stream(c.getDeclaredConstructors())) .filter(c -> { boolean canAssignArgv = canAssignArguments(c, parameters); return canAssignArgv; }) new ResolvedFunction( func, threadSafe, ctor.getParameterTypes(), parameters, getInputClass(ctor.getDeclaringClass()), getOutputClas(ctor.getDeclaringClass()), "defaultimpl") );
@Override public List<ResolvedFunction> resolveFunctions( Class<?> returnType, Class<?> inputType, String functionName, Object... parameters) { List<ResolvedFunction> resolvedFunctions = new ArrayList<>(); List<ResolvedFunction> resolved = resolver.resolveFunctions(returnType, inputType, functionName, parameters); // Written this way to allow for easy debugging and understanding, do not convert to .stream()... if (resolved.size()>0) { resolvedFunctions.addAll(resolved); } return resolvedFunctions; } }
private Class<?> getOutputClas(Class<?> functionClass) { return toFunctionalMethod(functionClass).getReturnType(); }
private boolean canAssignInputType(Class<?> functionalClass, Class<?> inputType) { boolean isAssignable = toFunctionalMethod(functionalClass).getParameterTypes()[0].isAssignableFrom(inputType); return isAssignable; }
private boolean canAssignReturnType(Class<?> functionalClass, Class<?> returnType) { Class<?> sourceType = toFunctionalMethod(functionalClass).getReturnType(); boolean isAssignable = returnType.isAssignableFrom(sourceType); return isAssignable; }