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>
 
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::core::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
 *
 * Detects presence of required methods in Timer driver implementations.
 */
 
// Detect: static void delay_ms(uint32_t)
template<typename T, typename = void>
struct has_timer_delay_ms : std::false_type {};
 
template<typename T>
struct has_timer_delay_ms<T, std::void_t<decltype(
    T::delay_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 {};
 
/**
 * @brief UART Driver Method Detection
 *
 * Detects presence of required methods in UART driver implementations.
 * UART drivers must implement:
 * - init(const UartHandle&)
 * - write_byte(uint8_t byte)
 * - write(const uint8_t* data, size_t len)
 */
 
// Detect: static void init(const UartHandle&)
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 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(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 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 void init()
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::core::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;
};
 
} // namespace validation
} // namespace sbl
 
#endif // SBL_VALIDATION_METHOD_DETECTION_HPP_