feat: Unify usage of StrongType::get_value() and make this function a template function

get_value can now be used as a type converter if the type is specified.

- remove all wrapper functions (e.g, get_num, get_level, etc...) from the associated strong type classes
- unify the usage of the  inherited get_value() method throughout the code
- remove specific conversion functions and use template function StrongValue::get_value<>() instead

Author: SoucheSouche

examples/simple_spi_rw_example/main/simple_spi_rw_example.cpp

@@ -32,7 +32,7 @@ extern "C" void app_main(void)
                 MISO(26),
                 SCLK(27));
 
-        shared_ptr<SPIDevice> spi_dev = master.create_dev(CS(NSS.get_num()), Frequency::MHz(1));
+        shared_ptr<SPIDevice> spi_dev = master.create_dev(CS(NSS.get_value()), Frequency::MHz(1));
 
         vector<uint8_t> write_data = {MPU9250_WHO_AM_I_REG_ADDR | READ_FLAG, 0x00};
         vector<uint8_t> result = spi_dev->transfer(write_data).get();

gpio_cxx.cpp

@@ -31,11 +31,6 @@ constexpr std::array<uint32_t, 0> INVALID_GPIOS = {};
 #error "No GPIOs defined for the current target"
 #endif
 
-gpio_num_t gpio_to_driver_type(const GPIONum &gpio_num)
-{
-    return static_cast<gpio_num_t>(gpio_num.get_num());
-}
-
 }
 
 GPIOException::GPIOException(esp_err_t error) : ESPException(error) { }
