Merge #409 from '380-addOptionToSortTriplesNumerically' of https://github.com/metafacture/metafacture-core

Author: dr0i

metafacture-triples/build.gradle

@@ -24,3 +24,10 @@ dependencies {
   testImplementation 'junit:junit:4.12'
   testImplementation 'org.mockito:mockito-core:2.5.5'
 }
+
+test {
+  testLogging {
+    showStandardStreams = true
+    exceptionFormat = 'full'
+  }
+}

metafacture-triples/src/main/java/org/metafacture/triples/AbstractTripleSort.java

@@ -30,12 +30,14 @@
 import java.util.Comparator;
 import java.util.List;
 import java.util.PriorityQueue;
+import java.util.function.Function;
 
 /**
  * @author markus geipel
  *
  */
 public abstract class AbstractTripleSort extends DefaultObjectPipe<Triple, ObjectReceiver<Triple>> implements MemoryWarningSystem.Listener {
+
     /**
      * specifies the comparator
      */
@@ -63,17 +65,16 @@ public int order(final int indicator) {
         public abstract int order(int indicator);
     }
 
-    private final List<Triple> buffer = new ArrayList<Triple>();
+    private final List<Triple> buffer = new ArrayList<>();
     private final List<File> tempFiles;
     private Compare compare = Compare.SUBJECT;
     private Order order = Order.INCREASING;
+    private boolean numeric;
     private volatile boolean memoryLow;
 
     public AbstractTripleSort() {
         MemoryWarningSystem.addListener(this);
-        tempFiles = new ArrayList<File>(); // Initialized here to let the
-                                            // compiler enforce the call to
-                                            // super() in subclasses.
+        tempFiles = new ArrayList<>(); // Initialized here to let the compiler enforce the call to super() in subclasses.
     }
 
     @Override
@@ -93,6 +94,10 @@ protected final void setSortOrder(final Order newOrder) {
         order = newOrder;
     }
 
+    protected final void setSortNumeric(final boolean newNumeric) {
+        numeric = newNumeric;
+    }
+
     @Override
     public final void process(final Triple namedValue) {
         if (memoryLow) {
@@ -112,47 +117,38 @@ public final void process(final Triple namedValue) {
     }
 
     private void nextBatch() throws IOException {
-        Collections.sort(buffer, createComparator(compare, order));
+        Collections.sort(buffer, createComparator());
         final File tempFile = File.createTempFile("sort", "namedValues", null);
         tempFile.deleteOnExit();
-        final ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(tempFile));
 
-        try {
+        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(tempFile))) {
             for (final Triple triple : buffer) {
                 triple.write(out);
             }
         }
-        finally {
-            out.close();
-        }
+
         buffer.clear();
         tempFiles.add(tempFile);
     }
 
     @Override
     public final void onCloseStream() {
-
         if (tempFiles.isEmpty()) {
-            Collections.sort(buffer, createComparator(compare, order));
+            Collections.sort(buffer, createComparator());
+
             for (final Triple triple : buffer) {
                 sortedTriple(triple);
             }
+
             onFinished();
         }
         else {
-            final Comparator<Triple> comparator = createComparator(compare, order);
-            final PriorityQueue<SortedTripleFileFacade> queue = new PriorityQueue<SortedTripleFileFacade>(11,
-                    new Comparator<SortedTripleFileFacade>() {
-                        // private final Comparator<Triple> comparator =
-                        // getComparator();
-
-                        @Override
-                        public int compare(final SortedTripleFileFacade o1, final SortedTripleFileFacade o2) {
-                            return comparator.compare(o1.peek(), o2.peek());
-                        }
-                    });
+            final Comparator<Triple> comparator = createComparator();
+            final PriorityQueue<SortedTripleFileFacade> queue = new PriorityQueue<>(11, (o1, o2) -> comparator.compare(o1.peek(), o2.peek()));
+
             try {
                 nextBatch();
+
                 for (final File file : tempFiles) {
                     queue.add(new SortedTripleFileFacade(file));
                 }
@@ -168,6 +164,7 @@ public int compare(final SortedTripleFileFacade o1, final SortedTripleFileFacade
                         queue.add(sortedFileFacade);
                     }
                 }
+
                 onFinished();
             }
             catch (final IOException e) {
@@ -179,6 +176,7 @@ public int compare(final SortedTripleFileFacade o1, final SortedTripleFileFacade
                 }
             }
         }
+
         MemoryWarningSystem.removeListener(this);
     }
 
