Use initializer lists instead of parentheses

quentinguidee · quentinguidee · commit 94bdce46d452 · 2022-02-17T18:43:08.000+01:00
Signed-off-by: Quentin Guidée &lt;quentin.guidee@gmail.com&gt;
diff --git a/.clang-format b/.clang-format
@@ -21,3 +21,6 @@ ConstructorInitializerAllOnOneLineOrOnePerLine: false
 ColumnLimit: 0
 
 FixNamespaceComments: false
+
+Cpp11BracedListStyle: false
+SpaceBeforeCpp11BracedList: true
diff --git a/benchmarks/common.hpp b/benchmarks/common.hpp
@@ -20,9 +20,9 @@
 template <typename Decoder>
 RawImage decode(const std::string& filename)
 {
-    InputFileStream in(TEST_IMAGES_PATH + filename);
+    InputFileStream in { TEST_IMAGES_PATH + filename };
 
-    RawImage image = RawImage();
+    RawImage image;
     Decoder(in, image).decode();
 
     return image;
@@ -31,7 +31,7 @@ RawImage decode(const std::string& filename)
 template <typename Encoder>
 Encoder encode(const std::string& filename, RawImage& image)
 {
-    OutputFileStream out(TEST_IMAGES_PATH + filename);
+    OutputFileStream out { TEST_IMAGES_PATH + filename };
     Encoder encoder(out, image);
     encoder.encode();
 
@@ -48,7 +48,7 @@ void BM_decode(benchmark::State& state, const std::string& filename)
 template <typename Decoder, typename Encoder>
 void BM_encode(benchmark::State& state, const std::string& filename)
 {
-    std::string output_filename = "temp_" + filename;
+    std::string output_filename { "temp_" + filename };
 
     RawImage image = decode<Decoder>(filename);
 
diff --git a/src/bmp/bmp_common.cpp b/src/bmp/bmp_common.cpp
@@ -17,8 +17,8 @@ uint32_t BMP::float2_30_to_uint32(BMP::float2_30_t value)
 }
 
 BMP::Bitmask::Bitmask(uint32_t value) :
-    value(value),
-    offset(first_bit_set(value)),
-    divider(generate_bitmask<double>(count_set_bits(value)))
+    value{ value },
+    offset{ first_bit_set(value) },
+    divider{ generate_bitmask<double>(count_set_bits(value)) }
 {
 }
diff --git a/src/bmp/bmp_decoder.cpp b/src/bmp/bmp_decoder.cpp
@@ -41,7 +41,7 @@ void BMP::Decoder::decode()
             decode_info_header_v5();
             break;
         default:
-            throw UnsupportedVersionException("Cannot decode headers of size " + std::to_string(header_size) + ".");
+            throw UnsupportedVersionException { "Cannot decode headers of size " + std::to_string(header_size) + "." };
     }
 
     decode_color_table();
@@ -221,10 +221,10 @@ void BMP::Decoder::decode_pixel_array_16_bpp()
 {
     if (settings.compression == Compression::RGB)
     {
-        settings.bitmask_a = Bitmask(0b0000000000000000);
-        settings.bitmask_r = Bitmask(0b0000000000111110);
-        settings.bitmask_g = Bitmask(0b0000011111000000);
-        settings.bitmask_b = Bitmask(0b1111100000000000);
+        settings.bitmask_a = { 0b0000000000000000 };
+        settings.bitmask_r = { 0b0000000000111110 };
+        settings.bitmask_g = { 0b0000011111000000 };
+        settings.bitmask_b = { 0b1111100000000000 };
     }
 
     for (uint32_t y = 0; y < image.height; ++y)
@@ -240,7 +240,7 @@ void BMP::Decoder::decode_pixel_array_16_bpp()
 void BMP::Decoder::decode_pixel_array_24_bpp()
 {
     if (settings.compression == Compression::BITFIELDS)
-        throw DecodeException("The bitfields compression method is not allowed for 24bpp images.");
+        throw DecodeException { "The bitfields compression method is not allowed for 24bpp images." };
 
     for (uint32_t y = 0; y < image.height; ++y)
     {
@@ -256,10 +256,10 @@ void BMP::Decoder::decode_pixel_array_32_bpp()
 {
     if (settings.compression == Compression::RGB)
     {
-        settings.bitmask_a = Bitmask(0x00000000);
-        settings.bitmask_r = Bitmask(0x0000ff00);
-        settings.bitmask_g = Bitmask(0x00ff0000);
-        settings.bitmask_b = Bitmask(0xff000000);
+        settings.bitmask_a = { 0x00000000 };
+        settings.bitmask_r = { 0x0000ff00 };
+        settings.bitmask_g = { 0x00ff0000 };
+        settings.bitmask_b = { 0xff000000 };
     }
 
     for (uint32_t i = 0; i < image.width * image.height; ++i)
@@ -268,10 +268,11 @@ void BMP::Decoder::decode_pixel_array_32_bpp()
 
 void BMP::Decoder::decode_one_pixel_bitmask(uint32_t value)
 {
-    Pixel pixel(
-        ((value & settings.bitmask_r.value) >> settings.bitmask_r.offset) * (255 / settings.bitmask_r.divider),
-        ((value & settings.bitmask_g.value) >> settings.bitmask_g.offset) * (255 / settings.bitmask_g.divider),
-        ((value & settings.bitmask_b.value) >> settings.bitmask_b.offset) * (255 / settings.bitmask_b.divider));
+    Pixel pixel {
+        (uint8_t)(((value & settings.bitmask_r.value) >> settings.bitmask_r.offset) * (255 / settings.bitmask_r.divider)),
+        (uint8_t)(((value & settings.bitmask_g.value) >> settings.bitmask_g.offset) * (255 / settings.bitmask_g.divider)),
+        (uint8_t)(((value & settings.bitmask_b.value) >> settings.bitmask_b.offset) * (255 / settings.bitmask_b.divider)),
+    };
 
     if (settings.bitmask_a.value != 0)
         pixel.a = ((value & settings.bitmask_a.value) >> settings.bitmask_a.offset) * (255 / settings.bitmask_a.divider);
diff --git a/src/bmp/bmp_decoder.hpp b/src/bmp/bmp_decoder.hpp
@@ -17,7 +17,7 @@ class Decoder final : public BaseDecoder
 
 public:
     Decoder(InputStream &in, RawImage &image) :
-        BaseDecoder(in, image) {}
+        BaseDecoder { in, image } {}
 
     static bool can_decode(InputStream &in);
 
diff --git a/src/bmp/bmp_encoder.cpp b/src/bmp/bmp_encoder.cpp
@@ -41,7 +41,7 @@ void BMP::Encoder::encode()
             encode_info_header_v5();
             break;
         default:
-            throw UnsupportedVersionException("Cannot encode headers of size " + std::to_string(header_size) + ".");
+            throw UnsupportedVersionException { "Cannot encode headers of size " + std::to_string(header_size) + "." };
     }
 
     encode_color_table();
@@ -224,10 +224,10 @@ void BMP::Encoder::encode_pixel_array_16_bpp()
 {
     if (settings.compression == Compression::RGB)
     {
-        settings.bitmask_a = Bitmask(0b0000000000000000);
-        settings.bitmask_r = Bitmask(0b0000000000111110);
-        settings.bitmask_g = Bitmask(0b0000011111000000);
-        settings.bitmask_b = Bitmask(0b1111100000000000);
+        settings.bitmask_a = { 0b0000000000000000 };
+        settings.bitmask_r = { 0b0000000000111110 };
+        settings.bitmask_g = { 0b0000011111000000 };
+        settings.bitmask_b = { 0b1111100000000000 };
     }
 
     for (uint32_t y = 0; y < image.height; ++y)
@@ -252,7 +252,7 @@ void BMP::Encoder::encode_pixel_array_16_bpp()
 void BMP::Encoder::encode_pixel_array_24_bpp()
 {
     if (settings.compression == Compression::BITFIELDS)
-        throw std::runtime_error("The bitfields compression method is not allowed for 24bpp images.");
+        throw std::runtime_error { "The bitfields compression method is not allowed for 24bpp images." };
 
     for (uint32_t y = 0; y < image.height; ++y)
     {
@@ -268,10 +268,10 @@ void BMP::Encoder::encode_pixel_array_32_bpp()
 {
     if (settings.compression == Compression::RGB)
     {
-        settings.bitmask_a = Bitmask(0x00000000);
-        settings.bitmask_r = Bitmask(0x0000ff00);
-        settings.bitmask_g = Bitmask(0x00ff0000);
-        settings.bitmask_b = Bitmask(0xff000000);
+        settings.bitmask_a = { 0x00000000 };
+        settings.bitmask_r = { 0x0000ff00 };
+        settings.bitmask_g = { 0x00ff0000 };
+        settings.bitmask_b = { 0xff000000 };
     }
 
     for (uint32_t i = 0; i < image.width * image.height; ++i)
@@ -326,6 +326,6 @@ void BMP::Encoder::generate_colors_table_indexes()
     {
         const Pixel& pixel = settings.colors_table[i];
         const uint32_t hash = (pixel.r) + (pixel.g * 255) + (pixel.b * 255 * 255);
-        colors_table_indexes.insert({hash, i});
+        colors_table_indexes.insert({ hash, i });
     }
 }
diff --git a/src/bmp/bmp_encoder.hpp b/src/bmp/bmp_encoder.hpp
@@ -13,14 +13,14 @@ namespace BMP {
 class Encoder final : public BaseEncoder
 {
 private:
-    Settings settings;
+    Settings settings {};
 
     // r + 255 g + 255^2 b => colors_table index
-    std::unordered_map<uint32_t, uint32_t> colors_table_indexes;
+    std::unordered_map<uint32_t, uint32_t> colors_table_indexes {};
 
 public:
     Encoder(OutputStream &out, RawImage &image) :
-        BaseEncoder(out, image) {}
+        BaseEncoder { out, image } {}
 
     void encode() override;
 
diff --git a/src/bmp/bmp_format.hpp b/src/bmp/bmp_format.hpp
@@ -2,8 +2,8 @@
 
 #include "format.hpp"
 
-static const Format BMP_FORMAT{
+static const Format BMP_FORMAT {
     "bmp",
     "Bitmap",
-    {"bmp"},
+    { "bmp" },
 };
diff --git a/src/bmp/bmp_settings.hpp b/src/bmp/bmp_settings.hpp
@@ -11,17 +11,17 @@ namespace BMP {
 struct Settings
 {
     // Header
-    HeaderVersion header_version = HeaderVersion::INFO_HEADER_V5;
-    Signature signature = Signature::BM;
+    HeaderVersion header_version { HeaderVersion::INFO_HEADER_V5 };
+    Signature signature { Signature::BM };
     uint32_t starting_address;
 
     // Header core + info v1
-    StartDecodingPosition start_decoding_position = StartDecodingPosition::TopLeft;
-    BitCount bit_count = BitCount::BITCOUNT_6;
-    Compression compression = Compression::RGB;
+    StartDecodingPosition start_decoding_position { StartDecodingPosition::TopLeft };
+    BitCount bit_count { BitCount::BITCOUNT_6 };
+    Compression compression { Compression::RGB };
     int32_t x_pixels_per_meter, y_pixels_per_meter;
-    uint32_t colors_count = 0;
-    uint32_t important_colors_count = 0;
+    uint32_t colors_count { 0 };
+    uint32_t important_colors_count { 0 };
 
     // Header info v2
     Bitmask bitmask_r, bitmask_g, bitmask_b;
@@ -30,7 +30,7 @@ struct Settings
     Bitmask bitmask_a;
 
     // Header info v4
-    LogicalColorSpace color_space_type = LogicalColorSpace::SRGB;
+    LogicalColorSpace color_space_type { LogicalColorSpace::SRGB };
     CIEXYZTriple endpoints;
     float gamma_r, gamma_g, gamma_b;
 
@@ -40,7 +40,7 @@ struct Settings
     uint32_t profile_size;
 
     // Color table
-    std::vector<Pixel> colors_table;
+    std::vector<Pixel> colors_table {};
 };
 
 }
diff --git a/src/common/decoder.hpp b/src/common/decoder.hpp
@@ -13,7 +13,7 @@ class BaseDecoder
 
 public:
     BaseDecoder(InputStream& in, RawImage& image) :
-        in(in), image(image) {}
+        in { in }, image { image } {}
 
     virtual ~BaseDecoder() = default;
 
diff --git a/src/common/encoder.hpp b/src/common/encoder.hpp
@@ -13,7 +13,7 @@ class BaseEncoder
 
 public:
     BaseEncoder(OutputStream& out, RawImage& image) :
-        out(out), image(image) {}
+        out { out }, image { image } {}
 
     virtual ~BaseEncoder() = default;
 
diff --git a/src/common/exceptions.hpp b/src/common/exceptions.hpp
@@ -7,7 +7,7 @@ class DecodeException : public std::runtime_error
 {
 public:
     DecodeException(const std::string& error_message = "") :
-        std::runtime_error("Error while decoding image. " + error_message)
+        std::runtime_error { "Error while decoding image. " + error_message }
     {
     }
 };
@@ -16,7 +16,7 @@ class UnsupportedVersionException : public std::runtime_error
 {
 public:
     UnsupportedVersionException(const std::string& error_message = "") :
-        std::runtime_error("Error while encoding/decoding image. Probably because of an unsupported version. " + error_message)
+        std::runtime_error { "Error while encoding/decoding image. Probably because of an unsupported version. " + error_message }
     {
     }
 };
diff --git a/src/common/pixel.cpp b/src/common/pixel.cpp
@@ -1,7 +1,10 @@
 #include "pixel.hpp"
 
 Pixel::Pixel(uint8_t r, uint8_t g, uint8_t b, uint8_t a) :
-    r(r), g(g), b(b), a(a)
+    r { r },
+    g { g },
+    b { b },
+    a { a }
 {
 }
 
diff --git a/src/common/raw_image.hpp b/src/common/raw_image.hpp
@@ -11,7 +11,7 @@ struct RawImage
 {
     Pixels pixels;
 
-    uint32_t width = 0, height = 0;
+    uint32_t width { 0 }, height { 0 };
 
     RawImage() {}
 
diff --git a/src/common/stream.cpp b/src/common/stream.cpp
@@ -50,12 +50,12 @@ long InputStream::remaining_size()
 }
 
 InputFileStream::InputFileStream(const std::string& filename) :
-    input(std::ifstream(filename))
+    input { std::ifstream { filename } }
 {
     input.seekg(0, std::ios::beg);
 }
 
 OutputFileStream::OutputFileStream(const std::string& filename) :
-    output(std::ofstream(filename))
+    output { std::ofstream { filename } }
 {
 }
diff --git a/src/formats.cpp b/src/formats.cpp
@@ -5,9 +5,9 @@
 #include "bmp_format.hpp"
 #include "qoi_format.hpp"
 
-const std::unordered_map<std::string, Format> Formats::FORMATS{
-    {"qoi", QOI_FORMAT},
-    {"bmp", BMP_FORMAT},
+const std::unordered_map<std::string, Format> Formats::FORMATS {
+    { "qoi", QOI_FORMAT },
+    { "bmp", BMP_FORMAT },
 };
 
 const Format& Formats::get_by_id(const std::string& format_id)
diff --git a/src/qoi/qoi_decoder.hpp b/src/qoi/qoi_decoder.hpp
@@ -11,11 +11,11 @@ namespace QOI {
 class Decoder final : public BaseDecoder
 {
 private:
-    Settings settings;
+    Settings settings {};
 
 public:
     Decoder(InputStream &in, RawImage &image) :
-        BaseDecoder(in, image) {}
+        BaseDecoder { in, image } {}
 
     static bool can_decode(InputStream &in);
 
diff --git a/src/qoi/qoi_encoder.hpp b/src/qoi/qoi_encoder.hpp
@@ -10,11 +10,11 @@ namespace QOI {
 class Encoder final : public BaseEncoder
 {
 private:
-    Settings settings;
+    Settings settings {};
 
 public:
     Encoder(OutputStream &out, RawImage &image) :
-        BaseEncoder(out, image) {}
+        BaseEncoder { out, image } {}
 
     void encode() override;
 
diff --git a/src/qoi/qoi_format.hpp b/src/qoi/qoi_format.hpp
@@ -2,8 +2,8 @@
 
 #include "format.hpp"
 
-static const Format QOI_FORMAT{
+static const Format QOI_FORMAT {
     "qoi",
     "Quite OK image format",
-    {"qoi"},
+    { "qoi" },
 };
diff --git a/src/qoi/qoi_settings.hpp b/src/qoi/qoi_settings.hpp
@@ -6,8 +6,8 @@ namespace QOI {
 
 struct Settings
 {
-    Colorspace colorspace;
-    Channels channels;
+    Colorspace colorspace {};
+    Channels channels {};
 };
 
 }
diff --git a/tests/common_tests.cpp b/tests/common_tests.cpp
@@ -70,12 +70,12 @@ TEST(CommonTest, BufferStream)
 
 TEST(CommonTest, FileStream)
 {
-    OutputFileStream out("temporary_stream_test");
+    OutputFileStream out { "temporary_stream_test" };
     ASSERT_TRUE(out.is_open());
     test_write(out);
     out.close();
 
-    InputFileStream in("temporary_stream_test");
+    InputFileStream in { "temporary_stream_test" };
     ASSERT_TRUE(in.is_open());
     test_read(in);
     in.close();
diff --git a/tests/conversion_common.hpp b/tests/conversion_common.hpp
diff --git a/viewer/app.cpp b/viewer/app.cpp
diff --git a/viewer/app.hpp b/viewer/app.hpp
diff --git a/viewer/image_widget.cpp b/viewer/image_widget.cpp
diff --git a/viewer/image_widget.hpp b/viewer/image_widget.hpp
diff --git a/viewer/image_widget_bmp.cpp b/viewer/image_widget_bmp.cpp
diff --git a/viewer/image_widget_qoi.cpp b/viewer/image_widget_qoi.cpp

Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,8 @@ uint32_t BMP::float2_30_to_uint32(BMP::float2_30_t value)`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`BMP::Bitmask::Bitmask(uint32_t value) :`
`20`		`- value(value),`
`21`		`- offset(first_bit_set(value)),`
`22`		`- divider(generate_bitmask<double>(count_set_bits(value)))`
	`20`	`+ value{ value },`
	`21`	`+ offset{ first_bit_set(value) },`
	`22`	`+ divider{ generate_bitmask<double>(count_set_bits(value)) }`
`23`	`23`	`{`
`24`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ void BMP::Decoder::decode()`
`41`	`41`	`decode_info_header_v5();`
`42`	`42`	`break;`
`43`	`43`	`default:`
`44`		`- throw UnsupportedVersionException("Cannot decode headers of size " + std::to_string(header_size) + ".");`
	`44`	`+ throw UnsupportedVersionException { "Cannot decode headers of size " + std::to_string(header_size) + "." };`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`decode_color_table();`
`@@ -221,10 +221,10 @@ void BMP::Decoder::decode_pixel_array_16_bpp()`
`221`	`221`	`{`
`222`	`222`	`if (settings.compression == Compression::RGB)`
`223`	`223`	`{`
`224`		`- settings.bitmask_a = Bitmask(0b0000000000000000);`
`225`		`- settings.bitmask_r = Bitmask(0b0000000000111110);`
`226`		`- settings.bitmask_g = Bitmask(0b0000011111000000);`
`227`		`- settings.bitmask_b = Bitmask(0b1111100000000000);`
	`224`	`+ settings.bitmask_a = { 0b0000000000000000 };`
	`225`	`+ settings.bitmask_r = { 0b0000000000111110 };`
	`226`	`+ settings.bitmask_g = { 0b0000011111000000 };`
	`227`	`+ settings.bitmask_b = { 0b1111100000000000 };`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`for (uint32_t y = 0; y < image.height; ++y)`
`@@ -240,7 +240,7 @@ void BMP::Decoder::decode_pixel_array_16_bpp()`
`240`	`240`	`void BMP::Decoder::decode_pixel_array_24_bpp()`
`241`	`241`	`{`
`242`	`242`	`if (settings.compression == Compression::BITFIELDS)`
`243`		`- throw DecodeException("The bitfields compression method is not allowed for 24bpp images.");`
	`243`	`+ throw DecodeException { "The bitfields compression method is not allowed for 24bpp images." };`
`244`	`244`
`245`	`245`	`for (uint32_t y = 0; y < image.height; ++y)`
`246`	`246`	`{`
`@@ -256,10 +256,10 @@ void BMP::Decoder::decode_pixel_array_32_bpp()`
`256`	`256`	`{`
`257`	`257`	`if (settings.compression == Compression::RGB)`
`258`	`258`	`{`
`259`		`- settings.bitmask_a = Bitmask(0x00000000);`
`260`		`- settings.bitmask_r = Bitmask(0x0000ff00);`
`261`		`- settings.bitmask_g = Bitmask(0x00ff0000);`
`262`		`- settings.bitmask_b = Bitmask(0xff000000);`
	`259`	`+ settings.bitmask_a = { 0x00000000 };`
	`260`	`+ settings.bitmask_r = { 0x0000ff00 };`
	`261`	`+ settings.bitmask_g = { 0x00ff0000 };`
	`262`	`+ settings.bitmask_b = { 0xff000000 };`
`263`	`263`	`}`
`264`	`264`
`265`	`265`	`for (uint32_t i = 0; i < image.width * image.height; ++i)`
`@@ -268,10 +268,11 @@ void BMP::Decoder::decode_pixel_array_32_bpp()`
`268`	`268`
`269`	`269`	`void BMP::Decoder::decode_one_pixel_bitmask(uint32_t value)`
`270`	`270`	`{`
`271`		`- Pixel pixel(`
`272`		`- ((value & settings.bitmask_r.value) >> settings.bitmask_r.offset) * (255 / settings.bitmask_r.divider),`
`273`		`- ((value & settings.bitmask_g.value) >> settings.bitmask_g.offset) * (255 / settings.bitmask_g.divider),`
`274`		`- ((value & settings.bitmask_b.value) >> settings.bitmask_b.offset) * (255 / settings.bitmask_b.divider));`
	`271`	`+ Pixel pixel {`
	`272`	`+ (uint8_t)(((value & settings.bitmask_r.value) >> settings.bitmask_r.offset) * (255 / settings.bitmask_r.divider)),`
	`273`	`+ (uint8_t)(((value & settings.bitmask_g.value) >> settings.bitmask_g.offset) * (255 / settings.bitmask_g.divider)),`
	`274`	`+ (uint8_t)(((value & settings.bitmask_b.value) >> settings.bitmask_b.offset) * (255 / settings.bitmask_b.divider)),`
	`275`	`+ };`
`275`	`276`
`276`	`277`	`if (settings.bitmask_a.value != 0)`
`277`	`278`	`pixel.a = ((value & settings.bitmask_a.value) >> settings.bitmask_a.offset) * (255 / settings.bitmask_a.divider);`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ void BMP::Encoder::encode()`
`41`	`41`	`encode_info_header_v5();`
`42`	`42`	`break;`
`43`	`43`	`default:`
`44`		`- throw UnsupportedVersionException("Cannot encode headers of size " + std::to_string(header_size) + ".");`
	`44`	`+ throw UnsupportedVersionException { "Cannot encode headers of size " + std::to_string(header_size) + "." };`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`encode_color_table();`
`@@ -224,10 +224,10 @@ void BMP::Encoder::encode_pixel_array_16_bpp()`
`224`	`224`	`{`
`225`	`225`	`if (settings.compression == Compression::RGB)`
`226`	`226`	`{`
`227`		`- settings.bitmask_a = Bitmask(0b0000000000000000);`
`228`		`- settings.bitmask_r = Bitmask(0b0000000000111110);`
`229`		`- settings.bitmask_g = Bitmask(0b0000011111000000);`
`230`		`- settings.bitmask_b = Bitmask(0b1111100000000000);`
	`227`	`+ settings.bitmask_a = { 0b0000000000000000 };`
	`228`	`+ settings.bitmask_r = { 0b0000000000111110 };`
	`229`	`+ settings.bitmask_g = { 0b0000011111000000 };`
	`230`	`+ settings.bitmask_b = { 0b1111100000000000 };`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`for (uint32_t y = 0; y < image.height; ++y)`
`@@ -252,7 +252,7 @@ void BMP::Encoder::encode_pixel_array_16_bpp()`
`252`	`252`	`void BMP::Encoder::encode_pixel_array_24_bpp()`
`253`	`253`	`{`
`254`	`254`	`if (settings.compression == Compression::BITFIELDS)`
`255`		`- throw std::runtime_error("The bitfields compression method is not allowed for 24bpp images.");`
	`255`	`+ throw std::runtime_error { "The bitfields compression method is not allowed for 24bpp images." };`
`256`	`256`
`257`	`257`	`for (uint32_t y = 0; y < image.height; ++y)`
`258`	`258`	`{`
`@@ -268,10 +268,10 @@ void BMP::Encoder::encode_pixel_array_32_bpp()`
`268`	`268`	`{`
`269`	`269`	`if (settings.compression == Compression::RGB)`
`270`	`270`	`{`
`271`		`- settings.bitmask_a = Bitmask(0x00000000);`
`272`		`- settings.bitmask_r = Bitmask(0x0000ff00);`
`273`		`- settings.bitmask_g = Bitmask(0x00ff0000);`
`274`		`- settings.bitmask_b = Bitmask(0xff000000);`
	`271`	`+ settings.bitmask_a = { 0x00000000 };`
	`272`	`+ settings.bitmask_r = { 0x0000ff00 };`
	`273`	`+ settings.bitmask_g = { 0x00ff0000 };`
	`274`	`+ settings.bitmask_b = { 0xff000000 };`
`275`	`275`	`}`
`276`	`276`
`277`	`277`	`for (uint32_t i = 0; i < image.width * image.height; ++i)`
`@@ -326,6 +326,6 @@ void BMP::Encoder::generate_colors_table_indexes()`
`326`	`326`	`{`
`327`	`327`	`const Pixel& pixel = settings.colors_table[i];`
`328`	`328`	`const uint32_t hash = (pixel.r) + (pixel.g * 255) + (pixel.b * 255 * 255);`
`329`		`- colors_table_indexes.insert({hash, i});`
	`329`	`+ colors_table_indexes.insert({ hash, i });`
`330`	`330`	`}`
`331`	`331`	`}`