method_detection.hpp

Go to the documentation of this file.

/**
 * @file method_detection.hpp
 * @brief Method and interface detection for driver validation
 * @ingroup validation
 *
 * Uses C++17 SFINAE (Substitution Failure Is Not An Error) to detect what methods
 * drivers provide at compile-time. This enables comprehensive driver contract
 * validation with clear error messages.
 *
 * ## SFINAE Pattern
 *
 * All detection uses the consistent std::void_t pattern:
 * ```cpp
 * template<typename T, typename = void>
 * struct has_method : std::false_type {};
 *
 * template<typename T>
 * struct has_method<T, std::void_t<decltype(T::method(...))>>
 *     : std::true_type {};
 * ```
 *
 * @see gpio_requirements.hpp
 */
 
#ifndef SBL_VALIDATION_METHOD_DETECTION_HPP_
#define SBL_VALIDATION_METHOD_DETECTION_HPP_
 
#include <type_traits>
#include <cstdint>
#include <cstddef>
 
// Include canonical HAL types
#include <sbl/hal/gpio/handle.hpp>
#include <sbl/hal/gpio/types.hpp>
#include <sbl/hal/adc/handle.hpp>
#include <sbl/hal/adc/types.hpp>
#include <sbl/hal/uart/handle.hpp>
#include <sbl/hal/audio/types.hpp>
 
