Change increment decrement operators expression builder

One now use OperatorRepository

src/language/ast/ASTNodeIncDecExpressionBuilder.cpp

 #include <language/ast/ASTNodeIncDecExpressionBuilder.hpp>
 
 #include <language/PEGGrammar.hpp>
-#include <language/node_processor/IncDecExpressionProcessor.hpp>
+#include <language/utils/IncDecOperatorMangler.hpp>
+#include <language/utils/OperatorRepository.hpp>
 #include <language/utils/ParseError.hpp>
 
 ASTNodeIncDecExpressionBuilder::ASTNodeIncDecExpressionBuilder(ASTNode& n)
 {
-  auto set_inc_dec_operator_processor = [](ASTNode& n, const auto& operator_v) {
-    auto set_inc_dec_processor_for_value = [&](const ASTNodeDataType& data_type) {
-      using OperatorT = std::decay_t<decltype(operator_v)>;
-      switch (data_type) {
-      case ASTNodeDataType::unsigned_int_t: {
-        n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, uint64_t>>(n);
-        break;
-      }
-      case ASTNodeDataType::int_t: {
-        n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, int64_t>>(n);
-        break;
-      }
-      case ASTNodeDataType::double_t: {
-        n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, double>>(n);
-        break;
-      }
-      default: {
-        throw ParseError("unexpected error: undefined data type for unary operator", std::vector{n.begin()});
-      }
-      }
-    };
+  const ASTNodeDataType& data_type = n.children[0]->m_data_type;
 
   if (not n.children[0]->is_type<language::name>()) {
-      if (n.children[0]->is_type<language::post_minusminus>() or n.children[0]->is_type<language::post_plusplus>() or
-          n.children[0]->is_type<language::unary_minusminus>() or n.children[0]->is_type<language::unary_plusplus>()) {
-        throw ParseError("chaining ++ or -- operators is not allowed", std::vector{n.children[0]->begin()});
-      } else {
-        throw ParseError("invalid operand type for unary operator", std::vector{n.children[0]->begin()});
-      }
-    }
+    std::ostringstream error_message;
+    error_message << "invalid operand type. ++/-- operators only apply to variables";
 
-    set_inc_dec_processor_for_value(n.m_data_type);
-  };
+    throw ParseError(error_message.str(), std::vector{n.children[0]->begin()});
+  }
 
+  const std::string inc_dec_operator_name = [&] {
     if (n.is_type<language::unary_minusminus>()) {
-    set_inc_dec_operator_processor(n, language::unary_minusminus{});
+      return incDecOperatorMangler<language::unary_minusminus>(data_type);
     } else if (n.is_type<language::unary_plusplus>()) {
-    set_inc_dec_operator_processor(n, language::unary_plusplus{});
+      return incDecOperatorMangler<language::unary_plusplus>(data_type);
     } else if (n.is_type<language::post_minusminus>()) {
-    set_inc_dec_operator_processor(n, language::post_minusminus{});
+      return incDecOperatorMangler<language::post_minusminus>(data_type);
     } else if (n.is_type<language::post_plusplus>()) {
-    set_inc_dec_operator_processor(n, language::post_plusplus{});
+      return incDecOperatorMangler<language::post_plusplus>(data_type);
     } else {
-    throw ParseError("unexpected error: undefined increment/decrement operator", std::vector{n.begin()});
+      throw ParseError("unexpected error: undefined inc/dec operator", std::vector{n.begin()});
+    }
+  }();
+
+  const auto& optional_processor_builder =
+    OperatorRepository::instance().getIncDecProcessorBuilder(inc_dec_operator_name);
+
+  if (optional_processor_builder.has_value()) {
+    n.m_node_processor = optional_processor_builder.value()->getNodeProcessor(n);
+  } else {
+    std::ostringstream error_message;
+    error_message << "undefined affectation type: ";
+    error_message << rang::fgB::red << inc_dec_operator_name << rang::fg::reset;
+
+    throw ParseError(error_message.str(), std::vector{n.children[0]->begin()});
   }
 }

src/language/ast/ASTNodeUnaryOperatorExpressionBuilder.cpp

 #include <language/ast/ASTNodeUnaryOperatorExpressionBuilder.hpp>
 
 #include <language/PEGGrammar.hpp>
-#include <language/node_processor/UnaryExpressionProcessor.hpp>
 #include <language/utils/OperatorRepository.hpp>
 #include <language/utils/ParseError.hpp>
 #include <language/utils/UnaryOperatorMangler.hpp>

src/language/utils/AffectationRegisterForB.hpp

 #ifndef AFFECTATION_REGISTER_FOR_B_HPP
 #define AFFECTATION_REGISTER_FOR_B_HPP
 
