warnings

assira.core/src/main/java/net/ranides/assira/generic/CompareUtils.java

@@ -26,7 +26,8 @@ import net.ranides.assira.text.LexicalCast;
     "PMD.ShortMethodName"
 })
 public final class CompareUtils {
-    
+
+    @SuppressWarnings({"rawtypes"})
     private static final Comparator AUTO_COMPARATOR = new NComparator();
 
     private CompareUtils() { }
@@ -163,7 +164,7 @@ public final class CompareUtils {
      * This comparator is useful, if you want to store duplicates in standard TreeSets and TreeMaps
      */
     public static <T> Comparator<T> identity() {
-        return new IComparator();
+        return new IComparator<>();
     }
 
     private static final class IComparator<T> implements Comparator<T>, Serializable {

assira.core/src/main/java/net/ranides/assira/generic/EnumUtils.java

@@ -64,6 +64,7 @@ public final class EnumUtils {
             .orElse(IAnnotations.of());
     }
 
+    @SuppressWarnings("unchecked")
     public static <E extends Enum<E>> List<E> getItems(IClass<?> type) {
         if (!type.isEnum()) {
             throw new IReflectiveException(type.name() + " is not enum");
@@ -71,23 +72,4 @@ public final class EnumUtils {
         return (List)Arrays.asList(type.raw().getEnumConstants());
     }
 
-    private final class IndexFunction<E extends Enum<E>> implements IntFunction<E> {
-
-        private final int[] keys;
-        private final E[] values;
-
-        public IndexFunction(Class<E> eenum, ToIntFunction<E> function) {
-            values = eenum.getEnumConstants();
-            keys = Arrays.stream(values).mapToInt(function).toArray();
-            CollectionSort.sort(IntComparator.ASC, keys, values);
-        }
-
-        @Override
-        public E apply(int key) {
-            int i = Arrays.binarySearch(keys, key);
-            return i<0 ? null : values[i];
-        }
-
-    }
-
 }

assira.core/src/main/java/net/ranides/assira/reflection/impl/RGClass.java

@@ -95,6 +95,7 @@ public class RGClass<T> extends AClass<T> implements Serializable {
         return rtype.reflective();
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public Class<T> raw() {
         return (Class)rtype.raw();

assira.core/src/main/java/net/ranides/assira/reflection/impl/RWClass.java

@@ -96,6 +96,7 @@ public class RWClass<T> extends AClass<T> implements Serializable {
         return type;
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public Class<T> raw() {
         return (Class)Object.class;

assira.core/src/main/java/net/ranides/assira/reflection/impl/SClass.java

@@ -17,7 +17,7 @@ public class SClass extends AClass<Object> implements Serializable {
 
     private final Type type;
 
-
+    @SuppressWarnings("unchecked")
     public SClass(String fqn, Class<?> raw) {
         this.fqn = fqn;
         this.raw = (Class)raw;

assira.core/src/main/java/net/ranides/assira/text/NaturalComparator.java

@@ -27,19 +27,20 @@
 
 package net.ranides.assira.text;
 
-import java.util.Comparator;
+import lombok.experimental.UtilityClass;
 
-public class NaturalComparator implements Comparator<String> {
+import java.util.Comparator;
+import java.util.function.Function;
 
-    private static final NaturalComparator INSTANCE = new NaturalComparator();
+@UtilityClass
+public class NaturalComparator {
 
-    public static NaturalComparator getInstance() {
-        return INSTANCE;
+    public static Comparator<String> comparator() {
+        return NaturalComparator::compareTo;
     }
 
-    @Override
-    public int compare(String oa, String ob) {
-        return compareTo(oa, ob);
+    public static <T> Comparator<T> comparator(Function<T, String> map) {
+        return Comparator.comparing(map, comparator());
     }
 
     public static int compareTo(String a, String b) {

assira.core/src/test/java/net/ranides/assira/generic/NaturalComparatorTest.java

@@ -13,14 +13,14 @@ public class NaturalComparatorTest {
     @Test
     public void simple() {
         String[] list = {"hello3", "hello20", "hello1"};
-        Arrays.sort(list, NaturalComparator::compareTo);
+        Arrays.sort(list, NaturalComparator.comparator());
         assertArrayEquals(new String[]{"hello1", "hello3", "hello20"}, list);
     }
 
     @Test
     public void separators() {
         String[] list = {"hello3.14", "hello4.0", "hello3.0.1"};
-        Arrays.sort(list, NaturalComparator::compareTo);
+        Arrays.sort(list, NaturalComparator.comparator());
         System.out.println(Arrays.toString(list));
         assertArrayEquals(new String[]{"hello3.0.1", "hello3.14", "hello4.0"}, list);
     }
@@ -28,7 +28,7 @@ public class NaturalComparatorTest {
     @Test
     public void separators2() {
         String[] list = {"hello3.14", "hello4.0", "hello3.7.1", "hello3.20.1", "hello3.2.1"};
-        Arrays.sort(list, NaturalComparator::compareTo);
+        Arrays.sort(list, NaturalComparator.comparator());
         assertArrayEquals(new String[]{"hello3.2.1", "hello3.7.1", "hello3.14", "hello3.20.1", "hello4.0"}, list);
     }
 }