refact

Author: petesramek

src/PolylineAlgorithm.Abstraction/AbstractPolylineDecoder.cs

@@ -78,9 +78,9 @@ public IEnumerable<TCoordinate> Decode(TPolyline polyline) {
 
         ReadOnlyMemory<char> sequence = GetReadOnlyMemory(polyline);
 
-        if (sequence.Length < LibraryDefaults.Polyline.Block.Length.Min) {
+        if (sequence.Length < Defaults.Polyline.Block.Length.Min) {
             logger
-                .LogPolylineCannotBeShorterThanWarning(nameof(sequence), sequence.Length, LibraryDefaults.Polyline.Block.Length.Min);
+                .LogPolylineCannotBeShorterThanWarning(nameof(sequence), sequence.Length, Defaults.Polyline.Block.Length.Min);
             logger.
                 LogOperationFailedInfo(nameof(Decode));
 

src/PolylineAlgorithm.Abstraction/AbstractPolylineEncoder.cs

@@ -161,7 +161,7 @@ static int GetRemainingBufferSize(int position, int length) {
         int GetBufferLength(int count) {
             Debug.Assert(count > 0, "Count must be greater than zero.");
 
-            int requestedBufferLength = count * LibraryDefaults.Polyline.Block.Length.Max;
+            int requestedBufferLength = count * Defaults.Polyline.Block.Length.Max;
 
             Debug.Assert(Options.MaxBufferLength > 0, "Max buffer length must be greater than zero.");
             Debug.Assert(requestedBufferLength > 0, "Requested buffer length must be greater than zero.");

….Abstraction/Internal/LibraryDefaults.cs …gorithm.Abstraction/Internal/Defaults.cssrc/PolylineAlgorithm.Abstraction/Internal/LibraryDefaults.cs renamed to src/PolylineAlgorithm.Abstraction/Internal/Defaults.cs src/PolylineAlgorithm.Abstraction/Internal/LibraryDefaults.cs renamed to src/PolylineAlgorithm.Abstraction/Internal/Defaults.cs

@@ -11,129 +11,129 @@ namespace PolylineAlgorithm.Abstraction.Internal;
 /// Organizes defaults for algorithm parameters, polyline encoding, and geographic coordinates into nested static classes.
 /// </summary>
 [ExcludeFromCodeCoverage]
-internal static class LibraryDefaults {
+internal static class Defaults {
     /// <summary>
     /// Contains default values and constants specific to the polyline encoding algorithm.
     /// </summary>
-    public static class Algorithm {
+    internal static class Algorithm {
         /// <summary>
         /// The precision factor used to round coordinate values during polyline encoding.
         /// </summary>
-        public const int Precision = 100_000;
+        internal const int Precision = 100_000;
 
         /// <summary>
         /// The number of bits to shift during polyline encoding.
         /// </summary>
-        public const byte ShiftLength = 5;
+        internal const byte ShiftLength = 5;
 
         /// <summary>
         /// The ASCII value for the question mark character ('?').
         /// </summary>
-        public const byte QuestionMark = 63;
+        internal const byte QuestionMark = 63;
 
         /// <summary>
         /// The ASCII value for the space character (' ').
         /// </summary>
-        public const byte Space = 32;
+        internal const byte Space = 32;
 
         /// <summary>
         /// The ASCII value for the unit separator character.
         /// </summary>
-        public const byte UnitSeparator = 31;
+        internal const byte UnitSeparator = 31;
     }
 
-    public static class Coordinate {
+    internal static class Coordinate {
         /// <summary>
         /// Provides constants representing latitude values, including the default, minimum, and maximum valid values.
         /// </summary>
-        public static class Latitude {
+        internal static class Latitude {
             /// <summary>
             /// The default value for latitude, representing the equator.
             /// </summary>
-            public const double Default = 0.00000;
+            internal const double Default = 0.00000;
             /// <summary>
             /// The minimum valid latitude value.
             /// </summary>
-            public const double Min = -90.00000;
+            internal const double Min = -90.00000;
             /// <summary>
             /// The maximum valid latitude value.
             /// </summary>
-            public const double Max = 90.00000;
+            internal const double Max = 90.00000;
 
             /// <summary>
             /// Contains constants related to normalized latitude values.
             /// </summary>
-            public static class Normalized {
+            internal static class Normalized {
                 /// <summary>
                 /// The minimum normalized latitude value.
                 /// </summary>
-                public const int Min = (int)(Latitude.Min * Algorithm.Precision);
+                internal const int Min = (int)(Latitude.Min * Algorithm.Precision);
                 /// <summary>
                 /// The maximum normalized latitude value.
                 /// </summary>
-                public const int Max = (int)(Latitude.Max * Algorithm.Precision);
+                internal const int Max = (int)(Latitude.Max * Algorithm.Precision);
             }
         }
 
         /// <summary>
         /// Provides constants representing longitude values, including the default, minimum, and maximum valid values.
         /// </summary>
-        public static class Longitude {
+        internal static class Longitude {
             /// <summary>
             /// The default value for longitude, representing the equator.
             /// </summary>
-            public const double Default = 0.00000;
+            internal const double Default = 0.00000;
             /// <summary>
             /// The minimum valid longitude value.
             /// </summary>
-            public const double Min = -180.00000;
+            internal const double Min = -180.00000;
             /// <summary>
             /// The maximum valid longitude value.
             /// </summary>
-            public const double Max = 180.00000;
+            internal const double Max = 180.00000;
 
             /// <summary>
             /// Contains constants related to normalized longitude values.
             /// </summary>
-            public static class Normalized {
+            internal static class Normalized {
                 /// <summary>
                 /// The minimum normalized latitude value.
                 /// </summary>
-                public const int Min = (int)(Longitude.Min * Algorithm.Precision);
+                internal const int Min = (int)(Longitude.Min * Algorithm.Precision);
                 /// <summary>
                 /// The maximum normalized latitude value.
                 /// </summary>
-                public const int Max = (int)(Longitude.Max * Algorithm.Precision);
+                internal const int Max = (int)(Longitude.Max * Algorithm.Precision);
             }
         }
     }
 
     /// <summary>
     /// Contains default values and constants related to polyline.
     /// </summary>
-    public static class Polyline {
+    internal static class Polyline {
         /// <summary>
         /// Contains constants related to the polyline blocks.
         /// </summary>
-        public static class Block {
+        internal static class Block {
             /// <summary>
             /// An array of delimiter byte values used in polyline encoding, derived by adding the ASCII value of the question mark ('?') to a range of integers.
             /// </summary>
-            public static readonly byte[] Delimiters = [.. Enumerable.Range(0, 32).Select(n => (byte)(n + Algorithm.QuestionMark))];
+            internal static readonly byte[] Delimiters = [.. Enumerable.Range(0, 32).Select(n => (byte)(n + Algorithm.QuestionMark))];
 
             /// <summary>
             /// Contains constants related to the length of encoded coordinates in polyline encoding.
             /// </summary>
-            public static class Length {
+            internal static class Length {
                 /// <summary>
                 /// The minimum number of characters required to represent an encoded coordinate.
                 /// </summary>
-                public const int Min = 2;
+                internal const int Min = 2;
 
                 /// <summary>
                 /// The maximum number of characters allowed to represent an encoded coordinate.
                 /// </summary>
-                public const int Max = 12;
+                internal const int Max = 12;
             }
         }
     }

src/PolylineAlgorithm.Abstraction/PolylineEncoding.cs

@@ -53,20 +53,20 @@ public static bool TryReadValue(ref int variance, ref ReadOnlyMemory<char> buffe
 
         // Read characters from the buffer until a termination condition is met or the end of the buffer is reached.
         while (position < buffer.Length) {
-            chunk = span[position++] - LibraryDefaults.Algorithm.QuestionMark;
-            sum |= (chunk & LibraryDefaults.Algorithm.UnitSeparator) << shifter;
-            shifter += LibraryDefaults.Algorithm.ShiftLength;
+            chunk = span[position++] - Defaults.Algorithm.QuestionMark;
+            sum |= (chunk & Defaults.Algorithm.UnitSeparator) << shifter;
+            shifter += Defaults.Algorithm.ShiftLength;
 
             // If the chunk is less than the space character, it indicates the end of the value.
-            if (chunk < LibraryDefaults.Algorithm.Space) {
+            if (chunk < Defaults.Algorithm.Space) {
                 break;
             }
         }
 
         variance += (sum & 1) == 1 ? ~(sum >> 1) : sum >> 1;
 
         // If the end of the buffer was reached without reading a complete value, return false.
-        return chunk < LibraryDefaults.Algorithm.Space;
+        return chunk < Defaults.Algorithm.Space;
     }
 
     /// <summary>
@@ -106,7 +106,7 @@ public static double Denormalize(int value, CoordinateValueType type) {
             return 0.0;
         }
 
-        return Math.Truncate((double)value) / LibraryDefaults.Algorithm.Precision;
+        return Math.Truncate((double)value) / Defaults.Algorithm.Precision;
     }
 
     /// <summary>
@@ -146,13 +146,13 @@ public static bool TryWriteValue(int variance, ref Span<char> buffer, ref int po
         }
 
         // Write the value to the buffer in a way that encodes it using the specified algorithm.
-        while (rem >= LibraryDefaults.Algorithm.Space) {
-            buffer[position++] = (char)((LibraryDefaults.Algorithm.Space | rem & LibraryDefaults.Algorithm.UnitSeparator) + LibraryDefaults.Algorithm.QuestionMark);
-            rem >>= LibraryDefaults.Algorithm.ShiftLength;
+        while (rem >= Defaults.Algorithm.Space) {
+            buffer[position++] = (char)((Defaults.Algorithm.Space | rem & Defaults.Algorithm.UnitSeparator) + Defaults.Algorithm.QuestionMark);
+            rem >>= Defaults.Algorithm.ShiftLength;
         }
 
         // Write the final character, which is less than the space character.
-        buffer[position++] = (char)(rem + LibraryDefaults.Algorithm.QuestionMark);
+        buffer[position++] = (char)(rem + Defaults.Algorithm.QuestionMark);
 
         return true;
     }
@@ -200,7 +200,7 @@ public static int Normalize(double value, CoordinateValueType type) {
             return 0;
         }
 
-        return (int)Math.Round(value * LibraryDefaults.Algorithm.Precision);
+        return (int)Math.Round(value * Defaults.Algorithm.Precision);
     }
 
     /// <summary>
@@ -245,10 +245,10 @@ public static int Normalize(double value, CoordinateValueType type) {
     /// name="type"/>; otherwise, <see langword="false"/>.
     /// </returns>
     private static bool ValidateValue<T>(T value, CoordinateValueType type) => (type, value) switch {
-        (CoordinateValueType.Latitude, int normalized) when normalized >= LibraryDefaults.Coordinate.Latitude.Normalized.Min && normalized <= LibraryDefaults.Coordinate.Latitude.Normalized.Max => true,
-        (CoordinateValueType.Longitude, int normalized) when normalized >= LibraryDefaults.Coordinate.Longitude.Normalized.Min && normalized <= LibraryDefaults.Coordinate.Longitude.Normalized.Max => true,
-        (CoordinateValueType.Latitude, double denormalized) when denormalized >= LibraryDefaults.Coordinate.Latitude.Min && denormalized <= LibraryDefaults.Coordinate.Latitude.Max => true,
-        (CoordinateValueType.Longitude, double denormalized) when denormalized >= LibraryDefaults.Coordinate.Longitude.Min && denormalized <= LibraryDefaults.Coordinate.Longitude.Max => true,
+        (CoordinateValueType.Latitude, int normalized) when normalized >= Defaults.Coordinate.Latitude.Normalized.Min && normalized <= Defaults.Coordinate.Latitude.Normalized.Max => true,
+        (CoordinateValueType.Longitude, int normalized) when normalized >= Defaults.Coordinate.Longitude.Normalized.Min && normalized <= Defaults.Coordinate.Longitude.Normalized.Max => true,
+        (CoordinateValueType.Latitude, double denormalized) when denormalized >= Defaults.Coordinate.Latitude.Min && denormalized <= Defaults.Coordinate.Latitude.Max => true,
+        (CoordinateValueType.Longitude, double denormalized) when denormalized >= Defaults.Coordinate.Longitude.Min && denormalized <= Defaults.Coordinate.Longitude.Max => true,
         _ => false,
     };
 }

src/PolylineAlgorithm.Abstraction/PolylineEncodingOptions.cs

@@ -21,9 +21,9 @@ public sealed class PolylineEncodingOptions {
     /// Gets the maximum buffer size for encoding operations.
     /// </summary>
     /// <remarks>
-    /// The default buffer size is 64,000 bytes (64 KB). This can be adjusted based on the expected size of the polyline data.
+    /// The default buffer size is 2,048 bytes (2 KB). This can be adjusted based on the expected size of the polyline data.
     /// </remarks>
-    public int BufferSizeInBytes { get; internal set; } = 64_000;
+    public int BufferSizeInBytes { get; internal set; } = 2_048;
 
     /// <summary>
     /// Gets or sets the precision for encoding coordinates.

src/PolylineAlgorithm/Polyline.cs

@@ -21,20 +21,6 @@ namespace PolylineAlgorithm;
 public readonly struct Polyline : IEquatable<Polyline> {
     private readonly ReadOnlyMemory<char> _value;
 
-    ///// <summary>
-    ///// Initializes a new instance of the <see cref="Polyline"/> struct with the specified character sequence.
-    ///// </summary>
-    ///// <param name="value">
-    ///// A read-only span of characters representing an encoded polyline.
-    ///// </param>
-    //public Polyline(ReadOnlySpan<char> value) {
-    //    if (value.IsEmpty) {
-    //        _value = ReadOnlyMemory<char>.Empty;
-    //    } else {
-    //        _value = new ReadOnlyMemory<char>(value.ToArray());
-    //    }
-    //}
-
     /// <summary>
     /// Initializes a new, empty instance of the <see cref="Polyline"/> struct.
     /// </summary>