Make order preservation its own settings

Author: Genbox

Src/FastData.Tests/FastDataGeneratorTests.cs

@@ -10,9 +10,8 @@ namespace Genbox.FastData.Tests;
 public class FastDataGeneratorTests
 {
     [Theory]
-    [InlineData(DeduplicationMode.HashSetPreserveOrder)]
+    [InlineData(DeduplicationMode.HashSet)]
     [InlineData(DeduplicationMode.Sort)]
-    [InlineData(DeduplicationMode.SortPreserveOrder)]
     public void Generate_ThrowOnDuplicate(DeduplicationMode mode)
     {
         FastDataConfig config = new FastDataConfig();
@@ -25,9 +24,8 @@ public void Generate_ThrowOnDuplicate(DeduplicationMode mode)
 
     [Theory]
     [InlineData(DeduplicationMode.Disabled)]
-    [InlineData(DeduplicationMode.HashSetPreserveOrder)]
+    [InlineData(DeduplicationMode.HashSet)]
     [InlineData(DeduplicationMode.Sort)]
-    [InlineData(DeduplicationMode.SortPreserveOrder)]
     public void Generate_NoThrowOnDuplicates(DeduplicationMode mode)
     {
         FastDataConfig config = new FastDataConfig();
@@ -54,60 +52,76 @@ public void FastDataConfig_SkipQuantum_ThrowsWhenNotPowerOfTwo()
     }
 
     [Theory]
-    [InlineData(DeduplicationMode.HashSetPreserveOrder)]
-    [InlineData(DeduplicationMode.Sort)]
-    [InlineData(DeduplicationMode.SortPreserveOrder)]
-    public void GenerateKeyed_StringDeduplication_RemovesDuplicates(DeduplicationMode mode)
+    [InlineData(DeduplicationMode.HashSet, true)]
+    [InlineData(DeduplicationMode.HashSet, false)]
+    [InlineData(DeduplicationMode.Sort, true)]
+    [InlineData(DeduplicationMode.Sort, false)]
+    public void GenerateKeyed_StringDeduplication_RemovesDuplicates(DeduplicationMode mode, bool preserveOrder)
     {
         string[] keys = ["b", "a", "b", "c"];
         string[] values = ["vb", "va", "vb", "vc"];
 
         FastDataConfig config = new FastDataConfig(StructureType.Array);
         config.DeduplicationMode = mode;
         config.ThrowOnDuplicates = false;
+        config.PreserveOrder = preserveOrder;
 
         ContextCaptureGenerator generator = new ContextCaptureGenerator();
         FastDataGenerator.GenerateKeyed(keys, values, config, generator);
 
         ArrayContext<string, string> ctx = Assert.IsType<ArrayContext<string, string>>(generator.Context);
-        if (mode is DeduplicationMode.HashSetPreserveOrder or DeduplicationMode.SortPreserveOrder)
+
+        // If user asked for preserved order, we should preserve no matter what method used
+        if (preserveOrder)
         {
-            Assert.True(ctx.Keys.Span.SequenceEqual(["b", "a", "c"]));
-            Assert.True(ctx.Values.Span.SequenceEqual(["vb", "va", "vc"]));
+            Assert.Equal(["b", "a", "c"], ctx.Keys.Span);
+            Assert.Equal(["vb", "va", "vc"], ctx.Values.Span);
         }
         else
         {
-            Assert.True(ctx.Keys.Span.SequenceEqual(["a", "b", "c"]));
-            Assert.True(ctx.Values.Span.SequenceEqual(["va", "vb", "vc"]));
+            // Additionally, if the user asked for sort, but no preservation, data should be sorted
+            if (mode == DeduplicationMode.Sort)
+            {
+                Assert.Equal(["a", "b", "c"], ctx.Keys.Span);
+                Assert.Equal(["va", "vb", "vc"], ctx.Values.Span);
+            }
         }
     }
 
     [Theory]
-    [InlineData(DeduplicationMode.HashSetPreserveOrder)]
-    [InlineData(DeduplicationMode.Sort)]
-    [InlineData(DeduplicationMode.SortPreserveOrder)]
-    public void GenerateKeyed_NumericDeduplication_RemovesDuplicates(DeduplicationMode mode)
+    [InlineData(DeduplicationMode.HashSet, true)]
+    [InlineData(DeduplicationMode.HashSet, false)]
+    [InlineData(DeduplicationMode.Sort, true)]
+    [InlineData(DeduplicationMode.Sort, false)]
+    public void GenerateKeyed_NumericDeduplication_RemovesDuplicates(DeduplicationMode mode, bool preserveOrder)
     {
         int[] keys = [3, 1, 3, 2];
         string[] values = ["v3", "v1", "v3", "v2"];
 
         FastDataConfig config = new FastDataConfig(StructureType.Array);
         config.DeduplicationMode = mode;
         config.ThrowOnDuplicates = false;
+        config.PreserveOrder = preserveOrder;
 
         ContextCaptureGenerator generator = new ContextCaptureGenerator();
         FastDataGenerator.GenerateKeyed(keys, values, config, generator);
 
         ArrayContext<int, string> ctx = Assert.IsType<ArrayContext<int, string>>(generator.Context);
-        if (mode is DeduplicationMode.HashSetPreserveOrder or DeduplicationMode.SortPreserveOrder)
+
+        // If user asked for preserved order, we should preserve no matter what method used
+        if (preserveOrder)
         {
-            Assert.True(ctx.Keys.Span.SequenceEqual([3, 1, 2]));
-            Assert.True(ctx.Values.Span.SequenceEqual(["v3", "v1", "v2"]));
+            Assert.Equal([3, 1, 2], ctx.Keys.Span);
+            Assert.Equal(["v3", "v1", "v2"], ctx.Values.Span);
         }
         else
         {
-            Assert.True(ctx.Keys.Span.SequenceEqual([1, 2, 3]));
-            Assert.True(ctx.Values.Span.SequenceEqual(["v1", "v2", "v3"]));
+            // Additionally, if the user asked for sort, but no preservation, data should be sorted
+            if (mode == DeduplicationMode.Sort)
+            {
+                Assert.Equal([1, 2, 3], ctx.Keys.Span);
+                Assert.Equal(["v1", "v2", "v3"], ctx.Values.Span);
+            }
         }
     }
 

Src/FastData/DeduplicationMode.cs

@@ -10,15 +10,10 @@ public enum DeduplicationMode : byte
     /// <summary>
     /// Uses a hash set to deduplicate data. It is faster than sorting, but uses more memory. It does not change the order of keys.
     /// </summary>
-    HashSetPreserveOrder,
+    HashSet,
 
     /// <summary>
-    /// Uses sorting to deduplicate data. It is not as fast as <seealso cref="HashSetPreserveOrder" />, but it uses about half the memory. As a side effect, it changes the order of keys, which might be a desired side effect under certain circumstances.
+    /// Uses sorting to deduplicate data. It is not as fast as <seealso cref="HashSet" />, but it uses about half the memory. As a side effect, it changes the order of keys, which might be a desired side effect under certain circumstances.
     /// </summary>
     Sort,
-
-    /// <summary>
-    /// Same as <seealso cref="Sort" />, but input order is preserved.
-    /// </summary>
-    SortPreserveOrder
 }

Src/FastData/FastDataConfig.cs

@@ -9,8 +9,11 @@ public sealed class FastDataConfig(StructureType structureType = StructureType.A
     /// <summary>The type of structure to create. Defaults to Auto.</summary>
     public StructureType StructureType { get; set; } = structureType;
 
-    /// <summary>Set the method to use for deduplication of keys. Defaults to <see cref="DeduplicationMode.HashSetPreserveOrder" />.</summary>
-    public DeduplicationMode DeduplicationMode { get; set; } = DeduplicationMode.HashSetPreserveOrder;
+    /// <summary>Set the method to use for deduplication of keys. Defaults to <see cref="FastData.DeduplicationMode.HashSet" />.</summary>
+    public DeduplicationMode DeduplicationMode { get; set; } = DeduplicationMode.HashSet;
+
+    /// <summary>When true, FastData will only use data structures and algorithms that preserve the original data order</summary>
+    public bool PreserveOrder { get; set; } = true;
 
     /// <summary>When true, throws an exception on duplicate keys</summary>
     public bool ThrowOnDuplicates { get; set; } = true;

Src/FastData/FastDataGenerator.cs

@@ -299,15 +299,15 @@ private static bool DeduplicateKeys<TKey, TValue>(FastDataConfig fdCfg, ref Read
         bool isSorted = false;
         int uniqueCount;
 
-        if (fdCfg.DeduplicationMode == DeduplicationMode.HashSetPreserveOrder)
+        if (fdCfg.DeduplicationMode == DeduplicationMode.HashSet)
             DeduplicateWithHashSet(copyKeys, copyValues, fdCfg.ThrowOnDuplicates, equalityComparer, out uniqueCount);
+        else if (fdCfg.DeduplicationMode == DeduplicationMode.Sort && fdCfg.PreserveOrder)
+            DeduplicateWithSortPreserveInputOrder(copyKeys, copyValues, fdCfg.ThrowOnDuplicates, equalityComparer, sortComparer, out uniqueCount);
         else if (fdCfg.DeduplicationMode == DeduplicationMode.Sort)
         {
             DeduplicateWithSort(copyKeys, copyValues, fdCfg.ThrowOnDuplicates, equalityComparer, sortComparer, out uniqueCount);
             isSorted = true;
         }
-        else if (fdCfg.DeduplicationMode == DeduplicationMode.SortPreserveOrder)
-            DeduplicateWithSortPreserveInputOrder(copyKeys, copyValues, fdCfg.ThrowOnDuplicates, equalityComparer, sortComparer, out uniqueCount);
         else
             throw new InvalidOperationException("Unsupported deduplication mode: " + fdCfg.DeduplicationMode);