remove union from ControlSettings

Author: jube

include/gf2/core/ControlSettings.h

@@ -5,6 +5,8 @@
 
 #include <cstdint>
 
+#include <variant>
+
 #include "CoreApi.h"
 #include "GamepadTypes.h"
 #include "Keycode.h"
@@ -71,76 +73,94 @@ namespace gf {
   }
 
   enum class ControlType : uint8_t {
+    None,
     Keycode,
     Scancode,
     MouseButton,
     GamepadButton,
     GamepadAxis,
   };
 
-  struct GF_CORE_API ControlSettings {
+  class GF_CORE_API ControlSettings {
+  public:
     ControlSettings() = default;
 
     constexpr ControlSettings(Keycode keycode, Flags<Modifier> modifiers = None)
-    : type(ControlType::Keycode)
-    , keycode({ keycode, modifiers })
+    : m_data(KeycodeControlSettings{ keycode, modifiers })
     {
     }
 
     constexpr ControlSettings(Scancode scancode, Flags<Modifier> modifiers = None)
-    : type(ControlType::Scancode)
-    , scancode({ scancode, modifiers })
+    : m_data(ScancodeControlSettings{ scancode, modifiers })
     {
     }
 
     constexpr ControlSettings(MouseButton button)
-    : type(ControlType::MouseButton)
-    , mouse_button({ button })
+    : m_data(MouseButtonControlSettings{ button })
     {
     }
 
     constexpr ControlSettings(GamepadId gamepad_id, GamepadButton button)
-    : type(ControlType::GamepadButton)
-    , gamepad_button({ gamepad_id, button })
+    : m_data(GamepadButtonControlSettings{ gamepad_id, button })
     {
     }
 
     constexpr ControlSettings(GamepadId gamepad_id, GamepadAxis axis, GamepadAxisDirection direction)
-    : type(ControlType::GamepadAxis)
-    , gamepad_axis({ gamepad_id, axis, direction })
+    : m_data(GamepadAxisControlSettings{ gamepad_id, axis, direction })
+    {
+    }
+
+    constexpr ControlType type() const
     {
+      return static_cast<ControlType>(m_data.index());
     }
 
-    ControlType type;
-    union {
-      KeycodeControlSettings keycode;
-      ScancodeControlSettings scancode;
-      MouseButtonControlSettings mouse_button;
-      GamepadButtonControlSettings gamepad_button;
-      GamepadAxisControlSettings gamepad_axis;
-    };
+    template<typename T>
+    constexpr T& as()
+    {
+      return std::get<T>(m_data);
+    }
+
+    template<typename T>
+    constexpr const T& as() const
+    {
+      return std::get<T>(m_data);
+    }
+
+  private:
+    std::variant<
+      std::monostate,
+      KeycodeControlSettings,
+      ScancodeControlSettings,
+      MouseButtonControlSettings,
+      GamepadButtonControlSettings,
+      GamepadAxisControlSettings
+    > m_data;
   };
 
   template<typename Archive>
   inline Archive& operator|(Archive& ar, MaybeConst<ControlSettings, Archive>& settings)
   {
-    ar | settings.type;
+    ControlType type = settings.type();
+    ar | type;
 
-    switch (settings.type) {
+    switch (type) {
+      case ControlType::None:
+        break;
       case ControlType::Keycode:
-        ar | settings.keycode;
+        ar | settings.template as<KeycodeControlSettings>();
         break;
       case ControlType::Scancode:
-        ar | settings.scancode;
+        ar | settings.template as<ScancodeControlSettings>();
         break;
       case ControlType::MouseButton:
-        ar | settings.mouse_button;
+        ar | settings.template as<MouseButtonControlSettings>();
         break;
       case ControlType::GamepadButton:
-        ar | settings.gamepad_button;
+        ar | settings.template as<GamepadButtonControlSettings>();
         break;
       case ControlType::GamepadAxis:
-        ar | settings.gamepad_axis;
+        ar | settings.template as<GamepadAxisControlSettings>();
         break;
     }
 

include/gf2/graphics/Action.h

@@ -30,7 +30,7 @@ namespace gf {
     void add_gamepad_axis_control(GamepadId gamepad_id, GamepadAxis axis, GamepadAxisDirection direction);
 
     void add_control(const Control& control);
-    void add_control(const ControlSettings& settings);
+    void add_control_settings(const ControlSettings& settings);
 
     const Control* begin() const
     {

include/gf2/graphics/Control.h

@@ -32,7 +32,7 @@ namespace gf {
     void process_gamepad_button_control(const Event& event, const GamepadButtonControlSettings& settings);
     void process_gamepad_axis_control(const Event& event, const GamepadAxisControlSettings& settings);
 
-    ControlSettings m_settings = {};
+    ControlSettings m_settings;
     bool m_active = false;
     bool m_repeated = false;
   };

library/graphics/Action.cc

@@ -16,8 +16,8 @@ namespace gf {
   Action::Action(const ActionSettings& settings)
   : m_type(settings.type)
   {
-    for (const auto& control : settings.controls) {
-      add_control(control);
+    for (const auto& control_settings : settings.controls) {
+      add_control_settings(control_settings);
     }
   }
 
@@ -43,50 +43,30 @@ namespace gf {
 
   void Action::add_keycode_control(Keycode keycode, Flags<Modifier> modifiers)
   {
-    ControlSettings settings = {};
-    settings.type = ControlType::Keycode;
-    settings.keycode.keycode = keycode;
-    settings.keycode.modifiers = modifiers;
-    add_control(settings);
+    add_control_settings({ keycode, modifiers });
   }
 
   void Action::add_scancode_control(Scancode scancode, Flags<Modifier> modifiers)
   {
-    ControlSettings settings = {};
-    settings.type = ControlType::Scancode;
-    settings.scancode.scancode = scancode;
-    settings.scancode.modifiers = modifiers;
-    add_control(settings);
+    add_control_settings({ scancode, modifiers });
   }
 
   void Action::add_mouse_button_control(MouseButton button)
   {
-    ControlSettings settings = {};
-    settings.type = ControlType::MouseButton;
-    settings.mouse_button.button = button;
-    add_control(settings);
+    add_control_settings({ button });
   }
 
   void Action::add_gamepad_button_control(GamepadId gamepad_id, GamepadButton button)
   {
-    ControlSettings settings = {};
-    settings.type = ControlType::GamepadButton;
-    settings.gamepad_button.gamepad_id = gamepad_id;
-    settings.gamepad_button.button = button;
-    add_control(settings);
+    add_control_settings({ gamepad_id, button });
   }
 
   void Action::add_gamepad_axis_control(GamepadId gamepad_id, GamepadAxis axis, GamepadAxisDirection direction)
   {
-    ControlSettings settings = {};
-    settings.type = ControlType::GamepadAxis;
-    settings.gamepad_axis.gamepad_id = gamepad_id;
-    settings.gamepad_axis.axis = axis;
-    settings.gamepad_axis.direction = direction;
-    add_control(settings);
+    add_control_settings({ gamepad_id, axis, direction });
   }
 
-  void Action::add_control(const ControlSettings& settings)
+  void Action::add_control_settings(const ControlSettings& settings)
   {
     add_control(Control(settings));
   }

library/graphics/Control.cc

@@ -38,28 +38,29 @@ namespace gf {
 
   void Control::process_event(const Event& event)
   {
-    switch (m_settings.type) {
+    switch (m_settings.type()) {
+      case gf::ControlType::None:
+        break;
       case gf::ControlType::Keycode:
-        process_keycode_control(event, m_settings.keycode);
+        process_keycode_control(event, m_settings.as<KeycodeControlSettings>());
         break;
       case gf::ControlType::Scancode:
-        process_scancode_control(event, m_settings.scancode);
+        process_scancode_control(event, m_settings.as<ScancodeControlSettings>());
         break;
       case gf::ControlType::MouseButton:
-        process_mouse_button_control(event, m_settings.mouse_button);
+        process_mouse_button_control(event, m_settings.as<MouseButtonControlSettings>());
         break;
       case gf::ControlType::GamepadButton:
-        process_gamepad_button_control(event, m_settings.gamepad_button);
+        process_gamepad_button_control(event, m_settings.as<GamepadButtonControlSettings>());
         break;
       case gf::ControlType::GamepadAxis:
-        process_gamepad_axis_control(event, m_settings.gamepad_axis);
+        process_gamepad_axis_control(event, m_settings.as<GamepadAxisControlSettings>());
         break;
     }
   }
 
   void Control::process_keycode_control(const Event& event, const KeycodeControlSettings& settings)
   {
-
     if (event.type() == EventType::KeyPressed) {
       const auto& key_pressed_event = event.from<EventType::KeyPressed>();
       auto event_modifiers = key_pressed_event.modifiers & ~SpecialModifiers;