namespace sbl {
namespace validation {
 
/**
 * @brief GPIO Driver Method Detection (Handle-First API)
 *
 * Detects presence of required methods in GPIO driver implementations.
 * All GPIO drivers must implement:
 * - set_mode(const GpioHandle&, PinMode)
 * - write(const GpioHandle&, bool)
 * - read(const GpioHandle&) -> bool
 * - toggle(const GpioHandle&)
 */
 
// Detect: static void set_mode(const GpioHandle&, PinMode)
template<typename T, typename = void>
struct has_gpio_set_mode : std::false_type {};
 
template<typename T>
struct has_gpio_set_mode<T, std::void_t<decltype(
    T::set_mode(std::declval<const sbl::GpioHandle&>(),
                std::declval<sbl::hal::gpio::PinMode>()))>>
    : std::true_type {};
 
// Detect: static void write(const GpioHandle&, bool)
template<typename T, typename = void>
struct has_gpio_write : std::false_type {};
 
template<typename T>
struct has_gpio_write<T, std::void_t<decltype(
    T::write(std::declval<const sbl::GpioHandle&>(),
             std::declval<bool>()))>>
    : std::true_type {};
 
// Detect: static bool read(const GpioHandle&)
template<typename T, typename = void>
struct has_gpio_read : std::false_type {};
 
template<typename T>
struct has_gpio_read<T, std::void_t<decltype(
    T::read(std::declval<const sbl::GpioHandle&>()))>>
    : std::true_type {};
 
// Detect: static void toggle(const GpioHandle&)
template<typename T, typename = void>
struct has_gpio_toggle : std::false_type {};
 
template<typename T>
struct has_gpio_toggle<T, std::void_t<decltype(
    T::toggle(std::declval<const sbl::GpioHandle&>()))>>
    : std::true_type {};
 
/**
 * @brief Combined GPIO driver interface check
 *
 * True if driver implements all required handle-first GPIO methods.
 */
template<typename GpioDriver>
struct gpio_driver_interface_complete {
    static constexpr bool value =
        has_gpio_set_mode<GpioDriver>::value &&
        has_gpio_write<GpioDriver>::value &&
        has_gpio_read<GpioDriver>::value &&
        has_gpio_toggle<GpioDriver>::value;
};
 
/**
 * @brief Timer Driver Method Detection
 *
 * Required (all platforms):
 * - busy_wait_ms(uint32_t)
 * - millis() -> uint32_t
 * - micros() -> uint32_t
 *
 * Optional (platform-specific):
 * - init(uint32_t) — STM32 needs it, RP2xxx don't
 */
 
// Detect: static void busy_wait_ms(uint32_t)
template<typename T, typename = void>
struct has_timer_busy_wait_ms : std::false_type {};
 
template<typename T>
struct has_timer_busy_wait_ms<T, std::void_t<decltype(
    T::busy_wait_ms(std::declval<uint32_t>()))>>
    : std::true_type {};
 
// Detect: static uint32_t millis()
template<typename T, typename = void>
struct has_timer_millis : std::false_type {};
 
template<typename T>
struct has_timer_millis<T, std::void_t<decltype(T::millis())>>
    : std::true_type {};
 
// Detect: static uint32_t micros()
template<typename T, typename = void>
struct has_timer_micros : std::false_type {};
 
template<typename T>
struct has_timer_micros<T, std::void_t<decltype(T::micros())>>
    : std::true_type {};
 
// Detect: static init(uint32_t) — optional
template<typename T, typename = void>
struct has_timer_init : std::false_type {};
 
template<typename T>
struct has_timer_init<T, std::void_t<decltype(
    T::init(std::declval<uint32_t>()))>>
    : std::true_type {};
 
// Return type: micros() must return uint32_t
template<typename T, typename = void>
struct timer_micros_returns_uint32 : std::false_type {};
 
template<typename T>
struct timer_micros_returns_uint32<T, std::enable_if_t<
    std::is_same_v<decltype(T::micros()), uint32_t>>> : std::true_type {};
 
/**
 * @brief Combined Timer driver interface check
 *
 * True if driver implements all required Timer methods.
 */
template<typename TimerDriver>
struct timer_driver_interface_complete {
    static constexpr bool value =
        has_timer_busy_wait_ms<TimerDriver>::value &&
        has_timer_millis<TimerDriver>::value &&
        has_timer_micros<TimerDriver>::value;
};
 
/**
 * @brief UART Driver Method Detection
 *
 * Detects presence of required methods in UART driver implementations.
 *
 * Required (all platforms):
 * - init(const UartHandle&)
 * - init_rx(const UartHandle&)
 * - write_byte(uint8_t)
 * - write(const uint8_t*, size_t)
 * - write_string(const char*)
 * - available() -> bool
 * - read_byte() -> uint8_t
 *
 * Optional (platform-specific):
 * - try_write_byte(uint8_t) -> bool
 * - try_write_string(const char*) -> size_t
 */
 
// Detect: static init(const UartHandle&) — returns void or bool
template<typename T, typename = void>
struct has_uart_init : std::false_type {};
 
template<typename T>
struct has_uart_init<T, std::void_t<decltype(
    T::init(std::declval<const sbl::UartHandle&>()))>>
    : std::true_type {};
 
// Detect: static init_rx(const UartHandle&) — returns void or bool
template<typename T, typename = void>
struct has_uart_init_rx : std::false_type {};
 
template<typename T>
struct has_uart_init_rx<T, std::void_t<decltype(
    T::init_rx(std::declval<const sbl::UartHandle&>()))>>
    : std::true_type {};
 
// Detect: static void write_byte(uint8_t)
template<typename T, typename = void>
struct has_uart_write_byte : std::false_type {};
 
template<typename T>
struct has_uart_write_byte<T, std::void_t<decltype(
    T::write_byte(std::declval<uint8_t>()))>>
    : std::true_type {};
 
// Detect: static void write_string(const char*)
template<typename T, typename = void>
struct has_uart_write_string : std::false_type {};
 
template<typename T>
struct has_uart_write_string<T, std::void_t<decltype(
    T::write_string(std::declval<const char*>()))>>
    : std::true_type {};
 
// Detect: static bool available()
template<typename T, typename = void>
struct has_uart_available : std::false_type {};
 
template<typename T>
struct has_uart_available<T, std::void_t<decltype(T::available())>>
    : std::true_type {};
 
// Detect: static uint8_t read_byte()
template<typename T, typename = void>
struct has_uart_read_byte : std::false_type {};
 
template<typename T>
struct has_uart_read_byte<T, std::void_t<decltype(T::read_byte())>>
    : std::true_type {};
 
// Detect: static bool try_write_byte(uint8_t) — optional
template<typename T, typename = void>
struct has_uart_try_write_byte : std::false_type {};
 
template<typename T>
struct has_uart_try_write_byte<T, std::void_t<decltype(
    T::try_write_byte(std::declval<uint8_t>()))>>
    : std::true_type {};
 
// Detect: static size_t try_write_string(const char*) — optional
template<typename T, typename = void>
struct has_uart_try_write_string : std::false_type {};
 
template<typename T>
struct has_uart_try_write_string<T, std::void_t<decltype(
    T::try_write_string(std::declval<const char*>()))>>
    : std::true_type {};
 
// Return type: available() must return bool
template<typename T, typename = void>
struct uart_available_returns_bool : std::false_type {};
 
template<typename T>
struct uart_available_returns_bool<T, std::enable_if_t<
    std::is_same_v<decltype(T::available()), bool>>> : std::true_type {};
 
// Return type: read_byte() must return uint8_t
template<typename T, typename = void>
struct uart_read_byte_returns_uint8 : std::false_type {};
 
template<typename T>
struct uart_read_byte_returns_uint8<T, std::enable_if_t<
    std::is_same_v<decltype(T::read_byte()), uint8_t>>> : std::true_type {};
 
// Return type: try_write_byte() must return bool (if present)
template<typename T, typename = void>
struct uart_try_write_byte_returns_bool : std::false_type {};
 
template<typename T>
struct uart_try_write_byte_returns_bool<T, std::enable_if_t<
    std::is_same_v<decltype(T::try_write_byte(std::declval<uint8_t>())), bool>>>
    : std::true_type {};
 
// Detect: static void write(const uint8_t*, std::size_t)
template<typename T, typename = void>
struct has_uart_write : std::false_type {};
 
template<typename T>
struct has_uart_write<T, std::void_t<decltype(
    T::write(std::declval<const uint8_t*>(),
             std::declval<std::size_t>()))>>
    : std::true_type {};
 
/**
 * @brief Combined UART driver interface check
 *
 * True if driver implements all required UART methods.
 */
template<typename UartDriver>
struct uart_driver_interface_complete {
    static constexpr bool value =
        has_uart_init<UartDriver>::value &&
        has_uart_init_rx<UartDriver>::value &&
        has_uart_write_byte<UartDriver>::value &&
        has_uart_write<UartDriver>::value &&
        has_uart_write_string<UartDriver>::value &&
        has_uart_available<UartDriver>::value &&
        has_uart_read_byte<UartDriver>::value;
};
 
/**
 * @brief ADC Driver Method Detection
 *
 * Detects presence of required methods in ADC driver implementations.
 * ADC drivers must implement:
 * - init()
 * - configure_channel(const AdcHandle&, SampleTime)
 * - start_conversion(const AdcHandle&)
 * - is_conversion_complete() -> bool
 * - read_raw() -> uint16_t
 * - resolution_bits() -> uint8_t (constexpr)
 */
 
// Detect: static init() — returns void or bool
template<typename T, typename = void>
struct has_adc_init : std::false_type {};
 
template<typename T>
struct has_adc_init<T, std::void_t<decltype(T::init())>>
    : std::true_type {};
 
// Detect: static void configure_channel(const AdcHandle&, SampleTime)
template<typename T, typename = void>
struct has_adc_configure_channel : std::false_type {};
 
template<typename T>
struct has_adc_configure_channel<T, std::void_t<decltype(
    T::configure_channel(std::declval<const sbl::AdcHandle&>(),
                         std::declval<sbl::hal::adc::SampleTime>()))>>
    : std::true_type {};
 
// Detect: static void start_conversion(const AdcHandle&)
template<typename T, typename = void>
struct has_adc_start_conversion : std::false_type {};
 
template<typename T>
struct has_adc_start_conversion<T, std::void_t<decltype(
    T::start_conversion(std::declval<const sbl::AdcHandle&>()))>>
    : std::true_type {};
 
// Detect: static bool is_conversion_complete()
template<typename T, typename = void>
struct has_adc_is_conversion_complete : std::false_type {};
 
template<typename T>
struct has_adc_is_conversion_complete<T, std::void_t<decltype(T::is_conversion_complete())>>
    : std::true_type {};
 
// Detect: static uint16_t read_raw()
template<typename T, typename = void>
struct has_adc_read_raw : std::false_type {};
 
template<typename T>
struct has_adc_read_raw<T, std::void_t<decltype(T::read_raw())>>
    : std::true_type {};
 
// Detect: static constexpr uint8_t resolution_bits()
template<typename T, typename = void>
struct has_adc_resolution_bits : std::false_type {};
 
template<typename T>
struct has_adc_resolution_bits<T, std::void_t<decltype(T::resolution_bits())>>
    : std::true_type {};
 
/**
 * @brief Combined ADC driver interface check
 *
 * True if driver implements all required ADC methods.
 */
template<typename AdcDriver>
struct adc_driver_interface_complete {
    static constexpr bool value =
        has_adc_init<AdcDriver>::value &&
        has_adc_configure_channel<AdcDriver>::value &&
        has_adc_start_conversion<AdcDriver>::value &&
        has_adc_is_conversion_complete<AdcDriver>::value &&
        has_adc_read_raw<AdcDriver>::value &&
        has_adc_resolution_bits<AdcDriver>::value;
};
 
// Detect: static void start_dma_scan(...) — optional
template<typename T, typename = void>
struct has_adc_start_dma_scan : std::false_type {};
 
template<typename T>
struct has_adc_start_dma_scan<T, std::void_t<decltype(
    T::start_dma_scan(std::declval<const sbl::AdcHandle*>(),
                      std::declval<uint8_t>(),
                      std::declval<uint16_t*>(),
                      std::declval<sbl::hal::adc::SampleTime>()))>>
    : std::true_type {};
 
// Detect: static void stop_dma_scan() — optional
template<typename T, typename = void>
struct has_adc_stop_dma_scan : std::false_type {};
 
template<typename T>
struct has_adc_stop_dma_scan<T, std::void_t<decltype(T::stop_dma_scan())>>
    : std::true_type {};
 
/**
 * @brief Audio Driver Method Detection
 *
 * Detects presence of required methods in Audio driver implementations.
 * Audio drivers must implement:
 * - init()
 * - init(const AudioConfig&)
 * - set_callback(AudioCallback)
 * - start()
 * - stop()
 */
 
// Detect: static void init() [no-arg]
template<typename T, typename = void>
struct has_audio_init : std::false_type {};
 
template<typename T>
struct has_audio_init<T, std::void_t<decltype(T::init())>>
    : std::true_type {};
 
// Detect: static void init(const AudioConfig&)
template<typename T, typename = void>
struct has_audio_init_config : std::false_type {};
 
template<typename T>
struct has_audio_init_config<T, std::void_t<decltype(
    T::init(std::declval<const sbl::hal::audio::AudioConfig&>()))>>
    : std::true_type {};
 
// Detect: static void set_callback(AudioCallback)
template<typename T, typename = void>
struct has_audio_set_callback : std::false_type {};
 
template<typename T>
struct has_audio_set_callback<T, std::void_t<decltype(
    T::set_callback(std::declval<sbl::hal::audio::AudioCallback>()))>>
    : std::true_type {};
 
// Detect: static void start()
template<typename T, typename = void>
struct has_audio_start : std::false_type {};
 
template<typename T>
struct has_audio_start<T, std::void_t<decltype(T::start())>>
    : std::true_type {};
 
// Detect: static void stop()
template<typename T, typename = void>
struct has_audio_stop : std::false_type {};
 
template<typename T>
struct has_audio_stop<T, std::void_t<decltype(T::stop())>>
    : std::true_type {};
 
/**
 * @brief Combined Audio driver interface check
 *
 * True if driver implements all required audio methods.
 */
template<typename AudioDriver>
struct audio_driver_interface_complete {
    static constexpr bool value =
        has_audio_init<AudioDriver>::value &&
        has_audio_init_config<AudioDriver>::value &&
        has_audio_set_callback<AudioDriver>::value &&
        has_audio_start<AudioDriver>::value &&
        has_audio_stop<AudioDriver>::value;
};
 
} // namespace validation
} // namespace sbl
 
#endif // SBL_VALIDATION_METHOD_DETECTION_HPP_