update

Author: Pete Sramek

benchmarks/PolylineAlgorithm.Benchmarks/PolylineBuilderBenchmark.cs

@@ -7,6 +7,7 @@ namespace PolylineAlgorithm.Benchmarks;
 
 using BenchmarkDotNet.Attributes;
 using PolylineAlgorithm;
+using PolylineAlgorithm.Internal;
 using PolylineAlgorithm.Utility;
 
 /// <summary>
@@ -44,7 +45,7 @@ public class PolylineBuilderBenchmark {
 
     public char[] CopyToDestination { get; private set; }
 
-    internal Polyline.PolylineBuilder Builder { get; private set; }
+    internal PolylineBuilder Builder { 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.
 
@@ -54,7 +55,7 @@ public class PolylineBuilderBenchmark {
     /// </summary>
     [GlobalSetup]
     public void SetupData() {
-        Builder = new Polyline.PolylineBuilder();
+        Builder = new PolylineBuilder();
 
         var polyline = ValueProvider.GetPolyline(Count);
         StringValue = polyline.ToString();

benchmarks/PolylineAlgorithm.Benchmarks/PolylineDecoderBenchmark.cs

@@ -32,7 +32,7 @@ public class PolylineDecoderBenchmark {
     /// <summary>
     /// The polyline decoder instance.
     /// </summary>
-    public DefaultPolylineDecoder Decoder = new();
+    public PolylineDecoder Decoder = new();
 
     /// <summary>
     /// Sets up the data for the benchmarks.

benchmarks/PolylineAlgorithm.Benchmarks/PolylineEncoderBenchmark.cs

@@ -34,7 +34,7 @@ public class PolylineEncoderBenchmark {
     /// <summary>
     /// The polyline encoder instance.
     /// </summary>
-    public DefaultPolylineEncoder Encoder = new();
+    public PolylineEncoder Encoder = new();
 
     /// <summary>
     /// The async polyline encoder instance.

benchmarks/PolylineAlgorithm.Comparison.Benchmarks/PolylineDecoderBenchmark.cs

@@ -40,7 +40,7 @@ public class PolylineDecoderBenchmark {
     /// <summary>
     /// The polyline decoder instance.
     /// </summary>
-    public DefaultPolylineDecoder PolylineAlgorithm = new();
+    public PolylineDecoder PolylineAlgorithm = new();
 
     public PolylineEncoding Cloudikka = new();
 

benchmarks/PolylineAlgorithm.Comparison.Benchmarks/PolylineEncoderBenchmark.cs

@@ -52,7 +52,7 @@ public class PolylineEncoderBenchmark {
     /// <summary>
     /// The polyline encoder instance.
     /// </summary>
-    public DefaultPolylineEncoder PolylineAlgorithm = new();
+    public PolylineEncoder PolylineAlgorithm = new();
 
     public PolylineEncoding Cloudikka = new();
 

src/PolylineAlgorithm/Abstraction/IPolylineDecoder.cs

@@ -10,11 +10,11 @@ namespace PolylineAlgorithm.Abstraction;
 /// <summary>
 /// Defines a method to decode an encoded polyline into a set of coordinates.
 /// </summary>
-public interface IPolylineDecoder<TCoordinate> {
+public interface IPolylineDecoder {
     /// <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>
-    IEnumerable<TCoordinate> Decode(Polyline polyline);
+    IEnumerable<Coordinate> Decode(Polyline polyline);
 }

src/PolylineAlgorithm/Abstraction/IPolylineEncoder.cs

@@ -10,11 +10,11 @@ namespace PolylineAlgorithm.Abstraction;
 /// <summary>
 /// Defines a method to encode a set of coordinates into an encoded polyline.
 /// </summary>
-public interface IPolylineEncoder<TCoordinate> {
+public interface IPolylineEncoder {
     /// <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>
-    Polyline Encode(IEnumerable<TCoordinate> coordinates);
+    Polyline Encode(IEnumerable<Coordinate> coordinates);
 }

src/PolylineAlgorithm/DefaultPolylineDecoder.cs

@@ -5,15 +5,15 @@
 using System.Collections.Generic;
 
 public static class PolylineDecoderExtensions {
-    public static IEnumerable<TCoordinate> Decode<TCoordinate>(this IPolylineDecoder<TCoordinate> decoder, string polyline) {
+    public static IEnumerable<Coordinate> Decode(this IPolylineDecoder decoder, string polyline) {
         if (decoder is null) {
             throw new ArgumentNullException(nameof(decoder));
         }
 
         return decoder.Decode(Polyline.FromString(polyline));
     }
 
-    public static IEnumerable<TCoordinate> Decode<TCoordinate>(this IPolylineDecoder<TCoordinate> decoder, char[] polyline) {
+    public static IEnumerable<Coordinate> Decode(this IPolylineDecoder decoder, char[] polyline) {
         if (decoder is null) {
             throw new ArgumentNullException(nameof(decoder));
         }

src/PolylineAlgorithm/DefaultPolylineEncoder.cs

@@ -5,15 +5,15 @@
 using System.Collections.Generic;
 
 public static class PolylineEncoderExtensions {
-    public static Polyline Encode<TCoordinate>(this IPolylineEncoder<TCoordinate> encoder, ICollection<TCoordinate> coordinates) {
+    public static Polyline Encode<Coordinate>(this IPolylineEncoder encoder, ICollection<Coordinate> coordinates) {
         if (encoder is null) {
             throw new ArgumentNullException(nameof(encoder));
         }
 
         return encoder.Encode(coordinates);
     }
 
-    public static Polyline Encode<TCoordinate>(this IPolylineEncoder<TCoordinate> encoder, TCoordinate[] coordinates) {
+    public static Polyline Encode(this IPolylineEncoder encoder, Coordinate[] coordinates) {
         if (encoder is null) {
             throw new ArgumentNullException(nameof(encoder));
         }

src/PolylineAlgorithm/Extensions/PolylineDecoderExtensions.cs

@@ -2,10 +2,11 @@
 
 using System;
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 [DebuggerDisplay($"{{{nameof(ToString)}(),nq}}")]
-[StructLayout(LayoutKind.Sequential, Pack = 8, Size = 16)]
+[StructLayout(LayoutKind.Auto)]
 public struct CoordinateVariance {
     private (int Latitude, int Longitude) _current = (0, 0);
 
@@ -18,13 +19,15 @@ private CoordinateVariance(int latitude, int longitude) {
 
     public int Longitude { get; private set; }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Next((int Latitude, int Longitude) next) {
         Latitude = Variance(_current.Latitude, next.Latitude);
         Longitude = Variance(_current.Longitude, next.Longitude);
 
         _current = next;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int Variance(int initial, int next) => (initial, next) switch {
         (0, 0) => 0,
         (0, _) => next,

src/PolylineAlgorithm/Extensions/PolylineEncoderExtensions.cs

@@ -0,0 +1,27 @@
+namespace PolylineAlgorithm.Internal;
+
+using System;
+using System.Runtime.InteropServices;
+
+[StructLayout(LayoutKind.Auto)]
+internal struct PolylineBuilder {
+    private PolylineSegment? _initial;
+    private PolylineSegment? _last;
+
+    public void Append(ReadOnlyMemory<char> value) {
+        var current = new PolylineSegment(value);
+
+        _initial ??= current;
+
+        _last?.Append(current);
+        _last = current;
+    }
+
+    public readonly Polyline Build() {
+        if (_initial is null) {
+            return Polyline.FromMemory(ReadOnlyMemory<char>.Empty);
+        }
+
+        return Polyline.FromSequence(new(_initial, 0, _last, _last!.Memory.Length));
+    }
+}

src/PolylineAlgorithm/Internal/CoordinateVariance.cs

@@ -221,27 +221,4 @@ internal static Polyline FromSequence(ReadOnlySequence<char> value) {
     public static explicit operator Polyline(ReadOnlyMemory<char> polyline) => FromMemory(polyline);
 
     #endregion
-
-    [StructLayout(LayoutKind.Auto)]
-    internal struct PolylineBuilder {
-        private PolylineSegment? _initial;
-        private PolylineSegment? _last;
-
-        public void Append(ReadOnlyMemory<char> value) {
-            var current = new PolylineSegment(value);
-
-            _initial ??= current;
-
-            _last?.Append(current);
-            _last = current;
-        }
-
-        public Polyline Build() {
-            if (_initial is null) {
-                return FromMemory(ReadOnlyMemory<char>.Empty);
-            }
-
-            return FromSequence(new(_initial, 0, _last, _last!.Memory.Length));
-        }
-    }
 }

src/PolylineAlgorithm/Internal/PolylineBuilder.cs

@@ -3,8 +3,9 @@
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 //
 
-namespace PolylineAlgorithm.Abstraction;
+namespace PolylineAlgorithm;
 
+using PolylineAlgorithm.Abstraction;
 using PolylineAlgorithm.Properties;
 using System;
 using System.Buffers;
@@ -14,11 +15,11 @@ namespace PolylineAlgorithm.Abstraction;
 /// <summary>
 /// Performs polyline algorithm decoding
 /// </summary>
-public abstract class PolylineDecoder<TCoordinate> : IPolylineDecoder<TCoordinate> {
+public class PolylineDecoder : IPolylineDecoder {
     /// <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 IEnumerable<TCoordinate> Decode(Polyline polyline) {
+    public IEnumerable<Coordinate> Decode(Polyline polyline) {
         if (polyline.IsEmpty) {
             throw new ArgumentException(ExceptionMessageResource.ArgumentCannotBeNullEmptyOrWhitespaceMessage, nameof(polyline));
         }
@@ -39,7 +40,7 @@ public IEnumerable<TCoordinate> Decode(Polyline polyline) {
             while (PolylineEncoding.Default.TryReadValue(ref latitude, ref buffer, ref position)
                 && PolylineEncoding.Default.TryReadValue(ref longitude, ref buffer, ref position)
             ) {
-                yield return Construct(PolylineEncoding.Default.Denormalize(latitude), PolylineEncoding.Default.Denormalize(longitude));
+                yield return new(PolylineEncoding.Default.Denormalize(latitude), PolylineEncoding.Default.Denormalize(longitude));
             }
 
             consumed += position;
@@ -49,7 +50,4 @@ public IEnumerable<TCoordinate> Decode(Polyline polyline) {
             }
         }
     }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public abstract TCoordinate Construct(double latitude, double longitude);
 }

src/PolylineAlgorithm/Polyline.cs

@@ -3,20 +3,19 @@
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 //
 
-namespace PolylineAlgorithm.Abstraction;
+namespace PolylineAlgorithm;
 
+using PolylineAlgorithm.Abstraction;
 using PolylineAlgorithm.Internal;
 using System;
-using System.Buffers;
-using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 /// <summary>
 /// Provides methods to encode a set of coordinates into a polyline string.
 /// </summary>\
-public abstract class PolylineEncoder<TCoordinate> : IPolylineEncoder<TCoordinate> {
+public class PolylineEncoder : IPolylineEncoder {
     private const int MaxByteSize = 64_000;
     private const int MaxChars = MaxByteSize / sizeof(char);
     private const int MaxCount = MaxChars / Defaults.Polyline.MaxEncodedCoordinateLength;
@@ -28,7 +27,7 @@ public abstract class PolylineEncoder<TCoordinate> : IPolylineEncoder<TCoordinat
     /// <returns>A <see cref="Polyline"/> representing the encoded coordinates.</returns>
     /// <exception cref="ArgumentNullException">Thrown when the <paramref name="coordinates"/> argument is null.</exception>
     /// <exception cref="ArgumentException">Thrown when the <paramref name="coordinates"/> argument is an empty enumeration.</exception>
-    public Polyline Encode(IEnumerable<TCoordinate> coordinates) {
+    public Polyline Encode(IEnumerable<Coordinate> coordinates) {
         if (coordinates is null) {
             throw new ArgumentNullException(nameof(coordinates));
         }
@@ -45,14 +44,14 @@ public Polyline Encode(IEnumerable<TCoordinate> coordinates) {
         int consumed = 0;
         int length = GetMaxLength(count);
         bool isMultiSegment = count == -1 || count > MaxCount;
-        Polyline.PolylineBuilder builder = new();
+        PolylineBuilder builder = new();
         Span<char> buffer = stackalloc char[length];
 
         using var enumerator = coordinates.GetEnumerator();
 
         while (enumerator.MoveNext()) {
             variance
-                .Next(Normalize(Deconstruct(enumerator.Current)));
+                .Next(Normalize(enumerator.Current));
 
             if (isMultiSegment
                 && buffer.Length - position < 12) {
@@ -71,7 +70,7 @@ public Polyline Encode(IEnumerable<TCoordinate> coordinates) {
             consumed++;
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static (int Latitude, int Longitude) Normalize((double Latitude, double Longitude) coordinate) {
+            static (int Latitude, int Longitude) Normalize(Coordinate coordinate) {
                 return (PolylineEncoding.Default.Normalize(coordinate.Latitude), PolylineEncoding.Default.Normalize(coordinate.Longitude));
             }
         }
@@ -95,19 +94,16 @@ public Polyline Encode(IEnumerable<TCoordinate> coordinates) {
         };
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    protected abstract (double Latitude, double Longitude) Deconstruct(TCoordinate source);
-
     /// <summary>
     /// Gets the count of coordinates in the enumerable.
     /// </summary>
     /// <param name="coordinates">The enumerable of coordinates.</param>
     /// <returns>The count of coordinates.</returns>
     [ExcludeFromCodeCoverage]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    static int GetCount(IEnumerable<TCoordinate> coordinates) => coordinates switch {
-        ICollection collection => collection.Count,
-        //IEnumerable<TCoordinate> enumerable => enumerable.Count(),
+    static int GetCount(IEnumerable<Coordinate> coordinates) => coordinates switch {
+        ICollection<Coordinate> collection => collection.Count,
+        IEnumerable<Coordinate> enumerable => enumerable.Count(),
         _ => -1,
     };
 }

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

@@ -60,7 +60,7 @@ public bool TryWriteValue(int variance, ref Span<char> buffer, ref int position)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public int Normalize(double value) => Convert.ToInt32(value * Defaults.Algorithm.Precision);
+    public int Normalize(double value) => (int)Math.Truncate(value * Defaults.Algorithm.Precision);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public int GetCharCount(int variance) => variance switch {

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

@@ -18,7 +18,7 @@ public class PolylineDecoderTest {
     /// <summary>
     /// The instance of the <see cref="PolylineDecoder"/> used for testing.
     /// </summary>
-    public DefaultPolylineDecoder Decoder = new();
+    public PolylineDecoder Decoder = new();
 
     /// <summary>
     /// Tests the <see cref="PolylineDecoder.Decode(ref readonly Polyline)"/> method with an empty input, expecting an <see cref="ArgumentException"/>.

src/PolylineAlgorithm/PolylineEncoding.cs

@@ -18,7 +18,7 @@ public class PolylineEncoderTest {
     /// <summary>
     /// The instance of the <see cref="PolylineEncoder"/> used for testing.
     /// </summary>
-    public DefaultPolylineEncoder Encoder = new();
+    public PolylineEncoder Encoder = new();
 
     /// <summary>
     /// Tests the <see cref="PolylineEncoder.Encode(IEnumerable{Coordinate})"/> method with a null input, expecting an <see cref="ArgumentNullException"/>.

tests/PolylineAlgorithm.Tests/PolylineDecoderTest.cs

@@ -8,7 +8,7 @@
 public static class ValueProvider {
     private static readonly Random _random = new(DateTime.Now.Millisecond);
     private static readonly ConcurrentDictionary<int, CoordinatePair> _cache = new();
-    private static readonly DefaultPolylineEncoder _encoder = new();
+    private static readonly PolylineEncoder _encoder = new();
 
     public static IEnumerable<Coordinate> GetCoordinates(int count) {
         var entry = GetCaheEntry(count);