temp commit

Author: Petr Sramek

src/PolylineAlgorithm/IPolylineDecoder.cs

@@ -0,0 +1,21 @@
+//  
+// Copyright (c) Pete Sramek. All rights reserved.  
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.  
+//
+
+namespace PolylineAlgorithm;
+
+using System;
+using System.Collections.Generic;
+
+/// <summary>
+/// Defines method to decode a polyline.
+/// </summary>
+public interface IPolylineDecoder {
+    /// <summary>
+    /// Converts an encoded polyline to a set of coordinates.
+    /// </summary>
+    /// <param name="polyline">An encoded polyline to decode.</param>
+    /// <returns>A set of coordinates.</returns>
+    IEnumerable<Coordinate> Decode(ref readonly ReadOnlySpan<char> polyline);
+}

src/PolylineAlgorithm/IPolylineEncoder.cs

@@ -0,0 +1,21 @@
+//  
+// Copyright (c) Pete Sramek. All rights reserved.  
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.  
+//
+
+namespace PolylineAlgorithm;
+
+using System;
+using System.Collections.Generic;
+
+/// <summary>
+/// Defines method to encode a set of coordinates.
+/// </summary>
+public interface IPolylineEncoder {
+    /// <summary>
+    /// Converts a set of coordinates to an encoded polyline.
+    /// </summary>
+    /// <param name="coordinates">A set of coordinates to encode.</param>
+    /// <returns>An encoded polyline.</returns>
+    ReadOnlySpan<char> Encode(IEnumerable<Coordinate> coordinates);
+}

src/PolylineAlgorithm/Internal/Constants.cs

@@ -38,29 +38,29 @@ internal static class ASCII {
             public const int UnitSeparator = 31;
         }
 
-        ///// <summary>
-        ///// Defines coordinates constant values
-        ///// </summary>
-        //internal static class Coordinate {
-        //    /// <summary>
-        //    /// Defines the maximum value for latitude
-        //    /// </summary>
-        //    public const int MaxLatitude = 90;
+        /// <summary>
+        /// Defines coordinates constant values
+        /// </summary>
+        internal static class Coordinate {
+            /// <summary>
+            /// Defines the maximum value for latitude
+            /// </summary>
+            public const int MaxLatitude = 90;
 
-        //    /// <summary>
-        //    /// Defines the maximum value for longitude
-        //    /// </summary>
-        //    public const int MaxLongitude = 180;
+            /// <summary>
+            /// Defines the maximum value for longitude
+            /// </summary>
+            public const int MaxLongitude = 180;
 
-        //    /// <summary>
-        //    /// Defines the maximum value for latitude
-        //    /// </summary>
-        //    public const int MinLatitude = -MaxLatitude;
+            /// <summary>
+            /// Defines the maximum value for latitude
+            /// </summary>
+            public const int MinLatitude = -MaxLatitude;
 
-        //    /// <summary>
-        //    /// Defines the maximum value for longitude
-        //    /// </summary>
-        //    public const int MinLongitude = -MaxLongitude;
-        //}
+            /// <summary>
+            /// Defines the maximum value for longitude
+            /// </summary>
+            public const int MinLongitude = -MaxLongitude;
+        }
     }
 }

src/PolylineAlgorithm/Internal/PolylineReader.cs

