draconisplusplus/include/rfl/Literal.hpp

#ifndef RFL_LITERAL_HPP_
#define RFL_LITERAL_HPP_

#include <cstdint>
#include <functional>
#include <limits>
#include <stdexcept>
#include <string>
#include <tuple>
#include <type_traits>

#include "Result.hpp"
#include "internal/StringLiteral.hpp"
#include "internal/VisitTree.hpp"

namespace rfl {

template <internal::StringLiteral _field>
struct LiteralHelper {
  constexpr static internal::StringLiteral field_ = _field;
};

template <internal::StringLiteral... fields_>
class Literal {
  using FieldsType = std::tuple<LiteralHelper<fields_>...>;

 public:
  using ValueType =
      std::conditional_t<sizeof...(fields_) <=
                             std::numeric_limits<std::uint8_t>::max(),
                         std::uint8_t, std::uint16_t>;

  /// The number of different fields or different options that the literal
  /// can assume.
  static constexpr ValueType num_fields_ = sizeof...(fields_);

  using ReflectionType = std::string;

  /// Constructs a Literal from another literal.
  Literal(const Literal<fields_...>& _other) = default;

  /// Constructs a Literal from another literal.
  Literal(Literal<fields_...>&& _other) noexcept = default;

  Literal(const std::string& _str) : value_(find_value(_str).value()) {}

  /// A single-field literal is special because it
  /// can also have a default constructor.
  template <ValueType num_fields = num_fields_,
            typename = std::enable_if_t<num_fields <= 1>>
  Literal() : value_(0) {}

  ~Literal() = default;

  /// Constructs a new Literal.
  template <internal::StringLiteral _name>
  static Literal<fields_...> make() {
    return Literal(Literal<fields_...>::template value_of<_name>());
  }

  /// Constructs a new Literal, equivalent to make, for reasons of consistency.
  template <internal::StringLiteral _name>
  static Literal<fields_...> from_name() {
    return Literal<fields_...>::template make<_name>();
  }

  /// Constructs a new Literal.
  template <ValueType _value>
  static Literal<fields_...> from_value() {
    static_assert(_value < num_fields_,
                  "Value cannot exceed number of fields.");
    return Literal<fields_...>(_value);
  }

  /// Constructs a new Literal.
  static Result<Literal<fields_...>> from_value(ValueType _value) {
    if (_value >= num_fields_) {
      return Error("Value cannot exceed number of fields.");
    }
    return Literal<fields_...>(_value);
  }

  /// Determines whether the literal contains the string.
  static bool contains(const std::string& _str) {
    bool found = false;
    has_value(_str, &found);
    return found;
  }

  /// Determines whether the literal contains the string at compile time.
  template <internal::StringLiteral _name>
  static constexpr bool contains() {
    return find_value_of<_name>() != -1;
  }

  /// Determines whether the literal contains any of the strings in the other
  /// literal at compile time.
  template <class OtherLiteralType, int _i = 0>
  static constexpr bool contains_any() {
    if constexpr (_i == num_fields_) {
      return false;
    } else {
      constexpr auto name = find_name_within_own_fields<_i>();
      return OtherLiteralType::template contains<name>() ||
             contains_any<OtherLiteralType, _i + 1>();
    }
  }

  /// Determines whether the literal contains all of the strings in the other
  /// literal at compile time.
  template <class OtherLiteralType, int _i = 0, int _n_found = 0>
  static constexpr bool contains_all() {
    if constexpr (_i == num_fields_) {
      return _n_found == OtherLiteralType::num_fields_;
    } else {
      constexpr auto name = find_name_within_own_fields<_i>();
      if constexpr (OtherLiteralType::template contains<name>()) {
        return contains_all<OtherLiteralType, _i + 1, _n_found + 1>();
      } else {
        return contains_all<OtherLiteralType, _i + 1, _n_found>();
      }
    }
  }

  /// Determines whether the literal has duplicate strings at compile time.
  /// These is useful for checking collections of strings in other contexts.
  static constexpr bool has_duplicates() { return has_duplicate_strings(); }

  /// Constructs a Literal from a string. Returns an error if the string
  /// cannot be found.
  static Result<Literal> from_string(const std::string& _str) {
    const auto to_literal = [](const auto& _v) {
      return Literal<fields_...>(_v);
    };
    return find_value(_str).transform(to_literal);
  };

  /// The name defined by the Literal.
  std::string name() const { return find_name(); }

  /// Returns all possible values of the literal as a std::vector<std::string>.
  static std::vector<std::string> names() { return allowed_strings_vec(); }

  /// Helper function to retrieve a name at compile time.
  template <int _value>
  constexpr static auto name_of() {
    constexpr auto name = find_name_within_own_fields<_value>();
    return Literal<name>();
  }

  /// Assigns from another literal.
  Literal<fields_...>& operator=(const Literal<fields_...>& _other) = default;

  /// Assigns from another literal.
  Literal<fields_...>& operator=(Literal<fields_...>&& _other) noexcept =
      default;

  /// Assigns the literal from a string
  Literal<fields_...>& operator=(const std::string& _str) {
    value_ = find_value(_str);
    return *this;
  }

  /// <=> for other Literals with the same fields.
  auto operator<=>(const Literal<fields_...>& _other) const {
    return value() <=> _other.value();
  }

  /// <=> for other Literals with different fields.
  template <internal::StringLiteral... _fields>
  inline auto operator<=>(const Literal<_fields...>& _l2) const {
    return name() <=> _l2.name();
  }

  /// <=> for strings.
  inline auto operator<=>(const std::string& _str) const {
    return name() <=> _str;
  }

