applied file header rule

Author: Petr Sramek

benchmarks/PolylineAlgorithm.Benchmarks/PolylineDecoderBenchmark.cs

@@ -83,4 +83,4 @@ public void PolylineDecoder_Decode_FromMemory() {
             .Decode(in polyline)
             .Consume(_consumer);
     }
-}
+}

benchmarks/PolylineAlgorithm.Benchmarks/PolylineEncoderBenchmark.cs

@@ -59,4 +59,4 @@ public Polyline PolylineEncoder_Encode_List() {
     public Polyline PolylineEncoder_Encode_Enumerator() {
         return Encoder.Encode(Enumeration!);
     }
-}
+}

benchmarks/PolylineAlgorithm.Benchmarks/Program.cs

@@ -21,4 +21,4 @@ static void Main(string[] args) {
             .FromAssembly(typeof(Program).Assembly)
             .Run(args, DefaultConfig.Instance);
     }
-}
+}

src/PolylineAlgorithm/Coordinate.cs

@@ -131,4 +131,4 @@ public bool Equals(Coordinate other) {
     }
 
     #endregion
-}
+}

src/PolylineAlgorithm/IPolylineDecoder.cs

@@ -17,5 +17,4 @@ public interface IPolylineDecoder {
     /// <param name="polyline">An encoded polyline to decode.</param>
     /// <returns>A set of coordinates represented by the encoded polyline.</returns>
     IEnumerable<Coordinate> Decode(ref readonly Polyline polyline);
-}
-
+}

src/PolylineAlgorithm/IPolylineEncoder.cs

@@ -17,4 +17,4 @@ public interface IPolylineEncoder {
     /// <param name="coordinates">A set of coordinates to encode.</param>
     /// <returns>An encoded polyline representing the set of coordinates.</returns>
     Polyline Encode(IEnumerable<Coordinate> coordinates);
-}
+}

src/PolylineAlgorithm/Internal/Defaults.cs

@@ -92,4 +92,4 @@ public static class Range {
             public static readonly CoordinateRange Longitude = new(Coordinate.Longitude.Min, Coordinate.Longitude.Max);
         }
     }
-}
+}

src/PolylineAlgorithm/Internal/PolylineReader.cs

@@ -150,4 +150,4 @@ public ReaderState() {
         /// </summary>
         public int Longitude { get; set; }
     }
-}
+}

src/PolylineAlgorithm/Internal/PolylineWriter.cs

@@ -147,4 +147,4 @@ public WriterState() {
         /// </summary>
         public int Longitude { get; set; }
     }
-}
+}

src/PolylineAlgorithm/InvalidCoordinateException.cs

@@ -43,4 +43,4 @@ internal static void ThrowIfNotValid(Coordinate coordinate) {
 
         throw new InvalidCoordinateException(coordinate, string.Format(ExceptionMessageResource.CoordinateIsOutOfRangeMessageFormat, coordinate.Latitude, coordinate.Longitude));
     }
-}
+}

src/PolylineAlgorithm/InvalidPolylineException.cs

@@ -32,4 +32,4 @@ private InvalidPolylineException(string message)
     internal static void Throw(int position) {
         throw new InvalidPolylineException(string.Format(ExceptionMessageResource.PolylineStringIsMalformedMessage, position));
     }
-}
+}

src/PolylineAlgorithm/InvalidReaderStateException.cs

@@ -44,5 +44,4 @@ internal static void ThrowIfCannotRead(bool canRead, int readerPosition, int pol
             throw new InvalidReaderStateException(string.Format(ExceptionMessageResource.UnableToReadPolylineAtPositionMessageFormat, readerPosition, polylineLength));
         }
     }
-}
-
+}

src/PolylineAlgorithm/InvalidWriterStateException.cs

@@ -44,5 +44,4 @@ internal static void ThrowIfCannotWrite(bool canWrite, int writerPosition, int b
             throw new InvalidWriterStateException(string.Format(ExceptionMessageResource.UnableToWritePolylineBufferAtPositionMessageFormat, writerPosition, bufferSize));
         }
     }
-}
-
+}

src/PolylineAlgorithm/Polyline.cs

@@ -178,5 +178,4 @@ public Polyline(ReadOnlyMemory<char> value) {
     public static explicit operator Polyline(string polyline) => FromString(polyline);
 
     #endregion
-}
-
+}

src/PolylineAlgorithm/PolylineEncoder.cs

@@ -57,4 +57,4 @@ public Polyline Encode(IEnumerable<Coordinate> coordinates) {
             _ => coordinates.Count(),
         };
     }
-}
+}

src/PolylineAlgorithm/Validation/CoordinateRange.cs

@@ -107,4 +107,4 @@ public override int GetHashCode() {
     public static bool operator !=(CoordinateRange left, CoordinateRange right) {
         return !(left == right);
     }
-}
+}

src/PolylineAlgorithm/Validation/CoordinateValidator.cs

@@ -29,4 +29,4 @@ public bool IsValid(Coordinate coordinate) {
             Latitude.IsInRange(coordinate.Latitude)
             && Longitude.IsInRange(coordinate.Longitude);
     }