@@ -26,7 +26,7 @@ public Coordinate Read() {
         Coordinate coordinate = new(Precise(ref latitude), Precise(ref longitude));
 
         if (!coordinate.IsValid) {
-            throw new InvalidOperationException();
+            throw new InvalidCoordinateException(coordinate);
         }
 
         return coordinate;

src/PolylineAlgorithm/InvalidCoordinateException.cs

@@ -0,0 +1,27 @@
+//  
+// Copyright (c) Pete Sramek. All rights reserved.  
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.  
+//
+
+namespace PolylineAlgorithm;
+
+using PolylineAlgorithm.Internal;
+using System.Diagnostics.CodeAnalysis;
+
+/// <summary>
+/// Represents error that is caused by invalid coordinate.
+/// </summary>
+[SuppressMessage("Design", "CA1032:Implement standard exception constructors", Justification = "Main purpose is to report coordinate that is invalid, thus we have to have only one construtor.")]
+public sealed class InvalidCoordinateException : Exception {
+    public InvalidCoordinateException(Coordinate coordinate, Exception? innerException = null)
+        : base(string.Format(ExceptionMessageResource.CoordinateValidationExceptionCoordinateIsOutOfRangeErrorMessageFormat, coordinate.Latitude, coordinate.Longitude),
+               innerException)
+    {
+        Coordinate = coordinate;
+    }
+
+    /// <summary>
+    /// Coordinate that caused the exception.
+    /// </summary>
+    public Coordinate Coordinate { get; }
+}

src/PolylineAlgorithm/MalformedPolylineException.cs

@@ -0,0 +1,33 @@
+//  
+// Copyright (c) Pete Sramek. All rights reserved.  
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.  
+//
+
+namespace PolylineAlgorithm;
+
+using PolylineAlgorithm.Internal;
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+/// <summary>
+/// Represents error that occurs during polyline encoding. 
+/// </summary>
+[SuppressMessage("Design", "CA1032:Implement standard exception constructors", Justification = "Main purpose is to report position in which failure occurs, thus we have to have only one construtor.")]
+public sealed class MalformedPolylineException : Exception {
+    /// <summary>
+    /// Initializes an instance
+    /// </summary>
+    /// <param name="position"></param>
+    /// <param name="innerException"></param>
+    public MalformedPolylineException(int position, Exception? innerException = null)
+        : base(string.Format(ExceptionMessageResource.PolylineStringIsMalformed, position),
+               innerException)
+    {
+        Position = position;
+    }
+
+    /// <summary>
+    /// Position in polyline string at which error occurs.
+    /// </summary>
+    public int Position { get; }
+}

src/PolylineAlgorithm/PolylineEncoder.cs

@@ -33,12 +33,16 @@ public ReadOnlySpan<char> Encode(IEnumerable<Coordinate> coordinates) {
         }
 
         // Initializing local variables
-        int capacity = count * 11;
+        int capacity = count * 12;
         Span<char> buffer = new char[capacity];
         PolylineWriter writer = new(in buffer);
 
         // Looping over coordinates and building encoded result
         foreach (var coordinate in coordinates) {
+            if(!coordinate.IsValid) {
+                throw new InvalidCoordinateException(coordinate);
+            }
+
             writer.Write(in coordinate);
         }
 

src/PolylineAlgorithm/Validation/CoordinateRange.cs

@@ -0,0 +1,77 @@
+//  
+// Copyright (c) Pete Sramek. All rights reserved.  
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.  
+//
+
+namespace PolylineAlgorithm.Validation;
+
+using PolylineAlgorithm.Internal;
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+/// <summary>
+/// Represents a range within coordinate value, latitude or longitude, is considered valid.
+/// </summary>
+[DebuggerDisplay(@"{ Min: {Min}, Max: {Max} }")]
+[StructLayout(LayoutKind.Sequential, Pack = 8, Size = 16)]
+public readonly struct CoordinateRange : IEquatable<CoordinateRange> {
+    public CoordinateRange(double min, double max) {
+        if (min >= max) {
+            throw new ArgumentException(string.Format("", min.ToString(), max.ToString()), paramName: nameof(min));
+        }
+
+        Min = min;
+        Max = max;
+    }
+
+    /// <summary>
+    /// Represents inclusive minimal value of the range.
+    /// </summary>
+    public readonly double Min { get; }
+
+    /// <summary>
+    /// Represents inclusive maximal value of the range.
+    /// </summary>
+    public readonly double Max { get; }
+
+    /// <summary>
+    /// Indicates whether the <paramref name="value"/> is within the range.
+    /// </summary>
+    /// <param name="value">A value to be validated is in range.</param>
+    /// <returns><see langword="true" /> if <paramref name="value"/> is within the range; otherwise, <see langword="false"/>.</returns>
+    public bool IsInRange(double value) => value >= Min && value <= Max;
+
+    /// <summary>
+    /// Returns the formatted string respresentation of this instance.
+    /// </summary>
+    /// <returns>The formatted string respresentation of this instance.</returns>
+    /// <remarks>{ Min: [double], Max: [double] }</remarks>
+    public override string ToString() {
+        return $"{{ {nameof(Min)}: {Min}, {nameof(Max)}: {Max} }}";
+    }
+
+    /// <inheritdoc />
+    public override bool Equals(object? obj) {
+        return obj is CoordinateRange range && Equals(range);
+    }
+
+    /// <inheritdoc />
+    public bool Equals(CoordinateRange other) {
+        return Min == other.Min &&
+               Max == other.Max;
+    }
+
+    /// <inheritdoc />
+    public override int GetHashCode() {
+        return HashCode.Combine(Min, Max);
+    }
+
+    public static bool operator ==(CoordinateRange left, CoordinateRange right) {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(CoordinateRange left, CoordinateRange right) {
+        return !(left == right);
+    }
+}

src/PolylineAlgorithm/Validation/CoordinateValidator.cs

@@ -0,0 +1,41 @@
+//  
+// Copyright (c) Pete Sramek. All rights reserved.  
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.  
+//
+
+namespace PolylineAlgorithm.Validation;
+
+using PolylineAlgorithm.Internal;
+using System.Diagnostics.CodeAnalysis;
+
+/// <summary>
+/// 
+/// </summary>
+public sealed class CoordinateValidator {
+    /// <summary>
+    /// Represents default coordinate validator. This field is read-only.
+    /// </summary>
+    /// <remarks>Validates latitude between -90 and 90; longitude between -180 and 180.</remarks>
+    [SuppressMessage("Usage", "CA2211:Non-constant fields should not be visible", Justification = "We just want to deal with it this way.")]
+    public static readonly CoordinateValidator Default = new(new CoordinateRange(Constants.Coordinate.MinLatitude, Constants.Coordinate.MaxLatitude), new CoordinateRange(Constants.Coordinate.MinLongitude, Constants.Coordinate.MaxLongitude));
+
+    /// <summary>
+    /// Initializes an instance of coordinate validator.
+    /// </summary>
+    /// <param name="latitudeRange">A latitude range.</param>
+    /// <param name="longitudeRange">A longitude range.</param>
+    public CoordinateValidator(CoordinateRange latitudeRange, CoordinateRange longitudeRange) {
+        Latitude = latitudeRange;
+        Longitude = longitudeRange;
+    }
+
+    /// <summary>
+    /// A latitude validation range.
+    /// </summary>
+    public CoordinateRange Latitude { get; }
+
+    /// <summary>
+    /// A longitude validation range.
+    /// </summary>
+    public CoordinateRange Longitude { get; }
+}

tests/PolylineAlgorithm.Tests/GlobalSuppressions.cs

@@ -5,4 +5,4 @@
 
 using System.Diagnostics.CodeAnalysis;
 
-[assembly: SuppressMessage("Naming", "CA1707:Identifiers should not contain underscores", Justification = "Applies only to production code. Test assemblies are not production code.")]
+[assembly: SuppressMessage("Naming", "CA1707:Identifiers should not contain underscores", Justification = "Ignore in test asemblies.")]

tests/PolylineAlgorithm.Tests/GlobalUsings.cs

@@ -3,7 +3,4 @@
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.  
 //
 
-global using Microsoft.VisualStudio.TestTools.UnitTesting;
-global using System;
-global using System.Collections.Generic;
-global using System.Linq;
+global using Microsoft.VisualStudio.TestTools.UnitTesting;

tests/PolylineAlgorithm.Tests/Internal/Category.cs

@@ -0,0 +1,4 @@
+namespace PolylineAlgorithm.Tests.Internal;
+internal static class Category {
+    public const string Unit = nameof(Unit);
+}

tests/PolylineAlgorithm.Tests/Defaults.cs renamed to tests/PolylineAlgorithm.Tests/Internal/Defaults.cs

@@ -3,15 +3,16 @@
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.  
 //
 
-namespace PolylineAlgorithm.Tests;
+namespace PolylineAlgorithm.Tests.Internal;
 
-using System;
 using System.Collections.Generic;
 
 /// <summary>
 /// Defines default values and objects used for testing purposes
 /// </summary>
-public static class Defaults {
+internal static class Defaults {
+    internal static readonly Random R = new(DateTime.Now.Millisecond);
+
     /// <summary>
     /// Defines default decoded values and objects udśed for testing purposes
     /// </summary>
@@ -24,12 +25,12 @@ public static class Coordinates {
         /// <summary>
         /// Defines range of invalid coordinates. Equals to decoded <seealso cref="Polyline.Invalid"/>
         /// </summary>
-        //public static readonly IEnumerable<Coordinate> Invalid = [
-        //    new(149.47383, 259.06250),
-        //    new(-158.37407, 225.31250),
-        //    new(152.99363, -220.93750),
-        //    new(-144.49024, -274.37500)
-        //];
+        public static readonly IEnumerable<Coordinate> Invalid = [
+            new(149.47383, 259.06250),
+            new(-158.37407, 225.31250),
+            new(152.99363, -220.93750),
+            new(-144.49024, -274.37500)
+        ];
 
         /// <summary>
         /// Defines range of valid coordinates. Equals to decoded <seealso cref="Polyline.Valid"/>
@@ -61,4 +62,12 @@ public static class Polyline {
         /// </summary>
         public static readonly string Valid = "mz}lHssngJj`gqSnx~lEcovfTnms{Zdy~qQj_deI";
     }
+
+    public static class MalformedPolylineException {
+        public static readonly int Position = R.Next();
+    }
+
+    public static class InvalidCoordinateException {
+        public static readonly Coordinate Coordinate = new(R.NextDouble(), R.NextDouble());
+    }
 }