variants.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "irsol/macros.hpp"
#include "irsol/protocol/message/binary.hpp"
#include "irsol/traits.hpp"
#include "irsol/types.hpp"
 
#include <string>
#include <variant>
 
namespace irsol {
namespace protocol {
 
enum class InMessageKind
{
  ASSIGNMENT,
  INQUIRY,
  COMMAND
};
 
constexpr const char*
InMessageKindToString(InMessageKind kind)
{
  switch(kind) {
    case InMessageKind::ASSIGNMENT:
      return "ASSIGNMENT";
    case InMessageKind::INQUIRY:
      return "INQUIRY";
    case InMessageKind::COMMAND:
      return "COMMAND";
  }
  IRSOL_UNREACHABLE();
}
 
// Forward declarations of incoming message types
struct Assignment;
struct Inquiry;
struct Command;
 
using InMessage = std::variant<Assignment, Inquiry, Command>;
 
enum class OutMessageKind
{
  SUCCESS,
  BINARY_BUFFER,
  BW_IMAGE,
  COLOR_IMAGE,
  ERROR
};
 
constexpr const char*
OutMessageKindToString(OutMessageKind kind)
{
  switch(kind) {
    case OutMessageKind::SUCCESS:
      return "SUCCESS";
    case OutMessageKind::BINARY_BUFFER:
      return "BINARY_BUFFER";
    case OutMessageKind::BW_IMAGE:
      return "BW_IMAGE";
    case OutMessageKind::COLOR_IMAGE:
      return "COLOR_IMAGE";
    case OutMessageKind::ERROR:
      return "ERROR";
  }
  IRSOL_UNREACHABLE();
}
 
// Forward declarations of outgoing message types
struct Success;
struct Error;
 
using OutMessage =
  std::variant<Success, BinaryDataBuffer, ImageBinaryData, ColorImageBinaryData, Error>;
 
std::string toString(const InMessage& msg);
 
std::string toString(const OutMessage& msg);
 
template<typename T, std::enable_if_t<irsol::traits::is_type_in_variant_v<T, InMessage>, int> = 0>
constexpr InMessageKind
getInMessageKind(IRSOL_MAYBE_UNUSED const T& msg)
{
  if constexpr(std::is_same_v<T, Assignment>)
    return InMessageKind::ASSIGNMENT;
  else if constexpr(std::is_same_v<T, Inquiry>)
    return InMessageKind::INQUIRY;
  else if constexpr(std::is_same_v<T, Command>)
    return InMessageKind::COMMAND;
  else
    IRSOL_MISSING_TEMPLATE_SPECIALIZATION(T, "getInMessageKind()");
}
 
InMessageKind getInMessageKind(const InMessage& msg);
 
template<typename T, std::enable_if_t<irsol::traits::is_type_in_variant_v<T, InMessage>, int> = 0>
constexpr bool
isAssignment(IRSOL_MAYBE_UNUSED T& msg)
{
  return std::is_same_v<T, Assignment>;
}
bool isAssignment(const InMessage& msg);
 
template<typename T, std::enable_if_t<irsol::traits::is_type_in_variant_v<T, InMessage>, int> = 0>
constexpr bool
isInquiry(IRSOL_MAYBE_UNUSED T& msg)
{
  return std::is_same_v<T, Inquiry>;
}
bool isInquiry(const InMessage& msg);
 
template<typename T, std::enable_if_t<irsol::traits::is_type_in_variant_v<T, InMessage>, int> = 0>
constexpr bool
isCommand(IRSOL_MAYBE_UNUSED T& msg)
{
  return std::is_same_v<T, Command>;
}
bool isCommand(const InMessage& msg);
 
template<typename T, std::enable_if_t<irsol::traits::is_type_in_variant_v<T, OutMessage>, int> = 0>
constexpr OutMessageKind
getOutMessageKind(IRSOL_MAYBE_UNUSED const T& msg)
{
  if constexpr(std::is_same_v<T, Success>)
    return OutMessageKind::SUCCESS;
  else if constexpr(std::is_same_v<T, Error>)
    return OutMessageKind::ERROR;
  else if constexpr(std::is_same_v<T, BinaryDataBuffer>)
    return OutMessageKind::BINARY_BUFFER;
  else if constexpr(std::is_same_v<T, ImageBinaryData>)
    return OutMessageKind::BW_IMAGE;
  else if constexpr(std::is_same_v<T, ColorImageBinaryData>)
    return OutMessageKind::COLOR_IMAGE;
  else
    IRSOL_MISSING_TEMPLATE_SPECIALIZATION(T, "getOutMessageKind()");
}
 
OutMessageKind getOutMessageKind(const OutMessage& msg);
 
template<typename T, std::enable_if_t<irsol::traits::is_type_in_variant_v<T, OutMessage>, int> = 0>
constexpr bool
isSuccess(IRSOL_MAYBE_UNUSED T& msg)
{
  return std::is_same_v<T, Success>;
}
bool isSuccess(const OutMessage& msg);
 
template<typename T, std::enable_if_t<irsol::traits::is_type_in_variant_v<T, OutMessage>, int> = 0>
constexpr bool
isBinaryDataBuffer(IRSOL_MAYBE_UNUSED T& msg)
{
  return std::is_same_v<T, BinaryDataBuffer>;
}
bool isBinaryDataBuffer(const OutMessage& msg);
 
template<typename T, std::enable_if_t<irsol::traits::is_type_in_variant_v<T, OutMessage>, int> = 0>
constexpr bool
isImageBinaryData(IRSOL_MAYBE_UNUSED T& msg)
{
  return std::is_same_v<T, ImageBinaryData>;
}
bool isImageBinaryData(const OutMessage& msg);
 
template<typename T, std::enable_if_t<irsol::traits::is_type_in_variant_v<T, OutMessage>, int> = 0>
constexpr bool
isColorImageBinaryData(IRSOL_MAYBE_UNUSED T& msg)
{
  return std::is_same_v<T, ColorImageBinaryData>;
}
bool isColorImageBinaryData(const OutMessage& msg);
 
template<typename T, std::enable_if_t<irsol::traits::is_type_in_variant_v<T, OutMessage>, int> = 0>
constexpr bool
isError(IRSOL_MAYBE_UNUSED T& msg)
{
  return std::is_same_v<T, Error>;
}
bool isError(const OutMessage& msg);
 
}  // namespace protocol
}  // namespace irsol