Value API: sync simple types

Author: jknack

jooby/src/main/java/io/jooby/internal/HashValue.java

@@ -9,7 +9,6 @@
 import io.jooby.FileUpload;
 import io.jooby.Formdata;
 import io.jooby.Multipart;
-import io.jooby.TypeMismatchException;
 import io.jooby.Value;
 
 import javax.annotation.Nonnull;
@@ -202,31 +201,11 @@ public int size() {
   }
 
   @Nonnull @Override public <T> List<T> toList(@Nonnull Class<T> type) {
-    if (hash instanceof TreeMap) {
-      // indexes access, treat like a list
-      Collection<Value> values = hash.values();
-      List<T> result = new ArrayList<>(values.size());
-      for (Value value : values) {
-        result.add(value.to(type));
-      }
-      return result;
-    } else {
-      return Collections.singletonList(to(type));
-    }
+    return toCollection(type, new ArrayList<>());
   }
 
   @Nonnull @Override public <T> Set<T> toSet(@Nonnull Class<T> type) {
-    if (hash instanceof TreeMap) {
-      // indexes access, treat like a list
-      Collection<Value> values = hash.values();
-      Set<T> result = new LinkedHashSet<>(values.size());
-      for (Value value : values) {
-        result.add(value.to(type));
-      }
-      return result;
-    } else {
-      return Collections.singleton(to(type));
-    }
+    return toCollection(type, new LinkedHashSet<>());
   }
 
   @Nonnull @Override public <T> Optional<T> toOptional(@Nonnull Class<T> type) {
@@ -265,4 +244,17 @@ public HashValue put(Map<String, Collection<String>> headers) {
     }
     return this;
   }
+
+  private <T, C extends Collection<T>> C toCollection(@Nonnull Class<T> type, C collection) {
+    if (hash instanceof TreeMap) {
+      // indexes access, treat like a list
+      Collection<Value> values = hash.values();
+      for (Value value : values) {
+        collection.add(value.to(type));
+      }
+    } else {
+      collection.add(to(type));
+    }
+    return collection;
+  }
 }

jooby/src/main/java/io/jooby/internal/ValueConverters.java

@@ -87,44 +87,44 @@ public static <T> T convert(Value value, Type type, Router router) {
 
   public static <T> T convert(Value value, Class type, Router router) {
     if (type == String.class) {
-      return (T) first(value).valueOrNull();
+      return (T) value.valueOrNull();
     }
     if (type == int.class) {
-      return (T) Integer.valueOf(first(value).intValue());
+      return (T) Integer.valueOf(value.intValue());
     }
     if (type == long.class) {
-      return (T) Long.valueOf(first(value).longValue());
+      return (T) Long.valueOf(value.longValue());
     }
     if (type == float.class) {
-      return (T) Float.valueOf(first(value).intValue());
+      return (T) Float.valueOf(value.floatValue());
     }
     if (type == double.class) {
-      return (T) Double.valueOf(first(value).intValue());
+      return (T) Double.valueOf(value.doubleValue());
     }
     if (type == boolean.class) {
-      return (T) Boolean.valueOf(first(value).booleanValue());
+      return (T) Boolean.valueOf(value.booleanValue());
     }
     if (type == byte.class) {
-      return (T) Byte.valueOf(first(value).byteValue());
+      return (T) Byte.valueOf(value.byteValue());
     }
     if (type.isEnum()) {
-      return (T) enumValue(first(value), type);
+      return (T) enumValue(value, type);
     }
     // Wrapper
     if (type == Integer.class) {
-      return (T) (value.isMissing() ? null : Integer.valueOf(first(value).intValue()));
+      return (T) (value.isMissing() ? null : Integer.valueOf(value.intValue()));
     }
     if (type == Long.class) {
-      return (T) (value.isMissing() ? null : Long.valueOf(first(value).longValue()));
+      return (T) (value.isMissing() ? null : Long.valueOf(value.longValue()));
     }
     if (type == Float.class) {
-      return (T) (value.isMissing() ? null : Float.valueOf(first(value).floatValue()));
+      return (T) (value.isMissing() ? null : Float.valueOf(value.floatValue()));
     }
     if (type == Double.class) {
-      return (T) (value.isMissing() ? null : Double.valueOf(first(value).doubleValue()));
+      return (T) (value.isMissing() ? null : Double.valueOf(value.doubleValue()));
     }
     if (type == Byte.class) {
-      return (T) (value.isMissing() ? null : Byte.valueOf(first(value).byteValue()));
+      return (T) (value.isMissing() ? null : Byte.valueOf(value.byteValue()));
     }
     /** File Upload: */
     if (value.isUpload()) {
@@ -159,7 +159,7 @@ private static Object enumValue(Value value, Class type) {
       return Enum.valueOf(type, value.value().toUpperCase());
     } catch (IllegalArgumentException x) {
       String name = value.value();
-      // Fallback to ignore case version:
+      // Fallback: Ignore case:
       Set<Enum> enums = EnumSet.allOf(type);
       for (Enum e : enums) {
         if (e.name().equalsIgnoreCase(name)) {
@@ -169,17 +169,4 @@ private static Object enumValue(Value value, Class type) {
       throw x;
     }
   }
-
-  private static Value first(Value source) {
-    //    if (source.isSingle()) {
-    //      return source;
-    //    }
-    //    if (source.isArray()) {
-    //      return source.get(0);
-    //    }
-    //    if (source.isObject() && source.size() > 0) {
-    //      return source.iterator().next();
-    //    }
-    return source;
-  }
 }

modules/jooby-apt/src/main/java/io/jooby/internal/apt/ParamDefinition.java

@@ -26,10 +26,16 @@
 import javax.lang.model.util.Types;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
+import java.net.URI;
+import java.net.URL;
 import java.nio.file.Path;
+import java.time.Duration;
+import java.time.Period;
+import java.time.ZoneId;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
+import java.util.TimeZone;
 import java.util.stream.Collectors;
 
 public class ParamDefinition {
@@ -128,16 +134,13 @@ private boolean isSimpleType() {
         return true;
       }
     }
-    ElementKind kind = typeUtils.asElement(type.getType()).getKind();
-    if (kind == ElementKind.ENUM
-        || ((is(Optional.class) || is(List.class) || is(Set.class))) && kind == ElementKind.ENUM) {
-      return true;
-    }
     return false;
   }
 
   private Class[] builtinTypes() {
     return new Class[]{
+        String.class,
+
         Boolean.class,
         Boolean.TYPE,
         Byte.class,
@@ -154,14 +157,31 @@ private Class[] builtinTypes() {
         Float.TYPE,
         Double.class,
         Double.TYPE,
-        String.class,
+
         Enum.class,
-        java.time.Instant.class,
+
         java.util.UUID.class,
+
+        java.time.Instant.class,
+        java.util.Date.class,
+        java.time.LocalDate.class,
+        java.time.LocalDateTime.class,
+
         java.math.BigDecimal.class,
         java.math.BigInteger.class,
+
+        Duration.class,
+        Period.class,
+
         java.nio.charset.Charset.class,
-        io.jooby.StatusCode.class
+
+        io.jooby.StatusCode.class,
+
+        TimeZone.class,
+        ZoneId.class,
+
+        URI.class,
+        URL.class
     };
   }