#58 Remove duplicate class for standard number types in favor of typed constants on the enum itself

Author: ljacqu

src/main/java/ch/jalu/typeresolver/numbers/MoreNumberTypes.java

@@ -11,21 +11,21 @@ public final class MoreNumberTypes {
     public static final NumberType<Character> CHARACTER = new CharacterNumberType();
 
     public static final NumberType<AtomicInteger> ATOMIC_INTEGER =
-        new AtomicNumberType<>(AtomicInteger.class, StandardNumberType.INTEGER, AtomicInteger::new);
+        new AtomicNumberType<>(AtomicInteger.class, StandardNumberTypeEnum.T_INTEGER, AtomicInteger::new);
 
     public static final NumberType<AtomicLong> ATOMIC_LONG =
-        new AtomicNumberType<>(AtomicLong.class, StandardNumberType.LONG, AtomicLong::new);
+        new AtomicNumberType<>(AtomicLong.class, StandardNumberTypeEnum.T_LONG, AtomicLong::new);
 
     private MoreNumberTypes() {
     }
 
     private static final class AtomicNumberType<B extends Number, A extends Number> implements NumberType<A> {
 
         private final Class<A> type;
-        private final StandardNumberType<B> baseType;
+        private final NumberType<B> baseType;
         private final Function<B, A> toAtomicFn;
 
-        AtomicNumberType(Class<A> type, StandardNumberType<B> baseType, Function<B, A> toAtomicFn) {
+        AtomicNumberType(Class<A> type, NumberType<B> baseType, Function<B, A> toAtomicFn) {
             this.type = type;
             this.baseType = baseType;
             this.toAtomicFn = toAtomicFn;
@@ -82,9 +82,9 @@ public Character convertUnsafe(Number number) {
 
         @Override
         public ValueRangeComparison compareToValueRange(Number number) {
-            ValueRangeComparison rangeComparison = StandardNumberType.INTEGER.compareToValueRange(number);
+            ValueRangeComparison rangeComparison = StandardNumberTypeEnum.T_INTEGER.compareToValueRange(number);
             if (rangeComparison == ValueRangeComparison.WITHIN_RANGE) {
-                int intValue = StandardNumberType.INTEGER.convertUnsafe(number);
+                int intValue = StandardNumberTypeEnum.T_INTEGER.convertUnsafe(number);
                 if (intValue > maxValue) {
                     return ValueRangeComparison.ABOVE_MAXIMUM;
                 } else if (intValue < minValue) {
@@ -96,7 +96,7 @@ public ValueRangeComparison compareToValueRange(Number number) {
 
         @Override
         public Character convertToBounds(Number number) {
-            int result = StandardNumberType.INTEGER.convertToBounds(number);
+            int result = StandardNumberTypeEnum.T_INTEGER.convertToBounds(number);
             if (result > maxValue) {
                 return maxValue;
             } else if (result < minValue) {

src/main/java/ch/jalu/typeresolver/numbers/NumberType.java

@@ -7,10 +7,10 @@
  * data about the values the type can represent.
  * <p>
  * Standard implementations for basic Java number types are available at
- * {@link StandardNumberType} and {@link MoreNumberTypes}.
+ * {@link StandardNumberTypeEnum} and {@link MoreNumberTypes}.
  *
  * @param <N>
- * @see StandardNumberType
+ * @see StandardNumberTypeEnum
  * @see NumberTypes#from(Class)
  */
 public interface NumberType<N> {

src/main/java/ch/jalu/typeresolver/numbers/NumberTypes.java

@@ -28,7 +28,7 @@ public static <T> NumberType<T> from(@Nullable Class<T> clazz) {
 
     public static Stream<NumberType<?>> streamThroughAll() {
         return Stream.concat(
-            StandardNumberType.streamThroughAll(),
+            StandardNumberTypeEnum.streamThroughAll(),
             Stream.of(MoreNumberTypes.CHARACTER, MoreNumberTypes.ATOMIC_INTEGER, MoreNumberTypes.ATOMIC_LONG));
     }