refactoring

petesramek · petesramek · commit 6e48d252c5b2 · 2025-07-06T15:28:48.000+02:00
diff --git a/benchmarks/PolylineAlgorithm.Benchmarks/PolylineDecoderBenchmark.cs b/benchmarks/PolylineAlgorithm.Benchmarks/PolylineDecoderBenchmark.cs
@@ -31,7 +31,7 @@ public class PolylineDecoderBenchmark {
     /// <summary>
     /// The polyline decoder instance.
     /// </summary>
-    public CoordinateDecoder Decoder = new();
+    public PolylineDecoder Decoder = new();
 
     /// <summary>
     /// Sets up the data for the benchmarks.
diff --git a/benchmarks/PolylineAlgorithm.Benchmarks/PolylineEncoderBenchmark.cs b/benchmarks/PolylineAlgorithm.Benchmarks/PolylineEncoderBenchmark.cs
@@ -33,7 +33,7 @@ public class PolylineEncoderBenchmark {
     /// <summary>
     /// The polyline encoder instance.
     /// </summary>
-    public CoordinateEncoder Encoder = new();
+    public PolylineEncoder Encoder = new();
 
     /// <summary>
     /// Sets up the data for the benchmarks.
diff --git a/samples/PolylineAlgorithm.NetTopologySuite.Sample/NetTopologyPolylineDecoder.cs b/samples/PolylineAlgorithm.NetTopologySuite.Sample/NetTopologyPolylineDecoder.cs
@@ -4,7 +4,7 @@
 using PolylineAlgorithm.Abstraction;
 using System;
 
-internal class NetTopologyPolylineDecoder : PolylineDecoder<string, Point> {
+internal class NetTopologyPolylineDecoder : AbstractPolylineDecoder<string, Point> {
     protected override Point CreateCoordinate(double latitude, double longitude) {
         return new Point(latitude, longitude);
     }
diff --git a/samples/PolylineAlgorithm.NetTopologySuite.Sample/NetTopologyPolylineEncoder.cs b/samples/PolylineAlgorithm.NetTopologySuite.Sample/NetTopologyPolylineEncoder.cs
@@ -5,7 +5,7 @@
 using System.Buffers;
 using System.Text;
 
-internal class NetTopologyPolylineEncoder : PolylineEncoder<Point, string> {
+internal class NetTopologyPolylineEncoder : AbstractPolylineEncoder<Point, string> {
 
     protected override string CreatePolyline(ReadOnlyMemory<char> polyline) {
         if (polyline.IsEmpty) {
diff --git a/src/PolylineAlgorithm.Abstraction/AbstractPolylineDecoder.cs b/src/PolylineAlgorithm.Abstraction/AbstractPolylineDecoder.cs
@@ -14,11 +14,11 @@ namespace PolylineAlgorithm.Abstraction;
 /// Decodes encoded polyline strings into sequences of geographic coordinates.
 /// Implements the <see cref="IPolylineDecoder{TCoordinate, TPolyline}"/> interface.
 /// </summary>
-public abstract class PolylineDecoder<TPolyline, TCoordinate> : IPolylineDecoder<TPolyline, TCoordinate> {
-    public PolylineDecoder()
+public abstract class AbstractPolylineDecoder<TPolyline, TCoordinate> : IPolylineDecoder<TPolyline, TCoordinate> {
+    public AbstractPolylineDecoder()
         : this(new PolylineEncodingOptions()) { }
 
-    public PolylineDecoder(PolylineEncodingOptions options) {
+    public AbstractPolylineDecoder(PolylineEncodingOptions options) {
         Options = options ?? throw new ArgumentNullException(nameof(options));
     }
 
@@ -51,7 +51,7 @@ public IEnumerable<TCoordinate> Decode(TPolyline polyline) {
 
         if (sequence.Length < Defaults.Polyline.MinEncodedCoordinateLength) {
             Options
-                .UseLoggerFor<PolylineDecoder<TPolyline, TCoordinate>>()
+                .UseLoggerFor<AbstractPolylineDecoder<TPolyline, TCoordinate>>()
                 .LogPolylineCannotBeShorterThanError(nameof(sequence), sequence.Length, Defaults.Polyline.MinEncodedCoordinateLength);
 
             throw new ArgumentException(string.Format(ExceptionMessageResource.PolylineCannotBeShorterThanExceptionMessage, sequence.Length), nameof(polyline));
diff --git a/src/PolylineAlgorithm.Abstraction/AbstractPolylineEncoder.cs b/src/PolylineAlgorithm.Abstraction/AbstractPolylineEncoder.cs
@@ -17,11 +17,11 @@ namespace PolylineAlgorithm.Abstraction;
 /// Provides functionality to encode a collection of geographic coordinates into an encoded polyline string.
 /// Implements the <see cref="IPolylineEncoder{TCoordinate, TPolyline}"/> interface.
 /// </summary>
-public abstract class PolylineEncoder<TCoordinate, TPolyline> : IPolylineEncoder<TCoordinate, TPolyline> {
-    public PolylineEncoder()
+public abstract class AbstractPolylineEncoder<TCoordinate, TPolyline> : IPolylineEncoder<TCoordinate, TPolyline> {
+    public AbstractPolylineEncoder()
         : this(new PolylineEncodingOptions()) { }
 
-    public PolylineEncoder(PolylineEncodingOptions options) {
+    public AbstractPolylineEncoder(PolylineEncodingOptions options) {
         Options = options ?? throw new ArgumentNullException(nameof(options));
     }
 
@@ -49,15 +49,15 @@ public PolylineEncoder(PolylineEncodingOptions options) {
     public TPolyline Encode(IEnumerable<TCoordinate> coordinates) {
         if (coordinates is null) {
             Options
-                .UseLoggerFor<PolylineEncoder<TCoordinate, TPolyline>>().LogNullArgumentError(nameof(coordinates));
+                .UseLoggerFor<AbstractPolylineEncoder<TCoordinate, TPolyline>>().LogNullArgumentError(nameof(coordinates));
             throw new ArgumentNullException(nameof(coordinates));
         }
 
         int count = GetCount(coordinates);
 
         if (count == 0) {
             Options
-                .UseLoggerFor<PolylineEncoder<TCoordinate, TPolyline>>().LogEmptyArgumentError(nameof(coordinates));
+                .UseLoggerFor<AbstractPolylineEncoder<TCoordinate, TPolyline>>().LogEmptyArgumentError(nameof(coordinates));
 
             throw new ArgumentException(ExceptionMessageResource.ArgumentCannotBeEmptyEnumerationMessage, nameof(coordinates));
         }
@@ -78,7 +78,7 @@ public TPolyline Encode(IEnumerable<TCoordinate> coordinates) {
 
             if (GetRemainingBufferSize(position, buffer.Length) < GetRequiredLength(variance)) {
                 Options
-                    .UseLoggerFor<PolylineEncoder<TCoordinate, TPolyline>>().LogInternalBufferOverflowError(position, buffer.Length, GetRequiredLength(variance));
+                    .UseLoggerFor<AbstractPolylineEncoder<TCoordinate, TPolyline>>().LogInternalBufferOverflowError(position, buffer.Length, GetRequiredLength(variance));
                 throw new InternalBufferOverflowException();
             }
 
@@ -87,7 +87,7 @@ public TPolyline Encode(IEnumerable<TCoordinate> coordinates) {
             ) {
                 // This shouldn't happen, but if it does, log the error and throw an exception.
                 Options
-                    .UseLoggerFor<PolylineEncoder<TCoordinate, TPolyline>>().LogCannotWriteValueToBufferError(position);
+                    .UseLoggerFor<AbstractPolylineEncoder<TCoordinate, TPolyline>>().LogCannotWriteValueToBufferError(position);
                 throw new InvalidOperationException();
             }
 
@@ -116,7 +116,7 @@ int GetBufferLength(int count) {
 
             if (requestedBufferLength > maxBufferLength) {
                 Options
-                   .UseLoggerFor<PolylineEncoder<TCoordinate, TPolyline>>().LogRequestedBufferSizeExceedsMaxBufferLength(requestedBufferLength, maxBufferLength);
+                   .UseLoggerFor<AbstractPolylineEncoder<TCoordinate, TPolyline>>().LogRequestedBufferSizeExceedsMaxBufferLength(requestedBufferLength, maxBufferLength);
 
                 return maxBufferLength;
             }
diff --git a/src/PolylineAlgorithm/PolylineDecoder.cs b/src/PolylineAlgorithm/PolylineDecoder.cs
@@ -12,7 +12,7 @@ namespace PolylineAlgorithm;
 /// <summary>
 /// Performs decoding of encoded polyline strings into a sequence of geographic coordinates.
 /// </summary>
-public sealed class CoordinateDecoder : PolylineDecoder<Polyline, Coordinate> {
+public sealed class PolylineDecoder : AbstractPolylineDecoder<Polyline, Coordinate> {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     protected override Coordinate CreateCoordinate(double latitude, double longitude) {
         return new(latitude, longitude);
diff --git a/src/PolylineAlgorithm/PolylineEncoder.cs b/src/PolylineAlgorithm/PolylineEncoder.cs
@@ -13,7 +13,7 @@ namespace PolylineAlgorithm;
 /// Provides methods to encode a set of geographic coordinates into a polyline string.
 /// This class implements the <see cref="IPolylineEncoder"/> interface.
 /// </summary>
-public sealed class CoordinateEncoder : PolylineEncoder<Coordinate, Polyline> {
+public sealed class PolylineEncoder : AbstractPolylineEncoder<Coordinate, Polyline> {
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     protected override double GetLatitude(Coordinate coordinate) {
diff --git a/tests/PolylineAlgorithm.Abstraction.Tests/PolylineDecoderTest.cs b/tests/PolylineAlgorithm.Abstraction.Tests/PolylineDecoderTest.cs
@@ -132,7 +132,7 @@ public void Decode_StaticValue_ValidInput_Ok() {
         CollectionAssert.AreEqual(expected.ToArray(), result.ToArray());
     }
 
-    public class PolylineDecoder : PolylineDecoder<string, (double Latitude, double Longitude)> {
+    public class PolylineDecoder : AbstractPolylineDecoder<string, (double Latitude, double Longitude)> {
         public PolylineDecoder()
             : base() { }
 
diff --git a/tests/PolylineAlgorithm.Abstraction.Tests/PolylineEncoderTest.cs b/tests/PolylineAlgorithm.Abstraction.Tests/PolylineEncoderTest.cs
@@ -130,7 +130,7 @@ public void Encode_StaticValue_ValidInput_Ok() {
         Assert.IsTrue(expected.Equals(result));
     }
 
-    public class PolylineEncoder : PolylineEncoder<(double Latitude, double Longitude), string> {
+    public class PolylineEncoder : AbstractPolylineEncoder<(double Latitude, double Longitude), string> {
         public PolylineEncoder()
             : base() { }
 
diff --git a/tests/PolylineAlgorithm.Tests/PolylineDecoderTest.cs b/tests/PolylineAlgorithm.Tests/PolylineDecoderTest.cs
@@ -18,7 +18,7 @@ public class PolylineDecoderTest {
     /// <summary>
     /// The instance of the <see cref="PolylineDecoder"/> used for testing.
     /// </summary>
-    public CoordinateDecoder 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"/>.
diff --git a/tests/PolylineAlgorithm.Tests/PolylineEncoderTest.cs b/tests/PolylineAlgorithm.Tests/PolylineEncoderTest.cs
@@ -17,7 +17,7 @@ public class PolylineEncoderTest {
     /// <summary>
     /// The instance of the <see cref="PolylineEncoder"/> used for testing.
     /// </summary>
-    public CoordinateEncoder 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"/>.
@@ -102,8 +102,8 @@ public void EncodeDecode_RoundTrip_Ok() {
             new(0, 0)
         };
 
-        var encoder = new CoordinateEncoder();
-        var decoder = new CoordinateDecoder();
+        var encoder = new PolylineEncoder();
+        var decoder = new PolylineDecoder();
 
         var polyline = encoder.Encode(coordinates);
         var decoded = decoder.Decode(polyline).ToList();
diff --git a/utilities/PolylineAlgorithm.Utility/RandomValueProvider.cs b/utilities/PolylineAlgorithm.Utility/RandomValueProvider.cs
@@ -104,7 +104,7 @@ private readonly struct PolylineCoordinateCollectionPair(IEnumerable<(double Lat
         public string Polyline { get; } = polyline;
     }
 
-    private class PolylineEncoder : PolylineEncoder<(double Latitude, double Longitude), string> {
+    private class PolylineEncoder : AbstractPolylineEncoder<(double Latitude, double Longitude), string> {
 
         protected override string CreatePolyline(ReadOnlyMemory<char> polyline) {
             return polyline.ToString();

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`using PolylineAlgorithm.Abstraction;`
`5`	`5`	`using System;`
`6`	`6`
`7`		`-internal class NetTopologyPolylineDecoder : PolylineDecoder<string, Point> {`
	`7`	`+internal class NetTopologyPolylineDecoder : AbstractPolylineDecoder<string, Point> {`
`8`	`8`	`protected override Point CreateCoordinate(double latitude, double longitude) {`
`9`	`9`	`return new Point(latitude, longitude);`
`10`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ public void Decode_StaticValue_ValidInput_Ok() {`
`132`	`132`	`CollectionAssert.AreEqual(expected.ToArray(), result.ToArray());`
`133`	`133`	`}`
`134`	`134`
`135`		`- public class PolylineDecoder : PolylineDecoder<string, (double Latitude, double Longitude)> {`
	`135`	`+ public class PolylineDecoder : AbstractPolylineDecoder<string, (double Latitude, double Longitude)> {`
`136`	`136`	`public PolylineDecoder()`
`137`	`137`	`: base() { }`
`138`	`138`
Original file line number	Diff line number	Diff line change
`@@ -130,7 +130,7 @@ public void Encode_StaticValue_ValidInput_Ok() {`
`130`	`130`	`Assert.IsTrue(expected.Equals(result));`
`131`	`131`	`}`
`132`	`132`
`133`		`- public class PolylineEncoder : PolylineEncoder<(double Latitude, double Longitude), string> {`
	`133`	`+ public class PolylineEncoder : AbstractPolylineEncoder<(double Latitude, double Longitude), string> {`
`134`	`134`	`public PolylineEncoder()`
`135`	`135`	`: base() { }`
`136`	`136`