Changeset 10787

Timestamp:

04/23/14 18:33:14 (11 years ago)

Author:

abeham

Message:

#2106: Changed StableSort extension methods:

• Parameters index and count were ignored in List<T>.StableSort(int, int, Comparison<T>)
• Made both StableSortComparer<T> private classes
• Added sanity checks similar to those of Array.Sort and List<T>.Sort
  • Before it was possible that index + count was bigger than the size of the list
• Reduced number of method overloads to 2 by introducing IComparer<T> as optional parameter

Location:

trunk/sources/HeuristicLab.Common/3.3

Files:

• ArrayExtensions.cs (modified) (1 diff)
• ListExtensions.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.Common/3.3/ArrayExtensions.cs

@@ -26 +26 @@
 namespace HeuristicLab.Common {
   public static class ArrayExtensions {
-    public static void StableSort<T>(this T[] values) {
-      values.StableSort(0, values.Length);
+
+    public static void StableSort<T>(this T[] values, Comparison<T> comparison) {
+      values.StableSort(new StableSortComparer<T>(comparison));
     }
 
-    public static void StableSort<T>(this T[] values, int index, int count) {
-      var sortedArray = values.Skip(index).Take(count).OrderBy(x => x).ToArray();
-      Array.ConstrainedCopy(sortedArray, 0, values, index, count);
+    public static void StableSort<T>(this T[] values, IComparer<T> comparer = null) {
+      var sorted = values.OrderBy(x => x, comparer ?? Comparer<T>.Default).ToArray();
+      Array.ConstrainedCopy(sorted, 0, values, 0, values.Length);
     }
 
-    public static void StableSort<T>(this T[] values, IComparer<T> comparer) {
-      values.StableSort(0, values.Length, comparer);
+    public static void StableSort<T>(this T[] values, int index, int length, Comparison<T> comparison) {
+      values.StableSort(index, length, new StableSortComparer<T>(comparison));
     }
 
-    public static void StableSort<T>(this T[] values, int index, int count, IComparer<T> comparer) {
-      var sortedArray = values.Skip(index).Take(count).OrderBy(x => x, comparer).ToArray();
-      Array.ConstrainedCopy(sortedArray, 0, values, index, count);
+    public static void StableSort<T>(this T[] values, int index, int length, IComparer<T> comparer = null) {
+      if (index < 0) throw new ArgumentOutOfRangeException("index is less than zero.");
+      if (length < 0) throw new ArgumentOutOfRangeException("length is less than zero.");
+      if (index + length > values.Length) throw new ArgumentException("index and length do not specify a valid range in the array.");
+      var sortedArray = values.Skip(index).Take(length).OrderBy(x => x, comparer ?? Comparer<T>.Default).ToArray();
+      Array.ConstrainedCopy(sortedArray, 0, values, index, length);
     }
 
-    public static void StableSort<T>(this T[] values, Comparison<T> comparison) {
-      values.StableSort(0, values.Length, comparison);
-    }
-
-    public static void StableSort<T>(this T[] values, int index, int count, Comparison<T> comparison) {
-      var sortedArray = values.Skip(index).Take(count).OrderBy(x => x, new StableSortComparer<T>(comparison)).ToArray();
-      Array.ConstrainedCopy(sortedArray, 0, values, index, count);
-    }
-
-    public class StableSortComparer<T> : IComparer<T> {
+    private class StableSortComparer<T> : IComparer<T> {
       public StableSortComparer(Comparison<T> comparison) {
         this.comparison = comparison;

trunk/sources/HeuristicLab.Common/3.3/ListExtensions.cs

@@ -26 +26 @@
 namespace HeuristicLab.Common {
   public static class ListExtensions {
-    public static void StableSort<T>(this List<T> values) {
-      values.StableSort(0, values.Count);
+
+    public static void StableSort<T>(this List<T> values, Comparison<T> comparison) {
+      values.StableSort(new StableSortComparer<T>(comparison));
     }
 
-    public static void StableSort<T>(this List<T> values, int index, int count) {
-      var orderedList = values.Skip(index).Take(count).OrderBy(x => x);
+    public static void StableSort<T>(this List<T> values, IComparer<T> comparer = null) {
+      int i = 0;
+      foreach (var e in values.OrderBy(x => x, comparer ?? Comparer<T>.Default))
+        values[i++] = e;
+    }
+
+    public static void StableSort<T>(this List<T> values, int index, int count, Comparison<T> comparison) {
+      values.StableSort(index, count, new StableSortComparer<T>(comparison));
+    }
+
+    public static void StableSort<T>(this List<T> values, int index, int count, IComparer<T> comparer = null) {
+      if (index < 0) throw new ArgumentOutOfRangeException("index is less than zero.");
+      if (count < 0) throw new ArgumentOutOfRangeException("count is less than zero.");
+      if (index + count > values.Count) throw new ArgumentException("index and count do not specify a valid range in the List<T>.");
+      var orderedList = values.Skip(index).Take(count).OrderBy(x => x, comparer ?? Comparer<T>.Default);
       int i = index;
       foreach (var e in orderedList)
@@ -37 +51 @@
     }
 
-    public static void StableSort<T>(this List<T> values, IComparer<T> comparer) {
-      values.StableSort(0, values.Count, comparer);
-    }
-
-    public static void StableSort<T>(this List<T> values, int index, int count, IComparer<T> comparer) {
-      var orderedList = values.OrderBy(x => x, comparer);
-      int i = 0;
-      foreach (var e in orderedList)
-        values[i++] = e;
-    }
-
-    public static void StableSort<T>(this List<T> values, Comparison<T> comparison) {
-      values.StableSort(0, values.Count, comparison);
-    }
-
-    public static void StableSort<T>(this List<T> values, int index, int count, Comparison<T> comparison) {
-      var orderedList = values.OrderBy(x => x, new StableSortComparer<T>(comparison));
-      int i = 0;
-      foreach (var e in orderedList)
-        values[i++] = e;
-    }
-
-    public class StableSortComparer<T> : IComparer<T> {
+    private class StableSortComparer<T> : IComparer<T> {
       public StableSortComparer(Comparison<T> comparison) {
         this.comparison = comparison;