Bump org.apache.maven.plugins:maven-surefire-plugin from 3.2.2 to 3.2.3

pom.xml

@@ -45,7 +45,7 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>
-            <version>5.7.0</version>
+            <version>5.10.1</version>
             <scope>test</scope>
         </dependency>
     </dependencies>
@@ -55,7 +55,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.8.1</version>
+                <version>3.11.0</version>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>
@@ -64,12 +64,12 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
-                <version>2.22.2</version>
+                <version>3.2.3</version>
             </plugin>
             <plugin>
                 <groupId>org.jacoco</groupId>
                 <artifactId>jacoco-maven-plugin</artifactId>
-                <version>0.8.6</version>
+                <version>0.8.11</version>
                 <executions>
                     <execution>
                         <goals>

src/main/java/com/bestvike/Index.java

@@ -0,0 +1,99 @@
+package com.bestvike;
+
+import com.bestvike.linq.exception.ExceptionArgument;
+import com.bestvike.linq.exception.ThrowHelper;
+
+/**
+ * Represent a type can be used to index a collection either from the start or the end.
+ * <p>
+ * <pre>
+ * {@code
+ * List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
+ * Integer lastElement = Linq.of(list).elementAt(Index.fromEnd(1)); // lastElement = 5
+ * }
+ * </pre>
+ * <p>
+ * Created by 许崇雷 on 2023-05-31.
+ */
+public final class Index {
+    public static final Index Start = new Index(0);
+    public static final Index End = new Index(~0);
+    private final int value;
+
+    // The following private constructors mainly created for perf reason to avoid the checks
+    private Index(int value) {
+        this.value = value;
+    }
+
+    public Index(int value, boolean fromEnd) {
+        if (value < 0)
+            ThrowHelper.throwArgumentOutOfRangeException(ExceptionArgument.value);
+        if (fromEnd) {
+            this.value = ~value;
+        } else {
+            this.value = value;
+        }
+    }
+
+    public static Index fromStart(int value) {
+        if (value < 0)
+            ThrowHelper.throwArgumentOutOfRangeException(ExceptionArgument.value);
+        return new Index(value);
+    }
+
+    public static Index fromEnd(int value) {
+        if (value < 0)
+            ThrowHelper.throwArgumentOutOfRangeException(ExceptionArgument.value);
+        return new Index(~value);
+    }
+
+    public int getValue() {
+        if (this.value < 0)
+            return ~this.value;
+        else
+            return this.value;
+    }
+
+    public boolean isFromEnd() {
+        return this.value < 0;
+    }
+
+    public int getOffset(int length) {
+        int offset = this.value;
+        if (this.isFromEnd()) {
+            offset += length + 1;
+        }
+        return offset;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Index) {
+            return this.value == ((Index) obj).value;
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return this.value;
+    }
+
+    @Override
+    @SuppressWarnings("MethodDoesntCallSuperMethod")
+    protected Index clone() {
+        return new Index(this.value);
+    }
+
+    @Override
+    public String toString() {
+        if (this.isFromEnd()) {
+            return this.toStringFromEnd();
+        }
+        return String.valueOf(this.value);
+    }
+
+    private String toStringFromEnd() {
+        return '^' + String.valueOf(this.getValue());
+    }
+}

src/main/java/com/bestvike/Range.java

