lot of rewortk done

Author: Petr Sramek

benchmarks/PolylineAlgorithm.Benchmarks/PolylineAlgorithm.Benchmarks.csproj

@@ -16,6 +16,7 @@
 
 	<ItemGroup>
 		<PackageReference Include="BenchmarkDotNet" Version="0.*" />
+		<PackageReference Include="Microsoft.Extensions.ObjectPool" Version="9.0.2" />
 	</ItemGroup>
 
 	<ItemGroup>

benchmarks/PolylineAlgorithm.Benchmarks/PolylineDecoderBenchmark.cs

@@ -9,6 +9,7 @@ namespace PolylineAlgorithm.Benchmarks;
 using BenchmarkDotNet.Engines;
 using PolylineAlgorithm;
 using PolylineAlgorithm.Benchmarks.Internal;
+using System.Diagnostics;
 
 /// <summary>
 /// Benchmarks for the <see cref="PolylineDecoder"/> class.
@@ -42,6 +43,11 @@ public class PolylineDecoderBenchmark {
     /// </summary>
     public PolylineDecoder Decoder = new();
 
+    /// <summary>
+    /// The async polyline decoder instance.
+    /// </summary>
+    public AsyncPolylineDecoder AsyncDecoder = new();
+
     /// <summary>
     /// Sets up the data for the benchmarks.
     /// </summary>
@@ -60,7 +66,7 @@ public void PolylineDecoder_Decode_FromString() {
         Polyline polyline = Polyline.FromString(StringValue);
 
         Decoder
-            .Decode(in polyline)
+            .Decode(polyline)
             .Consume(_consumer);
     }
 
@@ -72,7 +78,7 @@ public void PolylineDecoder_Decode_FromCharArray() {
         Polyline polyline = Polyline.FromCharArray(CharArray);
 
         Decoder
-            .Decode(in polyline)
+            .Decode(polyline)
             .Consume(_consumer);
     }
 
@@ -84,7 +90,49 @@ public void PolylineDecoder_Decode_FromMemory() {
         Polyline polyline = Polyline.FromMemory(Memory);
 
         Decoder
-            .Decode(in polyline)
+            .Decode(polyline)
             .Consume(_consumer);
     }
+
+    /// <summary>
+    /// Benchmarks the decoding of a polyline from read-only memory.
+    /// </summary>
+    [Benchmark]
+    public async Task PolylineDecoder_DecodeAsync_FromString() {
+        Polyline polyline = Polyline.FromString(StringValue);
+
+        var result = AsyncDecoder
+            .DecodeAsync(polyline)
+            .ConfigureAwait(false);
+
+        await foreach (var _ in result) { }
+    }
+
+    /// <summary>
+    /// Benchmarks the decoding of a polyline from read-only memory.
+    /// </summary>
+    [Benchmark]
+    public async Task PolylineDecoder_DecodeAsync_CharArray() {
+        Polyline polyline = Polyline.FromCharArray(CharArray);
+
+        var result = AsyncDecoder
+            .DecodeAsync(polyline)
+            .ConfigureAwait(false);
+
+        await foreach (var _ in result) { }
+    }
+
+    /// <summary>
+    /// Benchmarks the decoding of a polyline from read-only memory.
+    /// </summary>
+    [Benchmark]
+    public async Task PolylineDecoder_DecodeAsync_FromMemory() {
+        Polyline polyline = Polyline.FromMemory(Memory);
+
+        var result = AsyncDecoder
+            .DecodeAsync(polyline)
+            .ConfigureAwait(false);
+
+        await foreach (var _ in result) { }
+    }
 }

benchmarks/PolylineAlgorithm.Benchmarks/PolylineEncoderBenchmark.cs

@@ -6,15 +6,23 @@
 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)]
     public int N;
 
