component.hpp

#pragma once
#include <bugui/concepts/device.hpp>
#include <bugui/concepts/color.hpp>
#include <bugui/concepts/protocol.hpp>
 
namespace bugui
{
// Color
template <typename Device, typename Component>
struct color_t final
{
  using type = void;
};

template <typename Device, typename Component>
  requires (has_color<Device> || !has_color<Component>)
struct color_t<Device, Component> final
{
  using type = class Device::color;
};

template <typename Device, has_color Component>
struct color_t<Device, Component> final
{
  using type = class Component::color;
};
 
// protocol
template <typename Device, typename Component>
struct protocol_t final
{
  using type = Device;
};

template <typename Device, has_protocol Component>
struct protocol_t<Device, Component> final
{
  using type = Component;
};
 
// clear
template <typename Device, typename Component>
struct clear_t;

template <has_clear Device, typename Component>
  requires (!has_clear<Component>)
struct clear_t<Device, Component> final
{
  using type = class Device::clear;
};

template <typename Device, has_clear Component>
struct clear_t<Device, Component> final
{
  using type = class Component::clear;
};
 
// init
template <typename Device, typename Component>
  requires (has_init<Device> || !has_init<Component>)
struct init_t final
{
  using type = class Component::init;
};

template <typename Device, typename Component>
  requires (has_init<Device> && !has_init<Component>)
struct init_t<Device, Component> final
{
  using type = class Device::init;
};
 
// component
template <typename Device, typename Component>
struct component;
 
// template <typename Device, typename Component>
// struct component final
// {
//   using color_t = color_t<Device, Component>::type;
//   using protocol_t = protocol_t<Device, Component>::type;
//   using init_t = init_t<Device, Component>::type;
//   using clear_t = clear_t<Device, Component>::type;
// };
 
} // namespace bugui