@@ -0,0 +1,106 @@
+package com.bestvike;
+
+import com.bestvike.linq.exception.ExceptionArgument;
+import com.bestvike.linq.exception.ThrowHelper;
+
+/**
+ * Represent a range has start and end indexes.
+ * <p>
+ * <pre>
+ * {@code
+ * List<Integer> someArray = Arrays.asList(1, 2, 3, 4, 5);
+ * Integer[] subArray1 = Linq.of(someArray).take(Range.endAt(Index.fromStart(2))).toArray(Integer.class); // { 1, 2 }
+ * Integer[] subArray2 = Linq.of(someArray).take(Range.startAt(Index.fromStart(1))).toArray(Integer.class); // { 2, 3, 4, 5 }
+ * }
+ * </pre>
+ * <p>
+ * Created by 许崇雷 on 2023-05-31.
+ */
+public final class Range {
+    public static final Range All = new Range(Index.Start, Index.End);
+    private final Index start;
+    private final Index end;
+
+    public Range(Index start, Index end) {
+        if (start == null)
+            ThrowHelper.throwArgumentNullException(ExceptionArgument.start);
+        if (end == null)
+            ThrowHelper.throwArgumentNullException(ExceptionArgument.end);
+        this.start = start;
+        this.end = end;
+    }
+
+    public static Range startAt(Index start) {
+        return new Range(start, Index.End);
+    }
+
+    public static Range endAt(Index end) {
+        return new Range(Index.Start, end);
+    }
+
+    public Index getStart() {
+        return this.start;
+    }
+
+    public Index getEnd() {
+        return this.end;
+    }
+
+    public OffsetLength getOffsetAndLength(int length) {
+        int start;
+        Index startIndex = this.getStart();
+        if (startIndex.isFromEnd())
+            start = length - startIndex.getValue();
+        else
+            start = startIndex.getValue();
+
+        int end;
+        Index endIndex = this.getEnd();
+        if (endIndex.isFromEnd())
+            end = length - endIndex.getValue();
+        else
+            end = endIndex.getValue();
+
+        if (Integer.compareUnsigned(end, length) > 0 || Integer.compareUnsigned(start, end) > 0)
+            ThrowHelper.throwArgumentOutOfRangeException(ExceptionArgument.length);
+
+        return new OffsetLength(start, end - start);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Range) {
+            Range r = (Range) obj;
+            return this.start.equals(r.start) && this.end.equals(r.end);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        int h1 = this.start.hashCode();
+        int h2 = this.end.hashCode();
+        return (h1 << 5) + h1 ^ h2;
+    }
+
+    @Override
+    @SuppressWarnings("MethodDoesntCallSuperMethod")
+    protected Range clone() {
+        return new Range(this.start, this.end);
+    }
+
+    @Override
+    public String toString() {
+        return this.start.toString() + ".." + this.end.toString();
+    }
+
+    public static final class OffsetLength {
+        public final int Offset;
+        public final int Length;
+
+        public OffsetLength(int offset, int length) {
+            this.Offset = offset;
+            this.Length = length;
+        }
+    }
+}

src/main/java/com/bestvike/collections/generic/Comparer.java

@@ -14,6 +14,8 @@
 public final class Comparer<T> implements Comparator<T> {
     private static final Comparer<?> DEFAULT = new Comparer<>(null);
     private static final Comparer<?> DEFAULT_INVARIANT = new Comparer<>(CultureInfo.getInvariantCulture());
+    private static final Comparator<Float> FLOAT = new FloatComparer();
+    private static final Comparator<Double> DOUBLE = new DoubleComparer();
 
     private final Collator collator;
 
@@ -31,6 +33,14 @@ public static <T> Comparator<T> DefaultInvariant() {
         return (Comparator<T>) DEFAULT_INVARIANT;
     }
 
+    public static Comparator<Float> Float() {
+        return FLOAT;
+    }
+
+    public static Comparator<Double> Double() {
+        return DOUBLE;
+    }
+
     public static <T> Comparator<T> create(Collator collator) {
         if (collator == null)
             ThrowHelper.throwArgumentNullException(ExceptionArgument.collator);
@@ -62,4 +72,64 @@ public int compare(T x, T y) {
         ThrowHelper.throwImplementComparableException();
         return 0;
     }
+
+
+    private static final class FloatComparer implements Comparator<Float> {
+        @Override
+        public int compare(Float x, Float y) {
+            if (x != null) {
+                if (y != null)
+                    return this.comparePrimitive(x, y);
+                return 1;
+            }
+            if (y != null)
+                return -1;
+            return 0;
+        }
+
+        private int comparePrimitive(float x, float y) {
+            if (x < y)
+                return -1;
+            if (x > y)
+                return 1;
+            if (x == y)
+                return 0;
+
+            // At least one of the values is NaN.
+            if (Float.isNaN(x))
+                return Float.isNaN(y) ? 0 : -1;
+            else // y is NaN.
+                return 1;
+        }
+    }
+
+
+    private static final class DoubleComparer implements Comparator<Double> {
+        @Override
+        public int compare(Double x, Double y) {
+            if (x != null) {
+                if (y != null)
+                    return this.comparePrimitive(x, y);
+                return 1;
+            }
+            if (y != null)
+                return -1;
+            return 0;
+        }
+
+        private int comparePrimitive(double x, double y) {
+            if (x < y)
+                return -1;
+            if (x > y)
+                return 1;
+            if (x == y)
+                return 0;
+
+            // At least one of the values is NaN.
+            if (Double.isNaN(x))
+                return Double.isNaN(y) ? 0 : -1;
+            else // y is NaN.
+                return 1;
+        }
+    }
 }