-#include <language/utils/OperatorRepository.hpp>
-
 class AffectationRegisterForB
 {
  public:

src/language/utils/AffectationRegisterForN.hpp

 #ifndef AFFECTATION_REGISTER_FOR_N_HPP
 #define AFFECTATION_REGISTER_FOR_N_HPP
 
-#include <language/utils/OperatorRepository.hpp>
-
 class AffectationRegisterForN
 {
  private:

src/language/utils/AffectationRegisterForR.hpp

 #ifndef AFFECTATION_REGISTER_FOR_R_HPP
 #define AFFECTATION_REGISTER_FOR_R_HPP
 
-#include <language/utils/OperatorRepository.hpp>
-
 class AffectationRegisterForR
 {
  private:

src/language/utils/AffectationRegisterForR1.hpp

 #ifndef AFFECTATION_REGISTER_FOR_R1_HPP
 #define AFFECTATION_REGISTER_FOR_R1_HPP
 
-#include <language/utils/OperatorRepository.hpp>
-
 class AffectationRegisterForR1
 {
  private:

src/language/utils/AffectationRegisterForR2.hpp

 #ifndef AFFECTATION_REGISTER_FOR_R2_HPP
 #define AFFECTATION_REGISTER_FOR_R2_HPP
 
-#include <language/utils/OperatorRepository.hpp>
-
 class AffectationRegisterForR2
 {
  private:

src/language/utils/AffectationRegisterForR3.hpp

 #ifndef AFFECTATION_REGISTER_FOR_R3_HPP
 #define AFFECTATION_REGISTER_FOR_R3_HPP
 
-#include <language/utils/OperatorRepository.hpp>
-
 class AffectationRegisterForR3
 {
  private:

src/language/utils/AffectationRegisterForString.hpp

 #ifndef AFFECTATION_REGISTER_FOR_STRING_HPP
 #define AFFECTATION_REGISTER_FOR_STRING_HPP
 
-#include <language/utils/OperatorRepository.hpp>
-
 class AffectationRegisterForString
 {
  private:

src/language/utils/AffectationRegisterForZ.hpp

 #ifndef AFFECTATION_REGISTER_FOR_Z_HPP
 #define AFFECTATION_REGISTER_FOR_Z_HPP
 
-#include <language/utils/OperatorRepository.hpp>
-
 class AffectationRegisterForZ
 {
  private:

src/language/utils/CMakeLists.txt

@@ -15,6 +15,9 @@ add_library(PugsLanguageUtils
   ASTPrinter.cpp
   DataVariant.cpp
   EmbeddedData.cpp
+  IncDecOperatorRegisterForN.cpp
+  IncDecOperatorRegisterForR.cpp
+  IncDecOperatorRegisterForZ.cpp
   OperatorRepository.cpp
   UnaryOperatorRegisterForB.cpp
   UnaryOperatorRegisterForN.cpp

src/language/utils/IIncDecOperatorProcessorBuilder.hpp

+#ifndef I_INC_DEC_OPERATOR_PROCESSOR_BUILDER_HPP
+#define I_INC_DEC_OPERATOR_PROCESSOR_BUILDER_HPP
+
+class ASTNode;
+class INodeProcessor;
+
+#include <memory>
+
+class IIncDecOperatorProcessorBuilder
+{
+ public:
+  virtual std::unique_ptr<INodeProcessor> getNodeProcessor(ASTNode& node) const = 0;
+
+  virtual ~IIncDecOperatorProcessorBuilder() = default;
+};
+
+#endif   // I_INC_DEC_OPERATOR_PROCESSOR_BUILDER_HPP

src/language/utils/IncDecOperatorMangler.hpp

+#ifndef INC_DEC_OPERATOR_MANGLER_HPP
+#define INC_DEC_OPERATOR_MANGLER_HPP
+
+#include <language/utils/ASTNodeDataType.hpp>
+#include <utils/Exceptions.hpp>
+
+#include <string>
+
+namespace language
+{
+struct unary_minusminus;
+struct unary_plusplus;
+struct post_minusminus;
+struct post_plusplus;
+}   // namespace language
+
+template <typename IncDecOperatorT>
+std::string
+incDecOperatorMangler(const ASTNodeDataType& operand)
+{
+  if constexpr (std::is_same_v<language::unary_minusminus, IncDecOperatorT>) {
+    return std::string{"-- "} + dataTypeName(operand);
+  } else if constexpr (std::is_same_v<language::post_minusminus, IncDecOperatorT>) {
+    return dataTypeName(operand) + " --";
+  } else if constexpr (std::is_same_v<language::unary_plusplus, IncDecOperatorT>) {
+    return std::string{"++ "} + dataTypeName(operand);
+  } else if constexpr (std::is_same_v<language::post_plusplus, IncDecOperatorT>) {
+    return dataTypeName(operand) + " ++";
+  } else {
+    static_assert(std::is_same_v<language::unary_minusminus, IncDecOperatorT>, "undefined inc/dec operator");
+  }
+}
+
+#endif   // INC_DEC_OPERATOR_MANGLER_HPP

src/language/utils/IncDecOperatorProcessorBuilder.hpp

+#ifndef INC_DEC_OPERATOR_PROCESSOR_BUILDER_HPP
+#define INC_DEC_OPERATOR_PROCESSOR_BUILDER_HPP
+
+#include <algebra/TinyVector.hpp>
+#include <language/PEGGrammar.hpp>
+#include <language/node_processor/IncDecExpressionProcessor.hpp>
+#include <language/utils/IIncDecOperatorProcessorBuilder.hpp>
+
+#include <type_traits>
+
+template <typename OperatorT, typename DataT>
+class IncDecOperatorProcessorBuilder final : public IIncDecOperatorProcessorBuilder
+{
+ public:
+  IncDecOperatorProcessorBuilder() = default;
+
+  std::unique_ptr<INodeProcessor>
+  getNodeProcessor(ASTNode& node) const
+  {
+    return std::make_unique<IncDecExpressionProcessor<OperatorT, DataT>>(node);
+  }
+};
+
+#endif   // INC_DEC_OPERATOR_PROCESSOR_BUILDER_HPP

src/language/utils/IncDecOperatorRegisterForN.cpp

+#include <language/utils/IncDecOperatorRegisterForN.hpp>
+
+#include <language/utils/IncDecOperatorProcessorBuilder.hpp>
+#include <language/utils/OperatorRepository.hpp>
+
+void
+IncDecOperatorRegisterForN::_register_unary_minusminus()
+{
+  OperatorRepository& repository = OperatorRepository::instance();
+
+  auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+
+  repository.addIncDecOperator<language::unary_minusminus>(N, std::make_shared<IncDecOperatorProcessorBuilder<
+                                                                language::unary_minusminus, uint64_t>>());
+}
+
+void
+IncDecOperatorRegisterForN::_register_unary_plusplus()
+{
+  OperatorRepository& repository = OperatorRepository::instance();
+
+  auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+
+  repository.addIncDecOperator<
+    language::unary_plusplus>(N,
+                              std::make_shared<IncDecOperatorProcessorBuilder<language::unary_plusplus, uint64_t>>());
+}
+
+void
+IncDecOperatorRegisterForN::_register_post_minusminus()
+{
+  OperatorRepository& repository = OperatorRepository::instance();
+
+  auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+
+  repository.addIncDecOperator<
+    language::post_minusminus>(N,
+                               std::make_shared<IncDecOperatorProcessorBuilder<language::post_minusminus, uint64_t>>());
+}
+
+void
+IncDecOperatorRegisterForN::_register_post_plusplus()
+{
+  OperatorRepository& repository = OperatorRepository::instance();
+
+  auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+
+  repository.addIncDecOperator<
+    language::post_plusplus>(N, std::make_shared<IncDecOperatorProcessorBuilder<language::post_plusplus, uint64_t>>());
+}
+
+IncDecOperatorRegisterForN::IncDecOperatorRegisterForN()
+{
+  this->_register_unary_minusminus();
+  this->_register_unary_plusplus();
+  this->_register_post_minusminus();
+  this->_register_post_plusplus();
+}

src/language/utils/IncDecOperatorRegisterForN.hpp

+#ifndef INC_DEC_OPERATOR_REGISTER_FOR_N_HPP
+#define INC_DEC_OPERATOR_REGISTER_FOR_N_HPP
+
+class IncDecOperatorRegisterForN
+{
+ private:
+  void _register_unary_minusminus();
+  void _register_unary_plusplus();
+  void _register_post_minusminus();
+  void _register_post_plusplus();
+
+ public:
+  IncDecOperatorRegisterForN();
+};
+
+#endif   // INC_DEC_OPERATOR_REGISTER_FOR_N_HPP

src/language/utils/IncDecOperatorRegisterForR.cpp

+#include <language/utils/IncDecOperatorRegisterForR.hpp>
+
+#include <language/utils/IncDecOperatorProcessorBuilder.hpp>
+#include <language/utils/OperatorRepository.hpp>
+
+void
+IncDecOperatorRegisterForR::_register_unary_minusminus()
+{
+  OperatorRepository& repository = OperatorRepository::instance();
+
+  auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+
+  repository.addIncDecOperator<language::unary_minusminus>(R, std::make_shared<IncDecOperatorProcessorBuilder<
+                                                                language::unary_minusminus, double_t>>());
+}
+
+void
+IncDecOperatorRegisterForR::_register_unary_plusplus()
+{
+  OperatorRepository& repository = OperatorRepository::instance();
+
+  auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+
+  repository.addIncDecOperator<
+    language::unary_plusplus>(R,
+                              std::make_shared<IncDecOperatorProcessorBuilder<language::unary_plusplus, double_t>>());
+}
+
+void
+IncDecOperatorRegisterForR::_register_post_minusminus()
+{
+  OperatorRepository& repository = OperatorRepository::instance();
+
+  auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+
+  repository.addIncDecOperator<
+    language::post_minusminus>(R,
+                               std::make_shared<IncDecOperatorProcessorBuilder<language::post_minusminus, double_t>>());
+}
+
+void
+IncDecOperatorRegisterForR::_register_post_plusplus()
+{
+  OperatorRepository& repository = OperatorRepository::instance();
+
+  auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+
+  repository.addIncDecOperator<
+    language::post_plusplus>(R, std::make_shared<IncDecOperatorProcessorBuilder<language::post_plusplus, double_t>>());
+}
+
+IncDecOperatorRegisterForR::IncDecOperatorRegisterForR()
+{
+  this->_register_unary_minusminus();
+  this->_register_unary_plusplus();
+  this->_register_post_minusminus();
+  this->_register_post_plusplus();
+}

src/language/utils/IncDecOperatorRegisterForR.hpp

+#ifndef INC_DEC_OPERATOR_REGISTER_FOR_R_HPP
+#define INC_DEC_OPERATOR_REGISTER_FOR_R_HPP
+
+class IncDecOperatorRegisterForR
+{
+ private:
+  void _register_unary_minusminus();
+  void _register_unary_plusplus();
+  void _register_post_minusminus();
+  void _register_post_plusplus();
+
+ public:
+  IncDecOperatorRegisterForR();
+};
+
+#endif   // INC_DEC_OPERATOR_REGISTER_FOR_Z_HPP

src/language/utils/IncDecOperatorRegisterForZ.cpp

+#include <language/utils/IncDecOperatorRegisterForZ.hpp>
+
+#include <language/utils/IncDecOperatorProcessorBuilder.hpp>
+#include <language/utils/OperatorRepository.hpp>
+
+void
+IncDecOperatorRegisterForZ::_register_unary_minusminus()
+{
+  OperatorRepository& repository = OperatorRepository::instance();
+
+  auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+
+  repository.addIncDecOperator<language::unary_minusminus>(Z, std::make_shared<IncDecOperatorProcessorBuilder<
+                                                                language::unary_minusminus, int64_t>>());
+}
+
+void
+IncDecOperatorRegisterForZ::_register_unary_plusplus()
+{
+  OperatorRepository& repository = OperatorRepository::instance();
+
+  auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+
+  repository.addIncDecOperator<
+    language::unary_plusplus>(Z, std::make_shared<IncDecOperatorProcessorBuilder<language::unary_plusplus, int64_t>>());
+}
+
+void
+IncDecOperatorRegisterForZ::_register_post_minusminus()
+{
+  OperatorRepository& repository = OperatorRepository::instance();
+
+  auto N = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+
+  repository.addIncDecOperator<
+    language::post_minusminus>(N,
+                               std::make_shared<IncDecOperatorProcessorBuilder<language::post_minusminus, int64_t>>());
+}
+
+void
+IncDecOperatorRegisterForZ::_register_post_plusplus()
+{
+  OperatorRepository& repository = OperatorRepository::instance();
+
+  auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+
+  repository.addIncDecOperator<
+    language::post_plusplus>(Z, std::make_shared<IncDecOperatorProcessorBuilder<language::post_plusplus, int64_t>>());
+}
+
+IncDecOperatorRegisterForZ::IncDecOperatorRegisterForZ()
+{
+  this->_register_unary_minusminus();
+  this->_register_unary_plusplus();
+  this->_register_post_minusminus();
+  this->_register_post_plusplus();
+}

src/language/utils/IncDecOperatorRegisterForZ.hpp

+#ifndef INC_DEC_OPERATOR_REGISTER_FOR_Z_HPP
+#define INC_DEC_OPERATOR_REGISTER_FOR_Z_HPP
+
+class IncDecOperatorRegisterForZ
+{
+ private:
+  void _register_unary_minusminus();
+  void _register_unary_plusplus();
+  void _register_post_minusminus();
+  void _register_post_plusplus();
+
+ public:
+  IncDecOperatorRegisterForZ();
+};
+
+#endif   // INC_DEC_OPERATOR_REGISTER_FOR_Z_HPP