rarg.h

#pragma once
 
#include "libmicroemu/register_id.h"
#include "libmicroemu/types.h"
#include <cstddef>
#include <cstdint>
#include <type_traits>

template <libmicroemu::RegisterId Rid> class RArgConst {
public:
  static constexpr auto kRegId = Rid;
  constexpr libmicroemu::RegisterId Get() const { return kRegId; }

  constexpr RArgConst() = default;

  ~RArgConst() = default;

  constexpr RArgConst(const RArgConst &r_src) = default;

  constexpr RArgConst &operator=(const RArgConst &r_src) = default;

  constexpr RArgConst(RArgConst &&r_src) = default;

  constexpr RArgConst &operator=(RArgConst &&r_src) = default;
 
  // Equality operator
  template <typename R> bool operator==(const R &other) const { return Get() == other.Get(); }
 
  // Inequality operator
  template <typename R> bool operator!=(const R &other) const { return !(Get() == other.Get()); }
 
private:
  // Deleting the addition operator
  RArgConst operator+(const RArgConst &) = delete;
 
  // Deleting the subtraction operator
  RArgConst operator-(const RArgConst &) = delete;
 
  // Deleting the multiplication operator
  RArgConst operator*(const RArgConst &) = delete;
 
  // Deleting the division operator
  RArgConst operator/(const RArgConst &) = delete;
};

template <typename T> class RArg {
public:
  RArg(T reg_id) : val_(reg_id) {
    static_assert(std::is_integral<T>::value, "T must be an integral type");
    static_assert(std::is_unsigned<T>::value, "T must be an unsigned type");
    static_assert(std::is_same_v<T, std::underlying_type_t<libmicroemu::RegisterId>>,
                  "RArg only allows underlying type of RegisterId");
  }

  ~RArg() = default;

  RArg(const RArg &r_src) = default;

  RArg &operator=(const RArg &r_src) = default;

  RArg(RArg &&r_src) = default;

  RArg &operator=(RArg &&r_src) = default;
 
  inline libmicroemu::RegisterId Get() const { return static_cast<libmicroemu::RegisterId>(val_); }
 
  // Equality operator
  template <typename R> bool operator==(const R &other) const { return Get() == other.Get(); }
 
  // Inequality operator
  template <typename R> bool operator!=(const R &other) const { return !(Get() == other.Get()); }
 
private:
  T val_;
 
  // Deleting the addition operator
  RArg operator+(const RArg &) = delete;
 
  // Deleting the subtraction operator
  RArg operator-(const RArg &) = delete;
 
  // Deleting the multiplication operator
  RArg operator*(const RArg &) = delete;
 
  // Deleting the division operator
  RArg operator/(const RArg &) = delete;
};