  /// <=> for const char*.
  template <internal::StringLiteral... other_fields>
  inline auto operator<=>(const char* _str) const {
    return name() <=> _str;
  }

  /// Equality operator.
  template <class Other>
  bool operator==(const Other& _other) const {
    return (*this <=> _other) == 0;
  }

  /// Alias for .name().
  std::string reflection() const { return name(); }

  /// Returns the number of fields in the Literal.
  static constexpr size_t size() { return num_fields_; }

  /// Alias for .name().
  std::string str() const { return name(); }

  /// Alias for .names().
  static std::vector<std::string> strings() { return allowed_strings_vec(); }

  /// Returns the value actually contained in the Literal.
  ValueType value() const { return value_; }

  /// Returns the value of the string literal in the template.
  template <internal::StringLiteral _name>
  static constexpr ValueType value_of() {
    constexpr auto value = find_value_of<_name>();
    static_assert(value >= 0, "String not supported.");
    return value;
  }

 private:
  /// Only the static methods are allowed to access this.
  Literal(const ValueType _value) : value_(_value) {}

  /// Returns all of the allowed fields.
  static std::string allowed_strings() {
    const auto vec = allowed_strings_vec();
    std::string str;
    for (size_t i = 0; i < vec.size(); ++i) {
      const auto head = "'" + vec[i] + "'";
      str += i == 0 ? head : (", " + head);
    }
    return str;
  }

  /// Returns all of the allowed fields.
  template <int _i = 0>
  static std::vector<std::string> allowed_strings_vec(
      std::vector<std::string> _values = {}) {
    using FieldType = typename std::tuple_element<_i, FieldsType>::type;
    const auto head = FieldType::field_.str();
    _values.push_back(head);
    if constexpr (_i + 1 < num_fields_) {
      return allowed_strings_vec<_i + 1>(std::move(_values));
    } else {
      return _values;
    }
  }

  /// Whether the Literal contains duplicate strings.
  template <int _i = 1>
  constexpr static bool has_duplicate_strings() {
    if constexpr (_i >= num_fields_) {
      return false;
    } else {
      return is_duplicate<_i>() || has_duplicate_strings<_i + 1>();
    }
  }

  template <int _i, int _j = _i - 1>
  constexpr static bool is_duplicate() {
    using FieldType1 = typename std::tuple_element<_i, FieldsType>::type;
    using FieldType2 = typename std::tuple_element<_j, FieldsType>::type;
    if constexpr (FieldType1::field_ == FieldType2::field_) {
      return true;
    } else if constexpr (_j > 0) {
      return is_duplicate<_i, _j - 1>();
    } else {
      return false;
    }
  }

  /// Finds the correct index associated with
  /// the string at run time.
  template <int _i = 0>
  std::string find_name() const {
    if (_i == value_) {
      using FieldType = typename std::tuple_element<_i, FieldsType>::type;
      return FieldType::field_.str();
    }
    if constexpr (_i + 1 == num_fields_) {
      return "";
    } else {
      return find_name<_i + 1>();
    }
  }

  /// Finds the correct index associated with
  /// the string at compile time within the Literal's own fields.
  template <int _i>
  constexpr static auto find_name_within_own_fields() {
    using FieldType = typename std::tuple_element<_i, FieldsType>::type;
    return FieldType::field_;
  }

  /// Finds the correct value associated with
  /// the string at run time.
  template <int _i = 0>
  static Result<int> find_value(const std::string& _str) {
    using FieldType = typename std::tuple_element<_i, FieldsType>::type;
    if (FieldType::field_.str() == _str) {
      return _i;
    }
    if constexpr (_i + 1 == num_fields_) {
      return Error(
          "Literal does not support string '" + _str +
          "'. The following strings are supported: " + allowed_strings() + ".");
    } else {
      return find_value<_i + 1>(_str);
    }
  }

  /// Finds the value of a string literal at compile time.
  template <internal::StringLiteral _name, int _i = 0>
  static constexpr int find_value_of() {
    if constexpr (_i == num_fields_) {
      return -1;
    } else {
      using FieldType = typename std::tuple_element<_i, FieldsType>::type;
      if constexpr (FieldType::field_ == _name) {
        return _i;
      } else {
        return find_value_of<_name, _i + 1>();
      }
    }
  }

  /// Whether the literal contains this string.
  template <int _i = 0>
  static void has_value(const std::string& _str, bool* _found) {
    if constexpr (_i == num_fields_) {
      *_found = false;
      return;
    } else {
      using FieldType = typename std::tuple_element<_i, FieldsType>::type;
      if (FieldType::field_.str() == _str) {
        *_found = true;
        return;
      }
      return has_value<_i + 1>(_str, _found);
    }
  }

  static_assert(sizeof...(fields_) <= std::numeric_limits<ValueType>::max(),
                "Too many fields.");

  static_assert(sizeof...(fields_) <= 1 || !has_duplicates(),
                "Duplicate strings are not allowed in a Literal.");

 private:
  /// The underlying value.
  ValueType value_;
};

/// Helper function to retrieve a name at compile time.
template <class LiteralType, int _value>
inline constexpr auto name_of() {
  return LiteralType::template name_of<_value>();
}

/// Helper function to retrieve a value at compile time.
template <class LiteralType, internal::StringLiteral _name>
inline constexpr auto value_of() {
  return LiteralType::template value_of<_name>();
}

}  // namespace rfl

namespace std {

template <rfl::internal::StringLiteral... fields>
struct hash<rfl::Literal<fields...>> {
  size_t operator()(const rfl::Literal<fields...>& _l) const {
    return hash<int>()(static_cast<int>(_l.value()));
  }
};

}  // namespace std

#endif  // RFL_LITERAL_HPP_