draconisplusplus/include/rfl/TaggedUnion.hpp

#ifndef RFL_TAGGEDUNION_HPP_
#define RFL_TAGGEDUNION_HPP_

#include <variant>

#include "define_literal.hpp"
#include "internal/Getter.hpp"
#include "internal/StringLiteral.hpp"
#include "internal/tag_t.hpp"

namespace rfl {

// https://serde.rs/enum-representations.html
template <internal::StringLiteral _discriminator, class... Ts>
struct TaggedUnion {
  static constexpr internal::StringLiteral discrimininator_ = _discriminator;

  /// The type of the underlying variant.
  using VariantType = std::variant<Ts...>;

  /// A literal containing all the tags that are possible
  using PossibleTags = define_literal_t<internal::tag_t<_discriminator, Ts>...>;

  TaggedUnion(const VariantType& _variant) : variant_(_variant) {}

  TaggedUnion(VariantType&& _variant) noexcept
      : variant_(std::move(_variant)) {}

  TaggedUnion(const TaggedUnion<_discriminator, Ts...>& _tagged_union) =
      default;

  TaggedUnion(TaggedUnion<_discriminator, Ts...>&& _tagged_union) noexcept =
      default;

  template <class T,
            typename std::enable_if<std::is_convertible_v<T, VariantType>,
                                    bool>::type = true>
  TaggedUnion(const T& _t) : variant_(_t) {}

  template <class T,
            typename std::enable_if<std::is_convertible_v<T, VariantType>,
                                    bool>::type = true>
  TaggedUnion(T&& _t) noexcept : variant_(std::forward<T>(_t)) {}

  ~TaggedUnion() = default;

  /// Assigns the underlying object.
  TaggedUnion<_discriminator, Ts...>& operator=(const VariantType& _variant) {
    variant_ = _variant;
    return *this;
  }

  /// Assigns the underlying object.
  TaggedUnion<_discriminator, Ts...>& operator=(VariantType&& _variant) {
    variant_ = std::move(_variant);
    return *this;
  }

  /// Assigns the underlying object.
  template <class T,
            typename std::enable_if<std::is_convertible_v<T, VariantType>,
                                    bool>::type = true>
  TaggedUnion<_discriminator, Ts...>& operator=(T&& _variant) {
    variant_ = std::forward<T>(_variant);
    return *this;
  }

  /// Assigns the underlying object.
  template <class T,
            typename std::enable_if<std::is_convertible_v<T, VariantType>,
                                    bool>::type = true>
  TaggedUnion<_discriminator, Ts...>& operator=(const T& _variant) {
    variant_ = _variant;
    return *this;
  }

  /// Assigns the underlying object.
  TaggedUnion<_discriminator, Ts...>& operator=(
      const TaggedUnion<_discriminator, Ts...>& _other) = default;

  /// Assigns the underlying object.
  TaggedUnion<_discriminator, Ts...>& operator=(
      TaggedUnion<_discriminator, Ts...>&& _other) = default;

  /// Returns the underlying variant.
  VariantType& variant() { return variant_; }

  /// Returns the underlying variant.
  const VariantType& variant() const { return variant_; }

  static_assert(!PossibleTags::has_duplicates(),
                "Duplicate tags are not allowed inside tagged unions.");

  /// The underlying variant - a TaggedUnion is a thin wrapper
  /// around a variant that is mainly used for parsing.
  VariantType variant_;
};

namespace internal {

template <StringLiteral _discriminator, class... NamedTupleTypes>
struct Getter<TaggedUnion<_discriminator, NamedTupleTypes...>> {
 public:
  /// Retrieves the indicated value from the tuple.
  template <int _index>
  static inline auto& get(
      TaggedUnion<_discriminator, NamedTupleTypes...>& _tu) {
    return Getter<std::variant<NamedTupleTypes...>>::template get<_index>(
        _tu.variant_);
  }

  /// Gets a field by name.
  template <StringLiteral _field_name>
  static inline auto& get(
      TaggedUnion<_discriminator, NamedTupleTypes...>& _tu) {
    return Getter<std::variant<NamedTupleTypes...>>::template get<_field_name>(
        _tu.variant_);
  }

  /// Gets a field by the field type.
  template <class Field>
  static inline auto& get(
      TaggedUnion<_discriminator, NamedTupleTypes...>& _tu) {
    return Getter<std::variant<NamedTupleTypes...>>::template get<Field>(
        _tu.variant_);
  }

  /// Retrieves the indicated value from the tuple.
  template <int _index>
  static inline const auto& get_const(
      const TaggedUnion<_discriminator, NamedTupleTypes...>& _tu) {
    return Getter<std::variant<NamedTupleTypes...>>::template get_const<_index>(
        _tu.variant_);
  }

  /// Gets a field by name.
  template <StringLiteral _field_name>
  static inline const auto& get_const(
      const TaggedUnion<_discriminator, NamedTupleTypes...>& _tu) {
    return Getter<std::variant<NamedTupleTypes...>>::template get_const<
        _field_name>(_tu.variant_);
  }

  /// Gets a field by the field type.
  template <class Field>
  static inline const auto& get_const(
      const TaggedUnion<_discriminator, NamedTupleTypes...>& _tu) {
    return Getter<std::variant<NamedTupleTypes...>>::template get_const<Field>(
        _tu.variant_);
  }
};

}  // namespace internal

}  // namespace rfl

#endif  // RFL_TAGGEDUNION_HPP_