Sort analyzer results by earliest represented switch configuration (#1093)

diylc/diylc-core/src/main/java/org/diylc/netlist/Netlist.java

@@ -86,8 +86,10 @@ public class Netlist implements Comparable<Netlist> {
   }
 
   public String getSwitchSetupString() {
-    return getSwitchSetup().isEmpty() ? "[ ALL ]" : "[ " +
+    return switchSetup.isEmpty() ? "[ ALL ]" : "[ " +
-        getSwitchSetup().stream().map(x -> x.toString()).collect(Collectors.joining(",")) + " ]";
+            getSortedSwitchSetup().stream()
+                    .map(SwitchSetup::toString)
+                    .collect(Collectors.joining(", ")) + " ]";
   }
 
   @Override
@@ -103,6 +105,21 @@ public class Netlist implements Comparable<Netlist> {
 
   @Override
   public int compareTo(Netlist o) {
-    return switchSetup.toString().compareToIgnoreCase(o.switchSetup.toString());
+    List<SwitchSetup> left = getSortedSwitchSetup();
+    List<SwitchSetup> right = o.getSortedSwitchSetup();
+
+    SwitchSetup unrestricted =
+            new SwitchSetup(new ArrayList<Position>());
+
+    SwitchSetup firstLeft = left.isEmpty() ? unrestricted : left.get(0);
+    SwitchSetup firstRight = right.isEmpty() ? unrestricted : right.get(0);
+
+    return firstLeft.compareTo(firstRight);
+  }
+
+  private List<SwitchSetup> getSortedSwitchSetup() {
+    List<SwitchSetup> result = new ArrayList<>(switchSetup);
+    Collections.sort(result);
+    return result;
   }
 }

diylc/diylc-core/src/main/java/org/diylc/netlist/NetlistSummaryHtmlReport.java

@@ -37,7 +37,7 @@ public class NetlistSummaryHtmlReport {
 
         for (Summary summary : summaries) {
             if (summaries.size() > 1) {
-                sb.append("<h2>Switch configuration: ").append(summary.getNetlist().getSwitchSetup())
+                sb.append("<h2>Switch configuration: ").append(summary.getNetlist().getSwitchSetupString())
                     .append("</h2>");
             }
 

diylc/diylc-core/src/main/java/org/diylc/netlist/Position.java

@@ -83,8 +83,17 @@ public class Position implements Comparable<Position> {
 
   @Override
   public int compareTo(Position o) {
-    if (theSwitch instanceof IDIYComponent<?> && o.theSwitch instanceof IDIYComponent<?>)
+    int comparison = getSwitchName().compareToIgnoreCase(o.getSwitchName());
-      return ((IDIYComponent<?>) theSwitch).getName().compareToIgnoreCase(((IDIYComponent<?>) o.theSwitch).getName());
+    return comparison != 0
-    return 0;
+            ? comparison
+            : Integer.compare(position, o.position);
+  }
+
+  String getSwitchName() {
+    String name = theSwitch instanceof IDIYComponent<?>
+            ? ((IDIYComponent<?>) theSwitch).getName()
+            : theSwitch.getClass().getName();
+
+    return name == null ? "" : name;
   }
 }

diylc/diylc-core/src/main/java/org/diylc/netlist/SwitchSetup.java

@@ -21,6 +21,7 @@
 */
 package org.diylc.netlist;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
@@ -82,6 +83,47 @@ public class SwitchSetup implements Comparable<SwitchSetup> {
 
   @Override
   public int compareTo(SwitchSetup o) {
+    List<Position> left = new ArrayList<>(positions);
+    List<Position> right = new ArrayList<>(o.positions);
+    Collections.sort(left);
+    Collections.sort(right);
+
+    int i = 0;
+    int j = 0;
+
+    while (i < left.size() || j < right.size()) {
+      int comparison;
+
+      if (i == left.size()) {
+        // This setup omits the next switch: use its lowest position.
+        comparison = Integer.compare(0, right.get(j++).getPosition());
+      } else if (j == right.size()) {
+        comparison = Integer.compare(left.get(i++).getPosition(), 0);
+      } else {
+        Position a = left.get(i);
+        Position b = right.get(j);
+        int nameComparison =
+                a.getSwitchName().compareToIgnoreCase(b.getSwitchName());
+
+        if (nameComparison < 0) {
+          comparison = Integer.compare(a.getPosition(), 0);
+          i++;
+        } else if (nameComparison > 0) {
+          comparison = Integer.compare(0, b.getPosition());
+          j++;
+        } else {
+          comparison = Integer.compare(a.getPosition(), b.getPosition());
+          i++;
+          j++;
+        }
+      }
+
+      if (comparison != 0) {
+        return comparison;
+      }
+    }
+
+    // Same earliest full configuration: use the description as a tie-breaker.
     return toString().compareToIgnoreCase(o.toString());
   }
 }