@@ -189,58 +187,47 @@ protected void onFinished() {
     protected abstract void sortedTriple(Triple namedValue);
 
     public final Comparator<Triple> createComparator() {
-        return createComparator(compare, order);
+        return createComparator(compare, order, numeric);
+    }
+
+    public static Comparator<Triple> createComparator(final Compare compare, final Order order) {
+        return createComparator(compare, order, false);
     }
 
-    public static Comparator<Triple> createComparator(final Compare compareBy, final Order order) {
-        final Comparator<Triple> comparator;
-        switch (compareBy) {
+    private static Comparator<Triple> createComparator(final Compare compare, final Order order, final boolean numeric) {
+        final Function<Triple, String> tripleFunction;
+        switch (compare) {
             case ALL:
-                comparator = new Comparator<Triple>() {
-                    @Override
-                    public int compare(final Triple o1, final Triple o2) {
-                        return order.order(o1.compareTo(o2));
-                    }
-                };
-                break;
+                return (o1, o2) -> order.order(o1.compareTo(o2));
             case OBJECT:
-                comparator = new Comparator<Triple>() {
-                    @Override
-                    public int compare(final Triple o1, final Triple o2) {
-                        return order.order(o1.getObject().compareTo(o2.getObject()));
-                    }
-                };
+                tripleFunction = Triple::getObject;
                 break;
             case SUBJECT:
-                comparator = new Comparator<Triple>() {
-                    @Override
-                    public int compare(final Triple o1, final Triple o2) {
-                        return order.order(o1.getSubject().compareTo(o2.getSubject()));
-                    }
-                };
+                tripleFunction = Triple::getSubject;
                 break;
             case PREDICATE:
             default:
-                comparator = new Comparator<Triple>() {
-                    @Override
-                    public int compare(final Triple o1, final Triple o2) {
-                        return order.order(o1.getPredicate().compareTo(o2.getPredicate()));
-                    }
-                };
+                tripleFunction = Triple::getPredicate;
                 break;
         }
 
-        return comparator;
+        final Function<Triple, Integer> numericFunction = tripleFunction.andThen(Integer::valueOf);
+        return numeric ?
+            (o1, o2) -> order.order(numericFunction.apply(o1).compareTo(numericFunction.apply(o2))) :
+            (o1, o2) -> order.order(tripleFunction.apply(o1).compareTo(tripleFunction.apply(o2)));
     }
 
     @Override
     public final void onResetStream() {
         buffer.clear();
+
         for (final File file : tempFiles) {
             if (file.exists()) {
                 file.delete();
             }
         }
+
         tempFiles.clear();
     }
+
 }

metafacture-triples/src/main/java/org/metafacture/triples/TripleSort.java

@@ -27,7 +27,7 @@
  * @author markus geipel
  *
  */
-@Description("Sorts triples")
+@Description("Sorts triples. Several options can be combined, e.g. `by=\"object\",numeric=\"true\",order=\"decreasing\"` will numerically sort the Object of the triples in decreasing order (given that all Objects are indeed of numeric type).")
 @In(Triple.class)
 @Out(Triple.class)
 @FluxCommand("sort-triples")
@@ -49,4 +49,8 @@ public void setOrder(final Order order) {
         setSortOrder(order);
     }
 
+    public void setNumeric(final boolean numeric) {
+        setSortNumeric(numeric);
+    }
+
 }