@@ -28,20 +36,35 @@ public class PolylineEncoderBenchmark {
     /// Gets the list of coordinates to be encoded.
     /// </summary>
     public static List<Coordinate> List { get; private set; }
+
+    public static IAsyncEnumerable<Coordinate> AsyncEnumeration { get; private set; }
 #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
 
     /// <summary>
     /// The polyline encoder instance.
     /// </summary>
     public PolylineEncoder Encoder = new();
 
+    /// <summary>
+    /// The async polyline encoder instance.
+    /// </summary>
+    public AsyncPolylineEncoder AsyncEncoder = new();
+
     /// <summary>
     /// Sets up the data for the benchmarks.
     /// </summary>
     [GlobalSetup]
     public void SetupData() {
+        Directory.CreateDirectory(_dir);
         Enumeration = ValueProvider.GetCoordinates(N);
-        List = [..Enumeration];
+        List = [.. Enumeration];
+        AsyncEnumeration = GetAsyncEnumeration(Enumeration!);
+    }
+
+    private async IAsyncEnumerable<Coordinate> GetAsyncEnumeration(IEnumerable<Coordinate> enumerable) {
+        foreach (var item in enumerable) {
+            yield return await new ValueTask<Coordinate>(item);
+        }
     }
 
     /// <summary>
@@ -50,7 +73,9 @@ public void SetupData() {
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
     public Polyline PolylineEncoder_Encode_List() {
-        return Encoder.Encode(List!);
+        var polyline = Encoder.Encode(List!);
+
+        return polyline;
     }
 
     /// <summary>
@@ -59,6 +84,20 @@ public Polyline PolylineEncoder_Encode_List() {
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
     public Polyline PolylineEncoder_Encode_Enumerator() {
-        return Encoder.Encode(Enumeration!);
+        var polyline = Encoder.Encode(Enumeration!);
+
+        return polyline;
+    }
+
+    /// <summary>
+    /// Benchmarks the encoding of an enumeration of coordinates into a polyline.
+    /// </summary>
+    /// <returns>The encoded polyline.</returns>
+    [Benchmark]
+    public async Task PolylineEncoder_EncodeAsync_String() {
+        var result = AsyncEncoder
+            .EncodeAsync(AsyncEnumeration!);
+
+        await foreach (var _ in result) { }
     }
 }

src/PolylineAlgorithm/Abstraction/IAsyncPolylineDecoder.cs

@@ -0,0 +1,20 @@
+//
+// Copyright © Pete Sramek. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+//
+
+namespace PolylineAlgorithm.Abstraction;
+
+using System.Collections.Generic;
+
+/// <summary>
+/// Defines a method to decode an encoded polyline into a set of coordinates.
+/// </summary>
+public interface IAsyncPolylineDecoder {
+    /// <summary>
+    /// Converts an encoded polyline to a set of coordinates.
+    /// </summary>
+    /// <param name="polyline">An encoded polyline to decode.</param>
+    /// <returns>A set of coordinates represented by the encoded polyline.</returns>
+    IAsyncEnumerable<Coordinate> DecodeAsync(Polyline polyline);
+}

src/PolylineAlgorithm/Abstraction/IAsyncPolylineEncoder.cs

@@ -0,0 +1,20 @@
+//
+// Copyright © Pete Sramek. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+//
+
+namespace PolylineAlgorithm.Abstraction;
+
+using System.Collections.Generic;
+
+/// <summary>
+/// Defines a method to encode a set of coordinates into an encoded polyline.
+/// </summary>
+public interface IAsyncPolylineEncoder {
+    /// <summary>
+    /// Converts a set of coordinates to an encoded polyline.
+    /// </summary>
+    /// <param name="coordinates">A set of coordinates to encode.</param>
+    /// <returns>An encoded polyline representing the set of coordinates.</returns>
+    IAsyncEnumerable<Polyline> EncodeAsync(IAsyncEnumerable<Coordinate> coordinates);
+}

src/PolylineAlgorithm/IPolylineDecoder.cs renamed to src/PolylineAlgorithm/Abstraction/IPolylineDecoder.cs

@@ -3,7 +3,7 @@
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 //
 
-namespace PolylineAlgorithm;
+namespace PolylineAlgorithm.Abstraction;
 
 using System.Collections.Generic;
 
@@ -16,5 +16,5 @@ public interface IPolylineDecoder {
     /// </summary>
     /// <param name="polyline">An encoded polyline to decode.</param>
     /// <returns>A set of coordinates represented by the encoded polyline.</returns>
-    IEnumerable<Coordinate> Decode(ref readonly Polyline polyline);
+    IEnumerable<Coordinate> Decode(Polyline polyline);
 }

src/PolylineAlgorithm/IPolylineEncoder.cs renamed to src/PolylineAlgorithm/Abstraction/IPolylineEncoder.cs

@@ -3,7 +3,7 @@
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 //
 
-namespace PolylineAlgorithm;
+namespace PolylineAlgorithm.Abstraction;
 
 using System.Collections.Generic;
 

src/PolylineAlgorithm/AsyncPolylineDecoder.cs

@@ -0,0 +1,44 @@
+//
+// Copyright © Pete Sramek. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+//
+
+namespace PolylineAlgorithm;
+
+using PolylineAlgorithm.Abstraction;
+using PolylineAlgorithm.Internal;
+using PolylineAlgorithm.Properties;
+using System.Buffers;
+
+
+/// <summary>
+/// Performs polyline algorithm decoding
+/// </summary>
+public class AsyncPolylineDecoder : IAsyncPolylineDecoder {
+    /// <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<Coordinate> DecodeAsync(Polyline polyline) {
+        // Checking null and at least one character
+        if (polyline.IsEmpty) {
+            throw new ArgumentException(ExceptionMessageResource.ArgumentCannotBeNullEmptyOrWhitespaceMessage, nameof(polyline));
+        }
+
+        int latitude = 0;
+        int longitude = 0;
+        long position = 0;
+        ReadOnlySequence<char> sequence = polyline.AsSequence();
+
+        while (
+            DecodingAlgorithm.DecodeNext(ref latitude, ref position, ref sequence)
+            && DecodingAlgorithm.DecodeNext(ref longitude, ref position, ref sequence)
+        ) {
+            Coordinate coordinate = Coordinate.FromImprecise(latitude, longitude);
+
+            InvalidCoordinateException.ThrowIfNotValid(coordinate);
+
+            yield return await new ValueTask<Coordinate>(coordinate)
+                .ConfigureAwait(false);
+        }
+    }
+}

src/PolylineAlgorithm/AsyncPolylineEncoder.cs

@@ -0,0 +1,51 @@
+//
+// Copyright © Pete Sramek. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+//
+
+namespace PolylineAlgorithm;
+
+using PolylineAlgorithm.Abstraction;
+using PolylineAlgorithm.Internal;
+
+
+/// <summary>
+/// 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) {
+        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;
+            }
+        }
+    }
+}

