clang-tidy:

- fix more errors

Author: Totto16

src/helper/errors.cpp

@@ -14,7 +14,6 @@ helper::GeneralError::GeneralError(const GeneralError& error) noexcept = default
 [[nodiscard]] helper::GeneralError& helper::GeneralError::operator=(const GeneralError& error) noexcept = default;
 
 helper::GeneralError::GeneralError(GeneralError&& error) noexcept = default;
-
 [[nodiscard]] helper::GeneralError& helper::GeneralError::operator=(GeneralError&& error) noexcept = default;
 
 

src/helper/parse_json.cpp

@@ -34,21 +34,21 @@ std::string json::get_json_type(const nlohmann::json::value_t& type) {
     }
 }
 
-void json::check_for_no_additional_keys(const nlohmann::json& j, const std::vector<std::string>& keys) {
+void json::check_for_no_additional_keys(const nlohmann::json& obj, const std::vector<std::string>& keys) {
 
-    if (not j.is_object()) {
+    if (not obj.is_object()) {
         throw nlohmann::json::type_error::create(
-                302, fmt::format("expected an object, but got type '{}'", get_json_type(j.type())), &j
+                302, fmt::format("expected an object, but got type '{}'", get_json_type(obj.type())), &obj
         );
     }
 
-    const auto& object = j.get<nlohmann::json::object_t>();
+    const auto& object = obj.get<nlohmann::json::object_t>();
 
 
     for (const auto& [key, _] : object) {
         if (std::ranges::find(keys, key) == keys.cend()) {
             throw nlohmann::json::type_error::create(
-                    302, fmt::format("object may only contain expected keys, but contained '{}'", key), &j
+                    302, fmt::format("object may only contain expected keys, but contained '{}'", key), &obj
             );
         }
     }

src/helper/parse_json.hpp

@@ -23,21 +23,21 @@
 NLOHMANN_JSON_NAMESPACE_BEGIN
 template<typename T>
 struct adl_serializer<helper::optional<T>> {
-    static void to_json(json& j, const helper::optional<T>& opt) {
+    static void to_json(json& obj, const helper::optional<T>& opt) {
         if (not opt) {
-            j = nullptr;
+            obj = nullptr;
         } else {
-            j = *opt; // this will call adl_serializer<T>::to_json which will
-                      // find the free function to_json in T's namespace!
+            obj = *opt; // this will call adl_serializer<T>::to_json which will
+                        // find the free function to_json in T's namespace!
         }
     }
 
-    static void from_json(const json& j, helper::optional<T>& opt) {
-        if (j.is_null()) {
+    static void from_json(const json& obj, helper::optional<T>& opt) {
+        if (obj.is_null()) {
             opt = helper::nullopt;
         } else {
-            opt = j.template get<T>(); // same as above, but with
-                                       // adl_serializer<T>::from_json
+            opt = obj.template get<T>(); // same as above, but with
+                                         // adl_serializer<T>::from_json
         }
     }
 };
@@ -111,7 +111,7 @@ namespace json {
 
     std::string get_json_type(const nlohmann::json::value_t& type);
 
-    void check_for_no_additional_keys(const nlohmann::json& j, const std::vector<std::string>& keys);
+    void check_for_no_additional_keys(const nlohmann::json& obj, const std::vector<std::string>& keys);
 
 
 } // namespace json

src/input/game_input.hpp

@@ -45,10 +45,8 @@ namespace input {
 
         std::unordered_map<HoldableKey, u64> m_keys_hold;
         GameInputType m_input_type;
-
-    private:
         Tetrion* m_target_tetrion{};
-        OnEventCallback m_on_event_callback{};
+        OnEventCallback m_on_event_callback;
 
     protected:
         explicit GameInput(GameInputType input_type) : m_input_type{ input_type } { }

src/input/guid.hpp

@@ -109,7 +109,7 @@ namespace { //NOLINT(cert-dcl59-cpp,google-build-namespaces)
         sdl::GUID::ArrayType result{};
 
         for (size_t i = 0; i < amount; ++i) {
-            size_t offset = i * (width);
+            const size_t offset = i * width;
 
 
             const auto temp_result =

src/input/input.cpp

@@ -20,6 +20,12 @@ input::Input::Input(std::string name, InputType type) : m_name{ std::move(name)
 
 input::Input::~Input() = default;
 
+input::Input::Input(const Input& input) noexcept = default;
+[[nodiscard]] input::Input& input::Input::operator=(const Input& input) noexcept = default;
+
+input::Input::Input(Input&& input) noexcept = default;
+[[nodiscard]] input::Input& input::Input::operator=(Input&& input) noexcept = default;
+
 input::PointerEventHelper::PointerEventHelper(shapes::IPoint pos, PointerEvent event)
     : m_pos{ pos },
       m_event{ event } { }
@@ -306,7 +312,8 @@ namespace {
 } // namespace
 
 
-[[nodiscard]] helper::optional<std::shared_ptr<input::GameInput>> input::InputManager::get_game_input(
+[[nodiscard]] helper::optional<std::shared_ptr<input::GameInput>>
+input::InputManager::get_game_input( //NOLINT(readability-convert-member-functions-to-static)
         ServiceProvider* service_provider
 ) {
 

src/input/input.hpp

@@ -33,8 +33,15 @@ namespace input {
 
     public:
         Input(std::string name, InputType type);
+
         virtual ~Input();
 
+        Input(const Input& input) noexcept;
+        Input& operator=(const Input& input) noexcept;
+
+        Input(Input&& input) noexcept;
+        Input& operator=(Input&& input) noexcept;
+
         [[nodiscard]] const std::string& name() const;
         [[nodiscard]] InputType type();
 
@@ -76,7 +83,7 @@ namespace input {
 
     struct InputManager {
     private:
-        std::vector<std::unique_ptr<Input>> m_inputs{};
+        std::vector<std::unique_ptr<Input>> m_inputs;
 
     public:
         explicit InputManager(const std::shared_ptr<Window>& window);

src/input/joystick_input.cpp

@@ -22,6 +22,12 @@ input::JoystickInput::~JoystickInput() {
 }
 
 
+input::JoystickInput::JoystickInput(const JoystickInput& input) noexcept = default;
+input::JoystickInput& input::JoystickInput::operator=(const JoystickInput& input) noexcept = default;
+
+input::JoystickInput::JoystickInput(JoystickInput&& input) noexcept = default;
+input::JoystickInput& input::JoystickInput::operator=(JoystickInput&& input) noexcept = default;
+
 [[nodiscard]] helper::optional<std::unique_ptr<input::JoystickInput>> input::JoystickInput::get_joystick_by_guid(
         const sdl::GUID& guid,
         SDL_Joystick* joystick,
@@ -558,6 +564,22 @@ input::_3DSJoystickInput_Type1::default_settings_raw() const {
 #endif
 #endif
 
+input::JoystickGameInput::JoystickGameInput(EventDispatcher* event_dispatcher, JoystickInput* underlying_input)
+    : GameInput{ GameInputType::Controller },
+      m_event_dispatcher{ event_dispatcher },
+      m_underlying_input{ underlying_input } {
+    m_event_dispatcher->register_listener(this);
+}
+
+
+input::JoystickGameInput::~JoystickGameInput() {
+    m_event_dispatcher->unregister_listener(this);
+}
+
+input::JoystickGameInput::JoystickGameInput(JoystickGameInput&& input) noexcept = default;
+[[nodiscard]] input::JoystickGameInput& input::JoystickGameInput::operator=(JoystickGameInput&& input
+) noexcept = default;
+
 void input::JoystickGameInput::handle_event(const SDL_Event& event) {
     m_event_buffer.push_back(event);
 }

src/input/joystick_input.hpp

@@ -61,8 +61,7 @@ namespace input {
  * @note regarding the NOLINT: the destructor just cleans up the SDL_Joystick, it has nothing to do with class members that would need special member functions to be explicitly defined
  * 
  */
-    struct JoystickInput //NOLINT(cppcoreguidelines-special-member-functions)
-        : Input {
+    struct JoystickInput : Input {
     private:
         SDL_Joystick* m_joystick;
         SDL_JoystickID m_instance_id;
@@ -76,7 +75,14 @@ namespace input {
 
     public:
         JoystickInput(SDL_Joystick* joystick, SDL_JoystickID instance_id, const std::string& name);
-        ~JoystickInput();
+
+        ~JoystickInput() override;
+
+        JoystickInput(const JoystickInput& input) noexcept;
+        JoystickInput& operator=(const JoystickInput& input) noexcept;
+
+        JoystickInput(JoystickInput&& input) noexcept;
+        JoystickInput& operator=(JoystickInput&& input) noexcept;
 
         [[nodiscard]] static helper::expected<std::unique_ptr<JoystickInput>, std::string> get_by_device_index(
                 int device_index
@@ -204,21 +210,21 @@ namespace input {
     X_LIST_MACRO(open_settings)
 
 
-#define TRY_CONVERT(original, target, map, key)                                                               \
-    do /*NOLINT(cppcoreguidelines-avoid-do-while)*/ {                                                         \
-        if (map.contains(original.key)) {                                                                     \
-            target.key = map.at(original.key);                                                                \
-        } else {                                                                                              \
-            return helper::unexpected<std::string>{                                                           \
-                fmt::format("While parsing key '{}': '{}' is not a valid joystick input", #key, original.key) \
-            };                                                                                                \
-        }                                                                                                     \
+#define TRY_CONVERT(original, target, map, key) /*NOLINT(cppcoreguidelines-macro-usage)*/                       \
+    do /*NOLINT(cppcoreguidelines-avoid-do-while)*/ {                                                           \
+        if ((map).contains((original).key)) {                                                                   \
+            (target).key = (map).at((original).key);                                                            \
+        } else {                                                                                                \
+            return helper::unexpected<std::string>{                                                             \
+                fmt::format("While parsing key '{}': '{}' is not a valid joystick input", #key, (original).key) \
+            };                                                                                                  \
+        }                                                                                                       \
     } while (false)
 
 
-#define SETTINGS_TO_STRING(original, target, fn, key) \
-    do /*NOLINT(cppcoreguidelines-avoid-do-while)*/ { \
-        target.key = fn(original.key);                \
+#define SETTINGS_TO_STRING(original, target, fn, key) /*NOLINT(cppcoreguidelines-macro-usage)*/ \
+    do /*NOLINT(cppcoreguidelines-avoid-do-while)*/ {                                           \
+        (target).key = fn((original).key);                                                      \
     } while (false)
 
 
@@ -227,20 +233,23 @@ namespace input {
         std::vector<SDL_Event> m_event_buffer;
         EventDispatcher* m_event_dispatcher;
 
-    protected:
+
         JoystickInput* m_underlying_input;
 
+    protected:
+        [[nodiscard]] const JoystickInput* underlying_input() const;
+
+
     public:
-        JoystickGameInput(EventDispatcher* event_dispatcher, JoystickInput* underlying_input)
-            : GameInput{ GameInputType::Controller },
-              m_event_dispatcher{ event_dispatcher },
-              m_underlying_input{ underlying_input } {
-            m_event_dispatcher->register_listener(this);
-        }
+        JoystickGameInput(EventDispatcher* event_dispatcher, JoystickInput* underlying_input);
 
-        ~JoystickGameInput() override {
-            m_event_dispatcher->unregister_listener(this);
-        }
+        ~JoystickGameInput() override;
+
+        JoystickGameInput(const JoystickGameInput& input) = delete;
+        [[nodiscard]] JoystickGameInput& operator=(const JoystickGameInput& input) = delete;
+
+        JoystickGameInput(JoystickGameInput&& input) noexcept;
+        [[nodiscard]] JoystickGameInput& operator=(JoystickGameInput&& input) noexcept;
 
         void handle_event(const SDL_Event& event) override;
 
@@ -264,7 +273,7 @@ namespace input {
             AbstractJoystickSettings<T> result{};
 
 
-#define X_LIST_MACRO(x) TRY_CONVERT(settings, result, map, x);
+#define X_LIST_MACRO(x) TRY_CONVERT(settings, result, map, x); //NOLINT(cppcoreguidelines-macro-usage)
 
             X_LIST_OF_SETTINGS_KEYS
 
@@ -343,8 +352,8 @@ namespace nlohmann {
             return input::JoystickIdentification{ .guid = value.value(), .name = name };
         }
 
-        static void to_json(json& j, const input::JoystickIdentification& identification) {
-            j = nlohmann::json{
+        static void to_json(json& obj, const input::JoystickIdentification& identification) {
+            obj = nlohmann::json{
                 { "guid", identification.guid.to_string(), { "name", identification.name } },
             };
         }
@@ -359,7 +368,7 @@ namespace nlohmann {
                            "move_down", "drop", "hold", "menu" }
             );
 
-            input::JoystickIdentification identification =
+            const input::JoystickIdentification identification =
                     adl_serializer<input::JoystickIdentification>::from_json(obj.at("identification"));
 
             const auto rotate_left = json_helper::get_key_from_object(obj, "rotate_left");

src/input/keyboard_input.cpp

@@ -158,6 +158,11 @@ input::KeyboardGameInput::~KeyboardGameInput() {
 }
 
 
+input::KeyboardGameInput::KeyboardGameInput(KeyboardGameInput&& input) noexcept = default;
+[[nodiscard]] input::KeyboardGameInput& input::KeyboardGameInput::operator=(KeyboardGameInput&& input
+) noexcept = default;
+
+
 [[nodiscard]] helper::expected<bool, std::string> input::KeyboardSettings::validate() const {
 
     const std::vector<sdl::Key> to_use{ rotate_left, rotate_right, move_left, move_right,   move_down,
@@ -166,9 +171,9 @@ input::KeyboardGameInput::~KeyboardGameInput() {
     return input::InputSettings::has_unique_members(to_use);
 }
 
-sdl::Key json_helper::get_key(const nlohmann::json& j, const std::string& name) {
+sdl::Key json_helper::get_key(const nlohmann::json& obj, const std::string& name) {
 
-    auto context = j.at(name);
+    auto context = obj.at(name);
 
     std::string input;
     context.get_to(input);