refact

Author: Petr Sramek

benchmarks/PolylineAlgorithm.Benchmarks/Internal/ValueProvider.cs

@@ -4,8 +4,8 @@
 
     public static class ValueProvider
     {
-        private static ConcurrentDictionary<int, CoordinatePair> _cache = new();
-        private static PolylineEncoder _encoder = new();
+        private static readonly ConcurrentDictionary<int, CoordinatePair> _cache = new();
+        private static readonly PolylineEncoder _encoder = new();
 
         public static IEnumerable<Coordinate> GetCoordinates(int count) {
             var entry = GetCaheEntry(count);

benchmarks/PolylineAlgorithm.Benchmarks/PolylineDecoderBenchmark.cs

@@ -18,7 +18,7 @@ namespace PolylineAlgorithm.Benchmarks;
 public class PolylineDecoderBenchmark {
     private readonly Consumer _consumer = new();
 
-    [Params(10, 100, 1_000, 10_000, 100_000)]
+    [Params(1, 10, 100, 1_000, 10_000, 100_000, 1_000_000)]
     public int N;
 
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.

benchmarks/PolylineAlgorithm.Benchmarks/PolylineEncoderBenchmark.cs

@@ -6,24 +6,17 @@
 namespace PolylineAlgorithm.Benchmarks;
 
 using BenchmarkDotNet.Attributes;
-using Microsoft.Extensions.ObjectPool;
 using PolylineAlgorithm;
-using PolylineAlgorithm.Abstraction;
 using PolylineAlgorithm.Benchmarks.Internal;
-using System;
 using System.Collections.Generic;
-using System.Text;
 using System.Threading.Tasks;
 
 /// <summary>
 /// Benchmarks for the <see cref="PolylineEncoder"/> class.
 /// </summary>
 [RankColumn]
 public class PolylineEncoderBenchmark {
-    private static string _dir = "C:\\temp_benchmark";
-    private static StringBuilderPooledObjectPolicy _policy = new();
-
-    [Params(10, 100, 1_000, 10_000, 100_000)]
+    [Params(1, 10, 100, 1_000, 10_000, 100_000, 1_000_000)]
     public int N;
 
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
@@ -55,7 +48,6 @@ public class PolylineEncoderBenchmark {
     /// </summary>
     [GlobalSetup]
     public void SetupData() {
-        Directory.CreateDirectory(_dir);
         Enumeration = ValueProvider.GetCoordinates(N);
         List = [.. Enumeration];
         AsyncEnumeration = GetAsyncEnumeration(Enumeration!);
@@ -94,10 +86,16 @@ public Polyline PolylineEncoder_Encode_Enumerator() {
     /// </summary>
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
-    public async Task PolylineEncoder_EncodeAsync_String() {
+    public async Task<Polyline> PolylineEncoder_EncodeAsync_String() {
         var result = AsyncEncoder
             .EncodeAsync(AsyncEnumeration!);
 
-        await foreach (var _ in result) { }
+        var polyline = new Polyline();
+
+        await foreach (var item in result.ConfigureAwait(false)) {
+           polyline.Append(item);
+        }
+
+        return polyline;
     }
 }

src/PolylineAlgorithm/Abstraction/IAsyncPolylineEncoder.cs

@@ -15,6 +15,7 @@ public interface IAsyncPolylineEncoder {
     /// Converts a set of coordinates to an encoded polyline.
     /// </summary>
     /// <param name="coordinates">A set of coordinates to encode.</param>
+    /// <param name="cancellation">A cancellation token.</param>
     /// <returns>An encoded polyline representing the set of coordinates.</returns>
-    IAsyncEnumerable<Polyline> EncodeAsync(IAsyncEnumerable<Coordinate> coordinates);
+    IAsyncEnumerable<Polyline> EncodeAsync(IAsyncEnumerable<Coordinate> coordinates, CancellationToken? cancellation);
 }

src/PolylineAlgorithm/AsyncPolylineEncoder.cs

@@ -13,39 +13,24 @@ namespace PolylineAlgorithm;
 /// Performs polyline algorithm decoding
 /// </summary>
 public class AsyncPolylineEncoder : IAsyncPolylineEncoder {
-    private uint _batchSize = 10000;
-
     /// <inheritdoc />
     /// <exception cref="ArgumentException">Thrown when <paramref name="polyline"/> argument is null -or- empty.</exception>
     /// <exception cref="InvalidOperationException">Thrown when <paramref name="polyline"/> is not in correct format.</exception>
-    public async IAsyncEnumerable<Polyline> EncodeAsync(IAsyncEnumerable<Coordinate> coordinates) {
+    public async IAsyncEnumerable<Polyline> EncodeAsync(IAsyncEnumerable<Coordinate> coordinates, CancellationToken? cancellation = null) {
         if (coordinates is null) {
             throw new ArgumentNullException(nameof(coordinates));
         }
 
-        ulong index = 0;
         CoordinateDifference diff = new();
-        Polyline polyline = new();
 
         await foreach (var coordinate in coordinates.ConfigureAwait(false)) {
             InvalidCoordinateException.ThrowIfNotValid(coordinate);
 
             diff.DiffNext(coordinate);
 
             var result = EncodingAlgorithm.EncodeNext(diff.Latitude, diff.Longitude);
-            
-            polyline = polyline
-                .Append(Polyline.FromMemory(result));
-
-            index++;
-
-            if (index == _batchSize) {
-                var temp = polyline;
-
-                polyline = new();
 
-                yield return temp;
-            }
+            yield return new Polyline(result);
         }
     }
 }

src/PolylineAlgorithm/Internal/CoordinateDifference.cs

@@ -1,10 +1,9 @@
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
 
-namespace PolylineAlgorithm.Internal
-{
+namespace PolylineAlgorithm.Internal {
     [DebuggerDisplay($"{{{nameof(ToString)}(),nq}}")]
-    internal struct CoordinateDifference
-    {
+    internal struct CoordinateDifference {
         public CoordinateDifference() {
             Coordinate = default;
             Latitude = default;
@@ -18,17 +17,35 @@ public CoordinateDifference() {
         public override string ToString()
             => $"Latitude: {Latitude}, Longitude: {Longitude}";
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void DiffNext(Coordinate next) {
-            Coordinate.Imprecise(out int currentLatitude, out int currentLongitude);
+            var current = Exchange(next);
+
+            current.Imprecise(out int currentLatitude, out int currentLongitude);
             next.Imprecise(out int nextLatitude, out int nextLongitude);
 
-            Coordinate = next;
             Latitude = Difference(currentLatitude, nextLatitude);
             Longitude = Difference(currentLongitude, nextLongitude);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int Difference(int first, int second) => (first, second) switch {
+            (0, 0) => 0,
+            (0, _) => second,
+            (_, 0) => -first,
+            ( < 0, < 0) => -(Math.Abs(second) - Math.Abs(first)),
+            ( < 0, > 0) => second + Math.Abs(first),
+            ( > 0, < 0) => -(Math.Abs(second) + first),
+            ( > 0, > 0) => second - first,
+        };
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private Coordinate Exchange(Coordinate value) {
+            var current = Coordinate;
+
+            Coordinate = value;
 
-            static int Difference(int first, int second) {
-                return Math.Max(first, second) + Math.Min(first, second);
-            }
+            return current;
         }
     }
 }

src/PolylineAlgorithm/Internal/EncodingAlgorithm.cs

@@ -15,7 +15,7 @@ internal static ReadOnlyMemory<char> EncodeNext(int latitudeDiff, int longitudeD
         index = EncodeDifference(ref latitudeDiff, ref index, ref buffer);
         index = EncodeDifference(ref longitudeDiff, ref index, ref buffer);
 
-        return buffer.ToArray();
+        return buffer[..index].ToArray();
     }
 
     // [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -38,7 +38,7 @@ private static ref int EncodeDifference(ref int difference, ref int index, ref S
 
     // [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int GetRequiredCharCount(int difference) => difference switch {
-        // DO NOT CHANGE THE ORDER. We are skipping inside ranges as those are covered by previous statements.
+        // DO NOT CHANGE THE ORDER. We are skipping inside exclusive ranges as those are covered by previous statements.
         >= -16 and <= +15 => 1,
         >= -512 and <= +511 => 2,
         >= -16384 and <= +16383 => 3,

src/PolylineAlgorithm/Internal/PolylineSequence.cs

@@ -9,14 +9,12 @@ public PolylineSegment(ReadOnlyMemory<char> memory, long runningIndex = 0) {
     }
 
     public PolylineSegment Append(ReadOnlyMemory<char> memory) {
-        var segment = new PolylineSegment(memory, RunningIndex + memory.Length);
-
-        Next = segment;
-
-        return segment;
+        return Append(new PolylineSegment(memory));
     }
 
     public PolylineSegment Append(PolylineSegment next) {
+        next.RunningIndex = RunningIndex + Memory.Length;
+
         Next = next;
 
         return next;

src/PolylineAlgorithm/Polyline.cs

@@ -12,6 +12,8 @@ namespace PolylineAlgorithm;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
+using System.Text;
+using System.Text.RegularExpressions;
 
 /// <summary>
 /// Represents a readonly encoded polyline string.
@@ -97,7 +99,7 @@ public Polyline(ReadOnlyMemory<char> value) {
     /// Returns a string representation of the value of this instance.
     /// </summary>
     /// <returns>The string value of this <see cref="Polyline"/> object.</returns>
-    public override string ToString() => _value.ToString();
+    public override string ToString() => Value.ToString();
 
     public Polyline Append(Polyline other) {
         if (other.IsEmpty) {
@@ -151,7 +153,42 @@ private PolylineSegment GetSegments(out PolylineSegment initial) {
     #region IEquatable<Polyline> implementation
 
     /// <inheritdoc />
-    public bool Equals(Polyline other) => Value.Equals(other.Value);
+    public bool Equals(Polyline other) {
+        if(IsEmpty && other.IsEmpty) {
+            return true;
+        }
+
+        if(Length != other.Length) {
+            return false;
+        }
+
+        long start = 0;
+        bool result = true;
+        int chunkSize = 256;
+        long max = Math.DivRem(Length, chunkSize, out long remainder) + (remainder > 0 ? 1 : 0);
+        Span<char> @this = stackalloc char[chunkSize];
+        Span<char> that = stackalloc char[chunkSize];
+
+        for (int i = 0; i < max; i++) {
+            start = i * chunkSize;
+
+            if(max - i == 1) {
+                @this.Clear();
+                that.Clear();
+                chunkSize = (int)remainder;
+            }
+
+            Value.Slice(start, chunkSize).CopyTo(@this);
+            other.Value.Slice(start, chunkSize).CopyTo(that);
+
+            if(!@this.SequenceEqual(that)) {
+                result = false;
+                break;
+            }
+        }
+
+        return result;
+    }
 
     #endregion
 

tests/PolylineAlgorithm.Tests/AsyncPolylineEncoderTest.cs

@@ -0,0 +1,103 @@
+//
+// Copyright © Pete Sramek. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+//
+
+namespace PolylineAlgorithm.Tests;
+
+using PolylineAlgorithm;
+using PolylineAlgorithm.Tests.Data;
+
+/// <summary>
+/// Defines tests for the <see cref="PolylineDecoder"/> type.
+/// </summary>
+[TestClass]
+public class AsyncPolylineEncoderTest {
+    /// <summary>
+    /// The instance of the <see cref="PolylineDecoder"/> used for testing.
+    /// </summary>
+    public AsyncPolylineEncoder Encoder = new();
+
+
+
+    private async IAsyncEnumerable<Coordinate> GetAsyncEnumeration(IEnumerable<Coordinate> enumerable) {
+        foreach (var item in enumerable) {
+            yield return await new ValueTask<Coordinate>(item);
+        }
+    }
+
+    /// <summary>
+    /// Tests the <see cref="PolylineDecoder.Decode(ref readonly Polyline)"/> method with an empty input, expecting an <see cref="ArgumentException"/>.
+    /// </summary>
+    [TestMethod]
+    public async Task Decode_Null_Input_ThrowsException() {
+        // Arrange
+        IAsyncEnumerable<Coordinate> @null = null!;
+
+        // Act
+        async Task<Polyline> Execute(IAsyncEnumerable<Coordinate> value) {
+            var result = new Polyline();
+
+            await foreach (var polyline in Encoder.EncodeAsync(value)) {
+                result = result
+                    .Append(polyline);
+            }
+
+            return result;
+        };
+
+        // Assert
+        await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await Execute(@null));
+    }
+
+    ///// <summary>
+    ///// Tests the <see cref="PolylineDecoder.Decode(ref readonly Polyline)"/> method with an invalid input, expecting an <see cref="InvalidCoordinateException"/>.
+    ///// </summary>
+    //[TestMethod]
+    //public async Task Decode_Invalid_Input_ThrowsException() {
+    //    // Arrange
+    //    Polyline invalid = new(Values.Polyline.Invalid);
+
+    //    // Act
+    //    async Task<IEnumerable<Coordinate>> Execute(Polyline value) {
+    //        var result = new List<Coordinate>();
+
+    //        await foreach (var coordinate in Decoder.DecodeAsync(value)) {
+    //            result.Add(coordinate);
+    //        }
+
+    //        return result;
+    //    }
+    //    ;
+
+    //    // Assert
+    //    await Assert.ThrowsExactlyAsync<InvalidCoordinateException>(async () => await Execute(invalid));
+    //}
+
+    /// <summary>
+    /// Tests the <see cref="PolylineDecoder.Decode(ref readonly Polyline)"/> method with a valid input.
+    /// </summary>
+    /// <remarks>Expected result to equal <see cref="Values.Coordinates.Valid"/>.</remarks>
+    [TestMethod]
+    public async Task Decode_Valid_Input_Ok() {
+        // Arrange
+        IAsyncEnumerable<Coordinate> valid = GetAsyncEnumeration(Values.Coordinates.Valid);
+
+        // Act
+        var collection = new List<Polyline>();
+
+        var result = new Polyline();
+
+        await foreach (var polyline in Encoder.EncodeAsync(valid)) {
+            collection
+                .Add(polyline);
+            result = result
+                .Append(polyline);
+        }
+
+        // Assert
+        Assert.AreEqual(Values.Coordinates.Valid.Count(), collection.Count);
+        Assert.AreEqual(Values.Polyline.Valid, result.ToString());
+        Assert.AreEqual(Polyline.FromString(Values.Polyline.Valid), result);
+    }
+}