Automatic cleanup

Author: Genbox

Imports/Library.props

@@ -20,7 +20,7 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(IncludeAnalyzers)' == 'True'">
-<!--    <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" PrivateAssets="all" />-->
+    <!--    <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" PrivateAssets="all" />-->
     <PackageReference Include="ConfigureAwaitChecker.Analyzer" PrivateAssets="all" />
     <PackageReference Include="IDisposableAnalyzers" PrivateAssets="all" />
     <PackageReference Include="Roslynator.Analyzers" PrivateAssets="all" />

README.md

@@ -5,12 +5,14 @@
 
 ## Description
 
-FastData is a code generator that analyzes your data and creates high-performance, read-only lookup data structures for static data. It can output the data structures
+FastData is a code generator that analyzes your data and creates high-performance, read-only lookup data structures for
+static data. It can output the data structures
 in many different languages (C#, C++, Rust, etc.), ready for inclusion in your project with zero dependencies.
 
 ## Use case
 
-Imagine a scenario where you have a predefined list of words (e.g., dog breeds) and need to check whether a specific dog breed exists in the set.
+Imagine a scenario where you have a predefined list of words (e.g., dog breeds) and need to check whether a specific dog
+breed exists in the set.
 Usually you create an array and look up the value. However, this is far from optimal and is missing a few optimizations.
 
 ```csharp
@@ -140,15 +142,17 @@ Each output language has different settings. Type `fastdata <lang> --help` to se
 
 ### Data structures
 
-By default, FastData chooses the optimal data structure for your data, but you can also set it manually with `fastdata -s <type>`. See the details of each structure type below.
+By default, FastData chooses the optimal data structure for your data, but you can also set it manually with
+`fastdata -s <type>`. See the details of each structure type below.
 
 #### SingleValue
 
 * Memory: Low
 * Latency: Low
 * Complexity: O(1)
 
-This data structure only supports a single value. It is much faster than an array with a single item and has no overhead associated with it.
+This data structure only supports a single value. It is much faster than an array with a single item and has no overhead
+associated with it.
 FastData always selects this data structure whenever your dataset only contains one item.
 
 #### Conditional
@@ -157,9 +161,11 @@ FastData always selects this data structure whenever your dataset only contains
 * Latency: Low
 * Complexity: O(n)
 
-This data structure relies on built-in logic in the programming language. It produces if/switch statements which ultimately become machine instructions on the CPU, rather than data
+This data structure relies on built-in logic in the programming language. It produces if/switch statements which
+ultimately become machine instructions on the CPU, rather than data
 that resides in memory.
-Latency is therefore incredibly low, but the higher number of instructions bloat the assembly, and at a certain point it becomes more efficient to have
+Latency is therefore incredibly low, but the higher number of instructions bloat the assembly, and at a certain point it
+becomes more efficient to have
 the data reside in memory.
 
 #### Array
@@ -168,33 +174,39 @@ the data reside in memory.
 * Latency: Low
 * Complexity: O(n)
 
-This data structure uses an array as the backing store. It is often faster than a normal array due to efficient early exits (value/length range checks).
-It works well for small amounts of data since the array is scanned linearly, but for larger datasets, the O(n) complexity hurts performance a lot.
+This data structure uses an array as the backing store. It is often faster than a normal array due to efficient early
+exits (value/length range checks).
+It works well for small amounts of data since the array is scanned linearly, but for larger datasets, the O(n)
+complexity hurts performance a lot.
 
 #### BinarySearch
 
 * Memory: Low
 * Latency: Medium
 * Complexity: O(log n)
 
-This data structure sorts your data and does a binary search on it. Since data is sorted at compile time, there is no overhead at runtime. Each lookup
-has a higher latency than a simple array, but once the dataset gets to a few hundred items, it beats the array due to a lower complexity.
+This data structure sorts your data and does a binary search on it. Since data is sorted at compile time, there is no
+overhead at runtime. Each lookup
+has a higher latency than a simple array, but once the dataset gets to a few hundred items, it beats the array due to a
+lower complexity.
 
 #### EytzingerSearch
 
 * Memory: Low
 * Latency: Medium
 * Complexity: O(n*log(n))
 
-This data structure sorts data using an Eytzinger layout. It has better cache-locality than binary search. Under some circumstances it has better performance.
+This data structure sorts data using an Eytzinger layout. It has better cache-locality than binary search. Under some
+circumstances it has better performance.
 
 #### KeyLength
 
 * Memory: Low
 * Latency: Low
 * Complexity: O(1)
 
-This data structure only works on strings, but it indexes them after their length, rather than a hash. In the case all the strings have unique lengths, the
+This data structure only works on strings, but it indexes them after their length, rather than a hash. In the case all
+the strings have unique lengths, the
 data structure further optimizes for latency.
 
 #### HashSetChain
@@ -203,7 +215,8 @@ data structure further optimizes for latency.
 * Latency: Medium
 * Complexity: O(1)
 
-This data structure is based on a hash table with separate chaining collision resolution. It uses a separate array for buckets to stay cache coherent, but it also uses more
+This data structure is based on a hash table with separate chaining collision resolution. It uses a separate array for
+buckets to stay cache coherent, but it also uses more
 memory since it needs to keep track of indices.
 
 #### HashSetLinear
@@ -220,7 +233,8 @@ This data structure is also a hash table, but with linear collision resolution.
 * Latency: Low
 * Complexity: O(1)
 
-This data structure tries to create a perfect hash for the dataset. It does so by brute-forcing a seed for a simple hash function
+This data structure tries to create a perfect hash for the dataset. It does so by brute-forcing a seed for a simple hash
+function
 until it hits the right combination. If the dataset is small enough, it can even produce a minimal perfect hash.
 
 #### PerfectHashGPerf
@@ -229,12 +243,15 @@ until it hits the right combination. If the dataset is small enough, it can even
 * Latency: Low
 * Complexity: O(1)
 
-This data structure uses the same algorithm as gperf to derive a perfect hash. It uses Richard J. Cichelli's method for creating an associative table,
-which is augmented using alpha increments to resolve collisions. It only works on strings, but it is great for medium-sized datasets.
+This data structure uses the same algorithm as gperf to derive a perfect hash. It uses Richard J. Cichelli's method for
+creating an associative table,
+which is augmented using alpha increments to resolve collisions. It only works on strings, but it is great for
+medium-sized datasets.
 
 ## How does it work?
 
-The idea behind the project is to generate a data-dependent optimized data structure for read-only lookup. When data is known beforehand, the algorithm can select from a set
+The idea behind the project is to generate a data-dependent optimized data structure for read-only lookup. When data is
+known beforehand, the algorithm can select from a set
 of different data structures, indexing, and comparison methods that are tailor-built for the data.
 
 ### Compile-time generation
@@ -256,12 +273,15 @@ FastData uses advanced data analysis techniques to generate optimized data struc
 * Character mapping
 * Encoding analysis
 
-It uses the analysis to create so-called early-exits, which are fast `O(1)` checks on your input before doing any `O(n)` checks on the actual dataset.
+It uses the analysis to create so-called early-exits, which are fast `O(1)` checks on your input before doing any `O(n)`
+checks on the actual dataset.
 
 #### Hash function generators
 
-Hash functions come in many flavors. Some are designed for low latency, some for throughput, others for low collision rate.
-Programming language runtimes come with a hash function that is a tradeoff between these parameters. FastData builds a hash function specifically tailored to the dataset.
+Hash functions come in many flavors. Some are designed for low latency, some for throughput, others for low collision
+rate.
+Programming language runtimes come with a hash function that is a tradeoff between these parameters. FastData builds a
+hash function specifically tailored to the dataset.
 It has support for several techniques:
 
 1. **Default:** If no technique is selected, FastData uses a hash function by Daniel Bernstein (DJB2)

Src/FastData.Benchmarks/Benchmarks/ArrayVsHashSetBenchmarks.cs

@@ -3,10 +3,7 @@
 
 namespace Genbox.FastData.Benchmarks.Benchmarks;
 
-/// <summary>
-/// Benchmark used to illustrate the algorithmic complexity differences between Array and HashSet.
-/// Needed for the Readme.
-/// </summary>
+/// <summary>Benchmark used to illustrate the algorithmic complexity differences between Array and HashSet. Needed for the Readme.</summary>
 [Orderer(SummaryOrderPolicy.FastestToSlowest)]
 public class ArrayVsHashSetBenchmarks
 {

Src/FastData.Benchmarks/Benchmarks/DogsBenchmark.cs

@@ -2,9 +2,7 @@
 
 namespace Genbox.FastData.Benchmarks.Benchmarks;
 
-/// <summary>
-/// Benchmark used in Readme
-/// </summary>
+/// <summary>Benchmark used in Readme</summary>
 [Orderer(SummaryOrderPolicy.FastestToSlowest)]
 public class DogsBenchmark
 {
@@ -20,7 +18,7 @@ private static class Dogs
     {
         public static bool Contains(string value)
         {
-            if ((49280UL & (1UL << (value.Length - 1) % 64)) == 0)
+            if ((49280UL & (1UL << ((value.Length - 1) % 64))) == 0)
                 return false;
 
             return value switch

Src/FastData.Benchmarks/Benchmarks/GetHashCodeBenchmarks.cs

@@ -1,5 +1,6 @@
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Configs;
+// ReSharper disable All
 
 namespace Genbox.FastData.Benchmarks.Benchmarks;
 

Src/FastData.Benchmarks/Benchmarks/HashBenchmarks.cs

@@ -42,7 +42,9 @@ public ulong XXHashTest()
         ulong value = 0;
 
         foreach (string s in _array)
+        {
             value += XxHash.ComputeHash(s);
+        }
 
         return value;
     }
@@ -67,7 +69,7 @@ private static uint ComputeHash(ref char ptr, int length, ulong seed = PRIME64_5
             while (length >= 4)
             {
                 hash1 ^= Round(0, ptr64);
-                hash1 = (RotateLeft(hash1, 27) * PRIME64_1) + PRIME64_4;
+                hash1 = RotateLeft(hash1, 27) * PRIME64_1 + PRIME64_4;
                 ptr64 = ref Unsafe.Add(ref ptr64, 1);
                 length -= 4;
             }

Src/FastData.Benchmarks/Benchmarks/PriorityStructureBenchmarks.cs

@@ -5,9 +5,9 @@ namespace Genbox.FastData.Benchmarks.Benchmarks;
 [InvocationCount(1_000_000)]
 public class PriorityStructureBenchmarks
 {
-    private readonly MinHeap<bool> _heap = new MinHeap<bool>(10);
     private readonly RingBuffer _buffer = new RingBuffer(10);
     private readonly FixedSet _fixedSet = new FixedSet(10);
+    private readonly MinHeap<bool> _heap = new MinHeap<bool>(10);
     private readonly SortedSet<double> _sorted = new SortedSet<double>();
 
     [IterationCleanup]
@@ -23,28 +23,36 @@ public void Cleanup()
     public void MinHeapTest()
     {
         for (double i = 0; i < 100; i++)
+        {
             _heap.Add(i, true);
+        }
     }
 
     [Benchmark]
     public void RingBufferTest()
     {
         for (double i = 0; i < 100; i++)
+        {
             _buffer.Add(i);
+        }
     }
 
     [Benchmark]
     public void FixedSetTest()
     {
         for (double i = 0; i < 100; i++)
+        {
             _fixedSet.Add(i);
+        }
     }
 
     [Benchmark]
     public void SortedSetTest()
     {
         for (double i = 0; i < 100; i++)
+        {
             _sorted.Add(i);
+        }
     }
 
     private sealed class FixedSet(int capacity)
@@ -81,8 +89,8 @@ private sealed class RingBuffer(int capacity)
     {
         private readonly double[] _buffer = new double[capacity];
         private int _count;
-        private int _next;
         private int _minIndex = -1;
+        private int _next;
 
         public void Add(double value)
         {

Src/FastData.Benchmarks/Benchmarks/SegmentGeneratorsBenchmarks.cs

@@ -8,13 +8,14 @@ namespace Genbox.FastData.Benchmarks.Benchmarks;
 [MemoryDiagnoser]
 public class SegmentGeneratorsBenchmarks
 {
-    //We start at 8 and go up to 100 to cover as many cases as possible
-    private readonly StringProperties _props = DataAnalyzer.GetStringProperties(Enumerable.Range(8, 100).Select(x => TestHelper.GenerateRandomString(Random.Shared, x)).ToArray());
     private readonly BruteForceGenerator _bfGen = new BruteForceGenerator(8);
-    private readonly EdgeGramGenerator _egGen = new EdgeGramGenerator(8);
     private readonly DeltaGenerator _deltaGen = new DeltaGenerator();
+    private readonly EdgeGramGenerator _egGen = new EdgeGramGenerator(8);
     private readonly OffsetGenerator _ofGen = new OffsetGenerator();
 
+    //We start at 8 and go up to 100 to cover as many cases as possible
+    private readonly StringProperties _props = DataAnalyzer.GetStringProperties(Enumerable.Range(8, 100).Select(x => TestHelper.GenerateRandomString(Random.Shared, x)).ToArray());
+
     [Benchmark]
     public object BruteForceGenerator() => _bfGen.Generate(_props).ToArray();
 

Src/FastData.Cli/Program.cs

@@ -143,7 +143,9 @@ private static async IAsyncEnumerable<object> ReadFile(string file, DataType dat
         Func<string, object> func = GetTypeFunc(dataType);
 
         await foreach (string line in File.ReadLinesAsync(file))
+        {
             yield return func(line);
+        }
     }
 
     private static Func<string, object> GetTypeFunc(DataType dataType) => dataType switch

Src/FastData.Generator.CPlusPlus.Benchmarks/Program.cs

@@ -57,7 +57,9 @@ private static string PrintQueries(ITestData data, string identifier)
         StringBuilder sb = new StringBuilder();
 
         for (int i = 0; i < 25; i++)
+        {
             sb.AppendLine(CultureInfo.InvariantCulture, $"        DoNotOptimize({identifier}::contains({data.GetValueLabel(helper)}));");
+        }
 
         return sb.ToString();
     }