fix: DynamicInvoker (generic return)

new: StringUtils#upper #lower

assira/src/main/java/net/ranides/assira/generic/DynamicInvoker.java

@@ -52,12 +52,21 @@ public class DynamicInvoker {
         return func.apply(value);
     }
 
-    @SuppressWarnings("unchecked")
+    public <T,R> R call(IClass<R> returns, T value) {
+        Function<T, R> func = match(returns, value)
+                .orElseThrow(() -> new IllegalArgumentException("No method found for: " + value.getClass() + "=>" + ClassUtils.box(returns)));
+        return func.apply(value);
+    }
+
     public <T, R> Optional<Function<T,R>> match(Class<R> returns, T value) {
-        Class<?> ir = ClassUtils.box(returns);
+        return match(IClass.typeinfo(returns), value);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T, R> Optional<Function<T,R>> match(IClass<R> returns, T value) {
         for (RFunction r : list) {
             if (r.arg.isInstance(value)) {
-                if(ir.isAssignableFrom(r.ret)) {
+                if(returns.isSuper(r.ret)) {
                     return Optional.of(r.func);
                 }
 
@@ -73,11 +82,15 @@ public class DynamicInvoker {
         private final List<RFunction> list = new ArrayList<>();
 
         public <T,R> Builder append(Class<T> argument, Class<R> returns, Function<T, R> function) {
+            return append0(argument, IClass.typeinfo(returns), function);
+        }
+
+        public <T,R> Builder append(Class<T> argument, IClass<R> returns, Function<T, R> function) {
             return append0(argument, returns, function);
         }
 
         public <T> Builder append(Class<T> argument, Consumer<T> consumer) {
-            return append(argument, void.class, v -> { consumer.accept(v); return null; });
+            return append(argument, IClass.VOID, v -> { consumer.accept(v); return null; });
         }
 
         public Builder appendHelper(Class<?> helper) {
@@ -89,7 +102,7 @@ public class DynamicInvoker {
                     .stream()
                     .each(m -> {
                         Class<?> a = m.arguments().first().get().type().raw();
-                        Class<?> r = m.returns().raw();
+                        IClass<?> r = m.returns();
                         append0(a, r, v -> m.call(v));
                     });
             return this;
@@ -103,7 +116,7 @@ public class DynamicInvoker {
                     .stream()
                     .each(m -> {
                         Class<?> a = m.arguments().first().get().type().raw();
-                        Class<?> r = m.returns().raw();
+                        IClass<?> r = m.returns();
 
                         if (m.attributes().has(IAttribute.STATIC)) {
                             append0(a, r, v -> m.call(v));
@@ -114,7 +127,7 @@ public class DynamicInvoker {
             return this;
         }
 
-        private <T,R> Builder append0(Class<?> argument, Class<?> returns, Function function) {
+        private <T,R> Builder append0(Class<?> argument, IClass<?> returns, Function function) {
             map.append(argument, new RFunction(argument, returns, function));
             return this;
         }
@@ -130,13 +143,13 @@ public class DynamicInvoker {
 
         private final Class<?> arg;
 
-        private final Class<?> ret;
+        private final IClass<?> ret;
 
         private final Function func;
 
-        public RFunction(Class<?> arg, Class<?> ret, Function func) {
-            this.arg = ClassUtils.box(arg);
-            this.ret = ClassUtils.box(ret);
+        public RFunction(Class<?> arg, IClass<?> ret, Function func) {
+            this.arg = arg;
+            this.ret = ret;
             this.func = func;
         }
     }

assira/src/main/java/net/ranides/assira/text/StringUtils.java

@@ -931,6 +931,14 @@ public final class StringUtils {
     public static boolean contains(CharSequence text, char ch) {
         return indexOf(text, ch) >= 0;
     }
+
+    public static String upper(String text) {
+        return null == text ? "" : text.toUpperCase(Locale.ROOT);
+    }
+
+    public static String lower(String text) {
+        return null == text ? "" : text.toLowerCase(Locale.ROOT);
+    }
     
     public static String escapeRE(String text) {
         return REGEX_SPECIAL.matcher(text).replaceAll("\\\\$1");

assira/src/test/java/net/ranides/assira/generic/DynamicInvokerTest.java

@@ -7,6 +7,7 @@ import org.junit.Test;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
@@ -52,6 +53,20 @@ public class DynamicInvokerTest {
 
     }
 
+    @Test
+    public void generic() {
+
+        DynamicInvoker di = DynamicInvoker.builder()
+                .appendDelegate(new InvokeHelper(2000))
+                .build();
+
+        assertNotNull(di.call(new TypeToken<List<?>>() {}, "10,20,30"));
+        assertNotNull(di.call(List.class, "10,20,30"));
+
+        assertEquals(Arrays.asList("~10", "~20", "~30"), di.call(new TypeToken<List<String>>() {}, "10,20,30"));
+        assertEquals(Arrays.asList(10, 20, 30), di.call(new TypeToken<List<Integer>>() {}, "10,20,30"));
+    }
+
     @RequiredArgsConstructor
     public static class InvokeHelper {
 
@@ -77,5 +92,15 @@ public class DynamicInvokerTest {
             return v + values.size();
         }
 
+        @Meta.DynamicDispatch
+        private static List<String> asTexts(String value) {
+            return Arrays.stream(value.split(",")).map(v -> "~"+v).collect(Collectors.toList());
+        }
+
+        @Meta.DynamicDispatch
+        private static List<Integer> asInts(String value) {
+            return Arrays.stream(value.split(",")).map(Integer::parseInt).collect(Collectors.toList());
+        }
+
     }
 }