Github user tedyu commented on a diff in the pull request:
https://github.com/apache/flink/pull/4039#discussion_r122570865
--- Diff:
flink-core/src/main/java/org/apache/flink/api/java/typeutils/TypeExtractionUtils.java
---
@@ -161,6 +164,77 @@ public static LambdaExecutable
checkAndExtractLambda(Function function) throws T
}
/**
+ * Extracts type from given index from lambda. It supports nested types.
+ *
+ * @param exec lambda function to extract the type from
+ * @param lambdaTypeArgumentIndices position of type to extract in type
hierarchy
+ * @param paramLen count of total parameters of the lambda (including
closure parameters)
+ * @param baseParametersLen count of lambda interface parameters
(without closure parameters)
+ * @return extracted type
+ */
+ public static Type extractTypeFromLambda(
+ LambdaExecutable exec,
+ int[] lambdaTypeArgumentIndices,
+ int paramLen,
+ int baseParametersLen) {
+ Type output = exec.getParameterTypes()[paramLen -
baseParametersLen + lambdaTypeArgumentIndices[0]];
+ for (int i = 1; i < lambdaTypeArgumentIndices.length; i++) {
+ output = extractTypeArgument(output,
lambdaTypeArgumentIndices[i]);
+ }
+ return output;
+ }
+
+ /**
+ * * This method extracts the n-th type argument from the given type.
An InvalidTypesException
+ * is thrown if the type does not have any type arguments or if the
index exceeds the number
+ * of type arguments.
+ *
+ * @param t Type to extract the type arguments from
+ * @param index Index of the type argument to extract
+ * @return The extracted type argument
+ * @throws InvalidTypesException if the given type does not have any
type arguments or if the
+ * index exceeds the number of type arguments.
+ */
+ public static Type extractTypeArgument(Type t, int index) throws
InvalidTypesException {
+ if (t instanceof ParameterizedType) {
+ Type[] actualTypeArguments = ((ParameterizedType)
t).getActualTypeArguments();
+
+ if (index < 0 || index >= actualTypeArguments.length) {
+ throw new InvalidTypesException("Cannot extract
the type argument with index " +
+
index + " because the type has only " +
actualTypeArguments.length +
+
" type arguments.");
+ } else {
+ return actualTypeArguments[index];
+ }
+ } else {
+ throw new InvalidTypesException("The given type " + t +
" is not a parameterized type.");
+ }
+ }
+
+ /**
+ * Extracts a Single Abstract Method (SAM) as defined in Java
Specification (4.3.2. The Class Object,
+ * 9.8 Functional Interfaces, 9.4.3 Interface Method Body) from given
class.
+ *
+ * @param baseClass
+ * @throws InvalidTypesException if the given class does not implement
+ * @return
+ */
+ public static Method getSingleAbstractMethod(Class<?> baseClass) {
+ Method sam = null;
+ for (Method method : baseClass.getMethods()) {
+ if (Modifier.isAbstract(method.getModifiers())) {
+ if (sam == null) {
+ sam = method;
+ } else {
+ throw new InvalidTypesException(
+ "Given class: " + baseClass + "
is not a FunctionalInterface. It does not have a SAM.");
--- End diff --
This message seems to be inexact: if there is no SAM, sam would be null
upon returning from the method.
I suggest changing the message and adding a check (for null sam) prior to
returning.
---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at infrastruct...@apache.org or file a JIRA ticket
with INFRA.
---
