Hide JavaLangType and replace with Class

kwakeroni · Jan 3, 2019 · c1c4ec0 · c1c4ec0
1 parent 1895059
commit c1c4ec0
Show file tree

Hide file tree

Showing 7 changed files with 54 additions and 46 deletions.
diff --git a/...-elasticsearch/src/main/java/be/kwakeroni/parameters/basic/definition/es/TypeMapping.java b/...-elasticsearch/src/main/java/be/kwakeroni/parameters/basic/definition/es/TypeMapping.java
@@ -2,10 +2,9 @@
 
 import be.kwakeroni.parameters.backend.es.api.ElasticSearchDataType;
 import be.kwakeroni.parameters.types.support.BasicType;
-import be.kwakeroni.parameters.types.support.JavaLangType;
 
 import java.util.Collections;
-import java.util.EnumMap;
+import java.util.HashMap;
 import java.util.Map;
 
 /**
@@ -14,19 +13,19 @@
 class TypeMapping {
 
     static <B> ElasticSearchDataType<B> getElasticSearchType(BasicType<?, B> basicType) {
-        ElasticSearchDataType<?> esType = BASIC_TYPE_MAPPING.get(basicType.asBasicType());
+        ElasticSearchDataType<?> esType = BASIC_TYPE_MAPPING.get(basicType.getBasicJavaClass());
         if (esType == null) {
-            throw new IllegalArgumentException("Cannot represent Java type " + basicType.asBasicType() + " as ElasticSearch type");
+            throw new IllegalArgumentException("Cannot represent Java type " + basicType.getBasicJavaClass() + " as ElasticSearch type");
         }
         return (ElasticSearchDataType<B>) esType;
     }
 
-    private static Map<JavaLangType, ElasticSearchDataType<?>> BASIC_TYPE_MAPPING;
+    private static Map<Class<?>, ElasticSearchDataType<?>> BASIC_TYPE_MAPPING;
 
     static {
-        Map<JavaLangType, ElasticSearchDataType<?>> map = new EnumMap<>(JavaLangType.class);
+        Map<Class<?>, ElasticSearchDataType<?>> map = new HashMap<>();
 
-        map.put(JavaLangType.INT, ElasticSearchDataType.INTEGER);
+        map.put(Integer.class, ElasticSearchDataType.INTEGER);
         // TODO complete
 
         BASIC_TYPE_MAPPING = Collections.unmodifiableMap(map);

diff --git a/...e-support/src/main/java/be/kwakeroni/parameters/core/support/client/ParameterSupport.java b/...e-support/src/main/java/be/kwakeroni/parameters/core/support/client/ParameterSupport.java
@@ -2,7 +2,7 @@
 
 import be.kwakeroni.parameters.client.api.model.Parameter;
 import be.kwakeroni.parameters.types.api.ParameterType;
-import be.kwakeroni.parameters.types.support.JavaLangType;
+import be.kwakeroni.parameters.types.support.ParameterTypes;
 
 public class ParameterSupport<T> implements Parameter<T> {
 
@@ -30,23 +30,23 @@ public String toString(T value) {
     }
 
     public static Parameter<String> ofString(String name) {
-        return new ParameterSupport<>(name, JavaLangType.STRING);
+        return new ParameterSupport<>(name, ParameterTypes.STRING);
     }
 
     public static Parameter<Integer> ofInt(String name) {
-        return new ParameterSupport<>(name, JavaLangType.INT);
+        return new ParameterSupport<>(name, ParameterTypes.INT);
     }
 
     public static Parameter<Long> ofLong(String name) {
-        return new ParameterSupport<>(name, JavaLangType.LONG);
+        return new ParameterSupport<>(name, ParameterTypes.LONG);
     }
 
     public static Parameter<Boolean> ofBoolean(String name) {
-        return new ParameterSupport<>(name, JavaLangType.BOOLEAN);
+        return new ParameterSupport<>(name, ParameterTypes.BOOLEAN);
     }
 
     public static Parameter<Character> ofChar(String name) {
-        return new ParameterSupport<>(name, JavaLangType.CHAR);
+        return new ParameterSupport<>(name, ParameterTypes.CHAR);
     }
 
 }
diff --git a/...ers-types-support/src/main/java/be/kwakeroni/parameters/types/support/AdhocBasicType.java b/...ers-types-support/src/main/java/be/kwakeroni/parameters/types/support/AdhocBasicType.java
@@ -5,29 +5,34 @@
 /**
  * Created by kwakeroni on 12.04.17.
  */
