Do not unnecessarily cast format parameters

Types like strong enumerations and std::uint8_t are gracefully handled
by the formatter.

Author: trflynn89

fly/coders/huffman/huffman_decoder.cpp

@@ -46,9 +46,7 @@ bool HuffmanDecoder::decode_binary(BitStreamReader &encoded, std::ostream &decod
 
         if (!decode_codes(encoded, max_code_length))
         {
-            LOGW(
-                "Error decoding codes from stream (maximum code length = {})",
-                static_cast<std::uint32_t>(m_max_code_length));
+            LOGW("Error decoding codes from stream (maximum code length = {})", m_max_code_length);
             return false;
         }
         else if (!decode_symbols(encoded, max_code_length, chunk_size, decoded))
@@ -82,7 +80,7 @@ bool HuffmanDecoder::decode_header(BitStreamReader &encoded, std::uint32_t &chun
             return decode_header_version1(encoded, chunk_size);
 
         default:
-            LOGW("Decoded invalid Huffman version {}", static_cast<std::uint32_t>(huffman_version));
+            LOGW("Decoded invalid Huffman version {}", huffman_version);
             break;
     }
 
@@ -102,7 +100,7 @@ bool HuffmanDecoder::decode_header_version1(BitStreamReader &encoded, std::uint3
     }
     else if (encoded_chunk_size_kb == 0)
     {
-        LOGW("Decoded invalid chunk size {}", static_cast<std::uint32_t>(encoded_chunk_size_kb));
+        LOGW("Decoded invalid chunk size {}", encoded_chunk_size_kb);
         return false;
     }
 
@@ -118,9 +116,7 @@ bool HuffmanDecoder::decode_header_version1(BitStreamReader &encoded, std::uint3
         (encoded_max_code_length == 0) ||
         (encoded_max_code_length >= std::numeric_limits<code_type>::digits))
     {
-        LOGW(
-            "Decoded invalid maximum code length {}",
-            static_cast<std::uint32_t>(encoded_max_code_length));
+        LOGW("Decoded invalid maximum code length {}", encoded_max_code_length);
         return false;
     }
 
@@ -145,9 +141,7 @@ bool HuffmanDecoder::decode_codes(BitStreamReader &encoded, length_type &max_cod
     }
     else if ((counts_size == 0) || (counts_size > (m_max_code_length + 1)))
     {
-        LOGW(
-            "Decoded invalid number of code length counts {}",
-            static_cast<std::uint32_t>(counts_size));
+        LOGW("Decoded invalid number of code length counts {}", counts_size);
         return false;
     }
 
@@ -176,9 +170,7 @@ bool HuffmanDecoder::decode_codes(BitStreamReader &encoded, length_type &max_cod
 
             if (!encoded.read_byte(symbol))
             {
-                LOGW(
-                    "Could not decode symbol of length {} bits",
-                    static_cast<std::uint32_t>(length));
+                LOGW("Could not decode symbol of length {} bits", length);
                 return false;
             }
 

fly/coders/huffman/huffman_encoder.cpp

@@ -31,9 +31,7 @@ bool HuffmanEncoder::encode_binary(std::istream &decoded, BitStreamWriter &encod
 {
     if (m_max_code_length >= std::numeric_limits<code_type>::digits)
     {
-        LOGW(
-            "Maximum Huffman code length {} is too large for code_type",
-            static_cast<std::uint32_t>(m_max_code_length));
+        LOGW("Maximum Huffman code length {} is too large for code_type", m_max_code_length);
         return false;
     }
 

fly/config/config_manager.cpp

@@ -30,7 +30,7 @@ ConfigManager::ConfigManager(
             break;
 
         default:
-            LOGE("Unrecognized configuration type: {}", static_cast<int>(file_type));
+            LOGE("Unrecognized configuration type: {}", file_type);
             break;
     }
 }

fly/parser/json_parser.cpp

@@ -272,11 +272,7 @@ JsonParser::ParseState JsonParser::consume_token(Token token)
 
     if (const Token parsed = get<Token>(); parsed != token)
     {
-        JLOG(
-            "Unexpected character '{}', was expecting '{}'",
-            static_cast<char>(parsed),
-            static_cast<char>(token));
-
+        JLOG("Unexpected character '{:c}', was expecting '{:c}'", parsed, token);
         return ParseState::Invalid;
     }
 
@@ -409,7 +405,7 @@ JsonParser::ParseState JsonParser::consume_comment()
         }
 
         default:
-            JLOG("Invalid start sequence for comments: '/{}'", static_cast<char>(token));
+            JLOG("Invalid start sequence for comments: '/{:c}'", token);
             return ParseState::Invalid;
     }