ASTNodeListAffectationExpressionBuilder.cpp

#include <ASTNodeListAffectationExpressionBuilder.hpp>
#include <PEGGrammar.hpp>

#include <node_processor/AffectationProcessor.hpp>

#include <ASTNodeDataTypeFlattener.hpp>
#include <ASTNodeNaturalConversionChecker.hpp>

template <typename OperatorT>
void
ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
  const ASTNodeSubDataType& rhs_node_sub_data_type,
  ASTNode& value_node,
  std::unique_ptr<ListAffectationProcessor<OperatorT>>& list_affectation_processor)
{
  auto add_affectation_processor_for_data = [&](const auto& value, const ASTNodeSubDataType& node_sub_data_type) {
    using ValueT = std::decay_t<decltype(value)>;
    switch (node_sub_data_type.m_data_type) {
    case ASTNodeDataType::bool_t: {
      list_affectation_processor->template add<ValueT, bool>(value_node);
      break;
    }
    case ASTNodeDataType::unsigned_int_t: {
      list_affectation_processor->template add<ValueT, uint64_t>(value_node);
      break;
    }
    case ASTNodeDataType::int_t: {
      list_affectation_processor->template add<ValueT, int64_t>(value_node);
      break;
    }
    case ASTNodeDataType::double_t: {
      list_affectation_processor->template add<ValueT, double>(value_node);
      break;
    }
      // LCOV_EXCL_START
    default: {
      throw parse_error("unexpected error: invalid operand type for affectation",
                        std::vector{node_sub_data_type.m_parent_node.begin()});
    }
      // LCOV_EXCL_STOP
    }
  };

  auto add_affectation_processor_for_vector_data = [&](const auto& value,
                                                       const ASTNodeSubDataType& node_sub_data_type) {
    using ValueT = std::decay_t<decltype(value)>;
    if constexpr (std::is_same_v<ValueT, TinyVector<1>>) {
      if ((node_sub_data_type.m_data_type == ASTNodeDataType::vector_t) and
          (node_sub_data_type.m_data_type.dimension() == value.dimension())) {
        list_affectation_processor->template add<ValueT, ValueT>(value_node);
      } else {
        add_affectation_processor_for_data(value, node_sub_data_type);
      }
    } else if constexpr (std::is_same_v<ValueT, TinyVector<2>> or std::is_same_v<ValueT, TinyVector<3>>) {
      if ((node_sub_data_type.m_data_type == ASTNodeDataType::vector_t) and
          (node_sub_data_type.m_data_type.dimension() == value.dimension())) {
        list_affectation_processor->template add<ValueT, ValueT>(value_node);
      } else if (node_sub_data_type.m_parent_node.is_type<language::integer>()) {
        if (std::stoi(node_sub_data_type.m_parent_node.string()) == 0) {
          list_affectation_processor->template add<ValueT, ZeroType>(value_node);
        } else {
          throw parse_error("invalid operand value", std::vector{node_sub_data_type.m_parent_node.begin()});
        }
      } else {
        throw parse_error("invalid dimension", std::vector{node_sub_data_type.m_parent_node.begin()});
      }
    } else {
      throw parse_error("unexpected error: invalid value type");
    }
  };