new: NaturalComparator

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

@@ -0,0 +1,156 @@
+/*
+ Natural ordering comparator. It is based on https://github.com/paour/natorder
+ @author Mariusz Czarnowski <contact@ranides.net>
+
+ NaturalOrderComparator.java -- Perform 'natural order' comparisons of strings in Java.
+ Copyright (C) 2003 by Pierre-Luc Paour <natorder@paour.com>
+
+ Based on the C version by Martin Pool, of which this is more or less a straight conversion.
+ Copyright (C) 2000 by Martin Pool <mbp@humbug.org.au>
+
+ This software is provided 'as-is', without any express or implied
+ warranty.  In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+package net.ranides.assira.generic;
+
+import java.util.Comparator;
+
+public class NaturalComparator<T> implements Comparator<T> {
+
+    private static final NaturalComparator INSTANCE = new NaturalComparator();
+
+    public static <T> NaturalComparator<T> getInstance() {
+        return INSTANCE;
+    }
+
+    @Override
+    public int compare(T oa, T ob) {
+        return compareTo(oa, ob);
+    }
+
+    public static int compareTo(Object oa, Object ob) {
+        String a = String.valueOf(oa);
+        String b = String.valueOf(ob);
+        int ia = 0, ib = 0;
+        int nza, nzb;
+        char ca, cb;
+
+        while (true) {
+            // Only count the number of zeroes leading the last number compared
+            nza = nzb = 0;
+
+            ca = charAt(a, ia);
+            cb = charAt(b, ib);
+
+            // skip over leading spaces or zeros
+            while (Character.isSpaceChar(ca) || ca == '0') {
+                if (ca == '0') {
+                    nza++;
+                } else {
+                    // Only count consecutive zeroes
+                    nza = 0;
+                }
+
+                ca = charAt(a, ++ia);
+            }
+
+            while (Character.isSpaceChar(cb) || cb == '0') {
+                if (cb == '0') {
+                    nzb++;
+                } else {
+                    // Only count consecutive zeroes
+                    nzb = 0;
+                }
+
+                cb = charAt(b, ++ib);
+            }
+
+            // Process run of digits
+            if (Character.isDigit(ca) && Character.isDigit(cb)) {
+                int bias = compareRight(a.substring(ia), b.substring(ib));
+                if (bias != 0) {
+                    return bias;
+                }
+            }
+
+            if (ca == 0 && cb == 0) {
+                // The strings compare the same. Perhaps the caller
+                // will want to call strcmp to break the tie.
+                return compareEqual(a, b, nza, nzb);
+            }
+            if (ca < cb) {
+                return -1;
+            }
+            if (ca > cb) {
+                return +1;
+            }
+
+            ++ia;
+            ++ib;
+        }
+    }
+
+    private static int compareRight(String a, String b) {
+        int bias = 0, ia = 0, ib = 0;
+
+        // The longest run of digits wins. That aside, the greatest
+        // value wins, but we can't know that it will until we've scanned
+        // both numbers to know that they have the same magnitude, so we
+        // remember it in BIAS.
+        for (; ; ia++, ib++) {
+            char ca = charAt(a, ia);
+            char cb = charAt(b, ib);
+
+            if (!Character.isDigit(ca) && !Character.isDigit(cb)) {
+                return bias;
+            }
+            if (!Character.isDigit(ca)) {
+                return -1;
+            }
+            if (!Character.isDigit(cb)) {
+                return +1;
+            }
+            if (ca == 0 && cb == 0) {
+                return bias;
+            }
+
+            if (bias == 0) {
+                if (ca < cb) {
+                    bias = -1;
+                } else if (ca > cb) {
+                    bias = +1;
+                }
+            }
+        }
+    }
+
+    private static char charAt(String s, int i) {
+        return i >= s.length() ? 0 : s.charAt(i);
+    }
+
+    private static int compareEqual(String a, String b, int nza, int nzb) {
+        if (nza - nzb != 0) {
+            return nza - nzb;
+        }
+
+        if (a.length() == b.length()) {
+            return a.compareTo(b);
+        }
+
+        return a.length() - b.length();
+    }
+}

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

@@ -0,0 +1,32 @@
+package net.ranides.assira.generic;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class NaturalComparatorTest {
+
+    @Test
+    public void simple() {
+        String[] list = {"hello3", "hello20", "hello1"};
+        Arrays.sort(list, NaturalComparator::compareTo);
+        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);
+        System.out.println(Arrays.toString(list));
+        assertArrayEquals(new String[]{"hello3.0.1", "hello3.14", "hello4.0"}, list);
+    }
+
+    @Test
+    public void separators2() {
+        String[] list = {"hello3.14", "hello4.0", "hello3.7.1", "hello3.20.1", "hello3.2.1"};
+        Arrays.sort(list, NaturalComparator::compareTo);
+        assertArrayEquals(new String[]{"hello3.2.1", "hello3.7.1", "hello3.14", "hello3.20.1", "hello4.0"}, list);
+    }
+}