alicat_basis2_uart_interface.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <cstddef>
#include <type_traits>
 
namespace alicat_basis2 {
 
template <typename Derived>
class UartInterface {
public:
    void write(const uint8_t* data, std::size_t length) noexcept {
        static_cast<Derived*>(this)->write(data, length);
    }
 
    std::size_t read(uint8_t* out, std::size_t max, uint32_t timeout_ms) noexcept {
        return static_cast<Derived*>(this)->read(out, max, timeout_ms);
    }
 
    void flush_rx() noexcept {
        static_cast<Derived*>(this)->flush_rx();
    }
 
    void delay_ms(uint32_t ms) noexcept {
        if constexpr (HasDelay<Derived>::value) {
            static_cast<Derived*>(this)->delay_ms_impl(ms);
        } else {
            (void)ms;
        }
    }
 
    template <typename... Args>
    void log(const char* tag, const char* fmt, Args... args) noexcept {
      if constexpr (HasLog<Derived, Args...>::value) {
        static_cast<Derived*>(this)->log_impl(tag, fmt, args...);
      } else {
        (void)tag;
        (void)fmt;
        ((void)args, ...);
      }
    }
 
private:
    template <typename, typename = void>
    struct HasDelay : std::false_type {};
    template <typename T>
    struct HasDelay<T, std::void_t<decltype(std::declval<T&>().delay_ms_impl(uint32_t{0}))>>
        : std::true_type {};
 
    template <typename T, typename Void, typename... Args>
    struct HasLogImpl : std::false_type {};
    template <typename T, typename... Args>
    struct HasLogImpl<T,
                      std::void_t<decltype(std::declval<T&>().log_impl(
                          static_cast<const char*>(nullptr), static_cast<const char*>(nullptr),
                          std::declval<Args>()...))>,
                      Args...> : std::true_type {};
    template <typename T, typename... Args>
    using HasLog = HasLogImpl<T, void, Args...>;
};
 
}  // namespace alicat_basis2