Address cppcoreguidelines-avoid-magic-numbers warnings

Author: glynos

include/skyr/core/schemes.hpp

@@ -22,11 +22,11 @@ constexpr auto is_special(std::string_view scheme) noexcept -> bool {
 /// \returns
 constexpr auto default_port(std::string_view scheme) noexcept -> std::optional<std::uint16_t> {
   if (scheme == "ftp") {
-    return 21;
+    return 21;  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
   } else if ((scheme == "http") || (scheme == "ws")) {
-    return 80;
+    return 80;  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
   } else if ((scheme == "https") || (scheme == "wss")) {
-    return 443;
+    return 443;  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
   }
   return std::nullopt;
 }

include/skyr/domain/punycode.hpp

@@ -41,7 +41,7 @@ constexpr auto adapt(uint32_t delta, uint32_t numpoints, bool firsttime) -> std:
     delta /= base - tmin;
     k += base;
   }
-  return k + (base - tmin + 1ul) * delta / (delta + skew);
+  return k + ((base - tmin + 1ul) * delta / (delta + skew));
 }
 }  // namespace punycode
 
@@ -54,16 +54,18 @@ constexpr auto adapt(uint32_t delta, uint32_t numpoints, bool firsttime) -> std:
 inline auto punycode_encode(std::u32string_view input, std::string* output) -> std::expected<void, domain_errc> {
   using namespace punycode::constants;
 
-  constexpr auto is_ascii_value = [](auto c) { return c < 0x80; };
+  constexpr auto is_ascii_value = [](auto c) { return c < 0x80; };  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
   constexpr auto to_char = [](auto c) { return static_cast<char>(c); };
 
   // encode_digit(d,flag) returns the basic code point whose value
   // (when used for representing integers) is d, which needs to be in
   // the range 0 to base-1.  The lowercase form is used unless flag is
   // nonzero, in which case the uppercase form is used.  The behavior
   // is undefined if flag is nonzero and digit d has no uppercase form.
-  constexpr auto encode_digit = [](std::uint32_t d, std::uint32_t flag) -> char {
-    return d + 0x16ul + (0x4bul * (d < 0x1aul)) - ((flag != 0ul) << 0x5ul);
+  constexpr auto encode_digit = [](const std::uint32_t d, const std::uint32_t flag) -> char {
+    return static_cast<char>(d + 0x16ul + (0x4bul * (d < 0x1aul)) -
+                             ((flag != 0ul) << 0x5ul)  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
+    );
     //  0..25 map to ASCII a..z or A..Z
     // 26..35 map to ASCII 0..9
   };

include/skyr/network/ipv4_address.hpp

@@ -57,23 +57,27 @@ class ipv4_address {
   /// The address in bytes in network byte order
   /// \returns The address in bytes
   [[nodiscard]] constexpr auto to_bytes() const noexcept -> std::array<unsigned char, 4> {
-    auto addr = address();
-    return {{static_cast<unsigned char>(addr >> 24u), static_cast<unsigned char>(addr >> 16u),
-             static_cast<unsigned char>(addr >> 8u), static_cast<unsigned char>(addr)}};
+    const auto addr = address();
+    return {{static_cast<unsigned char>(addr >> 24u),
+             static_cast<unsigned char>(addr >> 16u),  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
+             static_cast<unsigned char>(addr >> 8u),
+             static_cast<unsigned char>(addr)}};  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
   }
 
   /// \returns The address as a string
   [[nodiscard]] auto serialize() const -> std::string {
     using namespace std::string_literals;
     using namespace std::string_view_literals;
 
-    constexpr auto separator = [](auto i) { return (i < 4) ? "."sv : ""sv; };
+    constexpr auto separator = [](auto i) {
+      return (i < 4) ? "."sv : ""sv;
+    };  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 
     auto output = ""s;
     auto n = address();
     for (auto i = 1U; i <= 4U; ++i) {
       output = std::format("{}{}{}", separator(i), n % 256, output);
-      n >>= 8;
+      n >>= 8;  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
     }
     return output;
   }
@@ -82,21 +86,21 @@ class ipv4_address {
 namespace details {
 /// Computes 256^exp efficiently using bit shifts (256 = 2^8, so 256^n = 2^(8n))
 constexpr auto pow256(unsigned int exp) noexcept -> std::uint64_t {
-  return 1ULL << (exp * 8);
+  return 1ULL << (exp * 8);  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 }
 
 constexpr auto parse_ipv4_number(std::string_view input, bool* validation_error)
     -> std::expected<std::uint64_t, ipv4_address_errc> {
-  auto base = 10;
+  auto base = 10;  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 
   if ((input.size() >= 2) && (input[0] == '0') && (std::tolower(input[1], std::locale::classic()) == 'x')) {
     *validation_error |= true;
     input = input.substr(2);
-    base = 16;
+    base = 16;  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
   } else if ((input.size() >= 2) && (input[0] == '0')) {
     *validation_error |= true;
     input = input.substr(1);
-    base = 8;
+    base = 8;  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
   }
 
   if (input.empty()) {
@@ -162,7 +166,9 @@ constexpr auto parse_ipv4_address(std::string_view input, bool* validation_error
     numbers.push_back(number.value());
   }
 
-  constexpr auto greater_than_255 = [](auto number) { return number > 255; };
+  constexpr auto greater_than_255 = [](auto number) {
+    return number > 255;
+  };  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 
   if (std::ranges::cend(numbers) != std::ranges::find_if(numbers, greater_than_255)) {
     *validation_error |= true;
@@ -176,7 +182,7 @@ constexpr auto parse_ipv4_address(std::string_view input, bool* validation_error
     return std::unexpected(ipv4_address_errc::overflow);
   }
 
-  if (numbers.back() >= details::pow256(5 - numbers.size())) {
+  if (numbers.back() >= details::pow256(5 - numbers.size())) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
     *validation_error |= true;
     return std::unexpected(ipv4_address_errc::overflow);
   }
@@ -186,7 +192,7 @@ constexpr auto parse_ipv4_address(std::string_view input, bool* validation_error
 
   auto counter = 0UL;
   for (auto&& number : numbers) {
-    ipv4 += number * details::pow256(3 - counter);
+    ipv4 += number * details::pow256(3 - counter);  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
     ++counter;
   }
   return ipv4_address(static_cast<unsigned int>(ipv4));

include/skyr/network/ipv6_address.hpp

@@ -120,7 +120,7 @@ class ipv6_address {
     }
 
     auto ignore0 = false;
-    for (auto i = 0UL; i <= 7UL; ++i) {
+    for (auto i = 0UL; i <= 7UL; ++i) {    // NOLINT(cppcoreguidelines-avoid-magic-numbers)
       if (ignore0 && (address[i] == 0)) {  // NOLINT
         continue;
       } else if (ignore0) {
@@ -181,7 +181,7 @@ constexpr auto parse_ipv6_address(std::string_view input, bool* validation_error
   }
 
   while (it != last) {
-    if (piece_index == 8) {
+    if (piece_index == 8) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
       *validation_error |= true;
       return std::unexpected(ipv6_address_errc::invalid_piece);
     }
@@ -202,7 +202,8 @@ constexpr auto parse_ipv6_address(std::string_view input, bool* validation_error
     auto length = 0;
 
     while ((it != last) && ((length < 4) && std::isxdigit(*it, std::locale::classic()))) {
-      value = value * 0x10 + details::hex_to_dec<decltype(value)>(*it);
+      value =
+          (value * 0x10) + details::hex_to_dec<decltype(value)>(*it);  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
       ++it;
       ++length;
     }
@@ -215,7 +216,7 @@ constexpr auto parse_ipv6_address(std::string_view input, bool* validation_error
 
       std::ranges::advance(it, -length);
 
-      if (piece_index > 6) {
+      if (piece_index > 6) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
         *validation_error |= true;
         return std::unexpected(ipv6_address_errc::invalid_ipv4_segment_number);
       }
@@ -226,7 +227,7 @@ constexpr auto parse_ipv6_address(std::string_view input, bool* validation_error
         auto ipv4_piece = std::optional<int>();
 
         if (numbers_seen > 0) {
-          if ((*it == '.') && (numbers_seen < 4)) {
+          if ((*it == '.') && (numbers_seen < 4)) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
             ++it;
           } else {
             *validation_error |= true;
@@ -247,18 +248,19 @@ constexpr auto parse_ipv6_address(std::string_view input, bool* validation_error
             *validation_error |= true;
             return std::unexpected(ipv6_address_errc::invalid_ipv4_segment_number);
           } else {
-            ipv4_piece = ipv4_piece.value() * 10 + number;
+            ipv4_piece = (ipv4_piece.value() * 10) + number;  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
           }
 
-          if (ipv4_piece.value() > 255) {
+          if (ipv4_piece.value() > 255) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
             *validation_error |= true;
             return std::unexpected(ipv6_address_errc::invalid_ipv4_segment_number);
           }
 
           ++it;
         }
 
-        address[piece_index] = static_cast<std::uint16_t>((address[piece_index] << 8) + ipv4_piece.value());  // NOLINT
+        address[piece_index] = static_cast<std::uint16_t>(
+            (address[piece_index] << 8) + ipv4_piece.value());  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
         ++numbers_seen;
 
         if ((numbers_seen == 2) || (numbers_seen == 4)) {
@@ -288,13 +290,14 @@ constexpr auto parse_ipv6_address(std::string_view input, bool* validation_error
 
   if (compress) {
     auto swaps = piece_index - compress.value();
-    piece_index = 7;
+    piece_index = 7;  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
     while ((piece_index != 0) && (swaps > 0)) {
-      std::swap(address[piece_index], address[compress.value() + swaps - 1]);  // NOLINT
+      std::swap(address[piece_index],
+                address[compress.value() + swaps - 1]);  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
       --piece_index;
       --swaps;
     }
-  } else if (!compress && (piece_index != 8)) {
+  } else if (!compress && (piece_index != 8)) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
     *validation_error |= true;
     return std::unexpected(ipv6_address_errc::compress_expected);
   }

include/skyr/unicode/code_points/u16.hpp

@@ -27,7 +27,8 @@ class u16_code_point_t {
   }
 
   constexpr u16_code_point_t(char16_t lead_value, char16_t trail_value)
-      : code_point_((lead_value << 10U) + trail_value + constants::surrogates::offset) {
+      : code_point_((lead_value << 10U) + trail_value +
+                    constants::surrogates::offset) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
   }
 
   ///
@@ -39,14 +40,18 @@ class u16_code_point_t {
   ///
   /// \return
   [[nodiscard]] auto lead_value() const {
-    return is_surrogate_pair() ? static_cast<char16_t>((code_point_ >> 10U) + constants::surrogates::lead_offset)
-                               : static_cast<char16_t>(code_point_);
+    return is_surrogate_pair()
+               ? static_cast<char16_t>(
+                     (code_point_ >> 10U) +
+                     constants::surrogates::lead_offset)  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
+               : static_cast<char16_t>(code_point_);
   }
 
   ///
   /// \return
   [[nodiscard]] constexpr auto trail_value() const {
-    return is_surrogate_pair() ? static_cast<char16_t>((code_point_ & 0x3ffU) + constants::surrogates::trail_min) : 0;
+    return is_surrogate_pair() ? static_cast<char16_t>((code_point_ & 0x3ffU) + constants::surrogates::trail_min)
+                               : 0;  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
   }
 
   [[nodiscard]] constexpr auto u32_value() const noexcept -> std::expected<char32_t, unicode_errc> {

include/skyr/unicode/core.hpp

@@ -21,7 +21,7 @@ namespace skyr::unicode {
 template <class uintT>
 constexpr auto mask8(uintT value) {
   static_assert(std::is_unsigned_v<uintT>, "unsigned integral types only");
-  return static_cast<uintT>(0xffu & value);
+  return static_cast<uintT>(0xffu & value);  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 }
 
 ///
@@ -30,14 +30,14 @@ constexpr auto mask8(uintT value) {
 template <class uintT>
 constexpr auto mask16(uintT value) {
   static_assert(std::is_unsigned_v<uintT>, "unsigned integral types only");
-  return static_cast<uintT>(0xffffu & value);
+  return static_cast<uintT>(0xffffu & value);  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 }
 
 ///
 /// \param octet
 /// \return
 constexpr auto is_trail(uint8_t octet) {
-  return ((mask8(octet) >> 6u) == 0x2u);
+  return ((mask8(octet) >> 6u) == 0x2u);  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 }
 
 ///
@@ -73,13 +73,13 @@ constexpr auto is_valid_code_point(char32_t code_point) {
 /// \return 1, 2, 3 or 4
 constexpr auto sequence_length(uint8_t lead_value) {
   auto lead = mask8(lead_value);
-  if (lead < 0x80u) {
+  if (lead < 0x80u) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
     return 1;
-  } else if ((lead >> 5u) == 0x6u) {
+  } else if ((lead >> 5u) == 0x6u) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
     return 2;
-  } else if ((lead >> 4u) == 0xeu) {
+  } else if ((lead >> 4u) == 0xeu) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
     return 3;
-  } else if ((lead >> 3u) == 0x1eu) {
+  } else if ((lead >> 3u) == 0x1eu) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
     return 4;
   }
   return 0;

include/skyr/unicode/ranges/transforms/u8_transform.hpp

@@ -121,11 +121,11 @@ class u8_transform_iterator {
  private:
   constexpr void increment() {
     constexpr auto octet_count = [](char32_t code_point) {
-      if (code_point < 0x80u) {
+      if (code_point < 0x80u) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
         return 1;
-      } else if (code_point < 0x800u) {
+      } else if (code_point < 0x800u) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
         return 2;
-      } else if (code_point < 0x10000u) {
+      } else if (code_point < 0x10000u) {  // NOLINT(cppcoreguidelines-avoid-magic-numbers)
         return 3;
       } else {
         return 4;