-}
+}

src/PolylineAlgorithm/Validation/ICoordinateValidator.cs

@@ -32,4 +32,4 @@ public interface ICoordinateValidator {
     /// Gets the default coordinate validator instance.
     /// </summary>
     internal static ICoordinateValidator Default { get; } = new CoordinateValidator(Defaults.Coordinate.Range.Latitude, Defaults.Coordinate.Range.Longitude);
-}
+}

tests/PolylineAlgorithm.Tests/CoordinateTest.cs

@@ -134,7 +134,4 @@ public void Equals_Coordinate_False(double latitude, double longitude) {
         // Assert
         Assert.IsFalse(result);
     }
-}
-
-
-
+}

tests/PolylineAlgorithm.Tests/Data/Values.cs

@@ -218,7 +218,4 @@ public static class InvalidWriterStateException {
         /// </summary>
         public static readonly int Length = Position;
     }
-}
-
-
-
+}

tests/PolylineAlgorithm.Tests/Internal/PolylineReaderTest.cs

@@ -153,7 +153,4 @@ static void Read(string value) {
         // Assert
         Assert.ThrowsExactly<InvalidPolylineException>(() => Read(value));
     }
-}
-
-
-
+}

tests/PolylineAlgorithm.Tests/Internal/PolylineWriterTest.cs

@@ -141,7 +141,4 @@ static void Write(Coordinate coordinate, int bufferSize) {
         // Assert
         Assert.ThrowsExactly<InvalidWriterStateException>(() => Write(coordinate, bufferSize));
     }
-}
-
-
-
+}

tests/PolylineAlgorithm.Tests/InvalidCoordinateExceptionTest.cs

@@ -49,8 +49,4 @@ static void ThrowIfNotValid(Coordinate coordinate) {
         Assert.AreEqual(coordinate, exception.Coordinate);
         Assert.IsFalse(string.IsNullOrWhiteSpace(exception.Message));
     }
-}
-
-
-
-
+}

tests/PolylineAlgorithm.Tests/InvalidPolylineExceptionTest.cs

@@ -27,8 +27,4 @@ public void Throw_Method_Invalid_Coordinate_Parameter_PolylineMalformedException
         var exception = Assert.ThrowsExactly<InvalidPolylineException>(() => Throw(position));
         Assert.IsFalse(string.IsNullOrWhiteSpace(exception.Message));
     }
-}
-
-
-
-
+}

tests/PolylineAlgorithm.Tests/InvalidReaderStateExceptionTest.cs

@@ -46,9 +46,4 @@ public void ThrowIfCannotRead_Method_False_Random_Random_Parameter_InvalidReader
         var exception = Assert.ThrowsExactly<InvalidReaderStateException>(() => Throw(canRead, position, length));
         Assert.IsFalse(string.IsNullOrWhiteSpace(exception.Message));
     }
-}
-
-
-
-
-
+}

tests/PolylineAlgorithm.Tests/InvalidWriterStateExceptionTest.cs

@@ -46,9 +46,4 @@ public void ThrowIfCannotWrite_Method_False_Random_Random_Parameter_InvalidWrite
         var exception = Assert.ThrowsExactly<InvalidWriterStateException>(() => Throw(canWrite, position, length));
         Assert.IsFalse(string.IsNullOrWhiteSpace(exception.Message));
     }
-}
-
-
-
-
-
+}

tests/PolylineAlgorithm.Tests/PolylineDecoderTest.cs

@@ -63,9 +63,4 @@ public void Decode_Valid_Input_Ok() {
         // Assert
         CollectionAssert.AreEqual(Values.Coordinates.Valid.ToArray(), result.ToArray());
     }
-}
-
-
-
-
-
+}

tests/PolylineAlgorithm.Tests/PolylineEncoderTest.cs

@@ -83,9 +83,4 @@ public void Encode_ValidInput_Ok() {
         // Assert
         Assert.AreEqual(Values.Polyline.Valid, result.ToString());
     }
-}
-
-
-
-
-
+}

tests/PolylineAlgorithm.Tests/PolylineTest.cs

@@ -239,10 +239,4 @@ public void AsMemory_Equals_Constructor_Parameter(string value) {
         // Assert
         Assert.AreEqual(expected, result);
     }
-}
-
-
-
-
-
-
+}

tests/PolylineAlgorithm.Tests/Properties/Category.cs

@@ -13,6 +13,4 @@ internal static class Category {
     /// Represents the unit test category.
     /// </summary>
     public const string Unit = nameof(Unit);
-}
-
-
+}

tests/PolylineAlgorithm.Tests/Validation/CoordinateRangeTest.cs

@@ -125,6 +125,4 @@ public void Equals_CoordinateRange_False(double min, double max) {
         // Assert
         Assert.IsFalse(result);
     }
-}
-
-
+}

tests/PolylineAlgorithm.Tests/Validation/CoordinateValidatorTest.cs

@@ -63,6 +63,4 @@ static void New(double min, double max) {
         // Assert
         Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => New(min, max));
     }
-}
-
-
+}