Reorder params, fix other warnings.

JimBobSquarePants · JimBobSquarePants · commit 66d494e25054 · 2023-02-07T09:17:16.000+10:00
diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
@@ -159,7 +159,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
 
         WriteBitmapFileHeader(stream, infoHeaderSize, colorPaletteSize, iccProfileSize, infoHeader, buffer);
         this.WriteBitmapInfoHeader(stream, infoHeader, buffer, infoHeaderSize);
-        this.WriteImage(stream, image, configuration);
+        this.WriteImage(configuration, stream, image);
         WriteColorProfile(stream, iccProfileData, buffer);
 
         stream.Flush();
@@ -307,43 +307,43 @@ private void WriteBitmapInfoHeader(Stream stream, BmpInfoHeader infoHeader, Span
     /// Writes the pixel data to the binary stream.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="image">
     /// The <see cref="ImageFrame{TPixel}"/> containing pixel data.
     /// </param>
-    /// <param name="configuration">The global configuration.</param>
-    private void WriteImage<TPixel>(Stream stream, Image<TPixel> image, Configuration configuration)
+    private void WriteImage<TPixel>(Configuration configuration, Stream stream, Image<TPixel> image)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         Buffer2D<TPixel> pixels = image.Frames.RootFrame.PixelBuffer;
         switch (this.bitsPerPixel)
         {
             case BmpBitsPerPixel.Pixel32:
-                this.Write32BitPixelData(stream, pixels, configuration);
+                this.Write32BitPixelData(configuration, stream, pixels);
                 break;
 
             case BmpBitsPerPixel.Pixel24:
-                this.Write24BitPixelData(stream, pixels, configuration);
+                this.Write24BitPixelData(configuration, stream, pixels);
                 break;
 
             case BmpBitsPerPixel.Pixel16:
-                this.Write16BitPixelData(stream, pixels, configuration);
+                this.Write16BitPixelData(configuration, stream, pixels);
                 break;
 
             case BmpBitsPerPixel.Pixel8:
-                this.Write8BitPixelData(stream, image, configuration);
+                this.Write8BitPixelData(configuration, stream, image);
                 break;
 
             case BmpBitsPerPixel.Pixel4:
-                this.Write4BitPixelData(stream, image, configuration);
+                this.Write4BitPixelData(configuration, stream, image);
                 break;
 
             case BmpBitsPerPixel.Pixel2:
-                this.Write2BitPixelData(stream, image, configuration);
+                this.Write2BitPixelData(configuration, stream, image);
                 break;
 
             case BmpBitsPerPixel.Pixel1:
-                this.Write1BitPixelData(stream, image, configuration);
+                this.Write1BitPixelData(configuration, stream, image);
                 break;
         }
     }
@@ -355,10 +355,10 @@ private IMemoryOwner<byte> AllocateRow(int width, int bytesPerPixel)
     /// Writes 32-bit data with a color palette to the stream.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> containing pixel data.</param>
