refact

Author: petesramek

samples/PolylineAlgorithm.NetTopologySuite.Sample/NetTopologyPolylineDecoder.cs

@@ -13,6 +13,18 @@ namespace PolylineAlgorithm.NetTopologySuite.Sample;
 /// Represents a polyline decoder that converts encoded polyline strings into a collection of geographic coordinates using NetTopologySuite.
 /// </summary>
 public sealed class NetTopologyPolylineDecoder : AbstractPolylineDecoder<string, Point> {
+    /// <summary>
+    /// Creates a coordinate instance from the given latitude and longitude values.
+    /// </summary>
+    /// <param name="latitude">
+    /// The latitude value.
+    /// </param>
+    /// <param name="longitude">
+    /// The longitude value.
+    /// </param>
+    /// <returns>
+    /// A coordinate instance of type <typeparamref name="TCoordinate"/>.
+    /// </returns>
     protected override Point CreateCoordinate(double latitude, double longitude) {
         return new Point(latitude, longitude);
     }
@@ -30,10 +42,6 @@ protected override Point CreateCoordinate(double latitude, double longitude) {
     /// Thrown when the provided polyline string is null, empty, or consists only of whitespace characters.
     /// </exception>
     protected override ReadOnlyMemory<char> GetReadOnlyMemory(string polyline) {
-        if (string.IsNullOrWhiteSpace(polyline)) {
-            throw new ArgumentException("Value cannot be null, empty or whitespace.", nameof(polyline));
-        }
-
         return polyline.AsMemory();
     }
 }

src/PolylineAlgorithm/Abstraction/AbstractPolylineDecoder.cs

@@ -71,11 +71,11 @@ public IEnumerable<TCoordinate> Decode(TPolyline polyline) {
         logger.
             LogOperationStartedInfo(nameof(Decode));
 
-        ValidatePolyline(polyline, logger);
+        ValidateNullPolyline(polyline, logger);
 
         ReadOnlyMemory<char> sequence = GetReadOnlyMemory(polyline);
 
-        ValidateSequence(logger, sequence);
+        ValidateEmptySequence(logger, sequence);
 
         int position = 0;
         int latitude = 0;
@@ -105,7 +105,7 @@ public IEnumerable<TCoordinate> Decode(TPolyline polyline) {
         logger
             .LogOperationFinishedInfo(nameof(Decode));
 
-        static void ValidateSequence(ILogger<AbstractPolylineDecoder<TPolyline, TCoordinate>> logger, ReadOnlyMemory<char> sequence) {
+        static void ValidateEmptySequence(ILogger<AbstractPolylineDecoder<TPolyline, TCoordinate>> logger, ReadOnlyMemory<char> sequence) {
             if (sequence.Length < Defaults.Polyline.Block.Length.Min) {
                 logger
                     .LogPolylineCannotBeShorterThanWarning(nameof(sequence), sequence.Length, Defaults.Polyline.Block.Length.Min);
@@ -116,7 +116,7 @@ static void ValidateSequence(ILogger<AbstractPolylineDecoder<TPolyline, TCoordin
             }
         }
 
-        static void ValidatePolyline(TPolyline polyline, ILogger<AbstractPolylineDecoder<TPolyline, TCoordinate>> logger) {
+        static void ValidateNullPolyline(TPolyline polyline, ILogger<AbstractPolylineDecoder<TPolyline, TCoordinate>> logger) {
             if (polyline is null) {
                 logger
                     .LogNullArgumentWarning(nameof(polyline));
@@ -135,7 +135,7 @@ static void ValidatePolyline(TPolyline polyline, ILogger<AbstractPolylineDecoder
     /// <returns>
     /// A <see cref="ReadOnlyMemory{T}"/> representing the encoded polyline data.
     /// </returns>
-    protected abstract ReadOnlyMemory<char> GetReadOnlyMemory(TPolyline polyline);
+    protected abstract ReadOnlyMemory<char> GetReadOnlyMemory([NotNull]TPolyline polyline);
 
     /// <summary>
     /// Creates a coordinate instance from the given latitude and longitude values.

src/PolylineAlgorithm/Abstraction/AbstractPolylineEncoder.cs

@@ -14,7 +14,6 @@ namespace PolylineAlgorithm.Abstraction;
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Runtime.CompilerServices;
 
 /// <summary>
 /// Provides functionality to encode a collection of geographic coordinates into an encoded polyline string.
@@ -108,7 +107,7 @@ public TPolyline Encode(IEnumerable<TCoordinate> coordinates) {
                 logger
                     .LogOperationFailedInfo(nameof(Encode));
 
-                throw new InvalidOperationException();
+                throw new InvalidOperationException(ExceptionMessageResource.CouldNotWriteEncodedValueToTheBuffer);
             }
 
             consumed++;
@@ -196,7 +195,7 @@ static void ValidateBuffer(ILogger<AbstractPolylineDecoder<TPolyline, TCoordinat
     /// <returns>
     /// An instance of <typeparamref name="TPolyline"/> representing the encoded polyline.
     /// </returns>
-    
+
     protected abstract TPolyline CreatePolyline(ReadOnlyMemory<char> polyline);
 
     /// <summary>
@@ -206,7 +205,7 @@ static void ValidateBuffer(ILogger<AbstractPolylineDecoder<TPolyline, TCoordinat
     /// <returns>
     /// The longitude value as a <see cref="double"/>.
     /// </returns>
-    
+
     protected abstract double GetLongitude(TCoordinate current);
 
     /// <summary>
@@ -216,7 +215,7 @@ static void ValidateBuffer(ILogger<AbstractPolylineDecoder<TPolyline, TCoordinat
     /// <returns>
     /// The latitude value as a <see cref="double"/>.
     /// </returns>
-    
+
     protected abstract double GetLatitude(TCoordinate current);
 }
 

src/PolylineAlgorithm/Internal/CoordinateVariance.cs

@@ -7,7 +7,6 @@ namespace PolylineAlgorithm.Internal;
 
 using System;
 using System.Diagnostics;
-using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 /// <summary>
@@ -23,7 +22,7 @@ internal struct CoordinateVariance {
     /// Initializes a new instance of the <see cref="CoordinateVariance"/> struct with the default latitude and longitude deltas.
     /// </summary>
     public CoordinateVariance() {
-        _current = (0, 0);
+        _current =(default, default);
     }
 
     /// <summary>
@@ -37,16 +36,17 @@ public CoordinateVariance() {
     public int Longitude { get; private set; }
 
     /// <summary>
-    /// Updates the variance values based on the next latitude and longitude, and sets the current coordinate.
+    /// Updates the variance values based on the next latitude and longitude, and sets the current coordinate as next variance baseline.
     /// </summary>
     /// <param name="latitude">The next latitude value.</param>
     /// <param name="longitude">The next longitude value.</param>
-    
+
     public void Next(int latitude, int longitude) {
         Latitude = Variance(_current.Latitude, latitude);
         Longitude = Variance(_current.Longitude, longitude);
 
-        _current = (latitude, longitude);
+        _current.Latitude = latitude;
+        _current.Longitude = longitude;
     }
 
     /// <summary>
@@ -58,7 +58,7 @@ public void Next(int latitude, int longitude) {
     /// <param name="initial">The previous coordinate value.</param>
     /// <param name="next">The next coordinate value.</param>
     /// <returns>The computed variance between <paramref name="initial"/> and <paramref name="next"/>.</returns>
-    
+
     private static int Variance(int initial, int next) => (initial, next) switch {
         (0, 0) => 0,
         (0, _) => next,

src/PolylineAlgorithm/Internal/Defaults.cs

@@ -13,6 +13,15 @@ namespace PolylineAlgorithm.Internal;
 /// </summary>
 [ExcludeFromCodeCoverage]
 internal static class Defaults {
+    /// <summary>
+    /// Contains default values and constants specific to the polyline encoding logging.
+    /// </summary>
+    internal static class Logging {
+        /// <summary>
+        /// Log level multiplier used to distinguish event identification for each log level
+        /// </summary>
+        internal const int LogLevelMultiplier = 100;
+    }
     /// <summary>
     /// Contains default values and constants specific to the polyline encoding algorithm.
     /// </summary>

src/PolylineAlgorithm/Internal/Logging/LogInfoExtensions.cs

@@ -9,7 +9,7 @@ namespace PolylineAlgorithm.Internal.Logging;
 
 internal static partial class LogInfoExtensions {
     private const LogLevel LOG_LEVEL = LogLevel.Information;
-    private const int EVENT_ID_BASE = (int)LOG_LEVEL * LoggingDefaults.LogLevelMultiplier;
+    private const int EVENT_ID_BASE = (int)LOG_LEVEL * Defaults.Logging.LogLevelMultiplier;
 
     [LoggerMessage(EVENT_ID_BASE + 1, LOG_LEVEL, "Operation {operationName} has started.")]
     internal static partial void LogOperationStartedInfo(this ILogger logger, string operationName);

src/PolylineAlgorithm/Internal/Logging/LogWarningExtensions.cs

@@ -9,7 +9,7 @@ namespace PolylineAlgorithm.Internal.Logging;
 
 internal static partial class LogWarningExtensions {
     private const LogLevel LOG_LEVEL = LogLevel.Warning;
-    private const int EVENT_ID_BASE = (int)LOG_LEVEL * LoggingDefaults.LogLevelMultiplier;
+    private const int EVENT_ID_BASE = (int)LOG_LEVEL * Defaults.Logging.LogLevelMultiplier;
 
     [LoggerMessage(EVENT_ID_BASE + 1, LOG_LEVEL, "Argument {argumentName} is null.")]
     internal static partial void LogNullArgumentWarning(this ILogger logger, string argumentName);

src/PolylineAlgorithm/Internal/Logging/LoggingDefaults.cs

@@ -6,7 +6,6 @@
 namespace PolylineAlgorithm;
 
 using PolylineAlgorithm.Abstraction;
-using System.Runtime.CompilerServices;
 
 /// <inheritdoc cref="AbstractPolylineDecoder{TPolyline, TCoordinate}" />
 public sealed class PolylineDecoder : AbstractPolylineDecoder<Polyline, Coordinate> {

src/PolylineAlgorithm/PolylineDecoder.cs

@@ -6,7 +6,6 @@
 namespace PolylineAlgorithm;
 
 using PolylineAlgorithm.Abstraction;
-using System.Runtime.CompilerServices;
 
 /// <inheritdoc cref="AbstractPolylineEncoder{TCoordinate, TPolyline}" />
 public sealed class PolylineEncoder : AbstractPolylineEncoder<Coordinate, Polyline> {