Merge pull request #31 from SixLabors/upgrade-stylecop

Upgrade stylecop

Author: JimBobSquarePants

src/SixLabors.Core/Constants.cs

@@ -4,7 +4,7 @@
 namespace SixLabors
 {
     /// <summary>
-    /// Common constants used throughout the project
+    /// Common constants used throughout the project.
     /// </summary>
     internal static class Constants
     {

src/SixLabors.Core/HashCode.cs

@@ -44,6 +44,7 @@ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
 #if SUPPORTS_HASHCODE
 using System.Runtime.CompilerServices;
+
 [assembly: TypeForwardedTo(typeof(System.HashCode))]
 #else
 using System.Buffers.Binary;

src/SixLabors.Core/Helpers/DebugGuard.cs

@@ -18,8 +18,8 @@ internal static class DebugGuard
         /// </summary>
         /// <param name="target">The target object, which cannot be null.</param>
         /// <param name="parameterName">The name of the parameter that is to be checked.</param>
-        /// <exception cref="ArgumentNullException"><paramref name="target"/> is null</exception>
-        /// <typeparam name="T">The type of the object to verify</typeparam>
+        /// <exception cref="ArgumentNullException"><paramref name="target"/> is null.</exception>
+        /// <typeparam name="T">The type of the object to verify.</typeparam>
         [Conditional("DEBUG")]
         public static void NotNull<T>(T target, string parameterName)
             where T : class
@@ -119,12 +119,12 @@ public static void MustBeGreaterThanOrEqualTo<TValue>(TValue value, TValue min,
         /// <summary>
         /// Verifies, that the `target` array has declared the length  or longer.
         /// </summary>
-        /// <typeparam name="T">The element type of the spans</typeparam>
+        /// <typeparam name="T">The element type of the spans.</typeparam>
         /// <param name="target">The target array.</param>
         /// <param name="minLength">The min length the array must have.</param>
         /// <param name="parameterName">The name of the parameter that is to be checked.</param>
         /// <exception cref="ArgumentException">
-        /// <paramref name="target"/> is true
+        /// <paramref name="target"/> is true.
         /// </exception>
         [Conditional("DEBUG")]
         public static void MustBeSizedAtLeast<T>(T[] target, int minLength, string parameterName)

src/SixLabors.Core/Helpers/Guard.cs

@@ -118,7 +118,7 @@ public static void MustBeBetweenOrEqualTo<TValue>(TValue value, TValue min, TVal
         /// <summary>
         /// Verifies, that the `target` span has the length of 'minLength', or longer.
         /// </summary>
-        /// <typeparam name="T">The element type of the spans</typeparam>
+        /// <typeparam name="T">The element type of the spans.</typeparam>
         /// <param name="value">The target span.</param>
         /// <param name="minLength">The minimum length.</param>
         /// <param name="parameterName">The name of the parameter that is to be checked.</param>

src/SixLabors.Core/MathF.cs

@@ -219,7 +219,7 @@ public static float Sin(float f)
         /// <paramref name="f" /> parameter Return value Zero or positive The positive square root of <paramref name="f" />.
         /// Negative <see cref="F:System.Single.NaN" />Equals <see cref="F:System.Single.NaN" />
         /// <see cref="F:System.Single.NaN" />Equals <see cref="F:System.Single.PositiveInfinity" />
-        /// <see cref="F:System.Single.PositiveInfinity" />
+        /// <see cref="F:System.Single.PositiveInfinity" />.
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float Sqrt(float f)

src/SixLabors.Core/Memory/ArrayPoolMemoryAllocator.Buffer{T}.cs

@@ -9,7 +9,7 @@
 namespace SixLabors.Memory
 {
     /// <summary>
-    /// Contains <see cref="Buffer{T}"/> and <see cref="ManagedByteBuffer"/>
+    /// Contains <see cref="Buffer{T}"/> and <see cref="ManagedByteBuffer"/>.
     /// </summary>
     public partial class ArrayPoolMemoryAllocator
     {
@@ -20,7 +20,7 @@ private class Buffer<T> : ManagedBufferBase<T>
             where T : struct
         {
             /// <summary>
-            /// The length of the buffer
+            /// The length of the buffer.
             /// </summary>
             private readonly int length;
 

src/SixLabors.Core/Memory/ArrayPoolMemoryAllocator.CommonFactoryMethods.cs

@@ -32,7 +32,7 @@ public partial class ArrayPoolMemoryAllocator
         /// <summary>
         /// This is the default. Should be good for most use cases.
         /// </summary>
-        /// <returns>The memory manager</returns>
+        /// <returns>The memory manager.</returns>
         public static ArrayPoolMemoryAllocator CreateDefault()
         {
             return new ArrayPoolMemoryAllocator(
@@ -45,7 +45,7 @@ public static ArrayPoolMemoryAllocator CreateDefault()
         /// <summary>
         /// For environments with very limited memory capabilities, only small buffers like image rows are pooled.
         /// </summary>
-        /// <returns>The memory manager</returns>
+        /// <returns>The memory manager.</returns>
         public static ArrayPoolMemoryAllocator CreateWithMinimalPooling()
         {
             return new ArrayPoolMemoryAllocator(64 * 1024, 32 * 1024, 8, 24);
@@ -54,7 +54,7 @@ public static ArrayPoolMemoryAllocator CreateWithMinimalPooling()
         /// <summary>
         /// For environments with limited memory capabilities, only small array requests are pooled, which can result in reduced throughput.
         /// </summary>
-        /// <returns>The memory manager</returns>
+        /// <returns>The memory manager.</returns>
         public static ArrayPoolMemoryAllocator CreateWithModeratePooling()
         {
             return new ArrayPoolMemoryAllocator(1024 * 1024, 32 * 1024, 16, 24);
@@ -63,7 +63,7 @@ public static ArrayPoolMemoryAllocator CreateWithModeratePooling()
         /// <summary>
         /// For environments where memory capabilities are not an issue, the maximum amount of array requests are pooled which results in optimal throughput.
         /// </summary>
-        /// <returns>The memory manager</returns>
+        /// <returns>The memory manager.</returns>
         public static ArrayPoolMemoryAllocator CreateWithAggressivePooling()
         {
             return new ArrayPoolMemoryAllocator(128 * 1024 * 1024, 32 * 1024 * 1024, 16, 32);

src/SixLabors.Core/Memory/ArrayPoolMemoryAllocator.cs

@@ -58,8 +58,8 @@ public ArrayPoolMemoryAllocator(int maxPoolSizeInBytes, int poolSelectorThreshol
         /// </summary>
         /// <param name="maxPoolSizeInBytes">The maximum size of pooled arrays. Arrays over the thershold are gonna be always allocated.</param>
         /// <param name="poolSelectorThresholdInBytes">The threshold to pool arrays in <see cref="largeArrayPool"/> which has less buckets for memory safety.</param>
-        /// <param name="maxArraysPerBucketLargePool">Max arrays per bucket for the large array pool</param>
-        /// <param name="maxArraysPerBucketNormalPool">Max arrays per bucket for the normal array pool</param>
+        /// <param name="maxArraysPerBucketLargePool">Max arrays per bucket for the large array pool.</param>
+        /// <param name="maxArraysPerBucketNormalPool">Max arrays per bucket for the normal array pool.</param>
         public ArrayPoolMemoryAllocator(int maxPoolSizeInBytes, int poolSelectorThresholdInBytes, int maxArraysPerBucketLargePool, int maxArraysPerBucketNormalPool)
         {
             Guard.MustBeGreaterThan(maxPoolSizeInBytes, 0, nameof(maxPoolSizeInBytes));

src/SixLabors.Core/Memory/Internals/BasicArrayBuffer.cs

@@ -14,10 +14,10 @@ internal class BasicArrayBuffer<T> : ManagedBufferBase<T>
         where T : struct
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="BasicArrayBuffer{T}"/> class
+        /// Initializes a new instance of the <see cref="BasicArrayBuffer{T}"/> class.
         /// </summary>
-        /// <param name="array">The array</param>
-        /// <param name="length">The length of the buffer</param>
+        /// <param name="array">The array.</param>
+        /// <param name="length">The length of the buffer.</param>
         public BasicArrayBuffer(T[] array, int length)
         {
             DebugGuard.MustBeLessThanOrEqualTo(length, array.Length, nameof(length));
@@ -26,21 +26,21 @@ public BasicArrayBuffer(T[] array, int length)
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="BasicArrayBuffer{T}"/> class
+        /// Initializes a new instance of the <see cref="BasicArrayBuffer{T}"/> class.
         /// </summary>
-        /// <param name="array">The array</param>
+        /// <param name="array">The array.</param>
         public BasicArrayBuffer(T[] array)
             : this(array, array.Length)
         {
         }
 
         /// <summary>
-        /// Gets the array
+        /// Gets the array.
         /// </summary>
         public T[] Array { get; }
 
         /// <summary>
-        /// Gets the length
+        /// Gets the length.
         /// </summary>
         public int Length { get; }
 

src/SixLabors.Core/Memory/Internals/BasicByteBuffer.cs

@@ -9,9 +9,9 @@ namespace SixLabors.Memory.Internals
     internal sealed class BasicByteBuffer : BasicArrayBuffer<byte>, IManagedByteBuffer
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="BasicByteBuffer"/> class
+        /// Initializes a new instance of the <see cref="BasicByteBuffer"/> class.
         /// </summary>
-        /// <param name="array">The byte array</param>
+        /// <param name="array">The byte array.</param>
         internal BasicByteBuffer(byte[] array)
             : base(array)
         {