refactoring, cleanup

Author: Petr Sramek

benchmarks/PolylineAlgorithm.Benchmarks/PolylineDecoderBenchmark.cs

@@ -7,15 +7,14 @@ namespace PolylineAlgorithm.Benchmarks {
     using BenchmarkDotNet.Attributes;
     using BenchmarkDotNet.Engines;
     using BenchmarkDotNet.Order;
-    using PolylineAlgorithm.Internal;
 
     [MemoryDiagnoser]
     [MarkdownExporter]
     [Orderer(SummaryOrderPolicy.FastestToSlowest)]
     public class PolylineDecoderBenchmark {
         private readonly Consumer _consumer = new();
 
-        public PolylineDecoder Decoder { get; set; }
+        public IPolylineDecoder Decoder { get; set; }
 
         public static IEnumerable<string> GetPolylines() {
             yield return "mz}lHssngJj`gqSnx~lEcovfTnms{Zdy~qQj_deI";
@@ -25,7 +24,7 @@ public static IEnumerable<string> GetPolylines() {
 
         [GlobalSetup]
         public void Setup() {
-            Decoder = new PolylineDecoder();
+            Decoder = new PolylineDecoder(new CoordinateValidator());
         }
 
         [Benchmark]

benchmarks/PolylineAlgorithm.Benchmarks/PolylineEncoderBenchmark.cs

@@ -7,15 +7,14 @@ namespace PolylineAlgorithm.Benchmarks {
     using BenchmarkDotNet.Attributes;
     using BenchmarkDotNet.Engines;
     using BenchmarkDotNet.Order;
-    using PolylineAlgorithm.Internal;
 
     [MemoryDiagnoser]
     [MarkdownExporter]
     [Orderer(SummaryOrderPolicy.FastestToSlowest)]
     public class PolylineEncoderBenchmark {
         private readonly Consumer _consumer = new();
 
-        public PolylineEncoder Encoder { get; set; }
+        public IPolylineEncoder Encoder { get; set; }
 
         public IEnumerable<IEnumerable<(double, double)>> GetCoordinates() {
             yield return new[] { (49.47383, 59.06250), (-58.37407, 25.31250), (52.99363, -120.93750), (-44.49024, -174.37500) };
@@ -25,7 +24,7 @@ public class PolylineEncoderBenchmark {
 
         [GlobalSetup]
         public void Setup() {
-            Encoder = new PolylineEncoder();
+            Encoder = new PolylineEncoder(new CoordinateValidator());
         }
 
         [Benchmark]

benchmarks/PolylineAlgorithm.Implementation.Benchmarks/PolylineDecoderBenchmark.cs.cs

@@ -1,7 +1,7 @@
 namespace PolylineAlgorithm.Implementation.Benchmarks {
     using BenchmarkDotNet.Attributes;
     using BenchmarkDotNet.Engines;
-    using PolylineAlgorithm.Internal;
+    using PolylineAlgorithm;
     using System;
     using System.Runtime.CompilerServices;
 
@@ -10,6 +10,7 @@
     [Orderer(BenchmarkDotNet.Order.SummaryOrderPolicy.Declared)]
     public class PolylineDecoderBenchmark {
         private readonly Consumer _consumer = new();
+        private readonly static CoordinateValidator _validator = new();
         public static IEnumerable<string> Polylines() {
             yield return "mz}lHssngJj`gqSnx~lEcovfTnms{Zdy~qQj_deI";
             yield return "}vwdGjafcRsvjKi}pxUhsrtCngtcAjjgzEdqvtLrscbKj}nr@wetlUc`nq]}_kfCyrfaK~wluUl`u}|@wa{lUmmuap@va{lU~oihCu||bF`|era@wsnnIjny{DxamaScqxza@dklDf{}kb@mtpeCavfzGqhx`Wyzzkm@jm`d@dba~Pppkg@h}pxU|rtnHp|flA|~xaPuykyN}fhv[h}pxUx~p}Ymx`sZih~iB{edwB";
@@ -71,7 +72,7 @@ private class Current {
                     var coordinate = (GetCoordinate(latitude), GetCoordinate(longitude));
 
                     // Validating decoded coordinate. If not valid exception is thrown
-                    if (!CoordinateValidator.IsValid(coordinate)) {
+                    if (!_validator.IsValid(coordinate)) {
                         throw new InvalidOperationException(String.Empty);
                     }
 
@@ -542,7 +543,7 @@ private class V6 {
                     var coordinate = (GetCoordinate(latitude), GetCoordinate(longitude));
 
                     // Validating decoded coordinate. If not valid exception is thrown
-                    if (!CoordinateValidator.IsValid(coordinate)) {
+                    if (!_validator.IsValid(coordinate)) {
                         throw new InvalidOperationException(String.Empty);
                     }
 

src/PolylineAlgorithm.DependencyInjection/ServiceCollectionExtensions.cs

@@ -12,21 +12,11 @@ public static class ServiceCollectionExtensions {
         /// </summary>
         /// <param name="services">Instance of <seealso cref="IServiceCollection"/></param>
         /// <returns>nstance of <seealso cref="IServiceCollection"/></returns>
-        public static IServiceCollection AddPolylineEncoder(this IServiceCollection services) {
-            return services;
-            //.AddSingleton<DefaultPolylineEncoding, DefaultPolylineEncoding>();
-        }
-
-        /// <summary>
-        /// Registers singleton instance of <seealso cref="TImplementation" /> to dependency container.
-        /// </summary>
-        /// <param name="services">Instance of <seealso cref="IServiceCollection"/></param>
-        /// <returns>nstance of <seealso cref="IServiceCollection"/></returns>
-        public static IServiceCollection AddPolylineEncoder<TService, TImplementation>(this IServiceCollection services)
-            where TService : class
-            where TImplementation : class, TService {
+        public static IServiceCollection AddPolylineAlgorithm(this IServiceCollection services) {
             return services
-                .AddSingleton<TService, TImplementation>();
+                .AddSingleton<ICoordinateValidator, CoordinateValidator>()
+                .AddSingleton<IPolylineEncoder, PolylineEncoder>()
+                .AddSingleton<IPolylineDecoder, PolylineDecoder>();
         }
     }
 }

src/PolylineAlgorithm/Internal/CoordinateValidator.cs renamed to src/PolylineAlgorithm/CoordinateValidator.cs

@@ -1,27 +1,25 @@
-namespace PolylineAlgorithm.Internal {
+using PolylineAlgorithm.Internal;
+
+namespace PolylineAlgorithm {
     /// <summary>
     /// Performs coordinate validation
     /// </summary>
-    internal class CoordinateValidator {
-        #region Methods
-
+    public sealed class CoordinateValidator : ICoordinateValidator {
         /// <summary>
         /// Performs coordinate validation
         /// </summary>
         /// <param name="coordinate">Coordinate to validate</param>
         /// <returns>Returns validation result. If valid then true, otherwise false.</returns>
-        public static bool IsValid((double Latitude, double Longitude) coordinate) {
-            return IsValidLatitude(coordinate.Latitude) && IsValidLongitude(coordinate.Longitude);
+        public bool IsValid((double Latitude, double Longitude) coordinate) {
+            return IsValidLatitude(ref coordinate.Latitude) && IsValidLongitude(ref coordinate.Longitude);
         }
 
-        public static bool IsValidLatitude(double latitude) {
+        private static bool IsValidLatitude(ref readonly double latitude) {
             return latitude >= Constants.Coordinate.MinLatitude && latitude <= Constants.Coordinate.MaxLatitude;
         }
 
-        public static bool IsValidLongitude(double longitude) {
+        private static bool IsValidLongitude(ref readonly double longitude) {
             return longitude >= Constants.Coordinate.MinLongitude && longitude <= Constants.Coordinate.MaxLongitude;
         }
-
-        #endregion
     }
 }

src/PolylineAlgorithm/ICoordinateValidator.cs

@@ -0,0 +1,5 @@
+namespace PolylineAlgorithm;
+
+public interface ICoordinateValidator {
+    bool IsValid((double Latitude, double Longitude) coordinate);
+}

src/PolylineAlgorithm/IPolylineDecoder.cs

@@ -0,0 +1,7 @@
+namespace PolylineAlgorithm;
+
+using System.Collections.Generic;
+
+public interface IPolylineDecoder {
+    IEnumerable<(double Latitude, double Longitude)> Decode(string polyline);
+}

src/PolylineAlgorithm/IPolylineEncoder.cs

@@ -0,0 +1,12 @@
+//  
+// Copyright (c) Petr Šrámek. All rights reserved.  
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.  
+//
+
+namespace PolylineAlgorithm;
+
+using System.Collections.Generic;
+
+public interface IPolylineEncoder {
+    string Encode(IEnumerable<(double Latitude, double Longitude)> coordinates);
+}

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

@@ -1,9 +1,9 @@
-namespace PolylineAlgorithm.Internal;
+namespace PolylineAlgorithm;
 
-using System;
-using System.Collections.Generic;
+using PolylineAlgorithm.Internal;
 
-public sealed class PolylineDecoder {
+public sealed class PolylineDecoder(ICoordinateValidator validator) : IPolylineDecoder {
+    public ICoordinateValidator Validator { get; } = validator ?? throw new ArgumentNullException(nameof(validator));
 
     /// <summary>
     /// Method decodes polyline encoded representation to coordinates.
@@ -38,7 +38,7 @@ public sealed class PolylineDecoder {
             var coordinate = (GetCoordinate(latitude), GetCoordinate(longitude));
 
             // Validating decoded coordinate. If not valid exception is thrown
-            if (!CoordinateValidator.IsValid(coordinate)) {
+            if (!Validator.IsValid(coordinate)) {
                 throw new InvalidOperationException(string.Empty);
             }
 

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

@@ -3,15 +3,19 @@
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.  
 //
 
-namespace PolylineAlgorithm.Internal {
+using PolylineAlgorithm.Internal;
+
+namespace PolylineAlgorithm {
     using System;
     using System.Collections.Generic;
     using System.Linq;
 
     /// <summary>
     /// Performs polyline algorithm decoding and encoding
     /// </summary>
-    public sealed class PolylineEncoder {
+    public sealed class PolylineEncoder(ICoordinateValidator validator) : IPolylineEncoder {
+        public ICoordinateValidator Validator { get; } = validator ?? throw new ArgumentNullException(nameof(validator));
+
         /// <summary>
         /// Method encodes coordinates to polyline encoded representation
         /// </summary>
@@ -55,9 +59,9 @@ public string Encode(IEnumerable<(double Latitude, double Longitude)> coordinate
             return buffer[..index].ToString();
         }
 
-        private static bool TryValidate(IEnumerable<(double Latitude, double Longitude)> collection, ref ICollection<CoordinateValidationException> exceptions) {
+        private bool TryValidate(IEnumerable<(double Latitude, double Longitude)> collection, ref ICollection<CoordinateValidationException> exceptions) {
             foreach (var item in collection) {
-                if (!CoordinateValidator.IsValid(item)) {
+                if (!Validator.IsValid(item)) {
                     exceptions.Add(new CoordinateValidationException(item.Latitude, item.Longitude));
                 }
             }