@@ -117,55 +112,55 @@ GPIODriveStrength GPIODriveStrength::STRONGEST()
 
 GPIOBase::GPIOBase(GPIONum num) : gpio_num(num)
 {
-    GPIO_CHECK_THROW(gpio_reset_pin(gpio_to_driver_type(gpio_num)));
+    GPIO_CHECK_THROW(gpio_reset_pin(gpio_num.get_value<gpio_num_t>()));
 }
 
 void GPIOBase::hold_en()
 {
-    GPIO_CHECK_THROW(gpio_hold_en(gpio_to_driver_type(gpio_num)));
+    GPIO_CHECK_THROW(gpio_hold_en(gpio_num.get_value<gpio_num_t>()));
 }
 
 void GPIOBase::hold_dis()
 {
-    GPIO_CHECK_THROW(gpio_hold_dis(gpio_to_driver_type(gpio_num)));
+    GPIO_CHECK_THROW(gpio_hold_dis(gpio_num.get_value<gpio_num_t>()));
 }
 
 void GPIOBase::set_drive_strength(GPIODriveStrength strength)
 {
-    GPIO_CHECK_THROW(gpio_set_drive_capability(gpio_to_driver_type(gpio_num),
-            static_cast<gpio_drive_cap_t>(strength.get_strength())));
+    GPIO_CHECK_THROW(gpio_set_drive_capability(gpio_num.get_value<gpio_num_t>(),
+                                               strength.get_value<gpio_drive_cap_t>()));
 }
 
 GPIO_Output::GPIO_Output(GPIONum num) : GPIOBase(num)
 {
-    GPIO_CHECK_THROW(gpio_set_direction(gpio_to_driver_type(gpio_num), GPIO_MODE_OUTPUT));
+    GPIO_CHECK_THROW(gpio_set_direction(gpio_num.get_value<gpio_num_t>(), GPIO_MODE_OUTPUT));
 }
 
 void GPIO_Output::set_high()
 {
-    GPIO_CHECK_THROW(gpio_set_level(gpio_to_driver_type(gpio_num), 1));
+    GPIO_CHECK_THROW(gpio_set_level(gpio_num.get_value<gpio_num_t>(), 1));
 }
 
 void GPIO_Output::set_low()
 {
-    GPIO_CHECK_THROW(gpio_set_level(gpio_to_driver_type(gpio_num), 0));
+    GPIO_CHECK_THROW(gpio_set_level(gpio_num.get_value<gpio_num_t>(), 0));
 }
 
 GPIODriveStrength GPIOBase::get_drive_strength()
 {
     gpio_drive_cap_t strength;
-    GPIO_CHECK_THROW(gpio_get_drive_capability(gpio_to_driver_type(gpio_num), &strength));
+    GPIO_CHECK_THROW(gpio_get_drive_capability(gpio_num.get_value<gpio_num_t>(), &strength));
     return GPIODriveStrength(static_cast<uint32_t>(strength));
 }
 
 GPIOInput::GPIOInput(GPIONum num) : GPIOBase(num)
 {
-    GPIO_CHECK_THROW(gpio_set_direction(gpio_to_driver_type(gpio_num), GPIO_MODE_INPUT));
+    GPIO_CHECK_THROW(gpio_set_direction(gpio_num.get_value<gpio_num_t>(), GPIO_MODE_INPUT));
 }
 
 GPIOLevel GPIOInput::get_level() const noexcept
 {
-    int level = gpio_get_level(gpio_to_driver_type(gpio_num));
+    int level = gpio_get_level(gpio_num.get_value<gpio_num_t>());
     if (level) {
         return GPIOLevel::HIGH;
     } else {
@@ -175,34 +170,34 @@ GPIOLevel GPIOInput::get_level() const noexcept
 
 void GPIOInput::set_pull_mode(GPIOPullMode mode)
 {
-    GPIO_CHECK_THROW(gpio_set_pull_mode(gpio_to_driver_type(gpio_num),
-            static_cast<gpio_pull_mode_t>(mode.get_pull_mode())));
+    GPIO_CHECK_THROW(gpio_set_pull_mode(gpio_num.get_value<gpio_num_t>(),
+                                        mode.get_value<gpio_pull_mode_t>()));
 }
 
 void GPIOInput::wakeup_enable(GPIOWakeupIntrType interrupt_type)
 {
-    GPIO_CHECK_THROW(gpio_wakeup_enable(gpio_to_driver_type(gpio_num),
-            static_cast<gpio_int_type_t>(interrupt_type.get_level())));
+    GPIO_CHECK_THROW(gpio_wakeup_enable(gpio_num.get_value<gpio_num_t>(),
+                                        interrupt_type.get_value<gpio_int_type_t>()));
 }
 
 void GPIOInput::wakeup_disable()
 {
-    GPIO_CHECK_THROW(gpio_wakeup_disable(gpio_to_driver_type(gpio_num)));
+    GPIO_CHECK_THROW(gpio_wakeup_disable(gpio_num.get_value<gpio_num_t>()));
 }
 
 GPIO_OpenDrain::GPIO_OpenDrain(GPIONum num) : GPIOInput(num)
 {
-    GPIO_CHECK_THROW(gpio_set_direction(gpio_to_driver_type(gpio_num), GPIO_MODE_INPUT_OUTPUT_OD));
+    GPIO_CHECK_THROW(gpio_set_direction(gpio_num.get_value<gpio_num_t>(), GPIO_MODE_INPUT_OUTPUT_OD));
 }
 
 void GPIO_OpenDrain::set_floating()
 {
-    GPIO_CHECK_THROW(gpio_set_level(gpio_to_driver_type(gpio_num), 1));
+    GPIO_CHECK_THROW(gpio_set_level(gpio_num.get_value<gpio_num_t>(), 1));
 }
 
 void GPIO_OpenDrain::set_low()
 {
-    GPIO_CHECK_THROW(gpio_set_level(gpio_to_driver_type(gpio_num), 0));
+    GPIO_CHECK_THROW(gpio_set_level(gpio_num.get_value<gpio_num_t>(), 0));
 }
 
 }

host_test/fixtures/test_fixtures.hpp

@@ -86,8 +86,8 @@ struct GPIOFixture : public CMockFixture {
     GPIOFixture(idf::GPIONum gpio_num = idf::GPIONum(18), gpio_mode_t mode = GPIO_MODE_OUTPUT)
         : CMockFixture(), num(gpio_num)
     {
-        gpio_reset_pin_ExpectAndReturn(static_cast<gpio_num_t>(num.get_num()), ESP_OK);
-        gpio_set_direction_ExpectAndReturn(static_cast<gpio_num_t>(num.get_num()), mode, ESP_OK);
+        gpio_reset_pin_ExpectAndReturn(static_cast<gpio_num_t>(num.get_value()), ESP_OK);
+        gpio_set_direction_ExpectAndReturn(static_cast<gpio_num_t>(num.get_value()), mode, ESP_OK);
     }
 
     idf::GPIONum num;