draconisplusplus/include/rfl/parsing/Parser_variant.hpp

#ifndef RFL_PARSING_PARSER_VARIANT_HPP_
#define RFL_PARSING_PARSER_VARIANT_HPP_

#include <map>
#include <optional>
#include <type_traits>
#include <variant>

#include "../Ref.hpp"
#include "../Result.hpp"
#include "../always_false.hpp"
#include "FieldVariantParser.hpp"
#include "Parser_base.hpp"
#include "schema/Type.hpp"
#include "to_single_error_message.hpp"

namespace rfl {
namespace parsing {

template <class R, class W, class... FieldTypes, class ProcessorsType>
requires AreReaderAndWriter<R, W, std::variant<FieldTypes...>>
class Parser<R, W, std::variant<FieldTypes...>, ProcessorsType> {
 public:
  using InputVarType = typename R::InputVarType;
  using OutputVarType = typename W::OutputVarType;

  static Result<std::variant<FieldTypes...>> read(
      const R& _r, const InputVarType& _var) noexcept {
    if constexpr (internal::all_fields<std::tuple<FieldTypes...>>()) {
      return FieldVariantParser<R, W, ProcessorsType, FieldTypes...>::read(
          _r, _var);
    } else {
      std::optional<std::variant<FieldTypes...>> result;
      std::vector<Error> errors;
      read_variant(_r, _var, &result, &errors);
      if (result) {
        return std::move(*result);
      } else {
        return Error(
            to_single_error_message(errors,
                                    "Could not parse the variant. Each of the "
                                    "possible alternatives failed "
                                    "for the following reasons: ",
                                    100000));
      }
    }
  }

  template <class P>
  static void write(const W& _w, const std::variant<FieldTypes...>& _variant,
                    const P& _parent) noexcept {
    if constexpr (internal::all_fields<std::tuple<FieldTypes...>>()) {
      FieldVariantParser<R, W, ProcessorsType, FieldTypes...>::write(
          _w, _variant, _parent);
    } else {
      const auto handle = [&](const auto& _v) {
        using Type = std::remove_cvref_t<decltype(_v)>;
        Parser<R, W, Type, ProcessorsType>::write(_w, _v, _parent);
      };
      return std::visit(handle, _variant);
    }
  }

  template <size_t _i = 0>
  static schema::Type to_schema(
      std::map<std::string, schema::Type>* _definitions,
      std::vector<schema::Type> _types = {}) {
    if constexpr (internal::all_fields<std::tuple<FieldTypes...>>()) {
      return FieldVariantParser<R, W, ProcessorsType, FieldTypes...>::to_schema(
          _definitions);
    } else {
      using Type = schema::Type;
      constexpr size_t size = sizeof...(FieldTypes);
      if constexpr (_i == size) {
        return Type{Type::AnyOf{.types_ = _types}};
      } else {
        using U = std::remove_cvref_t<
            std::variant_alternative_t<_i, std::variant<FieldTypes...>>>;
        _types.push_back(
            Parser<R, W, U, ProcessorsType>::to_schema(_definitions));
        return to_schema<_i + 1>(_definitions, std::move(_types));
      }
    }
  }

 private:
  template <int _i = 0>
  static void read_variant(const R& _r, const InputVarType& _var,
                           std::optional<std::variant<FieldTypes...>>* _result,
                           std::vector<Error>* _errors) noexcept {
    constexpr size_t size = sizeof...(FieldTypes);
    if constexpr (_i < size) {
      using AltType = std::remove_cvref_t<
          std::variant_alternative_t<_i, std::variant<FieldTypes...>>>;
      auto res = Parser<R, W, AltType, ProcessorsType>::read(_r, _var);
      if (res) {
        *_result = std::move(*res);
        return;
      } else {
        _errors->emplace_back(*res.error());
        return read_variant<_i + 1>(_r, _var, _result, _errors);
      }
    }
  }
};

}  // namespace parsing
}  // namespace rfl

#endif