cleanup, refact

Author: petesramek

samples/PolylineAlgorithm.NetTopologySuite.Sample/NetTopologyPolylineDecoder.cs

@@ -12,16 +12,14 @@ namespace PolylineAlgorithm.NetTopologySuite.Sample;
 /// <summary>
 /// Polyline decoder using NetTopologySuite.
 /// </summary>
-public sealed class NetTopologyPolylineDecoder : AbstractPolylineDecoder<string, Point>
-{
+public sealed class NetTopologyPolylineDecoder : AbstractPolylineDecoder<string, Point> {
     /// <summary>
     /// Creates a NetTopologySuite point from latitude and longitude.
     /// </summary>
     /// <param name="latitude">Latitude value.</param>
     /// <param name="longitude">Longitude value.</param>
     /// <returns>Point instance.</returns>
-    protected override Point CreateCoordinate(double latitude, double longitude)
-    {
+    protected override Point CreateCoordinate(double latitude, double longitude) {
         // NetTopologySuite Point: x = longitude, y = latitude
         return new Point(longitude, latitude);
     }
@@ -31,8 +29,7 @@ protected override Point CreateCoordinate(double latitude, double longitude)
     /// </summary>
     /// <param name="polyline">Encoded polyline string.</param>
     /// <returns>ReadOnlyMemory of characters.</returns>
-    protected override ReadOnlyMemory<char> GetReadOnlyMemory(in string polyline)
-    {
+    protected override ReadOnlyMemory<char> GetReadOnlyMemory(in string polyline) {
         return polyline.AsMemory();
     }
 }

src/PolylineAlgorithm/Abstraction/AbstractPolylineDecoder.cs

@@ -4,14 +4,11 @@
 //
 
 using Microsoft.Extensions.Logging;
-using PolylineAlgorithm;
 using PolylineAlgorithm.Diagnostics;
 using PolylineAlgorithm.Internal;
 using PolylineAlgorithm.Internal.Diagnostics;
 using PolylineAlgorithm.Internal.Logging;
-using System;
 using System.Runtime.CompilerServices;
-using System.Threading;
 
 namespace PolylineAlgorithm.Abstraction {
     /// <summary>
@@ -33,14 +30,14 @@ protected AbstractPolylineDecoder()
         /// <summary>
         /// Initializes a new instance of the <see cref="AbstractPolylineDecoder{TPolyline, TCoordinate}"/> class with the specified encoding options.
         /// </summary>
-        /// <param name="encodingOptions">
+        /// <param name="options">
         /// The <see cref="PolylineEncodingOptions"/> to use for encoding operations.
         /// </param>
         /// <exception cref="ArgumentNullException">
-        /// Thrown when <paramref name="encodingOptions"/> is <see langword="null" />
+        /// Thrown when <paramref name="options"/> is <see langword="null" />
         /// </exception>
         protected AbstractPolylineDecoder(PolylineEncodingOptions options) {
-            if(options is null) {
+            if (options is null) {
                 ExceptionGuard.ThrowArgumentNull(nameof(options));
             }
 
@@ -110,7 +107,6 @@ public IEnumerable<TCoordinate> Decode(TPolyline polyline, CancellationToken can
                         _logger?.LogOperationFailedDebug(OperationName);
                         _logger?.LogInvalidPolylineWarning(position);
 
-                        OnInvalidPolyline(position, sequence);
                         ExceptionGuard.ThrowInvalidPolylineFormat(position);
                     }
 
@@ -126,6 +122,16 @@ public IEnumerable<TCoordinate> Decode(TPolyline polyline, CancellationToken can
             }
         }
 
+        /// <summary>
+        /// Validates that the provided polyline is not <see langword="null"/>.
+        /// Throws an <see cref="ArgumentNullException"/> if the polyline is <see langword="null"/>.
+        /// Optionally logs a warning if a logger is provided.
+        /// </summary>
+        /// <param name="polyline">The polyline instance to validate.</param>
+        /// <param name="logger">Optional logger for diagnostic messages.</param>
+        /// <exception cref="ArgumentNullException">
+        /// Thrown when <paramref name="polyline"/> is <see langword="null"/>.
+        /// </exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static void ValidateNullPolyline(TPolyline polyline, ILogger? logger) {
             if (polyline is null) {
@@ -134,6 +140,16 @@ private static void ValidateNullPolyline(TPolyline polyline, ILogger? logger) {
             }
         }
 
+        /// <summary>
+        /// Validates that the polyline sequence meets the minimum required length.
+        /// Throws an <see cref="InvalidPolylineException"/> if the sequence is too short.
+        /// Optionally logs diagnostic messages if a logger is provided.
+        /// </summary>
+        /// <param name="polylineSequence">The polyline character sequence to validate.</param>
+        /// <param name="logger">Optional logger for diagnostic messages.</param>
+        /// <exception cref="InvalidPolylineException">
+        /// Thrown when <paramref name="polylineSequence"/> is shorter than the minimum allowed length.
+        /// </exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static void ValidateSequence(ReadOnlyMemory<char> polylineSequence, ILogger? logger) {
             if (polylineSequence.Length < Defaults.Polyline.Block.Length.Min) {
@@ -158,13 +174,6 @@ protected virtual void ValidateFormat(ReadOnlyMemory<char> sequence, ILogger? lo
             }
         }
 
-        /// <summary>
-        /// Hook for subclasses to handle invalid polyline cases.
-        /// </summary>
-        protected virtual void OnInvalidPolyline(int position, ReadOnlyMemory<char> polylineSequence) {
-            // Subclasses can override for custom error handling/logging.
-        }
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         protected abstract ReadOnlyMemory<char> GetReadOnlyMemory(in TPolyline polyline);
 

src/PolylineAlgorithm/Abstraction/AbstractPolylineEncoder.cs

@@ -10,7 +10,6 @@ namespace PolylineAlgorithm.Abstraction;
 using PolylineAlgorithm.Internal;
 using PolylineAlgorithm.Internal.Diagnostics;
 using PolylineAlgorithm.Internal.Logging;
-using PolylineAlgorithm.Properties;
 using System;
 using System.Buffers;
 using System.Diagnostics;
@@ -113,7 +112,7 @@ public TPolyline Encode(ReadOnlySpan<TCoordinate> coordinates) {
                         .LogCannotWriteValueToBufferWarning(position, consumed);
 
                     ExceptionGuard.ThrowCouldNotWriteEncodedValueToBuffer();
-                    
+
                 }
 
                 consumed++;

src/PolylineAlgorithm/Diagnostics/InvalidPolylineException.cs

@@ -5,10 +5,8 @@
 
 namespace PolylineAlgorithm.Diagnostics;
 
-using PolylineAlgorithm.Internal.Diagnostics;
 using System;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 
 /// <summary>
 /// Exception thrown when a polyline is determined to be malformed or invalid during processing.
@@ -17,8 +15,7 @@ namespace PolylineAlgorithm.Diagnostics;
 /// This exception is used internally to indicate that a polyline string does not conform to the expected format or contains errors.
 /// </remarks>
 [DebuggerDisplay($"{nameof(InvalidPolylineException)}: {{ToString()}}")]
-public sealed class InvalidPolylineException : Exception
-{
+public sealed class InvalidPolylineException : Exception {
     /// <summary>
     /// Initializes a new instance of the <see cref="InvalidPolylineException"/> class.
     /// </summary>

src/PolylineAlgorithm/Polyline.cs

@@ -6,7 +6,6 @@
 namespace PolylineAlgorithm;
 
 using PolylineAlgorithm.Internal.Diagnostics;
-using PolylineAlgorithm.Properties;
 using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;