src/PolylineAlgorithm/Coordinate.cs

@@ -5,6 +5,7 @@
 
 namespace PolylineAlgorithm;
 
+using PolylineAlgorithm.Internal;
 using PolylineAlgorithm.Validation;
 using System;
 using System.Diagnostics;
@@ -18,6 +19,8 @@ namespace PolylineAlgorithm;
 [StructLayout(LayoutKind.Sequential, Pack = 8, Size = 16)]
 [DebuggerDisplay("{ToString()}")]
 public readonly struct Coordinate : IEquatable<Coordinate> {
+    internal static readonly Coordinate Default = new();
+
     /// <summary>
     /// Creates a new <see cref="Coordinate"/> structure with <see cref="Latitude"/> and <see cref="Longitude"/> set to their default values.
     /// </summary>
@@ -70,6 +73,15 @@ public void Deconstruct(out double latitude, out double longitude) {
         longitude = Longitude;
     }
 
+    internal void Imprecise(out int latitude, out int longitude) {
+        latitude = Convert.ToInt32(Latitude * Defaults.Algorithm.Precision);
+        longitude = Convert.ToInt32(Longitude * Defaults.Algorithm.Precision);
+    }
+
+    internal static Coordinate FromImprecise(int latitude, int longitude) {
+        return new(latitude / Defaults.Algorithm.Precision, longitude / Defaults.Algorithm.Precision);
+    }
+
     #region Overrides
 
     /// <inheritdoc />