clang-tidy:

Totto16 · Totto16 · commit cf604f865da6 · 2024-05-17T02:26:35.000+02:00
- fix more errors
diff --git a/.clang-tidy b/.clang-tidy
@@ -127,7 +127,7 @@ CheckOptions:
   - key: readability-identifier-naming.UnionCase
     value: "CamelCase"
   - key: readability-identifier-naming.ValueTemplateParameterCase
-    value: "lower_case"
+    value: "CamelCase"
   - key: readability-identifier-naming.VariableCase
     value: "lower_case"
   - key: readability-identifier-naming.VirtualMethodCase
diff --git a/src/helper/color_literals.hpp b/src/helper/color_literals.hpp
diff --git a/src/helper/const_utils.hpp b/src/helper/const_utils.hpp
@@ -28,13 +28,13 @@ s*/
     }())
 #endif
 
-#define CONSTEVAL_STATIC_ASSERT(CHECK, MSG)           \
-    do { /*NOLINT(cppcoreguidelines-avoid-do-while)*/ \
-        if (utils::is_constant_evaluated()) {         \
-            CONSTEVAL_ONLY_STATIC_ASSERT(CHECK, MSG); \
-        } else {                                      \
-            assert(CHECK&& MSG);                      \
-        }                                             \
+#define CONSTEVAL_STATIC_ASSERT(CHECK, MSG) /*NOLINT(cppcoreguidelines-macro-usage)*/    \
+    do {                                    /*NOLINT(cppcoreguidelines-avoid-do-while)*/ \
+        if (utils::is_constant_evaluated()) {                                            \
+            CONSTEVAL_ONLY_STATIC_ASSERT(CHECK, MSG);                                    \
+        } else {                                                                         \
+            assert((CHECK) && (MSG));                                                    \
+        }                                                                                \
     } while (false)
 
 
@@ -44,20 +44,20 @@ namespace const_utils {
 #define PROPAGATE(val, V, E) /*NOLINT(cppcoreguidelines-macro-usage)*/       \
     do {                     /*NOLINT(cppcoreguidelines-avoid-do-while)*/    \
         if (not((val).has_value())) {                                        \
-            return const_utils::expected<V, E>::error_result((val).error()); \
+            return const_utils::Expected<V, E>::error_result((val).error()); \
         }                                                                    \
     } while (false)
 
-    // represents a sort of constexpr std::expected
+    // represents a sort of constexpr std::Expected
     template<typename V, typename E>
         requires std::is_default_constructible_v<V> && std::is_default_constructible_v<E>
-    struct expected {
+    struct Expected {
     private:
         bool m_has_value;
         V m_value;
         E m_error;
 
-        constexpr expected(
+        constexpr Expected(
                 bool has_value,
                 const V& value,
                 const E& error
@@ -67,11 +67,11 @@ namespace const_utils {
               m_error{ error } { }
 
     public:
-        [[nodiscard]] constexpr static expected<V, E> good_result(const V& type) {
+        [[nodiscard]] constexpr static Expected<V, E> good_result(const V& type) {
             return { true, type, E{} };
         }
 
-        [[nodiscard]] constexpr static expected<V, E> error_result(const E& error) {
+        [[nodiscard]] constexpr static Expected<V, E> error_result(const E& error) {
             return { false, V{}, error };
         }
 
@@ -80,13 +80,13 @@ namespace const_utils {
         }
 
         [[nodiscard]] constexpr V value() const {
-            CONSTEVAL_STATIC_ASSERT((has_value()), "value() call on expected without value");
+            CONSTEVAL_STATIC_ASSERT((has_value()), "value() call on Expected without value");
 
             return m_value;
         }
 
         [[nodiscard]] constexpr E error() const {
-            CONSTEVAL_STATIC_ASSERT((not has_value()), "error() call on expected without error");
+            CONSTEVAL_STATIC_ASSERT((not has_value()), "error() call on Expected without error");
 
             return m_error;
         }
diff --git a/src/helper/nfd.cpp b/src/helper/nfd.cpp
@@ -73,7 +73,7 @@ helper::expected<std::filesystem::path, std::string> helper::openFileDialog(
 ) {
 
     NFD::UniquePathU8 out_path{};
-    auto filterItem = get_filter_items(allowed_files);
+    auto filter_item = get_filter_items(allowed_files);
 
     const auto path_deallocator = [](const nfdu8char_t* const char_value) {
         if (char_value == nullptr) {
@@ -93,7 +93,7 @@ helper::expected<std::filesystem::path, std::string> helper::openFileDialog(
     }
 
     const nfdresult_t result = NFD::OpenDialog(
-            out_path, filterItem.get(), static_cast<nfdfiltersize_t>(allowed_files.size()), default_path_value.get()
+            out_path, filter_item.get(), static_cast<nfdfiltersize_t>(allowed_files.size()), default_path_value.get()
     );
     if (result == NFD_OKAY) {
         return std::filesystem::path{ out_path.get() };
@@ -113,7 +113,7 @@ helper::expected<std::filesystem::path, std::string> helper::openFileDialog(
 ) {
 
     NFD::UniquePathSet out_paths{};
-    auto filterItem = get_filter_items(allowed_files);
+    auto filter_item = get_filter_items(allowed_files);
 
     const auto path_deallocator = [](const nfdu8char_t* const char_value) {
         if (char_value == nullptr) {
@@ -133,7 +133,7 @@ helper::expected<std::filesystem::path, std::string> helper::openFileDialog(
     }
 
     const nfdresult_t result = NFD::OpenDialogMultiple(
-            out_paths, filterItem.get(), static_cast<nfdfiltersize_t>(allowed_files.size()), default_path_value.get()
+            out_paths, filter_item.get(), static_cast<nfdfiltersize_t>(allowed_files.size()), default_path_value.get()
     );
     if (result == NFD_OKAY) {
         std::vector<std::filesystem::path> result_vector{};
diff --git a/src/helper/platform.cpp b/src/helper/platform.cpp
@@ -84,7 +84,7 @@ namespace {
 #error "Unsupported platform"
 #endif
 
-    const auto result = system(shell_command.c_str());
+    const auto result = system(shell_command.c_str()); //NOLINT(cert-env33-c)
     if (result < 0) {
         spdlog::error("Error in opening url: {}", get_error_from_errno());
         return false;
diff --git a/src/input/game_input.hpp b/src/input/game_input.hpp
@@ -27,7 +27,7 @@ namespace input {
 
     enum class GameInputType : u8 { Touch, Keyboard, Controller, Recording };
 
-    enum class MenuEvent : u8 { OPEN_SETTINGS, PAUSE };
+    enum class MenuEvent : u8 { OpenSettings, Pause };
 
 
     struct GameInput {
@@ -46,14 +46,23 @@ namespace input {
         std::unordered_map<HoldableKey, u64> m_keys_hold;
         GameInputType m_input_type;
 
-    protected:
+    private:
         Tetrion* m_target_tetrion{};
         OnEventCallback m_on_event_callback{};
 
+    protected:
         explicit GameInput(GameInputType input_type) : m_input_type{ input_type } { }
 
         void handle_event(InputEvent event, SimulationStep simulation_step_index);
 
+        [[nodiscard]] const Tetrion* target_tetrion() const {
+            return m_target_tetrion;
+        }
+
+        [[nodiscard]] const OnEventCallback& on_event_callback() const {
+            return m_on_event_callback;
+        }
+
     public:
         virtual void update(SimulationStep simulation_step_index);
         virtual void late_update(SimulationStep /*simulation_step*/){};
@@ -82,6 +91,9 @@ namespace input {
         GameInput(const GameInput&) = delete;
         GameInput& operator=(const GameInput&) = delete;
 
+        GameInput(GameInput&&) = default;
+        GameInput& operator=(GameInput&&) = default;
+
         virtual ~GameInput() = default;
     };
 } // namespace input
diff --git a/src/input/guid.hpp b/src/input/guid.hpp
@@ -53,24 +53,24 @@ struct fmt::formatter<sdl::GUID> : formatter<std::string> {
 namespace { //NOLINT(cert-dcl59-cpp,google-build-namespaces)
 
     // decode a single_hex_number
-    [[nodiscard]] constexpr const_utils::expected<u8, std::string> single_hex_number(char input) {
+    [[nodiscard]] constexpr const_utils::Expected<u8, std::string> single_hex_number(char input) {
         if (input >= '0' && input <= '9') {
-            return const_utils::expected<u8, std::string>::good_result(static_cast<u8>(input - '0'));
+            return const_utils::Expected<u8, std::string>::good_result(static_cast<u8>(input - '0'));
         }
 
         if (input >= 'A' && input <= 'F') {
-            return const_utils::expected<u8, std::string>::good_result(static_cast<u8>(input - 'A' + 10));
+            return const_utils::Expected<u8, std::string>::good_result(static_cast<u8>(input - 'A' + 10));
         }
 
         if (input >= 'a' && input <= 'f') {
-            return const_utils::expected<u8, std::string>::good_result(static_cast<u8>(input - 'a' + 10));
+            return const_utils::Expected<u8, std::string>::good_result(static_cast<u8>(input - 'a' + 10));
         }
 
-        return const_utils::expected<u8, std::string>::error_result("the input must be a valid hex character");
+        return const_utils::Expected<u8, std::string>::error_result("the input must be a valid hex character");
     }
 
     // decode a single 2 digit color value in hex
-    [[nodiscard]] constexpr const_utils::expected<u8, std::string> single_hex_color_value(const char* input) {
+    [[nodiscard]] constexpr const_utils::Expected<u8, std::string> single_hex_color_value(const char* input) {
 
         const auto first = single_hex_number(input[0]); //NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
 
@@ -80,14 +80,14 @@ namespace { //NOLINT(cert-dcl59-cpp,google-build-namespaces)
 
         PROPAGATE(second, u8, std::string);
 
-        return const_utils::expected<u8, std::string>::good_result((first.value() << 4) | second.value());
+        return const_utils::Expected<u8, std::string>::good_result((first.value() << 4) | second.value());
     }
 
-    [[nodiscard]] constexpr const_utils::expected<sdl::GUID, std::string>
+    [[nodiscard]] constexpr const_utils::Expected<sdl::GUID, std::string>
     get_guid_from_string_impl(const char* input, std::size_t size) {
 
         if (size == 0) {
-            return const_utils::expected<sdl::GUID, std::string>::error_result(
+            return const_utils::Expected<sdl::GUID, std::string>::error_result(
                     "not enough data to determine the literal type"
             );
         }
@@ -102,7 +102,7 @@ namespace { //NOLINT(cert-dcl59-cpp,google-build-namespaces)
             width = 3;
         } else {
 
-            return const_utils::expected<sdl::GUID, std::string>::error_result("Unrecognized guid literal");
+            return const_utils::Expected<sdl::GUID, std::string>::error_result("Unrecognized guid literal");
         }
 
 
@@ -122,15 +122,15 @@ namespace { //NOLINT(cert-dcl59-cpp,google-build-namespaces)
             result.at(i) = value;
         }
 
-        return const_utils::expected<sdl::GUID, std::string>::good_result(sdl::GUID{ result });
+        return const_utils::Expected<sdl::GUID, std::string>::good_result(sdl::GUID{ result });
     }
 
 } // namespace
 
 
 namespace detail {
 
-    [[nodiscard]] constexpr const_utils::expected<sdl::GUID, std::string> get_guid_from_string(const std::string& input
+    [[nodiscard]] constexpr const_utils::Expected<sdl::GUID, std::string> get_guid_from_string(const std::string& input
     ) {
         return get_guid_from_string_impl(input.c_str(), input.size());
     }
diff --git a/src/input/joystick_input.cpp b/src/input/joystick_input.cpp
@@ -813,10 +813,10 @@ helper::optional<InputEvent> input::ConsoleJoystickGameInput::sdl_event_to_input
         const auto button = event.jbutton.button;
 
         if (button == m_settings.pause) {
-            return MenuEvent::PAUSE;
+            return MenuEvent::Pause;
         }
         if (button == m_settings.open_settings) {
-            return MenuEvent::OPEN_SETTINGS;
+            return MenuEvent::OpenSettings;
         }
     }
 
@@ -826,9 +826,9 @@ helper::optional<InputEvent> input::ConsoleJoystickGameInput::sdl_event_to_input
 
 [[nodiscard]] std::string input::ConsoleJoystickGameInput::describe_menu_event(MenuEvent event) const {
     switch (event) {
-        case input::MenuEvent::PAUSE:
+        case input::MenuEvent::Pause:
             return m_underlying_joystick_input->key_to_string(m_settings.pause);
-        case input::MenuEvent::OPEN_SETTINGS:
+        case input::MenuEvent::OpenSettings:
             return m_underlying_joystick_input->key_to_string(m_settings.open_settings);
         default:
             utils::unreachable();
diff --git a/src/input/keyboard_input.cpp b/src/input/keyboard_input.cpp
@@ -191,10 +191,10 @@ SDL::Key json_helper::get_key(const nlohmann::json& j, const std::string& name)
     if (event.type == SDL_KEYDOWN and event.key.repeat == 0) {
         const auto key = SDL::Key{ event.key.keysym };
         if (key == m_settings.pause) {
-            return MenuEvent::PAUSE;
+            return MenuEvent::Pause;
         }
         if (key == m_settings.open_settings) {
-            return MenuEvent::OPEN_SETTINGS;
+            return MenuEvent::OpenSettings;
         }
     }
 
@@ -203,9 +203,9 @@ SDL::Key json_helper::get_key(const nlohmann::json& j, const std::string& name)
 
 [[nodiscard]] std::string input::KeyboardGameInput::describe_menu_event(MenuEvent event) const {
     switch (event) {
-        case input::MenuEvent::PAUSE:
+        case input::MenuEvent::Pause:
             return m_settings.pause.to_string();
-        case input::MenuEvent::OPEN_SETTINGS:
+        case input::MenuEvent::OpenSettings:
             return m_settings.open_settings.to_string();
         default:
             utils::unreachable();
diff --git a/src/input/replay_input.cpp b/src/input/replay_input.cpp
@@ -15,7 +15,7 @@ void input::ReplayGameInput::update(const SimulationStep simulation_step_index)
 
         const auto& record = m_recording_reader->at(m_next_record_index);
 
-        if (record.tetrion_index != m_target_tetrion->tetrion_index()) {
+        if (record.tetrion_index != target_tetrion()->tetrion_index()) {
             // the current record is not for this tetrion => discard record and keep reading
             ++m_next_record_index;
             continue;
@@ -46,20 +46,20 @@ void input::ReplayGameInput::late_update(const SimulationStep simulation_step_in
         }
 
         const auto& snapshot = m_recording_reader->snapshots().at(m_next_snapshot_index);
-        if (snapshot.tetrion_index() != m_target_tetrion->tetrion_index()) {
+        if (snapshot.tetrion_index() != target_tetrion()->tetrion_index()) {
             ++m_next_snapshot_index;
             continue;
         }
 
         // the snapshot corresponds to this tetrion
-        assert(snapshot.tetrion_index() == m_target_tetrion->tetrion_index());
+        assert(snapshot.tetrion_index() == target_tetrion()->tetrion_index());
 
         if (snapshot.simulation_step_index() != simulation_step_index) {
             break;
         }
 
         // create a snapshot from the current state of the tetrion and compare it to the loaded snapshot
-        const auto current_snapshot = TetrionSnapshot{ m_target_tetrion->core_information(), simulation_step_index };
+        const auto current_snapshot = TetrionSnapshot{ target_tetrion()->core_information(), simulation_step_index };
 
 
         spdlog::info("comparing tetrion snapshots at simulation_step {}", simulation_step_index);
diff --git a/src/input/touch_input.cpp b/src/input/touch_input.cpp
@@ -145,17 +145,17 @@ helper::optional<InputEvent> input::TouchGameInput::sdl_event_to_input_event(con
 [[nodiscard]] helper::optional<input::MenuEvent> input::TouchGameInput::get_menu_event(const SDL_Event& event) const {
 
     if (event.type == SDL_KEYDOWN and event.key.keysym.sym == SDLK_AC_BACK) {
-        return MenuEvent::PAUSE;
+        return MenuEvent::Pause;
     }
 
     return helper::nullopt;
 }
 
 [[nodiscard]] std::string input::TouchGameInput::describe_menu_event(MenuEvent event) const {
     switch (event) {
-        case input::MenuEvent::PAUSE:
+        case input::MenuEvent::Pause:
             return "Back";
-        case input::MenuEvent::OPEN_SETTINGS:
+        case input::MenuEvent::OpenSettings:
             throw std::runtime_error("Open Settings is not supported");
         default:
             utils::unreachable();
diff --git a/src/scenes/replay_game/replay_game.cpp b/src/scenes/replay_game/replay_game.cpp
@@ -120,7 +120,7 @@ namespace scenes {
         //TODO(Totto): re-add pause scene
         UNUSED(input_manager);
         UNUSED(event);
-        /*   if (utils::event_is_action(event, utils::CrossPlatformAction::PAUSE)) {
+        /*   if (utils::event_is_action(event, utils::CrossPlatformAction::Pause)) {
 
             for (auto& game : m_games) {
                 if (game->is_game_finished()) {
@@ -134,7 +134,7 @@ namespace scenes {
         }
 
 
-        if (utils::event_is_action(event, utils::CrossPlatformAction::OPEN_SETTINGS)) {
+        if (utils::event_is_action(event, utils::CrossPlatformAction::OpenSettings)) {
             m_next_scene = NextScene::Settings;
             return true;
         } */
diff --git a/src/scenes/settings_menu/settings_menu.cpp b/src/scenes/settings_menu/settings_menu.cpp
@@ -182,7 +182,7 @@ namespace scenes {
 
 
         if (m_game_input.has_value()
-            and m_game_input.value()->get_menu_event(event) == input::MenuEvent::OPEN_SETTINGS) {
+            and m_game_input.value()->get_menu_event(event) == input::MenuEvent::OpenSettings) {
             m_next_command = Command{ Return{} };
             return true;
         }
diff --git a/src/scenes/single_player_game/pause.cpp b/src/scenes/single_player_game/pause.cpp
@@ -12,7 +12,7 @@ namespace scenes {
         service_provider,
         fmt::format(
             "Pause ({}: continue, {}: quit)",
-            game_input->describe_menu_event(input::MenuEvent::PAUSE),
+            game_input->describe_menu_event(input::MenuEvent::Pause),
           service_provider->input_manager().get_primary_input()->describe_navigation_event(input::NavigationEvent::BACK)
         ),
         service_provider->font_manager().get(FontId::Default), 
@@ -49,7 +49,7 @@ namespace scenes {
         const auto navigation_event = input_manager->get_navigation_event(event);
 
 
-        if (m_game_input->get_menu_event(event) == input::MenuEvent::OPEN_SETTINGS) {
+        if (m_game_input->get_menu_event(event) == input::MenuEvent::OpenSettings) {
             m_should_unpause = true;
             return true;
         }
diff --git a/src/scenes/single_player_game/single_player_game.cpp b/src/scenes/single_player_game/single_player_game.cpp

Original file line number	Diff line number	Diff line change
`@@ -53,24 +53,24 @@ struct fmt::formatter<sdl::GUID> : formatter<std::string> {`
`53`	`53`	`namespace { //NOLINT(cert-dcl59-cpp,google-build-namespaces)`
`54`	`54`
`55`	`55`	`// decode a single_hex_number`
`56`		`- [[nodiscard]] constexpr const_utils::expected<u8, std::string> single_hex_number(char input) {`
	`56`	`+ [[nodiscard]] constexpr const_utils::Expected<u8, std::string> single_hex_number(char input) {`
`57`	`57`	`if (input >= '0' && input <= '9') {`
`58`		`- return const_utils::expected<u8, std::string>::good_result(static_cast<u8>(input - '0'));`
	`58`	`+ return const_utils::Expected<u8, std::string>::good_result(static_cast<u8>(input - '0'));`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`if (input >= 'A' && input <= 'F') {`
`62`		`- return const_utils::expected<u8, std::string>::good_result(static_cast<u8>(input - 'A' + 10));`
	`62`	`+ return const_utils::Expected<u8, std::string>::good_result(static_cast<u8>(input - 'A' + 10));`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`if (input >= 'a' && input <= 'f') {`
`66`		`- return const_utils::expected<u8, std::string>::good_result(static_cast<u8>(input - 'a' + 10));`
	`66`	`+ return const_utils::Expected<u8, std::string>::good_result(static_cast<u8>(input - 'a' + 10));`
`67`	`67`	`}`
`68`	`68`
`69`		`- return const_utils::expected<u8, std::string>::error_result("the input must be a valid hex character");`
	`69`	`+ return const_utils::Expected<u8, std::string>::error_result("the input must be a valid hex character");`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`// decode a single 2 digit color value in hex`
`73`		`- [[nodiscard]] constexpr const_utils::expected<u8, std::string> single_hex_color_value(const char* input) {`
	`73`	`+ [[nodiscard]] constexpr const_utils::Expected<u8, std::string> single_hex_color_value(const char* input) {`
`74`	`74`
`75`	`75`	`const auto first = single_hex_number(input[0]); //NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)`
`76`	`76`
`@@ -80,14 +80,14 @@ namespace { //NOLINT(cert-dcl59-cpp,google-build-namespaces)`
`80`	`80`
`81`	`81`	`PROPAGATE(second, u8, std::string);`
`82`	`82`
`83`		`- return const_utils::expected<u8, std::string>::good_result((first.value() << 4) \| second.value());`
	`83`	`+ return const_utils::Expected<u8, std::string>::good_result((first.value() << 4) \| second.value());`
`84`	`84`	`}`
`85`	`85`
`86`		`- [[nodiscard]] constexpr const_utils::expected<sdl::GUID, std::string>`
	`86`	`+ [[nodiscard]] constexpr const_utils::Expected<sdl::GUID, std::string>`
`87`	`87`	`get_guid_from_string_impl(const char* input, std::size_t size) {`
`88`	`88`
`89`	`89`	`if (size == 0) {`
`90`		`- return const_utils::expected<sdl::GUID, std::string>::error_result(`
	`90`	`+ return const_utils::Expected<sdl::GUID, std::string>::error_result(`
`91`	`91`	`"not enough data to determine the literal type"`
`92`	`92`	`);`
`93`	`93`	`}`
`@@ -102,7 +102,7 @@ namespace { //NOLINT(cert-dcl59-cpp,google-build-namespaces)`
`102`	`102`	`width = 3;`
`103`	`103`	`} else {`
`104`	`104`
`105`		`- return const_utils::expected<sdl::GUID, std::string>::error_result("Unrecognized guid literal");`
	`105`	`+ return const_utils::Expected<sdl::GUID, std::string>::error_result("Unrecognized guid literal");`
`106`	`106`	`}`
`107`	`107`
`108`	`108`
`@@ -122,15 +122,15 @@ namespace { //NOLINT(cert-dcl59-cpp,google-build-namespaces)`
`122`	`122`	`result.at(i) = value;`
`123`	`123`	`}`
`124`	`124`
`125`		`- return const_utils::expected<sdl::GUID, std::string>::good_result(sdl::GUID{ result });`
	`125`	`+ return const_utils::Expected<sdl::GUID, std::string>::good_result(sdl::GUID{ result });`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`} // namespace`
`129`	`129`
`130`	`130`
`131`	`131`	`namespace detail {`
`132`	`132`
`133`		`- [[nodiscard]] constexpr const_utils::expected<sdl::GUID, std::string> get_guid_from_string(const std::string& input`
	`133`	`+ [[nodiscard]] constexpr const_utils::Expected<sdl::GUID, std::string> get_guid_from_string(const std::string& input`
`134`	`134`	`) {`
`135`	`135`	`return get_guid_from_string_impl(input.c_str(), input.size());`
`136`	`136`	`}`