gwt: Sort statistics using natural ordering.

rosedu · Mar 10, 2015 · cd749df · cd749df
1 parent 7802b76
commit cd749df
Show file tree

Hide file tree

Showing 2 changed files with 124 additions and 0 deletions.
diff --git a/gwt/vmchecker-gui/src/ro/pub/cs/vmchecker/client/presenter/StatisticsPresenter.java b/gwt/vmchecker-gui/src/ro/pub/cs/vmchecker/client/presenter/StatisticsPresenter.java
@@ -1,6 +1,8 @@
 package ro.pub.cs.vmchecker.client.presenter;
 
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
 
 import ro.pub.cs.vmchecker.client.i18n.VmcheckerConstants;
 import ro.pub.cs.vmchecker.client.event.StatusChangedEvent;
@@ -9,6 +11,7 @@
 import ro.pub.cs.vmchecker.client.model.ResultInfo;
 import ro.pub.cs.vmchecker.client.model.User;
 import ro.pub.cs.vmchecker.client.service.HTTPService;
+import ro.pub.cs.vmchecker.client.util.AlphanumComparator;
 
 import com.google.gwt.core.client.GWT;
 import com.google.gwt.event.dom.client.ClickEvent;
@@ -55,6 +58,13 @@ public void onClick(ClickEvent event) {
 		}
 	}
 
+	private class ResultInfoComparator implements Comparator<ResultInfo> {
+		AlphanumComparator stringComparator = new AlphanumComparator();
+		@Override
+		public int compare(ResultInfo r1, ResultInfo r2) {
+			return stringComparator.compare(r1.name, r2.name);
+		}
+	}
 
 	private EventBus eventBus;
 	private HTTPService service;
@@ -153,6 +163,8 @@ private void processResults(ResultInfo[] resultsInfo) {
 				teamResultsInfo.add(result);
 			}
 		}
+		Collections.sort(studentResultsInfo, new ResultInfoComparator());
+		Collections.sort(teamResultsInfo, new ResultInfoComparator());
 	}
 
 	@Override

diff --git a/gwt/vmchecker-gui/src/ro/pub/cs/vmchecker/client/util/AlphanumComparator.java b/gwt/vmchecker-gui/src/ro/pub/cs/vmchecker/client/util/AlphanumComparator.java
@@ -0,0 +1,112 @@
+/*
+ * The Alphanum Algorithm is an improved sorting algorithm for strings
+ * containing numbers.  Instead of sorting numbers in ASCII order like
+ * a standard sort, this algorithm sorts numbers in numeric order.
+ *
+ * The Alphanum Algorithm is discussed at http://www.DaveKoelle.com
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+package ro.pub.cs.vmchecker.client.util;
+
+import java.util.Comparator;
+
+public class AlphanumComparator implements Comparator<String>
+{
+    private final boolean isDigit(char ch)
+    {
+        return ch >= 48 && ch <= 57;
+    }
+
+    /** Length of string is passed in for improved efficiency (only need to calculate it once) **/
+    private final String getChunk(String s, int slength, int marker)
+    {
+        StringBuilder chunk = new StringBuilder();
+        char c = s.charAt(marker);
+        chunk.append(c);
+        marker++;
+        if (isDigit(c))
+        {
+            while (marker < slength)
+            {
+                c = s.charAt(marker);
+                if (!isDigit(c))
+                    break;
+                chunk.append(c);
+                marker++;
+            }
+        } else
+        {
+            while (marker < slength)
+            {
+                c = s.charAt(marker);
+                if (isDigit(c))
+                    break;
+                chunk.append(c);
+                marker++;
+            }
+        }
+        return chunk.toString();
+    }
+
+    public int compare(String s1, String s2)
+    {
+        int thisMarker = 0;
+        int thatMarker = 0;
+        int s1Length = s1.length();
+        int s2Length = s2.length();
+
+        while (thisMarker < s1Length && thatMarker < s2Length)
+        {
+            String thisChunk = getChunk(s1, s1Length, thisMarker);
+            thisMarker += thisChunk.length();
+
+            String thatChunk = getChunk(s2, s2Length, thatMarker);
+            thatMarker += thatChunk.length();
+
+            // If both chunks contain numeric characters, sort them numerically
+            int result = 0;
+            if (isDigit(thisChunk.charAt(0)) && isDigit(thatChunk.charAt(0)))
+            {
+                // Simple chunk comparison by length.
+                int thisChunkLength = thisChunk.length();
+                result = thisChunkLength - thatChunk.length();
+                // If equal, the first different number counts
+                if (result == 0)
+                {
+                    for (int i = 0; i < thisChunkLength; i++)
+                    {
+                        result = thisChunk.charAt(i) - thatChunk.charAt(i);
+                        if (result != 0)
+                        {
+                            return result;
+                        }
+                    }
+                }
+            } else
+            {
+                result = thisChunk.compareTo(thatChunk);
+            }
+
+            if (result != 0)
+                return result;
+        }
+
+        return s1Length - s2Length;
+    }
+}