-class AdhocBasicType<T, B> extends AdhocType<T> implements BasicType<T, B> {
+class AdhocBasicType<T, B extends Comparable<B>> extends AdhocType<T> implements BasicType<T, B> {
 
-    private final JavaLangType javaLangType;
+    private final Class<B> basicClass;
     private final Function<? super B, ? extends T> fromBasic;
     private final Function<? super T, ? extends B> toBasic;
 
-    public AdhocBasicType(Function<? super String, ? extends T> fromString, Function<? super T, String> toString, JavaLangType javaLangType, Function<? super B, ? extends T> fromBasic, Function<? super T, ? extends B> toBasic) {
+    public AdhocBasicType(Function<? super String, ? extends T> fromString, Function<? super T, String> toString, Class<B> basicClass, Function<? super B, ? extends T> fromBasic, Function<? super T, ? extends B> toBasic) {
         super(fromString, toString);
-        this.javaLangType = javaLangType;
+        this.basicClass = basicClass;
         this.fromBasic = fromBasic;
         this.toBasic = toBasic;
     }
 
-    public AdhocBasicType(Class<T> type, Function<? super String, ? extends T> fromString, Function<? super T, String> toString, JavaLangType javaLangType, Function<? super B, ? extends T> fromBasic, Function<? super T, ? extends B> toBasic) {
+    public AdhocBasicType(Class<T> type, Function<? super String, ? extends T> fromString, Function<? super T, String> toString, Class<B> basicClass, Function<? super B, ? extends T> fromBasic, Function<? super T, ? extends B> toBasic) {
         super(type, fromString, toString);
-        this.javaLangType = javaLangType;
+        this.basicClass = basicClass;
         this.fromBasic = fromBasic;
         this.toBasic = toBasic;
     }
 
     @Override
-    public JavaLangType asBasicType() {
-        return javaLangType;
+    public Class<B> getBasicJavaClass() {
+        return basicClass;
+    }
+
+    @Override
+    public int compare(B o1, B o2) {
+        return o1.compareTo(o2);
     }
 
     @Override

diff --git a/...rameters-types-support/src/main/java/be/kwakeroni/parameters/types/support/BasicType.java b/...rameters-types-support/src/main/java/be/kwakeroni/parameters/types/support/BasicType.java
@@ -6,6 +6,7 @@
 
 /**
  * Represents a {@link ParameterType} that maps a custom type {@code T} to a standard java type {@code B}.
+ *
  * @param <T> Type of the values of this parameter type.
  * @param <B> Standard Java type backing this ParameterType.
  */
@@ -14,14 +15,12 @@ public interface BasicType<T, B> extends ParameterType<T>, Comparator<B> {
     /**
      * @return The standard Java type backing this ParameterType
      */
-    public JavaLangType asBasicType();
+    public Class<B> getBasicJavaClass();
 
     public B toBasic(T value);
 
     public T fromBasic(B value);
 
-    @Override
-    default int compare(B o1, B o2) {
-        return asBasicType().compare(o1, o2);
-    }
+    public int compare(B o1, B o2);
+
 }
diff --git a/...eters-types-support/src/main/java/be/kwakeroni/parameters/types/support/JavaLangType.java b/...eters-types-support/src/main/java/be/kwakeroni/parameters/types/support/JavaLangType.java
@@ -6,8 +6,8 @@
 /**
  * (C) 2017 Maarten Van Puymbroeck
  */
-public enum JavaLangType implements BasicType {
-    STRING {
+enum JavaLangType implements BasicType {
+    STRING(String.class) {
         @Override
         public Object fromString(String value) {
             return value;
@@ -18,7 +18,7 @@ public String toString(Object value) {
             return (String) value;
         }
     },
-    INT {
+    INT(Integer.class) {
         @Override
         public Object fromString(String value) {
             return Integer.parseInt(value);
@@ -29,7 +29,7 @@ public String toString(Object value) {
             return Integer.toString((int) value);
         }
     },
-    LONG {
+    LONG(Long.class) {
         @Override
         public Object fromString(String value) {
             return Long.parseLong(value);
@@ -40,7 +40,7 @@ public String toString(Object value) {
             return Long.toString((long) value);
         }
     },
-    BOOLEAN {
+    BOOLEAN(Boolean.class) {
         @Override
         public Object fromString(String value) {
             return Boolean.parseBoolean(value);
@@ -51,7 +51,7 @@ public String toString(Object value) {
             return Boolean.toString((boolean) value);
         }
     },
-    CHAR {
+    CHAR(Character.class) {
         @Override
         public Object fromString(String value) {
             return value.charAt(0);
@@ -62,7 +62,7 @@ public String toString(Object value) {
             return Character.toString((char) value);
         }
     },
-    LOCAL_DATE {
+    LOCAL_DATE(LocalDate.class) {
         private final DateTimeFormatter FORMAT = DateTimeFormatter.ofPattern("uuuuMMdd");
 
         @Override
@@ -76,10 +76,15 @@ public String toString(Object value) {
         }
     };
 
+    private final Class<? extends Comparable<?>> backingType;
+
+    private JavaLangType(Class<? extends Comparable<?>> backingType) {
+        this.backingType = backingType;
+    }
 
     @Override
-    public JavaLangType asBasicType() {
-        return this;
+    public Class getBasicJavaClass() {
+        return this.backingType;
     }
 
     @Override

diff --git a/...ers-types-support/src/main/java/be/kwakeroni/parameters/types/support/ParameterTypes.java b/...ers-types-support/src/main/java/be/kwakeroni/parameters/types/support/ParameterTypes.java
@@ -32,22 +32,22 @@ public static <T> ParameterType<T> of(Function<? super String, ? extends T> from
 
     public static <T> BasicType<T, Integer> ofIntegerType(Class<T> type, Function<? super String, ? extends T> fromString, Function<? super T, String> toString,
                                                           Function<? super Integer, ? extends T> fromBasic, Function<? super T, Integer> toBasic) {
-        return new AdhocBasicType<>(type, fromString, toString, JavaLangType.INT, fromBasic, toBasic);
+        return new AdhocBasicType<>(type, fromString, toString, Integer.class, fromBasic, toBasic);
     }
 
     public static <T> BasicType<T, Integer> ofIntegerType(Function<? super String, ? extends T> fromString, Function<? super T, String> toString,
                                                           Function<? super Integer, ? extends T> fromBasic, Function<? super T, Integer> toBasic) {
-        return new AdhocBasicType<>(fromString, toString, JavaLangType.INT, fromBasic, toBasic);
+        return new AdhocBasicType<>(fromString, toString, Integer.class, fromBasic, toBasic);
     }
 
     public static <T> BasicType<T, Long> ofLongType(Class<T> type, Function<? super String, ? extends T> fromString, Function<? super T, String> toString,
                                                           Function<? super Long, ? extends T> fromBasic, Function<? super T, Long> toBasic) {
-        return new AdhocBasicType<>(type, fromString, toString, JavaLangType.LONG, fromBasic, toBasic);
+        return new AdhocBasicType<>(type, fromString, toString, Long.class, fromBasic, toBasic);
     }
 
     public static <T> BasicType<T, Long> ofLongType(Function<? super String, ? extends T> fromString, Function<? super T, String> toString,
                                                           Function<? super Long, ? extends T> fromBasic, Function<? super T, Long> toBasic) {
-        return new AdhocBasicType<>(fromString, toString, JavaLangType.LONG, fromBasic, toBasic);
+        return new AdhocBasicType<>(fromString, toString, Long.class, fromBasic, toBasic);
     }
 
 }
diff --git a/...-support/src/test/java/be/kwakeroni/parameters/types/support/BasicParameterTypesTest.java b/...-support/src/test/java/be/kwakeroni/parameters/types/support/BasicParameterTypesTest.java
@@ -39,14 +39,14 @@ public class BasicParameterTypesTest<T, B> {
         expectStandardMapping(BOOLEAN, false, "false", true);
         expectStandardMapping(CHAR, '\u00C7', "Ç", '\u00C8');
         expectStandardMapping(LOCAL_DATE, LocalDate.of(1981, 12, 14), "19811214", LocalDate.of(2019, 1, 2));
-        expectMapping(CALENDAR, JavaLangType.LONG, SOME_PAST_CALENDAR, SOME_PAST_CALENDAR.getTimeInMillis(), "19811214151617891", System.currentTimeMillis());
-        expectMapping(ANONYMOUS, JavaLangType.LONG, SOME_PAST_CALENDAR, SOME_PAST_CALENDAR.getTimeInMillis(), "19811214151617891", System.currentTimeMillis());
+        expectMapping(CALENDAR, Long.class, SOME_PAST_CALENDAR, SOME_PAST_CALENDAR.getTimeInMillis(), "19811214151617891", System.currentTimeMillis());
+        expectMapping(ANONYMOUS, Long.class, SOME_PAST_CALENDAR, SOME_PAST_CALENDAR.getTimeInMillis(), "19811214151617891", System.currentTimeMillis());
     }
 
     @Parameter(0)
     public BasicType<T, B> type;
     @Parameter(1)
-    public JavaLangType javaType;
+    public Class<B> javaType;
     @Parameter(2)
     public T value;
     @Parameter(3)
@@ -58,7 +58,7 @@ public class BasicParameterTypesTest<T, B> {
 
     @Test
     public void asBasicType() {
-        assertThat(type.asBasicType()).isSameAs(javaType);
+        assertThat(type.getBasicJavaClass()).isSameAs(javaType);
     }
 
     @Test
@@ -96,14 +96,14 @@ public static Iterable<Object[]> data() {
     }
 
     private static <T> void expectStandardMapping(BasicType<T, T> javaType, T value, String stringValue, T largerBasicValue) {
-        expectMapping(javaType, (JavaLangType) javaType, value, value, stringValue, largerBasicValue);
+        expectMapping(javaType, javaType.getBasicJavaClass(), value, value, stringValue, largerBasicValue);
     }
 
-    private static <T, B> void expectMapping(BasicType<? super T, ? super B> type, JavaLangType javaType, T value, B basicValue, String stringValue, B largerBasicValue) {
+    private static <T, B> void expectMapping(BasicType<? super T, ? super B> type, Class<B> javaType, T value, B basicValue, String stringValue, B largerBasicValue) {
         MAPPINGS.add(mapping(type, javaType, value, basicValue, stringValue, largerBasicValue));
     }
 
-    private static <T, B> Object[] mapping(BasicType<? super T, ? super B> type, JavaLangType javaType, T value, B basicValue, String stringValue, B largerBasicValue) {
+    private static <T, B> Object[] mapping(BasicType<? super T, ? super B> type, Class<B> javaType, T value, B basicValue, String stringValue, B largerBasicValue) {
         return new Object[]{type, javaType, value, basicValue, stringValue, largerBasicValue};
     }