fix: fix many clang tidy errors (7/x)

this is part 7 of 143 errors in the whole codebase, it is split into multiple commits, so that each patch is not to big

Author: Totto16

src/executables/game/application.cpp

@@ -183,7 +183,7 @@ void Application::update() {
             if (scene_change) {
 
                 std::visit(
-                        helper::overloaded{
+                        helper::Overloaded{
                                 [this, index](const scenes::Scene::Pop&) {
                                     m_scene_stack.erase(
                                             m_scene_stack.begin()

src/executables/utility/main.cpp

@@ -81,7 +81,7 @@ int main(int argc, char** argv) noexcept {
         const auto recording_reader = std::move(parsed.value());
 
         std::visit(
-                helper::overloaded{ [&recording_reader](const Dump& dump) {
+                helper::Overloaded{ [&recording_reader](const Dump& dump) {
                                        dump_json(recording_reader, dump.pretty_print, dump.ensure_ascii);
                                    },
                                     [&recording_reader](const Info& /* info */) { print_info(recording_reader); } },

src/input/input.cpp

@@ -211,7 +211,7 @@ namespace {
 
 
         auto result = std::visit(
-                helper::overloaded{
+                helper::Overloaded{
                         [service_provider](const input::KeyboardSettings& keyboard_settings) mutable -> ReturnType {
                             auto* const event_dispatcher = &(service_provider->event_dispatcher());
                             return std::make_shared<input::KeyboardGameInput>(keyboard_settings, event_dispatcher);

src/libs/core/helper/date.cpp

@@ -37,7 +37,7 @@ helper::expected<date::ISO8601Date, std::string> date::ISO8601Date::from_string(
 
 
     std::istringstream input_stream{ input };
-    input_stream >> std::get_time(&tm, ISO8601Date::iso_8601_format_string);
+    input_stream >> std::get_time(&time_struct, ISO8601Date::iso_8601_format_string);
 
     if (input_stream.fail()) {
         return helper::unexpected<std::string>{ "error calling std::get_time(): unable to convert input" };
@@ -69,7 +69,7 @@ helper::expected<date::ISO8601Date, std::string> date::ISO8601Date::from_string(
 
     std::tm time_struct{};
 #if defined(_MSC_VER) || defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
-    if (gmtime_s(&tm, &value) != 0) {
+    if (gmtime_s(&time_struct, &value) != 0) {
         return helper::unexpected<std::string>{ "error calling gmtime_s" };
     }
 #else

src/libs/core/helper/static_string.hpp

@@ -9,21 +9,21 @@
 #include <string>
 #include <string_view>
 
-template<usize data_size>
+template<usize DataSize>
 struct StaticString {
 private:
-    std::array<char, data_size> m_data;
+    std::array<char, DataSize> m_data;
 
     constexpr StaticString() : m_data{} { }
 
 public:
     constexpr StaticString(const char (&chars // NOLINT(modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
-    )[data_size]) {
-        std::copy(chars, chars + data_size, begin());
+    )[DataSize]) {
+        std::copy(chars, chars + DataSize, begin());
     }
 
     [[nodiscard]] constexpr usize size() const {
-        return data_size - 1;
+        return DataSize - 1;
     }
 
     [[nodiscard]] constexpr usize length() const {
@@ -80,8 +80,8 @@ struct StaticString {
         return m_data.back();
     }
 
-    template<usize other_data_size, typename Result = StaticString<data_size + other_data_size - 1>>
-    [[nodiscard]] constexpr Result operator+(const StaticString<other_data_size>& other) const {
+    template<usize OtherDataSize, typename Result = StaticString<DataSize + OtherDataSize - 1>>
+    [[nodiscard]] constexpr Result operator+(const StaticString<OtherDataSize>& other) const {
         auto concatenated = Result{};
         std::ranges::copy(*this, concatenated.begin());
         std::ranges::copy(other, concatenated.begin() + size());
@@ -101,46 +101,46 @@ struct StaticString {
         return std::string_view{ cbegin(), cend() };
     }
 
-    template<usize other_data_size>
+    template<usize OtherDataSize>
     [[nodiscard]] friend constexpr bool
-    operator==(const StaticString<data_size>& self, const StaticString<other_data_size>& other) {
+    operator==(const StaticString<DataSize>& self, const StaticString<OtherDataSize>& other) {
         return self.m_data == other.m_data;
     }
 
-    template<usize other_data_size>
+    template<usize OtherDataSize>
     [[nodiscard]] friend constexpr bool
-    operator!=(const StaticString<data_size>& self, const StaticString<other_data_size>& other) {
+    operator!=(const StaticString<DataSize>& self, const StaticString<OtherDataSize>& other) {
         return not(self == other);
     }
 
-    template<usize first_data_size, usize... other_data_sizes>
+    template<usize FirstDataSize, usize... OtherDataSizes>
     [[nodiscard]] constexpr auto
-    join(const StaticString<first_data_size>& first, const StaticString<other_data_sizes>&... rest) const {
+    join(const StaticString<FirstDataSize>& first, const StaticString<OtherDataSizes>&... rest) const {
         if constexpr (sizeof...(rest) == 0) {
             return first;
         } else {
             return first + *this + join(rest...);
         }
     }
 
-    [[nodiscard]] constexpr operator const char*() const {
+    [[nodiscard]] constexpr operator const char*() const { //NOLINT(google-explicit-constructor)
         return c_str();
     }
 
-    [[nodiscard]] constexpr operator std::string_view() const {
+    [[nodiscard]] constexpr operator std::string_view() const { //NOLINT(google-explicit-constructor)
         return string_view();
     }
 
-    [[nodiscard]] operator std::string() const {
+    [[nodiscard]] operator std::string() const { //NOLINT(google-explicit-constructor)
         return string();
     }
 
-    [[nodiscard]] operator std::filesystem::path() const {
+    [[nodiscard]] operator std::filesystem::path() const { //NOLINT(google-explicit-constructor)
         return string();
     }
 
     // make all template instantiations of this template a friend
-    template<usize other_data_size>
+    template<usize OtherDataSize>
     friend struct StaticString;
 };
 

src/libs/core/helper/utils.hpp

@@ -18,11 +18,11 @@
 namespace helper {
 
     template<class... Ts>
-    struct overloaded : Ts... {
+    struct Overloaded : Ts... {
         using Ts::operator()...;
     };
     template<class... Ts>
-    overloaded(Ts...) -> overloaded<Ts...>;
+    Overloaded(Ts...) -> Overloaded<Ts...>;
 } // namespace helper
 
 
@@ -53,8 +53,8 @@ namespace utils {
     }
 
     template<class Enum>
-    [[nodiscard]] constexpr std::underlying_type_t<Enum> to_underlying(Enum enum_) noexcept {
-        return static_cast<std::underlying_type_t<Enum>>(enum_);
+    [[nodiscard]] constexpr std::underlying_type_t<Enum> to_underlying(Enum enum_value) noexcept {
+        return static_cast<std::underlying_type_t<Enum>>(enum_value);
     }
 
 #if __cpp_lib_unreachable >= 202202L

src/libs/recordings/utility/additional_information.cpp

@@ -9,7 +9,7 @@
 [[nodiscard]] std::string recorder::InformationValue::to_string(u32 recursion_depth // NOLINT(misc-no-recursion)
 ) const {
     return std::visit(
-            helper::overloaded{
+            helper::Overloaded{
                     [](const std::string& value) { return value; },
                     [](const float& value) { return std::to_string(value); },
                     [](const double& value) { return std::to_string(value); },

src/libs/recordings/utility/additional_information.hpp

@@ -81,7 +81,7 @@ namespace recorder {
 
         [[nodiscard]] bool operator==(const InformationValue& other) const { // NOLINT(misc-no-recursion)
             return std::visit(
-                    helper::overloaded{
+                    helper::Overloaded{
                             [this](const std::string& value) { return *this == value; },
                             [this](const float& value) { return *this == value; },
                             [this](const double& value) { return *this == value; },

src/libs/recordings/utility/recording_json_wrapper.hpp

@@ -21,7 +21,7 @@ namespace nlohmann {
 
         static void to_json(json& obj, const recorder::InformationValue& information) { // NOLINT(misc-no-recursion)
             std::visit(
-                    helper::overloaded{
+                    helper::Overloaded{
                             [&obj](const std::string& value) { obj = value; },
                             [&obj](const float& value) { obj = value; }, [&obj](const double& value) { obj = value; },
                             [&obj](const bool& value) { obj = value; }, [&obj](const u8& value) { obj = value; },

src/scenes/recording_selector/recording_selector.cpp

@@ -79,7 +79,7 @@ namespace scenes {
 
         if (m_next_command.has_value()) {
             return std::visit(
-                    helper::overloaded{
+                    helper::Overloaded{
                             [](const Return&) { return UpdateResult{ SceneUpdate::StopUpdating, Scene::Pop{} }; },
                             [this](const Action& action) {
                                 if (auto recording_component =