input_mapping: Amend specification of parameters

param tags are supposed to specify the parameter name without any
quoting.

Silences several -Wdocumentation warnings.

src/common/input.h

@@ -266,11 +266,9 @@ class OutputDevice {
 public:
     virtual ~OutputDevice() = default;
 
-    virtual void SetLED([[maybe_unused]] LedStatus led_status) {
-        return;
-    }
+    virtual void SetLED([[maybe_unused]] const LedStatus& led_status) {}
 
-    virtual VibrationError SetVibration([[maybe_unused]] VibrationStatus vibration_status) {
+    virtual VibrationError SetVibration([[maybe_unused]] const VibrationStatus& vibration_status) {
         return VibrationError::NotSupported;
     }
 

src/input_common/drivers/gc_adapter.cpp

@@ -69,7 +69,7 @@ private:
     libusb_device_handle* handle{};
 };
 
-GCAdapter::GCAdapter(const std::string& input_engine_) : InputEngine(input_engine_) {
+GCAdapter::GCAdapter(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
     if (usb_adapter_handle) {
         return;
     }
@@ -325,8 +325,8 @@ bool GCAdapter::GetGCEndpoint(libusb_device* device) {
     return true;
 }
 
-Common::Input::VibrationError GCAdapter::SetRumble(const PadIdentifier& identifier,
-                                                   const Common::Input::VibrationStatus vibration) {
+Common::Input::VibrationError GCAdapter::SetRumble(
+    const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) {
     const auto mean_amplitude = (vibration.low_amplitude + vibration.high_amplitude) * 0.5f;
     const auto processed_amplitude =
         static_cast<u8>((mean_amplitude + std::pow(mean_amplitude, 0.3f)) * 0.5f * 0x8);

src/input_common/drivers/gc_adapter.h

@@ -22,13 +22,13 @@ namespace InputCommon {
 class LibUSBContext;
 class LibUSBDeviceHandle;
 
-class GCAdapter : public InputCommon::InputEngine {
+class GCAdapter : public InputEngine {
 public:
-    explicit GCAdapter(const std::string& input_engine_);
-    ~GCAdapter();
+    explicit GCAdapter(std::string input_engine_);
+    ~GCAdapter() override;
 
     Common::Input::VibrationError SetRumble(
-        const PadIdentifier& identifier, const Common::Input::VibrationStatus vibration) override;
+        const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) override;
 
     /// Used for automapping features
     std::vector<Common::ParamPackage> GetInputDevices() const override;

src/input_common/drivers/keyboard.cpp

@@ -24,7 +24,7 @@ constexpr PadIdentifier keyboard_modifier_identifier = {
     .pad = 1,
 };
 
-Keyboard::Keyboard(const std::string& input_engine_) : InputEngine(input_engine_) {
+Keyboard::Keyboard(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
     // Keyboard is broken into 3 diferent sets:
     // key: Unfiltered intended for controllers.
     // keyboard_key: Allows only Settings::NativeKeyboard::Keys intended for keyboard emulation.

src/input_common/drivers/keyboard.h

@@ -12,9 +12,9 @@ namespace InputCommon {
  * A button device factory representing a keyboard. It receives keyboard events and forward them
  * to all button devices it created.
  */
-class Keyboard final : public InputCommon::InputEngine {
+class Keyboard final : public InputEngine {
 public:
-    explicit Keyboard(const std::string& input_engine_);
+    explicit Keyboard(std::string input_engine_);
 
     /**
      * Sets the status of all buttons bound with the key to pressed

src/input_common/drivers/mouse.cpp

@@ -24,7 +24,7 @@ constexpr PadIdentifier identifier = {
     .pad = 0,
 };
 
-Mouse::Mouse(const std::string& input_engine_) : InputEngine(input_engine_) {
+Mouse::Mouse(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
     PreSetController(identifier);
     PreSetAxis(identifier, mouse_axis_x);
     PreSetAxis(identifier, mouse_axis_y);

src/input_common/drivers/mouse.h

@@ -27,9 +27,9 @@ enum class MouseButton {
  * A button device factory representing a keyboard. It receives keyboard events and forward them
  * to all button devices it created.
  */
-class Mouse final : public InputCommon::InputEngine {
+class Mouse final : public InputEngine {
 public:
-    explicit Mouse(const std::string& input_engine_);
+    explicit Mouse(std::string input_engine_);
 
     /**
      * Signals that mouse has moved.

src/input_common/drivers/sdl_driver.cpp

@@ -88,7 +88,7 @@ public:
         return true;
     }
 
-    BasicMotion GetMotion() {
+    const BasicMotion& GetMotion() const {
         return motion;
     }
 
@@ -367,7 +367,7 @@ void SDLDriver::HandleGameControllerEvent(const SDL_Event& event) {
             if (joystick->UpdateMotion(event.csensor)) {
                 const PadIdentifier identifier = joystick->GetPadIdentifier();
                 SetMotion(identifier, 0, joystick->GetMotion());
-            };
+            }
         }
         break;
     }
@@ -387,7 +387,7 @@ void SDLDriver::CloseJoysticks() {
     joystick_map.clear();
 }
 
-SDLDriver::SDLDriver(const std::string& input_engine_) : InputEngine(input_engine_) {
+SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
     if (!Settings::values.enable_raw_input) {
         // Disable raw input. When enabled this setting causes SDL to die when a web applet opens
         SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT, "0");
@@ -491,8 +491,9 @@ std::vector<Common::ParamPackage> SDLDriver::GetInputDevices() const {
     }
     return devices;
 }
-Common::Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifier,
-                                                   const Common::Input::VibrationStatus vibration) {
+
+Common::Input::VibrationError SDLDriver::SetRumble(
+    const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) {
     const auto joystick =
         GetSDLJoystickByGUID(identifier.guid.Format(), static_cast<int>(identifier.port));
     const auto process_amplitude_exp = [](f32 amplitude, f32 factor) {
@@ -526,6 +527,7 @@ Common::Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifi
 
     return Common::Input::VibrationError::None;
 }
+
 Common::ParamPackage SDLDriver::BuildAnalogParamPackageForButton(int port, std::string guid,
                                                                  s32 axis, float value) const {
     Common::ParamPackage params{};

src/input_common/drivers/sdl_driver.h

@@ -19,19 +19,19 @@ using SDL_GameController = struct _SDL_GameController;
 using SDL_Joystick = struct _SDL_Joystick;
 using SDL_JoystickID = s32;
 
+namespace InputCommon {
+
+class SDLJoystick;
+
 using ButtonBindings =
     std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerButton>, 17>;
 using ZButtonBindings =
     std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerAxis>, 2>;
 
-namespace InputCommon {
-
-class SDLJoystick;
-
-class SDLDriver : public InputCommon::InputEngine {
+class SDLDriver : public InputEngine {
 public:
     /// Initializes and registers SDL device factories
-    SDLDriver(const std::string& input_engine_);
+    explicit SDLDriver(std::string input_engine_);
 
     /// Unregisters SDL device factories and shut them down.
     ~SDLDriver() override;
@@ -59,7 +59,7 @@ public:
     u8 GetHatButtonId(const std::string& direction_name) const override;
 
     Common::Input::VibrationError SetRumble(
-        const PadIdentifier& identifier, const Common::Input::VibrationStatus vibration) override;
+        const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) override;
 
 private:
     void InitJoystick(int joystick_index);

src/input_common/drivers/tas_input.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include <cstring>
-#include <regex>
 #include <fmt/format.h>
 
 #include "common/fs/file.h"
@@ -15,7 +14,7 @@
 
 namespace InputCommon::TasInput {
 
-enum TasAxes : u8 {
+enum class Tas::TasAxis : u8 {
     StickX,
     StickY,
     SubstickX,
@@ -47,7 +46,7 @@ constexpr std::array<std::pair<std::string_view, TasButton>, 20> text_to_tas_but
     {"KEY_ZR", TasButton::TRIGGER_ZR},
 };
 
-Tas::Tas(const std::string& input_engine_) : InputCommon::InputEngine(input_engine_) {
+Tas::Tas(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
     for (size_t player_index = 0; player_index < PLAYER_NUMBER; player_index++) {
         PadIdentifier identifier{
             .guid = Common::UUID{},
@@ -66,7 +65,7 @@ Tas::Tas(const std::string& input_engine_) : InputCommon::InputEngine(input_engi
 
 Tas::~Tas() {
     Stop();
-};
+}
 
 void Tas::LoadTasFiles() {
     script_length = 0;
@@ -79,43 +78,43 @@ void Tas::LoadTasFiles() {
 }
 
 void Tas::LoadTasFile(size_t player_index, size_t file_index) {
-    if (!commands[player_index].empty()) {
-        commands[player_index].clear();
-    }
+    commands[player_index].clear();
+
     std::string file = Common::FS::ReadStringFromFile(
         Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) /
             fmt::format("script{}-{}.txt", file_index, player_index + 1),
         Common::FS::FileType::BinaryFile);
-    std::stringstream command_line(file);
+    std::istringstream command_line(file);
     std::string line;
     int frame_no = 0;
     while (std::getline(command_line, line, '\n')) {
         if (line.empty()) {
             continue;
         }
-        std::smatch m;
 
-        std::stringstream linestream(line);
-        std::string segment;
-        std::vector<std::string> seglist;
-
-        while (std::getline(linestream, segment, ' ')) {
-            seglist.push_back(segment);
+        std::vector<std::string> seg_list;
+        {
+            std::istringstream line_stream(line);
+            std::string segment;
+            while (std::getline(line_stream, segment, ' ')) {
+                seg_list.push_back(std::move(segment));
+            }
         }
 
-        if (seglist.size() < 4) {
+        if (seg_list.size() < 4) {
             continue;
         }
 
-        while (frame_no < std::stoi(seglist.at(0))) {
-            commands[player_index].push_back({});
+        const auto num_frames = std::stoi(seg_list[0]);
+        while (frame_no < num_frames) {
+            commands[player_index].emplace_back();
             frame_no++;
         }
 
         TASCommand command = {
-            .buttons = ReadCommandButtons(seglist.at(1)),
-            .l_axis = ReadCommandAxis(seglist.at(2)),
-            .r_axis = ReadCommandAxis(seglist.at(3)),
+            .buttons = ReadCommandButtons(seg_list[1]),
+            .l_axis = ReadCommandAxis(seg_list[2]),
+            .r_axis = ReadCommandAxis(seg_list[3]),
         };
         commands[player_index].push_back(command);
         frame_no++;
@@ -123,16 +122,17 @@ void Tas::LoadTasFile(size_t player_index, size_t file_index) {
     LOG_INFO(Input, "TAS file loaded! {} frames", frame_no);
 }
 
-void Tas::WriteTasFile(std::u8string file_name) {
+void Tas::WriteTasFile(std::u8string_view file_name) {
     std::string output_text;
     for (size_t frame = 0; frame < record_commands.size(); frame++) {
         const TASCommand& line = record_commands[frame];
         output_text += fmt::format("{} {} {} {}\n", frame, WriteCommandButtons(line.buttons),
                                    WriteCommandAxis(line.l_axis), WriteCommandAxis(line.r_axis));
     }
-    const auto bytes_written = Common::FS::WriteStringToFile(
-        Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) / file_name,
-        Common::FS::FileType::TextFile, output_text);
+
+    const auto tas_file_name = Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) / file_name;
+    const auto bytes_written =
+        Common::FS::WriteStringToFile(tas_file_name, Common::FS::FileType::TextFile, output_text);
     if (bytes_written == output_text.size()) {
         LOG_INFO(Input, "TAS file written to file!");
     } else {
@@ -205,10 +205,10 @@ void Tas::UpdateThread() {
                 const int button = static_cast<int>(i);
                 SetButton(identifier, button, button_status);
             }
-            SetAxis(identifier, TasAxes::StickX, command.l_axis.x);
-            SetAxis(identifier, TasAxes::StickY, command.l_axis.y);
-            SetAxis(identifier, TasAxes::SubstickX, command.r_axis.x);
-            SetAxis(identifier, TasAxes::SubstickY, command.r_axis.y);
+            SetTasAxis(identifier, TasAxis::StickX, command.l_axis.x);
+            SetTasAxis(identifier, TasAxis::StickY, command.l_axis.y);
+            SetTasAxis(identifier, TasAxis::SubstickX, command.r_axis.x);
+            SetTasAxis(identifier, TasAxis::SubstickY, command.r_axis.y);
         }
     } else {
         is_running = Settings::values.tas_loop.GetValue();
@@ -224,27 +224,28 @@ void Tas::ClearInput() {
 }
 
 TasAnalog Tas::ReadCommandAxis(const std::string& line) const {
-    std::stringstream linestream(line);
-    std::string segment;
-    std::vector<std::string> seglist;
-
-    while (std::getline(linestream, segment, ';')) {
-        seglist.push_back(segment);
+    std::vector<std::string> seg_list;
+    {
+        std::istringstream line_stream(line);
+        std::string segment;
+        while (std::getline(line_stream, segment, ';')) {
+            seg_list.push_back(std::move(segment));
+        }
     }
 
-    const float x = std::stof(seglist.at(0)) / 32767.0f;
-    const float y = std::stof(seglist.at(1)) / 32767.0f;
+    const float x = std::stof(seg_list.at(0)) / 32767.0f;
+    const float y = std::stof(seg_list.at(1)) / 32767.0f;
 
     return {x, y};
 }
 
-u64 Tas::ReadCommandButtons(const std::string& data) const {
-    std::stringstream button_text(data);
-    std::string line;
+u64 Tas::ReadCommandButtons(const std::string& line) const {
+    std::istringstream button_text(line);
+    std::string button_line;
     u64 buttons = 0;
-    while (std::getline(button_text, line, ';')) {
-        for (auto [text, tas_button] : text_to_tas_button) {
-            if (text == line) {
+    while (std::getline(button_text, button_line, ';')) {
+        for (const auto& [text, tas_button] : text_to_tas_button) {
+            if (text == button_line) {
                 buttons |= static_cast<u64>(tas_button);
                 break;
             }
@@ -254,8 +255,8 @@ u64 Tas::ReadCommandButtons(const std::string& data) const {
 }
 
 std::string Tas::WriteCommandButtons(u64 buttons) const {
-    std::string returns = "";
-    for (auto [text_button, tas_button] : text_to_tas_button) {
+    std::string returns;
+    for (const auto& [text_button, tas_button] : text_to_tas_button) {
         if ((buttons & static_cast<u64>(tas_button)) != 0) {
             returns += fmt::format("{};", text_button);
         }
@@ -267,6 +268,10 @@ std::string Tas::WriteCommandAxis(TasAnalog analog) const {
     return fmt::format("{};{}", analog.x * 32767, analog.y * 32767);
 }
 
+void Tas::SetTasAxis(const PadIdentifier& identifier, TasAxis axis, f32 value) {
+    SetAxis(identifier, static_cast<int>(axis), value);
+}
+
 void Tas::StartStop() {
     if (!Settings::values.tas_enable) {
         return;

src/input_common/drivers/tas_input.h

@@ -5,11 +5,11 @@
 #pragma once
 
 #include <array>
+#include <string>
+#include <vector>
 
 #include "common/common_types.h"
-#include "common/settings_input.h"
 #include "input_common/input_engine.h"
-#include "input_common/main.h"
 
 /*
 To play back TAS scripts on Yuzu, select the folder with scripts in the configuration menu below
@@ -81,46 +81,46 @@ enum class TasState {
     Stopped,
 };
 
-class Tas final : public InputCommon::InputEngine {
+class Tas final : public InputEngine {
 public:
-    explicit Tas(const std::string& input_engine_);
-    ~Tas();
+    explicit Tas(std::string input_engine_);
+    ~Tas() override;
 
     /**
      * Changes the input status that will be stored in each frame
-     * @param buttons: bitfield with the status of the buttons
-     * @param left_axis: value of the left axis
-     * @param right_axis: value of the right axis
+     * @param buttons    Bitfield with the status of the buttons
+     * @param left_axis  Value of the left axis
+     * @param right_axis Value of the right axis
      */
     void RecordInput(u64 buttons, TasAnalog left_axis, TasAnalog right_axis);
 
     // Main loop that records or executes input
     void UpdateThread();
 
-    //  Sets the flag to start or stop the TAS command excecution and swaps controllers profiles
+    // Sets the flag to start or stop the TAS command execution and swaps controllers profiles
     void StartStop();
 
-    //  Stop the TAS and reverts any controller profile
+    // Stop the TAS and reverts any controller profile
     void Stop();
 
-    // Sets the flag to reload the file and start from the begining in the next update
+    // Sets the flag to reload the file and start from the beginning in the next update
     void Reset();
 
     /**
      * Sets the flag to enable or disable recording of inputs
-     * @return Returns true if the current recording status is enabled
+     * @returns true if the current recording status is enabled
      */
     bool Record();
 
     /**
      * Saves contents of record_commands on a file
-     * @param overwrite_file: Indicates if player 1 should be overwritten
+     * @param overwrite_file Indicates if player 1 should be overwritten
      */
     void SaveRecording(bool overwrite_file);
 
     /**
      * Returns the current status values of TAS playback/recording
-     * @return Tuple of
+     * @returns A Tuple of
      * TasState indicating the current state out of Running ;
      * Current playback progress ;
      * Total length of script file currently loaded or being recorded
@@ -128,6 +128,8 @@ public:
     std::tuple<TasState, size_t, size_t> GetStatus() const;
 
 private:
+    enum class TasAxis : u8;
+
     struct TASCommand {
         u64 buttons{};
         TasAnalog l_axis{};
@@ -137,29 +139,31 @@ private:
     /// Loads TAS files from all players
     void LoadTasFiles();
 
-    /** Loads TAS file from the specified player
-     * @param player_index: player number to save the script
-     * @param file_index: script number of the file
+    /**
+     * Loads TAS file from the specified player
+     * @param player_index Player number to save the script
+     * @param file_index   Script number of the file
      */
     void LoadTasFile(size_t player_index, size_t file_index);
 
-    /** Writes a TAS file from the recorded commands
-     * @param file_name: name of the file to be written
+    /**
+     * Writes a TAS file from the recorded commands
+     * @param file_name Name of the file to be written
      */
-    void WriteTasFile(std::u8string file_name);
+    void WriteTasFile(std::u8string_view file_name);
 
     /**
      * Parses a string containing the axis values. X and Y have a range from -32767 to 32767
-     * @param line: string containing axis values with the following format "x;y"
-     * @return Returns a TAS analog object with axis values with range from -1.0 to 1.0
+     * @param line String containing axis values with the following format "x;y"
+     * @returns A TAS analog object with axis values with range from -1.0 to 1.0
      */
     TasAnalog ReadCommandAxis(const std::string& line) const;
 
     /**
      * Parses a string containing the button values. Each button is represented by it's text format
      * specified in text_to_tas_button array
-     * @param line: string containing button name with the following format "a;b;c;d..."
-     * @return Returns a u64 with each bit representing the status of a button
+     * @param line string containing button name with the following format "a;b;c;d..."
+     * @returns A u64 with each bit representing the status of a button
      */
     u64 ReadCommandButtons(const std::string& line) const;
 
@@ -170,17 +174,20 @@ private:
 
     /**
      * Converts an u64 containing the button status into the text equivalent
-     * @param buttons: bitfield with the status of the buttons
-     * @return Returns a string with the name of the buttons to be written to the file
+     * @param buttons Bitfield with the status of the buttons
+     * @returns A string with the name of the buttons to be written to the file
      */
     std::string WriteCommandButtons(u64 buttons) const;
 
     /**
      * Converts an TAS analog object containing the axis status into the text equivalent
-     * @param data: value of the axis
-     * @return A string with the value of the axis to be written to the file
+     * @param analog Value of the axis
+     * @returns A string with the value of the axis to be written to the file
      */
-    std::string WriteCommandAxis(TasAnalog data) const;
+    std::string WriteCommandAxis(TasAnalog analog) const;
+
+    /// Sets an axis for a particular pad to the given value.
+    void SetTasAxis(const PadIdentifier& identifier, TasAxis axis, f32 value);
 
     size_t script_length{0};
     bool is_recording{false};

src/input_common/drivers/touch_screen.cpp

@@ -13,7 +13,7 @@ constexpr PadIdentifier identifier = {
     .pad = 0,
 };
 
-TouchScreen::TouchScreen(const std::string& input_engine_) : InputEngine(input_engine_) {
+TouchScreen::TouchScreen(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
     PreSetController(identifier);
 }
 

src/input_common/drivers/touch_screen.h

@@ -12,9 +12,9 @@ namespace InputCommon {
  * A button device factory representing a keyboard. It receives keyboard events and forward them
  * to all button devices it created.
  */
-class TouchScreen final : public InputCommon::InputEngine {
+class TouchScreen final : public InputEngine {
 public:
-    explicit TouchScreen(const std::string& input_engine_);
+    explicit TouchScreen(std::string input_engine_);
 
     /**
      * Signals that mouse has moved.

src/input_common/drivers/udp_client.cpp

@@ -136,7 +136,7 @@ static void SocketLoop(Socket* socket) {
     socket->Loop();
 }
 
-UDPClient::UDPClient(const std::string& input_engine_) : InputEngine(input_engine_) {
+UDPClient::UDPClient(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
     LOG_INFO(Input, "Udp Initialization started");
     ReloadSockets();
 }

src/input_common/drivers/udp_client.h

@@ -49,10 +49,10 @@ struct DeviceStatus {
  * A button device factory representing a keyboard. It receives keyboard events and forward them
  * to all button devices it created.
  */
-class UDPClient final : public InputCommon::InputEngine {
+class UDPClient final : public InputEngine {
 public:
-    explicit UDPClient(const std::string& input_engine_);
-    ~UDPClient();
+    explicit UDPClient(std::string input_engine_);
+    ~UDPClient() override;
 
     void ReloadSockets();
 

src/input_common/input_engine.cpp

@@ -10,41 +10,31 @@ namespace InputCommon {
 
 void InputEngine::PreSetController(const PadIdentifier& identifier) {
     std::lock_guard lock{mutex};
-    if (!controller_list.contains(identifier)) {
-        controller_list.insert_or_assign(identifier, ControllerData{});
-    }
+    controller_list.try_emplace(identifier);
 }
 
 void InputEngine::PreSetButton(const PadIdentifier& identifier, int button) {
     std::lock_guard lock{mutex};
     ControllerData& controller = controller_list.at(identifier);
-    if (!controller.buttons.contains(button)) {
-        controller.buttons.insert_or_assign(button, false);
-    }
+    controller.buttons.try_emplace(button, false);
 }
 
 void InputEngine::PreSetHatButton(const PadIdentifier& identifier, int button) {
     std::lock_guard lock{mutex};
     ControllerData& controller = controller_list.at(identifier);
-    if (!controller.hat_buttons.contains(button)) {
-        controller.hat_buttons.insert_or_assign(button, u8{0});
-    }
+    controller.hat_buttons.try_emplace(button, u8{0});
 }
 
 void InputEngine::PreSetAxis(const PadIdentifier& identifier, int axis) {
     std::lock_guard lock{mutex};
     ControllerData& controller = controller_list.at(identifier);
-    if (!controller.axes.contains(axis)) {
-        controller.axes.insert_or_assign(axis, 0.0f);
-    }
+    controller.axes.try_emplace(axis, 0.0f);
 }
 
 void InputEngine::PreSetMotion(const PadIdentifier& identifier, int motion) {
     std::lock_guard lock{mutex};
     ControllerData& controller = controller_list.at(identifier);
-    if (!controller.motions.contains(motion)) {
-        controller.motions.insert_or_assign(motion, BasicMotion{});
-    }
+    controller.motions.try_emplace(motion);
 }
 
 void InputEngine::SetButton(const PadIdentifier& identifier, int button, bool value) {
@@ -91,7 +81,7 @@ void InputEngine::SetBattery(const PadIdentifier& identifier, BatteryLevel value
     TriggerOnBatteryChange(identifier, value);
 }
 
-void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, BasicMotion value) {
+void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, const BasicMotion& value) {
     {
         std::lock_guard lock{mutex};
         ControllerData& controller = controller_list.at(identifier);
@@ -104,85 +94,93 @@ void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, BasicMo
 
 bool InputEngine::GetButton(const PadIdentifier& identifier, int button) const {
     std::lock_guard lock{mutex};
-    if (!controller_list.contains(identifier)) {
+    const auto controller_iter = controller_list.find(identifier);
+    if (controller_iter == controller_list.cend()) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return false;
     }
-    ControllerData controller = controller_list.at(identifier);
-    if (!controller.buttons.contains(button)) {
+    const ControllerData& controller = controller_iter->second;
+    const auto button_iter = controller.buttons.find(button);
+    if (button_iter == controller.buttons.cend()) {
         LOG_ERROR(Input, "Invalid button {}", button);
         return false;
     }
-    return controller.buttons.at(button);
+    return button_iter->second;
 }
 
 bool InputEngine::GetHatButton(const PadIdentifier& identifier, int button, u8 direction) const {
     std::lock_guard lock{mutex};
-    if (!controller_list.contains(identifier)) {
+    const auto controller_iter = controller_list.find(identifier);
+    if (controller_iter == controller_list.cend()) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return false;
     }
-    ControllerData controller = controller_list.at(identifier);
-    if (!controller.hat_buttons.contains(button)) {
+    const ControllerData& controller = controller_iter->second;
+    const auto hat_iter = controller.hat_buttons.find(button);
+    if (hat_iter == controller.hat_buttons.cend()) {
         LOG_ERROR(Input, "Invalid hat button {}", button);
         return false;
     }
-    return (controller.hat_buttons.at(button) & direction) != 0;
+    return (hat_iter->second & direction) != 0;
 }
 
 f32 InputEngine::GetAxis(const PadIdentifier& identifier, int axis) const {
     std::lock_guard lock{mutex};
-    if (!controller_list.contains(identifier)) {
+    const auto controller_iter = controller_list.find(identifier);
+    if (controller_iter == controller_list.cend()) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return 0.0f;
     }
-    ControllerData controller = controller_list.at(identifier);
-    if (!controller.axes.contains(axis)) {
+    const ControllerData& controller = controller_iter->second;
+    const auto axis_iter = controller.axes.find(axis);
+    if (axis_iter == controller.axes.cend()) {
         LOG_ERROR(Input, "Invalid axis {}", axis);
         return 0.0f;
     }
-    return controller.axes.at(axis);
+    return axis_iter->second;
 }
 
 BatteryLevel InputEngine::GetBattery(const PadIdentifier& identifier) const {
     std::lock_guard lock{mutex};
-    if (!controller_list.contains(identifier)) {
+    const auto controller_iter = controller_list.find(identifier);
+    if (controller_iter == controller_list.cend()) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return BatteryLevel::Charging;
     }
-    ControllerData controller = controller_list.at(identifier);
+    const ControllerData& controller = controller_iter->second;
     return controller.battery;
 }
 
 BasicMotion InputEngine::GetMotion(const PadIdentifier& identifier, int motion) const {
     std::lock_guard lock{mutex};
-    if (!controller_list.contains(identifier)) {
+    const auto controller_iter = controller_list.find(identifier);
+    if (controller_iter == controller_list.cend()) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return {};
     }
-    ControllerData controller = controller_list.at(identifier);
+    const ControllerData& controller = controller_iter->second;
     return controller.motions.at(motion);
 }
 
 void InputEngine::ResetButtonState() {
-    for (std::pair<PadIdentifier, ControllerData> controller : controller_list) {
-        for (std::pair<int, bool> button : controller.second.buttons) {
+    for (const auto& controller : controller_list) {
+        for (const auto& button : controller.second.buttons) {
             SetButton(controller.first, button.first, false);
         }
-        for (std::pair<int, bool> button : controller.second.hat_buttons) {
+        for (const auto& button : controller.second.hat_buttons) {
             SetHatButton(controller.first, button.first, false);
         }
     }
 }
 
 void InputEngine::ResetAnalogState() {
-    for (std::pair<PadIdentifier, ControllerData> controller : controller_list) {
-        for (std::pair<int, float> axis : controller.second.axes) {
+    for (const auto& controller : controller_list) {
+        for (const auto& axis : controller.second.axes) {
             SetAxis(controller.first, axis.first, 0.0);
         }
     }
@@ -190,7 +188,7 @@ void InputEngine::ResetAnalogState() {
 
 void InputEngine::TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value) {
     std::lock_guard lock{mutex_callback};
-    for (const std::pair<int, InputIdentifier> poller_pair : callback_list) {
+    for (const auto& poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Button, button)) {
             continue;
@@ -218,7 +216,7 @@ void InputEngine::TriggerOnButtonChange(const PadIdentifier& identifier, int but
 
 void InputEngine::TriggerOnHatButtonChange(const PadIdentifier& identifier, int button, u8 value) {
     std::lock_guard lock{mutex_callback};
-    for (const std::pair<int, InputIdentifier> poller_pair : callback_list) {
+    for (const auto& poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::HatButton, button)) {
             continue;
@@ -247,7 +245,7 @@ void InputEngine::TriggerOnHatButtonChange(const PadIdentifier& identifier, int
 
 void InputEngine::TriggerOnAxisChange(const PadIdentifier& identifier, int axis, f32 value) {
     std::lock_guard lock{mutex_callback};
-    for (const std::pair<int, InputIdentifier> poller_pair : callback_list) {
+    for (const auto& poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Analog, axis)) {
             continue;
@@ -274,7 +272,7 @@ void InputEngine::TriggerOnAxisChange(const PadIdentifier& identifier, int axis,
 void InputEngine::TriggerOnBatteryChange(const PadIdentifier& identifier,
                                          [[maybe_unused]] BatteryLevel value) {
     std::lock_guard lock{mutex_callback};
-    for (const std::pair<int, InputIdentifier> poller_pair : callback_list) {
+    for (const auto& poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Battery, 0)) {
             continue;
@@ -286,9 +284,9 @@ void InputEngine::TriggerOnBatteryChange(const PadIdentifier& identifier,
 }
 
 void InputEngine::TriggerOnMotionChange(const PadIdentifier& identifier, int motion,
-                                        BasicMotion value) {
+                                        const BasicMotion& value) {
     std::lock_guard lock{mutex_callback};
-    for (const std::pair<int, InputIdentifier> poller_pair : callback_list) {
+    for (const auto& poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Motion, motion)) {
             continue;
@@ -342,7 +340,7 @@ const std::string& InputEngine::GetEngineName() const {
 
 int InputEngine::SetCallback(InputIdentifier input_identifier) {
     std::lock_guard lock{mutex_callback};
-    callback_list.insert_or_assign(last_callback_key, input_identifier);
+    callback_list.insert_or_assign(last_callback_key, std::move(input_identifier));
     return last_callback_key++;
 }
 

src/input_common/input_engine.h

@@ -23,15 +23,15 @@ struct PadIdentifier {
     friend constexpr bool operator==(const PadIdentifier&, const PadIdentifier&) = default;
 };
 
-// Basic motion data containing data from the sensors and a timestamp in microsecons
+// Basic motion data containing data from the sensors and a timestamp in microseconds
 struct BasicMotion {
-    float gyro_x;
-    float gyro_y;
-    float gyro_z;
-    float accel_x;
-    float accel_y;
-    float accel_z;
-    u64 delta_timestamp;
+    float gyro_x{};
+    float gyro_y{};
+    float gyro_z{};
+    float accel_x{};
+    float accel_y{};
+    float accel_z{};
+    u64 delta_timestamp{};
 };
 
 // Stages of a battery charge
@@ -102,9 +102,7 @@ struct InputIdentifier {
 
 class InputEngine {
 public:
-    explicit InputEngine(const std::string& input_engine_) : input_engine(input_engine_) {
-        callback_list.clear();
-    }
+    explicit InputEngine(std::string input_engine_) : input_engine{std::move(input_engine_)} {}
 
     virtual ~InputEngine() = default;
 
@@ -116,14 +114,12 @@ public:
 
     // Sets a led pattern for a controller
     virtual void SetLeds([[maybe_unused]] const PadIdentifier& identifier,
-                         [[maybe_unused]] const Common::Input::LedStatus led_status) {
-        return;
-    }
+                         [[maybe_unused]] const Common::Input::LedStatus& led_status) {}
 
     // Sets rumble to a controller
     virtual Common::Input::VibrationError SetRumble(
         [[maybe_unused]] const PadIdentifier& identifier,
-        [[maybe_unused]] const Common::Input::VibrationStatus vibration) {
+        [[maybe_unused]] const Common::Input::VibrationStatus& vibration) {
         return Common::Input::VibrationError::NotSupported;
     }
 
@@ -140,36 +136,36 @@ public:
     /// Used for automapping features
     virtual std::vector<Common::ParamPackage> GetInputDevices() const {
         return {};
-    };
+    }
 
     /// Retrieves the button mappings for the given device
-    virtual InputCommon::ButtonMapping GetButtonMappingForDevice(
+    virtual ButtonMapping GetButtonMappingForDevice(
         [[maybe_unused]] const Common::ParamPackage& params) {
         return {};
-    };
+    }
 
     /// Retrieves the analog mappings for the given device
-    virtual InputCommon::AnalogMapping GetAnalogMappingForDevice(
+    virtual AnalogMapping GetAnalogMappingForDevice(
         [[maybe_unused]] const Common::ParamPackage& params) {
         return {};
-    };
+    }
 
     /// Retrieves the motion mappings for the given device
-    virtual InputCommon::MotionMapping GetMotionMappingForDevice(
+    virtual MotionMapping GetMotionMappingForDevice(
         [[maybe_unused]] const Common::ParamPackage& params) {
         return {};
-    };
+    }
 
     /// Retrieves the name of the given input.
     virtual Common::Input::ButtonNames GetUIName(
         [[maybe_unused]] const Common::ParamPackage& params) const {
         return Common::Input::ButtonNames::Engine;
-    };
+    }
 
     /// Retrieves the index number of the given hat button direction
     virtual u8 GetHatButtonId([[maybe_unused]] const std::string& direction_name) const {
         return 0;
-    };
+    }
 
     void PreSetController(const PadIdentifier& identifier);
     void PreSetButton(const PadIdentifier& identifier, int button);
@@ -194,7 +190,7 @@ protected:
     void SetHatButton(const PadIdentifier& identifier, int button, u8 value);
     void SetAxis(const PadIdentifier& identifier, int axis, f32 value);
     void SetBattery(const PadIdentifier& identifier, BatteryLevel value);
-    void SetMotion(const PadIdentifier& identifier, int motion, BasicMotion value);
+    void SetMotion(const PadIdentifier& identifier, int motion, const BasicMotion& value);
 
     virtual std::string GetHatButtonName([[maybe_unused]] u8 direction_value) const {
         return "Unknown";
@@ -206,14 +202,15 @@ private:
         std::unordered_map<int, u8> hat_buttons;
         std::unordered_map<int, float> axes;
         std::unordered_map<int, BasicMotion> motions;
-        BatteryLevel battery;
+        BatteryLevel battery{};
     };
 
     void TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value);
     void TriggerOnHatButtonChange(const PadIdentifier& identifier, int button, u8 value);
-    void TriggerOnAxisChange(const PadIdentifier& identifier, int button, f32 value);
+    void TriggerOnAxisChange(const PadIdentifier& identifier, int axis, f32 value);
     void TriggerOnBatteryChange(const PadIdentifier& identifier, BatteryLevel value);
-    void TriggerOnMotionChange(const PadIdentifier& identifier, int motion, BasicMotion value);
+    void TriggerOnMotionChange(const PadIdentifier& identifier, int motion,
+                               const BasicMotion& value);
 
     bool IsInputIdentifierEqual(const InputIdentifier& input_identifier,
                                 const PadIdentifier& identifier, EngineInputType type,

src/input_common/input_mapping.h

@@ -14,8 +14,8 @@ public:
     MappingFactory();
 
     /**
-     * Resets all varables to beggin the mapping process
-     * @param "type": type of input desired to be returned
+     * Resets all variables to begin the mapping process
+     * @param type type of input desired to be returned
      */
     void BeginMapping(Polling::InputType type);
 
@@ -24,8 +24,8 @@ public:
 
     /**
      * Registers mapping input data from the driver
-     * @param "data": An struct containing all the information needed to create a proper
-     * ParamPackage
+     * @param data A struct containing all the information needed to create a proper
+     *             ParamPackage
      */
     void RegisterInput(const MappingData& data);
 
@@ -34,42 +34,42 @@ public:
 
 private:
     /**
-     * If provided data satisfies the requeriments it will push an element to the input_queue
+     * If provided data satisfies the requirements it will push an element to the input_queue
      * Supported input:
      *     - Button: Creates a basic button ParamPackage
      *     - HatButton: Creates a basic hat button ParamPackage
      *     - Analog: Creates a basic analog ParamPackage
-     * @param "data": An struct containing all the information needed to create a proper
+     * @param data A struct containing all the information needed to create a proper
      * ParamPackage
      */
     void RegisterButton(const MappingData& data);
 
     /**
-     * If provided data satisfies the requeriments it will push an element to the input_queue
+     * If provided data satisfies the requirements it will push an element to the input_queue
      * Supported input:
      *     - Button, HatButton: Pass the data to RegisterButton
      *     - Analog: Stores the first axis and on the second axis creates a basic stick ParamPackage
-     * @param "data": An struct containing all the information needed to create a proper
-     * ParamPackage
+     * @param data A struct containing all the information needed to create a proper
+     *             ParamPackage
      */
     void RegisterStick(const MappingData& data);
 
     /**
-     * If provided data satisfies the requeriments it will push an element to the input_queue
+     * If provided data satisfies the requirements it will push an element to the input_queue
      * Supported input:
      *     - Button, HatButton: Pass the data to RegisterButton
      *     - Analog: Stores the first two axis and on the third axis creates a basic Motion
      * ParamPackage
      *     - Motion: Creates a basic Motion ParamPackage
-     * @param "data": An struct containing all the information needed to create a proper
-     * ParamPackage
+     * @param data A struct containing all the information needed to create a proper
+     *             ParamPackage
      */
     void RegisterMotion(const MappingData& data);
 
     /**
      * Returns true if driver can be mapped
-     * @param "data": An struct containing all the information needed to create a proper
-     * ParamPackage
+     * @param data A struct containing all the information needed to create a proper
+     *             ParamPackage
      */
     bool IsDriverValid(const MappingData& data) const;
 

src/input_common/input_poller.cpp

@@ -668,12 +668,12 @@ public:
     explicit OutputFromIdentifier(PadIdentifier identifier_, InputEngine* input_engine_)
         : identifier(identifier_), input_engine(input_engine_) {}
 
-    virtual void SetLED(Common::Input::LedStatus led_status) {
+    virtual void SetLED(const Common::Input::LedStatus& led_status) {
         input_engine->SetLeds(identifier, led_status);
     }
 
     virtual Common::Input::VibrationError SetVibration(
-        Common::Input::VibrationStatus vibration_status) {
+        const Common::Input::VibrationStatus& vibration_status) {
         return input_engine->SetRumble(identifier, vibration_status);
     }
 

src/input_common/input_poller.h

@@ -13,9 +13,6 @@ class Factory;
 
 namespace InputCommon {
 class InputEngine;
-/**
- * An Input factory. It receives input events and forward them to all input devices it created.
- */
 
 class OutputFactory final : public Common::Input::Factory<Common::Input::OutputDevice> {
 public:
@@ -24,10 +21,10 @@ public:
     /**
      * Creates an output device from the parameters given.
      * @param params contains parameters for creating the device:
-     * @param    - "guid": text string for identifing controllers
-     * @param    - "port": port of the connected device
-     * @param    - "pad": slot of the connected controller
-     * @return an unique ouput device with the parameters specified
+     *               - "guid" text string for identifying controllers
+     *               - "port": port of the connected device
+     *               - "pad": slot of the connected controller
+     * @returns a unique output device with the parameters specified
      */
     std::unique_ptr<Common::Input::OutputDevice> Create(
         const Common::ParamPackage& params) override;
@@ -36,6 +33,9 @@ private:
     std::shared_ptr<InputEngine> input_engine;
 };
 
+/**
+ * An Input factory. It receives input events and forward them to all input devices it created.
+ */
 class InputFactory final : public Common::Input::Factory<Common::Input::InputDevice> {
 public:
     explicit InputFactory(std::shared_ptr<InputEngine> input_engine_);
@@ -54,16 +54,16 @@ public:
      * - battery: Contains "battery"
      * - output: Contains "output"
      * @param params contains parameters for creating the device:
-     * @param    - "code": the code of the keyboard key to bind with the input
-     * @param    - "button": same as "code" but for controller buttons
-     * @param    - "hat": similar as "button" but it's a group of hat buttons from SDL
-     * @param    - "axis": the axis number of the axis to bind with the input
-     * @param    - "motion": the motion number of the motion to bind with the input
-     * @param    - "axis_x": same as axis but specifing horizontal direction
-     * @param    - "axis_y": same as axis but specifing vertical direction
-     * @param    - "axis_z": same as axis but specifing forward direction
-     * @param    - "battery": Only used as a placeholder to set the input type
-     * @return an unique input device with the parameters specified
+     *               - "code": the code of the keyboard key to bind with the input
+     *               - "button": same as "code" but for controller buttons
+     *               - "hat": similar as "button" but it's a group of hat buttons from SDL
+     *               - "axis": the axis number of the axis to bind with the input
+     *               - "motion": the motion number of the motion to bind with the input
+     *               - "axis_x": same as axis but specifying horizontal direction
+     *               - "axis_y": same as axis but specifying vertical direction
+     *               - "axis_z": same as axis but specifying forward direction
+     *               - "battery": Only used as a placeholder to set the input type
+     * @returns a unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> Create(const Common::ParamPackage& params) override;
 
@@ -71,14 +71,14 @@ private:
     /**
      * Creates a button device from the parameters given.
      * @param params contains parameters for creating the device:
-     * @param    - "code": the code of the keyboard key to bind with the input
-     * @param    - "button": same as "code" but for controller buttons
-     * @param    - "toggle": press once to enable, press again to disable
-     * @param    - "inverted": inverts the output of the button
-     * @param    - "guid": text string for identifing controllers
-     * @param    - "port": port of the connected device
-     * @param    - "pad": slot of the connected controller
-     * @return an unique input device with the parameters specified
+     *               - "code": the code of the keyboard key to bind with the input
+     *               - "button": same as "code" but for controller buttons
+     *               - "toggle": press once to enable, press again to disable
+     *               - "inverted": inverts the output of the button
+     *               - "guid": text string for identifying controllers
+     *               - "port": port of the connected device
+     *               - "pad": slot of the connected controller
+     * @returns a unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateButtonDevice(
         const Common::ParamPackage& params);
@@ -86,14 +86,14 @@ private:
     /**
      * Creates a hat button device from the parameters given.
      * @param params contains parameters for creating the device:
-     * @param    - "button": the controller hat id to bind with the input
-     * @param    - "direction": the direction id to be detected
-     * @param    - "toggle": press once to enable, press again to disable
-     * @param    - "inverted": inverts the output of the button
-     * @param    - "guid": text string for identifing controllers
-     * @param    - "port": port of the connected device
-     * @param    - "pad": slot of the connected controller
-     * @return an unique input device with the parameters specified
+     *               - "button": the controller hat id to bind with the input
+     *               - "direction": the direction id to be detected
+     *               - "toggle": press once to enable, press again to disable
+     *               - "inverted": inverts the output of the button
+     *               - "guid": text string for identifying controllers
+     *               - "port": port of the connected device
+     *               - "pad": slot of the connected controller
+     * @returns a unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateHatButtonDevice(
         const Common::ParamPackage& params);
@@ -101,19 +101,19 @@ private:
     /**
      * Creates a stick device from the parameters given.
      * @param params contains parameters for creating the device:
-     * @param    - "axis_x": the controller horizontal axis id to bind with the input
-     * @param    - "axis_y": the controller vertical axis id to bind with the input
-     * @param    - "deadzone": the mimimum required value to be detected
-     * @param    - "range": the maximum value required to reach 100%
-     * @param    - "threshold": the mimimum required value to considered pressed
-     * @param    - "offset_x": the amount of offset in the x axis
-     * @param    - "offset_y": the amount of offset in the y axis
-     * @param    - "invert_x": inverts the sign of the horizontal axis
-     * @param    - "invert_y": inverts the sign of the vertical axis
-     * @param    - "guid": text string for identifing controllers
-     * @param    - "port": port of the connected device
-     * @param    - "pad": slot of the connected controller
-     * @return an unique input device with the parameters specified
+     *               - "axis_x": the controller horizontal axis id to bind with the input
+     *               - "axis_y": the controller vertical axis id to bind with the input
+     *               - "deadzone": the minimum required value to be detected
+     *               - "range": the maximum value required to reach 100%
+     *               - "threshold": the minimum required value to considered pressed
+     *               - "offset_x": the amount of offset in the x axis
+     *               - "offset_y": the amount of offset in the y axis
+     *               - "invert_x": inverts the sign of the horizontal axis
+     *               - "invert_y": inverts the sign of the vertical axis
+     *               - "guid": text string for identifying controllers
+     *               - "port": port of the connected device
+     *               - "pad": slot of the connected controller
+     * @returns a unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateStickDevice(
         const Common::ParamPackage& params);
@@ -121,16 +121,16 @@ private:
     /**
      * Creates an analog device from the parameters given.
      * @param params contains parameters for creating the device:
-     * @param    - "axis": the controller axis id to bind with the input
-     * @param    - "deadzone": the mimimum required value to be detected
-     * @param    - "range": the maximum value required to reach 100%
-     * @param    - "threshold": the mimimum required value to considered pressed
-     * @param    - "offset": the amount of offset in the axis
-     * @param    - "invert": inverts the sign of the axis
-     * @param    - "guid": text string for identifing controllers
-     * @param    - "port": port of the connected device
-     * @param    - "pad": slot of the connected controller
-     * @return an unique input device with the parameters specified
+     *               - "axis": the controller axis id to bind with the input
+     *               - "deadzone": the minimum required value to be detected
+     *               - "range": the maximum value required to reach 100%
+     *               - "threshold": the minimum required value to considered pressed
+     *               - "offset": the amount of offset in the axis
+     *               - "invert": inverts the sign of the axis
+     *               - "guid": text string for identifying controllers
+     *               - "port": port of the connected device
+     *               - "pad": slot of the connected controller
+     * @returns a unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateAnalogDevice(
         const Common::ParamPackage& params);
@@ -138,20 +138,20 @@ private:
     /**
      * Creates a trigger device from the parameters given.
      * @param params contains parameters for creating the device:
-     * @param    - "button": the controller hat id to bind with the input
-     * @param    - "direction": the direction id to be detected
-     * @param    - "toggle": press once to enable, press again to disable
-     * @param    - "inverted": inverts the output of the button
-     * @param    - "axis": the controller axis id to bind with the input
-     * @param    - "deadzone": the mimimum required value to be detected
-     * @param    - "range": the maximum value required to reach 100%
-     * @param    - "threshold": the mimimum required value to considered pressed
-     * @param    - "offset": the amount of offset in the axis
-     * @param    - "invert": inverts the sign of the axis
-     * @param    - "guid": text string for identifing controllers
-     * @param    - "port": port of the connected device
-     * @param    - "pad": slot of the connected controller
-     * @return an unique input device with the parameters specified
+     *               - "button": the controller hat id to bind with the input
+     *               - "direction": the direction id to be detected
+     *               - "toggle": press once to enable, press again to disable
+     *               - "inverted": inverts the output of the button
+     *               - "axis": the controller axis id to bind with the input
+     *               - "deadzone": the minimum required value to be detected
+     *               - "range": the maximum value required to reach 100%
+     *               - "threshold": the minimum required value to considered pressed
+     *               - "offset": the amount of offset in the axis
+     *               - "invert": inverts the sign of the axis
+     *               - "guid": text string for identifying controllers
+     *               - "port": port of the connected device
+     *               - "pad": slot of the connected controller
+     * @returns a unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateTriggerDevice(
         const Common::ParamPackage& params);
@@ -159,23 +159,23 @@ private:
     /**
      * Creates a touch device from the parameters given.
      * @param params contains parameters for creating the device:
-     * @param    - "button": the controller hat id to bind with the input
-     * @param    - "direction": the direction id to be detected
-     * @param    - "toggle": press once to enable, press again to disable
-     * @param    - "inverted": inverts the output of the button
-     * @param    - "axis_x": the controller horizontal axis id to bind with the input
-     * @param    - "axis_y": the controller vertical axis id to bind with the input
-     * @param    - "deadzone": the mimimum required value to be detected
-     * @param    - "range": the maximum value required to reach 100%
-     * @param    - "threshold": the mimimum required value to considered pressed
-     * @param    - "offset_x": the amount of offset in the x axis
-     * @param    - "offset_y": the amount of offset in the y axis
-     * @param    - "invert_x": inverts the sign of the horizontal axis
-     * @param    - "invert_y": inverts the sign of the vertical axis
-     * @param    - "guid": text string for identifing controllers
-     * @param    - "port": port of the connected device
-     * @param    - "pad": slot of the connected controller
-     * @return an unique input device with the parameters specified
+     *               - "button": the controller hat id to bind with the input
+     *               - "direction": the direction id to be detected
+     *               - "toggle": press once to enable, press again to disable
+     *               - "inverted": inverts the output of the button
+     *               - "axis_x": the controller horizontal axis id to bind with the input
+     *               - "axis_y": the controller vertical axis id to bind with the input
+     *               - "deadzone": the minimum required value to be detected
+     *               - "range": the maximum value required to reach 100%
+     *               - "threshold": the minimum required value to considered pressed
+     *               - "offset_x": the amount of offset in the x axis
+     *               - "offset_y": the amount of offset in the y axis
+     *               - "invert_x": inverts the sign of the horizontal axis
+     *               - "invert_y": inverts the sign of the vertical axis
+     *               - "guid": text string for identifying controllers
+     *               - "port": port of the connected device
+     *               - "pad": slot of the connected controller
+     * @returns a unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateTouchDevice(
         const Common::ParamPackage& params);
@@ -183,10 +183,10 @@ private:
     /**
      * Creates a battery device from the parameters given.
      * @param params contains parameters for creating the device:
-     * @param    - "guid": text string for identifing controllers
-     * @param    - "port": port of the connected device
-     * @param    - "pad": slot of the connected controller
-     * @return an unique input device with the parameters specified
+     *               - "guid": text string for identifying controllers
+     *               - "port": port of the connected device
+     *               - "pad": slot of the connected controller
+     * @returns a unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateBatteryDevice(
         const Common::ParamPackage& params);
@@ -194,21 +194,21 @@ private:
     /**
      * Creates a motion device from the parameters given.
      * @param params contains parameters for creating the device:
-     * @param    - "axis_x": the controller horizontal axis id to bind with the input
-     * @param    - "axis_y": the controller vertical axis id to bind with the input
-     * @param    - "axis_z": the controller fordward axis id to bind with the input
-     * @param    - "deadzone": the mimimum required value to be detected
-     * @param    - "range": the maximum value required to reach 100%
-     * @param    - "offset_x": the amount of offset in the x axis
-     * @param    - "offset_y": the amount of offset in the y axis
-     * @param    - "offset_z": the amount of offset in the z axis
-     * @param    - "invert_x": inverts the sign of the horizontal axis
-     * @param    - "invert_y": inverts the sign of the vertical axis
-     * @param    - "invert_z": inverts the sign of the fordward axis
-     * @param    - "guid": text string for identifing controllers
-     * @param    - "port": port of the connected device
-     * @param    - "pad": slot of the connected controller
-     * @return an unique input device with the parameters specified
+     *               - "axis_x": the controller horizontal axis id to bind with the input
+     *               - "axis_y": the controller vertical axis id to bind with the input
+     *               - "axis_z": the controller forward axis id to bind with the input
+     *               - "deadzone": the minimum required value to be detected
+     *               - "range": the maximum value required to reach 100%
+     *               - "offset_x": the amount of offset in the x axis
+     *               - "offset_y": the amount of offset in the y axis
+     *               - "offset_z": the amount of offset in the z axis
+     *               - "invert_x": inverts the sign of the horizontal axis
+     *               - "invert_y": inverts the sign of the vertical axis
+     *               - "invert_z": inverts the sign of the forward axis
+     *               - "guid": text string for identifying controllers
+     *               - "port": port of the connected device
+     *               - "pad": slot of the connected controller
+     * @returns a unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateMotionDevice(Common::ParamPackage params);