-    /// <param name="configuration">The global configuration.</param>
-    private void Write32BitPixelData<TPixel>(Stream stream, Buffer2D<TPixel> pixels, Configuration configuration)
+    private void Write32BitPixelData<TPixel>(Configuration configuration, Stream stream, Buffer2D<TPixel> pixels)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using IMemoryOwner<byte> row = this.AllocateRow(pixels.Width, 4);
@@ -380,10 +380,10 @@ private void Write32BitPixelData<TPixel>(Stream stream, Buffer2D<TPixel> pixels,
     /// Writes 24-bit pixel data with a color palette to the stream.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> containing pixel data.</param>
-    /// <param name="configuration">The global configuration.</param>
-    private void Write24BitPixelData<TPixel>(Stream stream, Buffer2D<TPixel> pixels, Configuration configuration)
+    private void Write24BitPixelData<TPixel>(Configuration configuration, Stream stream, Buffer2D<TPixel> pixels)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int width = pixels.Width;
@@ -407,11 +407,11 @@ private void Write24BitPixelData<TPixel>(Stream stream, Buffer2D<TPixel> pixels,
     /// Writes 16-bit pixel data with a color palette to the stream.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> containing pixel data.</param>
-    /// <param name="configuration">The global configuration.</param>
-    private void Write16BitPixelData<TPixel>(Stream stream, Buffer2D<TPixel> pixels, Configuration configuration)
-        where TPixel : unmanaged, IPixel<TPixel>
+    private void Write16BitPixelData<TPixel>(Configuration configuration, Stream stream, Buffer2D<TPixel> pixels)
+    where TPixel : unmanaged, IPixel<TPixel>
     {
         int width = pixels.Width;
         int rowBytesWithoutPadding = width * 2;
@@ -436,10 +436,10 @@ private void Write16BitPixelData<TPixel>(Stream stream, Buffer2D<TPixel> pixels,
     /// Writes 8 bit pixel data with a color palette. The color palette has 256 entry's with 4 bytes for each entry.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="image"> The <see cref="Image{TPixel}"/> containing pixel data.</param>
-    /// <param name="configuration">The global configuration.</param>
-    private void Write8BitPixelData<TPixel>(Stream stream, Image<TPixel> image, Configuration configuration)
+    private void Write8BitPixelData<TPixel>(Configuration configuration, Stream stream, Image<TPixel> image)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         bool isL8 = typeof(TPixel) == typeof(L8);
@@ -452,19 +452,19 @@ private void Write8BitPixelData<TPixel>(Stream stream, Image<TPixel> image, Conf
         }
         else
         {
-            this.Write8BitColor(stream, image, colorPalette, configuration);
+            this.Write8BitColor(configuration, stream, image, colorPalette);
         }
     }
 
     /// <summary>
     /// Writes an 8 bit color image with a color palette. The color palette has 256 entry's with 4 bytes for each entry.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="image"> The <see cref="Image{TPixel}"/> containing pixel data.</param>
     /// <param name="colorPalette">A byte span of size 1024 for the color palette.</param>
-    /// <param name="configuration">The global configuration</param>
-    private void Write8BitColor<TPixel>(Stream stream, Image<TPixel> image, Span<byte> colorPalette, Configuration configuration)
+    private void Write8BitColor<TPixel>(Configuration configuration, Stream stream, Image<TPixel> image, Span<byte> colorPalette)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration);
@@ -473,7 +473,7 @@ private void Write8BitColor<TPixel>(Stream stream, Image<TPixel> image, Span<byt
         using IndexedImageFrame<TPixel> quantized = frameQuantizer.QuantizeFrame(image.Frames.RootFrame, image.Bounds);
 
         ReadOnlySpan<TPixel> quantizedColorPalette = quantized.Palette.Span;
-        WriteColorPalette(stream, quantizedColorPalette, colorPalette, configuration);
+        WriteColorPalette(configuration, stream, quantizedColorPalette, colorPalette);
 
         for (int y = image.Height - 1; y >= 0; y--)
         {
@@ -529,10 +529,10 @@ private void Write8BitPixelData<TPixel>(Stream stream, Image<TPixel> image, Span
     /// Writes 4 bit pixel data with a color palette. The color palette has 16 entry's with 4 bytes for each entry.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="image"> The <see cref="ImageFrame{TPixel}"/> containing pixel data.</param>
-    /// <param name="configuration">The global configuration.</param>
-    private void Write4BitPixelData<TPixel>(Stream stream, Image<TPixel> image, Configuration configuration)
+    private void Write4BitPixelData<TPixel>(Configuration configuration, Stream stream, Image<TPixel> image)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration, new QuantizerOptions()
@@ -547,7 +547,7 @@ private void Write4BitPixelData<TPixel>(Stream stream, Image<TPixel> image, Conf
 
         Span<byte> colorPalette = colorPaletteBuffer.GetSpan();
         ReadOnlySpan<TPixel> quantizedColorPalette = quantized.Palette.Span;
-        WriteColorPalette(stream, quantizedColorPalette, colorPalette, configuration);
+        WriteColorPalette(configuration, stream, quantizedColorPalette, colorPalette);
 
         ReadOnlySpan<byte> pixelRowSpan = quantized.DangerousGetRowSpan(0);
         int rowPadding = pixelRowSpan.Length % 2 != 0 ? this.padding - 1 : this.padding;
@@ -577,10 +577,10 @@ private void Write4BitPixelData<TPixel>(Stream stream, Image<TPixel> image, Conf
     /// Writes 2 bit pixel data with a color palette. The color palette has 4 entry's with 4 bytes for each entry.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="image"> The <see cref="ImageFrame{TPixel}"/> containing pixel data.</param>
-    /// <param name="configuration">The global configuration</param>
-    private void Write2BitPixelData<TPixel>(Stream stream, Image<TPixel> image, Configuration configuration)
+    private void Write2BitPixelData<TPixel>(Configuration configuration, Stream stream, Image<TPixel> image)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration, new QuantizerOptions()
@@ -595,7 +595,7 @@ private void Write2BitPixelData<TPixel>(Stream stream, Image<TPixel> image, Conf
 
         Span<byte> colorPalette = colorPaletteBuffer.GetSpan();
         ReadOnlySpan<TPixel> quantizedColorPalette = quantized.Palette.Span;
-        WriteColorPalette(stream, quantizedColorPalette, colorPalette, configuration);
+        WriteColorPalette(configuration, stream, quantizedColorPalette, colorPalette);
 
         ReadOnlySpan<byte> pixelRowSpan = quantized.DangerousGetRowSpan(0);
         int rowPadding = pixelRowSpan.Length % 4 != 0 ? this.padding - 1 : this.padding;
@@ -634,10 +634,10 @@ private void Write2BitPixelData<TPixel>(Stream stream, Image<TPixel> image, Conf
     /// Writes 1 bit pixel data with a color palette. The color palette has 2 entry's with 4 bytes for each entry.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="image"> The <see cref="ImageFrame{TPixel}"/> containing pixel data.</param>
-    /// <param name="configuration">The global configuration</param>
-    private void Write1BitPixelData<TPixel>(Stream stream, Image<TPixel> image, Configuration configuration)
+    private void Write1BitPixelData<TPixel>(Configuration configuration, Stream stream, Image<TPixel> image)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration, new QuantizerOptions()
@@ -652,7 +652,7 @@ private void Write1BitPixelData<TPixel>(Stream stream, Image<TPixel> image, Conf
 
         Span<byte> colorPalette = colorPaletteBuffer.GetSpan();
         ReadOnlySpan<TPixel> quantizedColorPalette = quantized.Palette.Span;
-        WriteColorPalette(stream, quantizedColorPalette, colorPalette, configuration);
+        WriteColorPalette(configuration, stream, quantizedColorPalette, colorPalette);
 
         ReadOnlySpan<byte> quantizedPixelRow = quantized.DangerousGetRowSpan(0);
         int rowPadding = quantizedPixelRow.Length % 8 != 0 ? this.padding - 1 : this.padding;
@@ -684,11 +684,11 @@ private void Write1BitPixelData<TPixel>(Stream stream, Image<TPixel> image, Conf
     /// Writes the color palette to the stream. The color palette has 4 bytes for each entry.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="quantizedColorPalette">The color palette from the quantized image.</param>
     /// <param name="colorPalette">A temporary byte span to write the color palette to.</param>
-    /// <param name="configuration">The global configuration</param>
-    private static void WriteColorPalette<TPixel>(Stream stream, ReadOnlySpan<TPixel> quantizedColorPalette, Span<byte> colorPalette, Configuration configuration)
+    private static void WriteColorPalette<TPixel>(Configuration configuration, Stream stream, ReadOnlySpan<TPixel> quantizedColorPalette, Span<byte> colorPalette)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int quantizedColorBytes = quantizedColorPalette.Length * 4;
diff --git a/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs
@@ -26,7 +26,7 @@ public struct OctreeQuantizer<TPixel> : IQuantizer<TPixel>
     private readonly int maxColors;
     private readonly int bitDepth;
     private readonly Octree octree;
-    private IMemoryOwner<TPixel> paletteOwner;
+    private readonly IMemoryOwner<TPixel> paletteOwner;
     private ReadOnlyMemory<TPixel> palette;
     private EuclideanPixelMap<TPixel>? pixelMap;
     private readonly bool isDithering;
@@ -38,11 +38,8 @@ public struct OctreeQuantizer<TPixel> : IQuantizer<TPixel>
     /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
     /// <param name="options">The quantizer options defining quantization rules.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public OctreeQuantizer(Configuration? configuration, QuantizerOptions options)
+    public OctreeQuantizer(Configuration configuration, QuantizerOptions options)
     {
-        Guard.NotNull(configuration, nameof(configuration));
-        Guard.NotNull(options, nameof(options));
-
         this.Configuration = configuration;
         this.Options = options;
 
diff --git a/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer{TPixel}.cs
@@ -17,10 +17,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
     "Design",
     "CA1001:Types that own disposable fields should be disposable",
     Justification = "https://github.com/dotnet/roslyn-analyzers/issues/6151")]
-internal struct PaletteQuantizer<TPixel> : IQuantizer<TPixel>
+internal readonly struct PaletteQuantizer<TPixel> : IQuantizer<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
-    private EuclideanPixelMap<TPixel> pixelMap;
+    private readonly EuclideanPixelMap<TPixel> pixelMap;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PaletteQuantizer{TPixel}"/> struct.
@@ -29,7 +29,7 @@ internal struct PaletteQuantizer<TPixel> : IQuantizer<TPixel>
     /// <param name="options">The quantizer options defining quantization rules.</param>
     /// <param name="palette">The palette to use.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public PaletteQuantizer(Configuration? configuration, QuantizerOptions options, ReadOnlyMemory<TPixel> palette)
+    public PaletteQuantizer(Configuration configuration, QuantizerOptions options, ReadOnlyMemory<TPixel> palette)
     {
         Guard.NotNull(configuration, nameof(configuration));
         Guard.NotNull(options, nameof(options));
@@ -65,8 +65,5 @@ public readonly byte GetQuantizedColor(TPixel color, out TPixel match)
         => (byte)this.pixelMap.GetClosestColor(color, out match);
 
     /// <inheritdoc/>
-    public void Dispose()
-    {
-        this.pixelMap.Dispose();
-    }
+    public void Dispose() => this.pixelMap.Dispose();
 }
diff --git a/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs
@@ -69,9 +69,9 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
     /// </summary>
     private const int TableLength = IndexCount * IndexCount * IndexCount * IndexAlphaCount;
 
-    private IMemoryOwner<Moment> momentsOwner;
-    private IMemoryOwner<byte> tagsOwner;
-    private IMemoryOwner<TPixel> paletteOwner;
+    private readonly IMemoryOwner<Moment> momentsOwner;
+    private readonly IMemoryOwner<byte> tagsOwner;
+    private readonly IMemoryOwner<TPixel> paletteOwner;
     private ReadOnlyMemory<TPixel> palette;
     private int maxColors;
     private readonly Box[] colorCube;
@@ -85,7 +85,7 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
     /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
     /// <param name="options">The quantizer options defining quantization rules.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public WuQuantizer(Configuration? configuration, QuantizerOptions options)
+    public WuQuantizer(Configuration configuration, QuantizerOptions options)
     {
         Guard.NotNull(configuration, nameof(configuration));
         Guard.NotNull(options, nameof(options));
