refactor: get rid of unordered_map in multiton classes

Author: zhora15

firmware/src/chipset/Servo/Servo.cpp

@@ -1,14 +1,21 @@
 #include "Servo.h"
 
+#include <array>
+#include <memory>
+
 #include "system_clock.h"
 
 Servo& Servo::get_instance(ServoType type) {
-    static std::unordered_map<ServoType, Servo *> instances;
-    auto it = instances.find(type);
-    if (it == instances.end()) {
-        instances[type] = new Servo(type);
+    static std::array<std::pair<ServoType, std::unique_ptr<Servo>>, 2> instances{
+        std::make_pair(ServoType::SERVO_LEFT,  std::make_unique<Servo>(Servo(ServoType::SERVO_LEFT))),
+        std::make_pair(ServoType::SERVO_RIGHT, std::make_unique<Servo>(Servo(ServoType::SERVO_RIGHT)))
+    };
+
+    for (auto& p : instances) {
+        if (p.first == type) {
+            return *p.second;
+        }
     }
-    return *instances[type];
 }
 
 uint32_t Servo::init() {

firmware/src/chipset/Servo/include/Servo.h

@@ -40,15 +40,17 @@ class Servo {
       }
   }
 
-  Servo(ServoType type) : pwm(get_pwm_instance(type)), adc(get_adc_instance(type)) {
-      type_ = type;
-  };
+  explicit Servo(ServoType type) : pwm(get_pwm_instance(type)), adc(get_adc_instance(type)), type_(type) {};
 
-  ~Servo() {};
   Servo(const Servo &obj) = delete;
   Servo &operator=(const Servo &obj) = delete;
 
  public:
+  Servo(Servo &&obj) noexcept = default;
+  Servo &operator=(Servo &&obj) noexcept = default;
+
+  ~Servo() = default;
+
   static Servo &get_instance(ServoType type);
 
   uint32_t init();

firmware/src/chipset/ads1115/ads1115.cpp

@@ -1,6 +1,7 @@
 #include "ads1115.h"
 
-#include <unordered_map>
+#include <array>
+#include <memory>
 
 #include "ads1115_registers.h"
 
@@ -18,12 +19,16 @@ ADS1115::ADS1115(ADCServoType id) {
 }
 
 ADS1115& ADS1115::get_instance(ADCServoType type) {
-    static std::unordered_map<ADCServoType, ADS1115 *> instances;
-    auto it = instances.find(type);
-    if (it == instances.end()) {
-        instances[type] = new ADS1115(type);
+    static std::array<std::pair<ADCServoType, std::unique_ptr<ADS1115>>, 2> instances{
+        std::make_pair(ADCServoType::ADC_SERVO_1, std::make_unique<ADS1115>(ADS1115(ADCServoType::ADC_SERVO_1))),
+        std::make_pair(ADCServoType::ADC_SERVO_2, std::make_unique<ADS1115>(ADS1115(ADCServoType::ADC_SERVO_2)))
+    };
+
+    for (auto& p : instances) {
+        if (p.first == type) {
+            return *p.second;
+        }
     }
-    return *instances[type];
 }
 
 uint32_t ADS1115::init(void) {

firmware/src/chipset/ads1115/include/ads1115.h

@@ -12,10 +12,6 @@ enum class ADCServoType : uint8_t {
 
 class ADS1115 {
  private:
-  ADS1115(ADCServoType id);
-  ~ADS1115() {};
-  ADS1115(const ADS1115 &obj);
-  ADS1115 &operator=(const ADS1115 &obj);
 
   I2C &i2c_handle = I2C::getInstance();
   uint8_t i2c_address = 0x00;
@@ -24,7 +20,16 @@ class ADS1115 {
 
   uint32_t config(void);
 
+  explicit ADS1115(ADCServoType id);
+
+  ADS1115(const ADS1115 &obj) = delete;
+  ADS1115 &operator=(const ADS1115 &obj) = delete;
  public:
+  ADS1115(ADS1115 &&obj) noexcept = default;
+  ADS1115 &operator=(ADS1115 &&obj) noexcept = default;
+
+  ~ADS1115() = default;
+
   uint32_t init();
   static ADS1115 &get_instance(ADCServoType type);
   uint32_t read_value(uint16_t& value);

firmware/src/chipset/wheel_encoder/include/wheel_encoder.h

@@ -3,7 +3,6 @@
 #define TRUCK_HW_CHIPSET_WHEEL_ENCODER_INCLUDE_WHEEL_ECNODER_H_
 
 #include <cstdint>
-#include <unordered_map>
 
 #include "encoder_timer.h"
 
@@ -21,17 +20,15 @@ class WheelEncoder {
   static constexpr float low_pass_coef = 0.1f;
 
   bool is_initialized = false;
-  enum WheelType type;
+  enum WheelType type_;
   EncoderTimer& encoder_timer_handle;
   static constexpr uint32_t max_data_size = 50;
   std::vector<int> encoder_ticks;
 
   float current_speed = 0.0f;
   uint32_t last_tick_ts = 0;
 
-  ~WheelEncoder() {};
-  WheelEncoder(const WheelEncoder &obj) = delete;
-  WheelEncoder &operator=(const WheelEncoder &obj) = delete;
+  void low_pas_filter_apply(float raw_speed);
 
   static EncoderTimer &get_timer_instance(WheelType wheel_type_) {
       switch (wheel_type_) {
@@ -46,11 +43,17 @@ class WheelEncoder {
       }
   }
 
-  WheelEncoder(WheelType id) : encoder_timer_handle(get_timer_instance(id)), type(id) {};
+  explicit WheelEncoder(WheelType type) : encoder_timer_handle(get_timer_instance(type)), type_(type) {};
 
-  void low_pas_filter_apply(float raw_speed);
+  WheelEncoder(const WheelEncoder &obj) = delete;
+  WheelEncoder &operator=(const WheelEncoder &obj) = delete;
 
  public:
+  WheelEncoder(WheelEncoder &&obj) noexcept = default;
+  WheelEncoder &operator=(WheelEncoder &&obj) noexcept = default;
+
+  ~WheelEncoder() = default;
+
   static WheelEncoder &get_instance(WheelType id);
 
   uint32_t init(void);

firmware/src/chipset/wheel_encoder/wheel_encoder.cpp

@@ -1,14 +1,23 @@
 #include "wheel_encoder.h"
 
+#include <array>
+#include <memory>
+
 #include "system_clock.h"
 
-WheelEncoder& WheelEncoder::get_instance(WheelType id) {
-    static std::unordered_map<WheelType, WheelEncoder *> instances;
-    auto it = instances.find(id);
-    if (it == instances.end()) {
-        instances[id] = new WheelEncoder(id);
+WheelEncoder& WheelEncoder::get_instance(WheelType type) {
+    static std::array<std::pair<WheelType, std::unique_ptr<WheelEncoder>>, 4> instances{
+        std::make_pair(WheelType::LEFT_FRONT,  std::make_unique<WheelEncoder>(WheelEncoder(WheelType::LEFT_FRONT))),
+        std::make_pair(WheelType::RIGHT_FRONT, std::make_unique<WheelEncoder>(WheelEncoder(WheelType::RIGHT_FRONT))),
+        std::make_pair(WheelType::LEFT_REAR,   std::make_unique<WheelEncoder>(WheelEncoder(WheelType::LEFT_REAR))),
+        std::make_pair(WheelType::RIGHT_REAR,  std::make_unique<WheelEncoder>(WheelEncoder(WheelType::RIGHT_REAR))),
+    };
+
+    for (auto& p : instances) {
+        if (p.first == type) {
+            return *p.second;
+        }
     }
-    return *instances[id];
 }
 
 uint32_t WheelEncoder::init(void) {

firmware/src/mcu/periphery/encoder_timer/encoder_timer.cpp

@@ -1,21 +1,31 @@
 #include "encoder_timer.h"
+
+#include <cstdio>
+#include <vector>
+#include <array>
+#include <memory>
+
 #include "stm32g4xx_ll_bus.h"
 #include "stm32g4xx_ll_tim.h"
 #include "stm32g4xx_ll_gpio.h"
-#include <vector>
-#include <cstdio>
 
 bool EncoderTimer::is_common_tim_initialized = false;
 
 static volatile bool dma_complete_irq[4] = {false};
 
-EncoderTimer& EncoderTimer::get_instance(EncoderType id) {
-    static std::unordered_map<EncoderType, EncoderTimer *> instances;
-    auto it = instances.find(id);
-    if (it == instances.end()) {
-        instances[id] = new EncoderTimer(id);
+EncoderTimer& EncoderTimer::get_instance(EncoderType type) {
+    static std::array<std::pair<EncoderType, std::unique_ptr<EncoderTimer>>, 4> instances{
+        std::make_pair(EncoderType::ID_0, std::make_unique<EncoderTimer>(EncoderTimer(EncoderType::ID_0))),
+        std::make_pair(EncoderType::ID_1, std::make_unique<EncoderTimer>(EncoderTimer(EncoderType::ID_1))),
+        std::make_pair(EncoderType::ID_2, std::make_unique<EncoderTimer>(EncoderTimer(EncoderType::ID_2))),
+        std::make_pair(EncoderType::ID_3, std::make_unique<EncoderTimer>(EncoderTimer(EncoderType::ID_3))),
+    };
+
+    for (auto& p : instances) {
+        if (p.first == type) {
+            return *p.second;
+        }
     }
-    return *instances[id];
 }
 
 uint32_t EncoderTimer::init() {

firmware/src/mcu/periphery/encoder_timer/include/encoder_timer.h

@@ -2,7 +2,6 @@
 #define TRUCK_HW_PERIPHERY_ENCODER_TIMER_INCLUDE_ENCODER_TIMER_H_
 
 #include <cstdint>
-#include <unordered_map>
 #include <array>
 #include <vector>
 #include <limits>
@@ -34,14 +33,19 @@ class EncoderTimer {
   uint32_t timer_channel;
   uint32_t dma_channel;
 
-  EncoderTimer(EncoderType id);
-  ~EncoderTimer() {};
+  uint32_t get_data_size();
+
+  explicit EncoderTimer(EncoderType id);
+
   EncoderTimer(const EncoderTimer &obj) = delete;
   EncoderTimer &operator=(const EncoderTimer &obj) = delete;
 
-  uint32_t get_data_size();
-
  public:
+  EncoderTimer(EncoderTimer &&obj) noexcept = default;
+  EncoderTimer &operator=(EncoderTimer &&obj) noexcept = default;
+
+  ~EncoderTimer() = default;
+
   static EncoderTimer &get_instance(EncoderType id);
 
   uint32_t init();

firmware/src/mcu/periphery/pwm_servo/include/pwm_servo.h

@@ -1,7 +1,6 @@
 #ifndef TRUCK_HW_PERIPHERY_PWM_SERVO_INCLUDE_PWM_SERVO_H_
 #define TRUCK_HW_PERIPHERY_PWM_SERVO_INCLUDE_PWM_SERVO_H_
 
-#include <unordered_map>
 #include "stm32g4xx_ll_tim.h"
 
 enum class PWMServoType : uint8_t {
@@ -19,12 +18,17 @@ class PWMServo {
   static constexpr uint32_t TIM_AUTORELOAD = 20000;
   uint32_t timer_channel;
 
-  PWMServo(PWMServoType init_type);
-  ~PWMServo() {};
+  explicit PWMServo(PWMServoType init_type);
+
   PWMServo(const PWMServo &obj) = delete;
   PWMServo &operator=(const PWMServo &obj) = delete;
 
  public:
+  PWMServo(PWMServo &&obj) noexcept = default;
+  PWMServo &operator=(PWMServo &&obj) noexcept = default;
+
+  ~PWMServo() = default;
+
   static PWMServo &get_instance(PWMServoType type);
 
   uint32_t init();

firmware/src/mcu/periphery/pwm_servo/pwm_servo.cpp

@@ -1,5 +1,8 @@
 #include "pwm_servo.h"
 
+#include <array>
+#include <memory>
+
 #include "stm32g4xx_ll_gpio.h"
 #include "stm32g4xx_ll_bus.h"
 
@@ -20,12 +23,16 @@ PWMServo::PWMServo(PWMServoType id) {
 }
 
 PWMServo& PWMServo::get_instance(PWMServoType type) {
-    static std::unordered_map<PWMServoType, PWMServo *> instances;
-    auto it = instances.find(type);
-    if (it == instances.end()) {
-        instances[type] = new PWMServo(type);
+    static std::array<std::pair<PWMServoType, std::unique_ptr<PWMServo>>, 2> instances{
+        std::make_pair(PWMServoType::PWM_SERVO_1, std::make_unique<PWMServo>(PWMServo(PWMServoType::PWM_SERVO_1))),
+        std::make_pair(PWMServoType::PWM_SERVO_2, std::make_unique<PWMServo>(PWMServo(PWMServoType::PWM_SERVO_2)))
+    };
+
+    for (auto& p : instances) {
+        if (p.first == type) {
+            return *p.second;
+        }
     }
-    return *instances[type];
 }
 
 uint32_t PWMServo::init() {