Change PositiveAdapter and NegativeAdatper to use _type and switch

Author: rob-bygrave

validator-generator/src/main/java/io/avaje/validation/generator/AnnotationUtil.java

@@ -109,6 +109,12 @@ static String lookupType(TypeMirror typeMirror) {
     if (val != null) {
       return val;
     }
+    if (isAssignable2Interface(rawType, "java.math.BigDecimal")) {
+      return "BigDecimal";
+    }
+    if (isAssignable2Interface(rawType, "java.math.BigInteger")) {
+      return "BigInteger";
+    }
     if (isAssignable2Interface(rawType, "java.lang.Number")) {
       return "Number";
     }

validator/src/main/java/io/avaje/validation/core/adapters/NumberAdapters.java

@@ -235,7 +235,7 @@ public boolean isValid(Object value) {
       if (value instanceof final BigDecimal bd) {
         bigNum = bd;
       } else {
-        bigNum = NumberSignHelper.getBigDecimalValue(value.toString()).stripTrailingZeros();
+        bigNum = NumberSignHelper.toBigDecimal(value.toString()).stripTrailingZeros();
       }
 
       final int integerPartLength = bigNum.precision() - bigNum.scale();
@@ -247,10 +247,12 @@ public boolean isValid(Object value) {
   private static final class PositiveAdapter extends AbstractConstraintAdapter<Object> {
 
     private final boolean inclusive;
+    private final String targetType;
 
     PositiveAdapter(AdapterCreateRequest request, boolean inclusive) {
       super(request);
       this.inclusive = inclusive;
+      this.targetType = request.targetType();
     }
 
     @Override
@@ -259,19 +261,20 @@ public boolean isValid(Object value) {
       if (value == null) {
         return true;
       }
-
-      final int sign = NumberSignHelper.signum(value, LESS_THAN);
+      final int sign = NumberSignHelper.signum(targetType, value, LESS_THAN);
       return !(inclusive ? sign < 0 : sign <= 0);
     }
   }
 
   private static final class NegativeAdapter extends AbstractConstraintAdapter<Object> {
 
     private final boolean inclusive;
+    private final String targetType;
 
     NegativeAdapter(AdapterCreateRequest request, boolean inclusive) {
       super(request);
       this.inclusive = inclusive;
+      this.targetType = request.targetType();
     }
 
     @Override
@@ -280,8 +283,7 @@ public boolean isValid(Object value) {
       if (value == null) {
         return true;
       }
-
-      final int sign = NumberSignHelper.signum(value, GREATER_THAN);
+      final int sign = NumberSignHelper.signum(targetType, value, GREATER_THAN);
       return !(inclusive ? sign > 0 : sign >= 0);
     }
   }

validator/src/main/java/io/avaje/validation/core/adapters/NumberSignHelper.java

@@ -13,46 +13,29 @@ private NumberSignHelper() {}
   private static final double DOUBLE_ZERO = 0D;
   private static final byte BYTE_ZERO = (byte) 0;
 
-  static BigDecimal getBigDecimalValue(Object value) {
-    BigDecimal bd;
+  static BigDecimal toBigDecimal(Object value) {
     try {
-      bd = new BigDecimal(value.toString());
+      return new BigDecimal(value.toString());
     } catch (final NumberFormatException nfe) {
       throw new IllegalArgumentException("Object: " + value + " Is not a valid number", nfe);
     }
-    return bd;
   }
 
-  static int signum(Object value, OptionalInt treatNanAs) {
-    if (value instanceof CharSequence) {
-      return signum(getBigDecimalValue(value), treatNanAs);
-    } else if (value instanceof final Number number) {
-      return signum(number, treatNanAs);
-    }
-    throw new IllegalArgumentException("Object: " + value + " Is not a valid number");
+  static int signum(String targetType, Object value, OptionalInt treatNanAs) {
+    return switch (targetType) {
+      case "String", "CharSequence" -> toBigDecimal(value).signum();
+      case "BigDecimal" -> ((BigDecimal)value).signum();
+      case "BigInteger" -> ((BigInteger)value).signum();
+      case "Byte" -> ((Byte)value).compareTo(BYTE_ZERO);
+      case "Short" -> ((Short)value).compareTo(SHORT_ZERO);
+      case "Integer" -> Integer.signum((Integer)value);
+      case "Long" -> Long.signum((Long)value);
+      case "Float" -> signum((Float)value, treatNanAs);
+      case "Double" -> signum((Double)value, treatNanAs);
+      default -> Double.compare(((Number)value).doubleValue(), DOUBLE_ZERO);
+    };
   }
 
-  private static int signum(Number number, OptionalInt treatNanAs) {
-    if (number instanceof final BigDecimal bd) {
-      return bd.signum();
-    } else if (number instanceof final BigInteger bi) {
-      return bi.signum();
-    } else if (number instanceof final Short sh) {
-      return sh.compareTo(SHORT_ZERO);
-    } else if (number instanceof final Integer i) {
-      return Integer.signum(i);
-    } else if (number instanceof final Long l) {
-      return Long.signum(l);
-    } else if (number instanceof final Float f) {
-      return signum(f, treatNanAs);
-    } else if (number instanceof final Double d) {
-      return signum(d, treatNanAs);
-    } else if (number instanceof final Byte b) {
-      return b.compareTo(BYTE_ZERO);
-    } else {
-      return Double.compare(number.doubleValue(), DOUBLE_ZERO);
-    }
-  }
 
   static int signum(Float number, OptionalInt treatNanAs) {
     final OptionalInt infinity = InfinityNumberComparatorHelper.infinityCheck(number, treatNanAs);

validator/src/test/java/io/avaje/validation/core/adapters/NumberSignHelperTest.java

@@ -0,0 +1,84 @@
+package io.avaje.validation.core.adapters;
+
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.OptionalInt;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class NumberSignHelperTest {
+
+  @Test
+  void signum() {
+    assertThat(NumberSignHelper.signum("Long", -1L, OptionalInt.of(1))).isEqualTo(-1);
+    assertThat(NumberSignHelper.signum("Long", 1L, OptionalInt.of(1))).isEqualTo(1);
+    assertThat(NumberSignHelper.signum("Integer", -1, OptionalInt.of(1))).isEqualTo(-1);
+    assertThat(NumberSignHelper.signum("Integer", 1, OptionalInt.of(1))).isEqualTo(1);
+    assertThat(NumberSignHelper.signum("Float", -1F, OptionalInt.of(1))).isEqualTo(-1);
+    assertThat(NumberSignHelper.signum("Float", 1F, OptionalInt.of(1))).isEqualTo(1);
+    assertThat(NumberSignHelper.signum("Double", -0.1D, OptionalInt.of(1))).isEqualTo(-1);
+    assertThat(NumberSignHelper.signum("Double", 0.1D, OptionalInt.of(1))).isEqualTo(1);
+    assertThat(NumberSignHelper.signum("Short", (short)-1, OptionalInt.of(1))).isEqualTo(-1);
+    assertThat(NumberSignHelper.signum("Short", (short)1, OptionalInt.of(1))).isEqualTo(1);
+    assertThat(NumberSignHelper.signum("Byte", (byte)-1, OptionalInt.of(1))).isEqualTo(-1);
+    assertThat(NumberSignHelper.signum("Byte", (byte)1, OptionalInt.of(1))).isEqualTo(1);
+  }
+
+  @Test
+  void signum_BigDecimal() {
+    assertThat(NumberSignHelper.signum("BigDecimal", BigDecimal.TEN, OptionalInt.of(1))).isEqualTo(1);
+    assertThat(NumberSignHelper.signum("BigDecimal", BigDecimal.valueOf(-2), OptionalInt.of(1))).isEqualTo(-1);
+  }
+
+  @Test
+  void signum_BigInteger() {
+    assertThat(NumberSignHelper.signum("BigInteger", BigInteger.TEN, OptionalInt.of(1))).isEqualTo(1);
+    assertThat(NumberSignHelper.signum("BigInteger", BigInteger.valueOf(-4), OptionalInt.of(1))).isEqualTo(-1);
+  }
+
+  @Test
+  void signum_String() {
+    assertThat(NumberSignHelper.signum("String", "5", OptionalInt.of(1))).isEqualTo(1);
+    assertThat(NumberSignHelper.signum("String", "-2", OptionalInt.of(1))).isEqualTo(-1);
+    assertThat(NumberSignHelper.signum("CharSequence", "5", OptionalInt.of(1))).isEqualTo(1);
+    assertThat(NumberSignHelper.signum("CharSequence", "-2", OptionalInt.of(1))).isEqualTo(-1);
+  }
+
+  @Test
+  void signum_Number() {
+    assertThat(NumberSignHelper.signum("Number", new FooNum(5.8), OptionalInt.of(1))).isEqualTo(1);
+    assertThat(NumberSignHelper.signum("Number", new FooNum(-5.8), OptionalInt.of(1))).isEqualTo(-1);
+  }
+
+
+  static final class FooNum extends Number {
+
+    final double doubleValue;
+
+    FooNum(double doubleValue) {
+      this.doubleValue = doubleValue;
+    }
+
+    @Override
+    public int intValue() {
+      return 0;
+    }
+
+    @Override
+    public long longValue() {
+      return 0;
+    }
+
+    @Override
+    public float floatValue() {
+      return 0;
+    }
+
+    @Override
+    public double doubleValue() {
+      return doubleValue;
+    }
+  }
+}