draconisplusplus/include/rfl/parsing/ViewReader.hpp

#ifndef RFL_PARSING_VIEWREADER_HPP_
#define RFL_PARSING_VIEWREADER_HPP_

#include <array>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>

#include "../Result.hpp"
#include "../internal/is_array.hpp"

namespace rfl::parsing {

template <class R, class W, class ViewType, class ProcessorsType>
class ViewReader {
 private:
  using InputVarType = typename R::InputVarType;
  static constexpr size_t size_ = ViewType::size();

 public:
  ViewReader(const R* _r, ViewType* _view, std::array<bool, size_>* _found,
             std::array<bool, size_>* _set, std::vector<Error>* _errors)
      : r_(_r), view_(_view), found_(_found), set_(_set), errors_(_errors) {}

  ~ViewReader() = default;

  /// Assigns the parsed version of _var to the field signified by _name, if
  /// such a field exists in the underlying view.
  void read(const std::string_view& _name, const InputVarType& _var) const {
    assign_to_matching_field(*r_, _name, _var, view_, errors_, found_, set_,
                             std::make_integer_sequence<int, size_>());
  }

  /// Because of the way we have allocated the fields, we need to manually
  /// trigger the destructors.
  void call_destructors_where_necessary() const {
    [&]<int... is>(std::integer_sequence<int, is...>) {
      (call_destructor_on_one_if_necessary<is>(), ...);
    }
    (std::make_integer_sequence<int, size_>());
  }

 private:
  template <int i>
  static void assign_if_field_matches(const R& _r,
                                      const std::string_view& _current_name,
                                      const auto& _var, auto* _view,
                                      auto* _errors, auto* _found, auto* _set,
                                      bool* _already_assigned) {
    using FieldType = std::tuple_element_t<i, typename ViewType::Fields>;
    using OriginalType = typename FieldType::Type;
    using T =
        std::remove_cvref_t<std::remove_pointer_t<typename FieldType::Type>>;
    constexpr auto name = FieldType::name();
    if (!(*_already_assigned) && !std::get<i>(*_found) &&
        _current_name == name) {
      std::get<i>(*_found) = true;
      *_already_assigned = true;
      auto res = Parser<R, W, T, ProcessorsType>::read(_r, _var);
      if (!res) {
        _errors->emplace_back(Error("Failed to parse field '" +
                                    std::string(name) +
                                    "': " + std::move(res.error()->what())));
        return;
      }
      if constexpr (std::is_pointer_v<OriginalType>) {
        move_to(rfl::get<i>(*_view), &(*res));
      } else {
        rfl::get<i>(*_view) = std::move(*res);
      }
      std::get<i>(*_set) = true;
    }
  }

  template <int... is>
  static void assign_to_matching_field(const R& _r,
                                       const std::string_view& _current_name,
                                       const auto& _var, auto* _view,
                                       auto* _errors, auto* _found, auto* _set,
                                       std::integer_sequence<int, is...>) {
    bool already_assigned = false;
    (assign_if_field_matches<is>(_r, _current_name, _var, _view, _errors,
                                 _found, _set, &already_assigned),
     ...);
  }

  template <class T>
  static void call_destructor_on_array(const size_t _size, T* _ptr) {
    for (size_t i = 0; i < _size; ++i) {
      if constexpr (std::is_array_v<T>) {
        call_destructor_on_array(sizeof(*_ptr) / sizeof(**_ptr), *(_ptr + i));
      } else if constexpr (std::is_destructible_v<T>) {
        (_ptr + i)->~T();
      }
    }
  }

  template <int _i>
  void call_destructor_on_one_if_necessary() const {
    using FieldType = std::tuple_element_t<_i, typename ViewType::Fields>;
    using OriginalType = std::remove_cvref_t<typename FieldType::Type>;
    using ValueType =
        std::remove_cvref_t<std::remove_pointer_t<typename FieldType::Type>>;
    if constexpr (!std::is_array_v<ValueType> &&
                  std::is_pointer_v<OriginalType> &&
                  std::is_destructible_v<ValueType>) {
      if (std::get<_i>(*set_)) {
        rfl::get<_i>(*view_)->~ValueType();
      }
    } else if constexpr (std::is_array_v<ValueType>) {
      if (std::get<_i>(*set_)) {
        auto ptr = rfl::get<_i>(*view_);
        call_destructor_on_array(sizeof(*ptr) / sizeof(**ptr), *ptr);
      }
    }
  }

  template <class Target, class Source>
  static void move_to(Target* _t, Source* _s) {
    if constexpr (std::is_const_v<Target>) {
      return move_to(const_cast<std::remove_const_t<Target>*>(_t), _s);
    } else if constexpr (!rfl::internal::is_array_v<Source> &&
                         !std::is_array_v<Target>) {
      ::new (_t) Target(std::move(*_s));
    } else if constexpr (rfl::internal::is_array_v<Source>) {
      static_assert(std::is_array_v<Target>,
                    "Expected target to be a c-array.");
      for (size_t i = 0; i < _s->arr_.size(); ++i) {
        move_to(&((*_t)[i]), &(_s->arr_[i]));
      }
    } else {
      for (size_t i = 0; i < _s->size(); ++i) {
        move_to(&((*_t)[i]), &((*_s)[i]));
      }
    }
  }

 private:
  /// The underlying reader.
  const R* r_;

  /// The underlying view.
  ViewType* view_;

  /// Indicates that a certain field has been found.
  std::array<bool, size_>* found_;

  /// Indicates that a certain field has been successfully set - necessary,
  /// because we have to trigger the destructors manually.
  std::array<bool, size_>* set_;

  /// Collects any errors we may have come across.
  std::vector<Error>* errors_;
};

}  // namespace rfl::parsing

#endif