uart_requirements.hpp

Go to the documentation of this file.

/**
 * @file uart_requirements.hpp
 * @brief UART driver requirements validator
 * @ingroup validation
 *
 * Validates that UART drivers provide required functionality using the
 * method detection system. This is the core UART contract enforcement
 * for Sound Byte Libs drivers.
 *
 * ## UART Driver Contract
 *
 * Every Sound Byte Libs UART driver MUST implement these methods:
 * - `init(const UartHandle&)` - Initialize UART with manifest-resolved handle
 * - `write_byte(uint8_t byte)` - Write single byte (blocking)
 * - `write(const uint8_t* data, size_t len)` - Write buffer (blocking)
 *
 * ## Validation Usage
 *
 * Add validation at the bottom of driver uart.hpp:
 * ```cpp
 * #include <sbl/validation/uart_requirements.hpp>
 * static_assert(sbl::validation::uart_driver_valid<sbl::driver::Uart>,
 *               "UART driver missing required methods");
 * ```
 *
 * @see method_detection.hpp
 */
 
#ifndef SBL_VALIDATION_UART_REQUIREMENTS_HPP_
#define SBL_VALIDATION_UART_REQUIREMENTS_HPP_
 
#include "method_detection.hpp"
 
namespace sbl {
namespace validation {
 
/**
 * @brief UART driver requirements validator
 *
 * Validates that UART drivers provide all required methods.
 */
template<typename UartDriver>
class UartDriverRequirements {
public:
    /**
     * @brief Validate all required UART methods
     */
    static constexpr bool validate() {
        static_assert(has_uart_init<UartDriver>::value,
                      "SBL ERROR: UART driver missing init() method.\n"
                      "Required: static void init(const sbl::UartHandle& handle)");
 
        static_assert(has_uart_write_byte<UartDriver>::value,
                      "SBL ERROR: UART driver missing write_byte() method.\n"
                      "Required: static void write_byte(uint8_t byte)");
 
        static_assert(has_uart_write<UartDriver>::value,
                      "SBL ERROR: UART driver missing write() method.\n"
                      "Required: static void write(const uint8_t* data, size_t len)");
 
        return true;
    }
};
 
/**
 * @brief Helper to validate a UART driver implementation
 *
 * Usage:
 * ```cpp
 * static_assert(sbl::validation::uart_driver_valid<MyUartDriver>,
 *               "UART driver incomplete");
 * ```
 */
template<typename UartDriver>
constexpr bool uart_driver_valid = UartDriverRequirements<UartDriver>::validate();
 
} // namespace validation
} // namespace sbl
 
#endif // SBL_VALIDATION_UART_REQUIREMENTS_HPP_