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