Rename forgotten processor -> converter in argument treatment

Also displace FunctionArgumentConverter in its own file in view to reusing it in
the CFunction context

src/language/ASTNodeFunctionExpressionBuilder.cpp

@@ -10,24 +10,26 @@
 
 template <typename SymbolType>
 std::unique_ptr<IFunctionArgumentConverter>
-ASTNodeFunctionExpressionBuilder::_getArgumentProcessor(SymbolType& parameter_symbol,
+ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_symbol,
                                                         const ASTNodeSubDataType& node_sub_data_type)
 {
-  auto get_function_argument_processor_for =
+  const size_t parameter_id = std::get<size_t>(parameter_symbol.attributes().value());
+
+  auto get_function_argument_converter_for =
     [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> {
     using ParameterT = std::decay_t<decltype(parameter_v)>;
     switch (node_sub_data_type.m_data_type) {
     case ASTNodeDataType::bool_t: {
-      return std::make_unique<FunctionArgumentConverter<ParameterT, bool>>(parameter_symbol);
+      return std::make_unique<FunctionArgumentConverter<ParameterT, bool>>(parameter_id);
     }
     case ASTNodeDataType::unsigned_int_t: {
-      return std::make_unique<FunctionArgumentConverter<ParameterT, uint64_t>>(parameter_symbol);
+      return std::make_unique<FunctionArgumentConverter<ParameterT, uint64_t>>(parameter_id);
     }
     case ASTNodeDataType::int_t: {
-      return std::make_unique<FunctionArgumentConverter<ParameterT, int64_t>>(parameter_symbol);
+      return std::make_unique<FunctionArgumentConverter<ParameterT, int64_t>>(parameter_id);
     }
     case ASTNodeDataType::double_t: {
-      return std::make_unique<FunctionArgumentConverter<ParameterT, double>>(parameter_symbol);
+      return std::make_unique<FunctionArgumentConverter<ParameterT, double>>(parameter_id);
     }
       // LCOV_EXCL_START
     default: {
@@ -37,22 +39,22 @@ ASTNodeFunctionExpressionBuilder::_getArgumentProcessor(SymbolType& parameter_sy
     }
   };
 
-  auto get_function_argument_processor_for_string = [&]() -> std::unique_ptr<IFunctionArgumentConverter> {
+  auto get_function_argument_converter_for_string = [&]() -> std::unique_ptr<IFunctionArgumentConverter> {
     switch (node_sub_data_type.m_data_type) {
     case ASTNodeDataType::bool_t: {
-      return std::make_unique<FunctionArgumentConverter<std::string, bool>>(parameter_symbol);
+      return std::make_unique<FunctionArgumentConverter<std::string, bool>>(parameter_id);
     }
     case ASTNodeDataType::unsigned_int_t: {
-      return std::make_unique<FunctionArgumentConverter<std::string, uint64_t>>(parameter_symbol);
+      return std::make_unique<FunctionArgumentConverter<std::string, uint64_t>>(parameter_id);
     }
     case ASTNodeDataType::int_t: {
-      return std::make_unique<FunctionArgumentConverter<std::string, int64_t>>(parameter_symbol);
+      return std::make_unique<FunctionArgumentConverter<std::string, int64_t>>(parameter_id);
     }
     case ASTNodeDataType::double_t: {
-      return std::make_unique<FunctionArgumentConverter<std::string, double>>(parameter_symbol);
+      return std::make_unique<FunctionArgumentConverter<std::string, double>>(parameter_id);
     }
     case ASTNodeDataType::string_t: {
-      return std::make_unique<FunctionArgumentConverter<std::string, std::string>>(parameter_symbol);
+      return std::make_unique<FunctionArgumentConverter<std::string, std::string>>(parameter_id);
     }
       // LCOV_EXCL_START
     default: {
@@ -62,22 +64,22 @@ ASTNodeFunctionExpressionBuilder::_getArgumentProcessor(SymbolType& parameter_sy
     }
   };
 
-  auto get_function_argument_processor_for_parameter_type = [&]() {
+  auto get_function_argument_converter_for_parameter_type = [&]() {
     switch (parameter_symbol.attributes().dataType()) {
     case ASTNodeDataType::bool_t: {
-      return get_function_argument_processor_for(bool{});
+      return get_function_argument_converter_for(bool{});
     }
     case ASTNodeDataType::unsigned_int_t: {
-      return get_function_argument_processor_for(uint64_t{});
+      return get_function_argument_converter_for(uint64_t{});
     }
     case ASTNodeDataType::int_t: {
-      return get_function_argument_processor_for(int64_t{});
+      return get_function_argument_converter_for(int64_t{});
     }
     case ASTNodeDataType::double_t: {
-      return get_function_argument_processor_for(double{});
+      return get_function_argument_converter_for(double{});
     }
     case ASTNodeDataType::string_t: {
-      return get_function_argument_processor_for_string();
+      return get_function_argument_converter_for_string();
     }
 
       // LCOV_EXCL_START
@@ -88,11 +90,11 @@ ASTNodeFunctionExpressionBuilder::_getArgumentProcessor(SymbolType& parameter_sy
     }
   };
 
-  return get_function_argument_processor_for_parameter_type();
+  return get_function_argument_converter_for_parameter_type();
 }
 
 void
-ASTNodeFunctionExpressionBuilder::_storeArgumentProcessor(ASTNode& parameter_variable,
+ASTNodeFunctionExpressionBuilder::_storeArgumentConverter(ASTNode& parameter_variable,
                                                           ASTNodeSubDataType& node_sub_data_type,
                                                           FunctionProcessor& function_processor)
 {
@@ -102,11 +104,11 @@ ASTNodeFunctionExpressionBuilder::_storeArgumentProcessor(ASTNode& parameter_var
     parameter_variable.m_symbol_table->find(parameter_variable.string(), parameter_variable.begin());
   Assert(found);
 
-  function_processor.addArgumentProcessor(this->_getArgumentProcessor(*i_parameter_symbol, node_sub_data_type));
+  function_processor.addArgumentConverter(this->_getArgumentConverter(*i_parameter_symbol, node_sub_data_type));
 }
 
 std::unique_ptr<FunctionProcessor>
-ASTNodeFunctionExpressionBuilder::_buildArgumentProcessors(FunctionDescriptor& function_descriptor, ASTNode& node)
+ASTNodeFunctionExpressionBuilder::_buildArgumentConverter(FunctionDescriptor& function_descriptor, ASTNode& node)
 {
   ASTNode& function_expression = *function_descriptor.definitionNode().children[1];
 
@@ -138,10 +140,10 @@ ASTNodeFunctionExpressionBuilder::_buildArgumentProcessors(FunctionDescriptor& f
   if (arguments_number > 1) {
     for (size_t i = 0; i < arguments_number; ++i) {
       ASTNode& parameter_variable = *parameter_variables.children[i];
-      this->_storeArgumentProcessor(parameter_variable, flattened_datatype_list[i], *function_processor);
+      this->_storeArgumentConverter(parameter_variable, flattened_datatype_list[i], *function_processor);
     }
   } else {
-    this->_storeArgumentProcessor(parameter_variables, flattened_datatype_list[0], *function_processor);
+    this->_storeArgumentConverter(parameter_variables, flattened_datatype_list[0], *function_processor);
   }
 
   return function_processor;
@@ -222,7 +224,7 @@ ASTNodeFunctionExpressionBuilder::ASTNodeFunctionExpressionBuilder(ASTNode& node
 
   FunctionDescriptor& function_descriptor = node.m_symbol_table->functionTable()[function_id];
 
-  std::unique_ptr function_processor = this->_buildArgumentProcessors(function_descriptor, node);
+  std::unique_ptr function_processor = this->_buildArgumentConverter(function_descriptor, node);
 
   auto add_component_expression = [&](ASTNode& expression_node, ASTNode& domain_node) {
     ASTNodeDataType expression_value_type = expression_node.m_data_type;

src/language/ASTNodeFunctionExpressionBuilder.hpp

@@ -16,14 +16,14 @@ class ASTNodeFunctionExpressionBuilder
   ASTNode& m_node;
 
   template <typename SymbolType>
-  std::unique_ptr<IFunctionArgumentConverter> _getArgumentProcessor(SymbolType& parameter_symbol,
+  std::unique_ptr<IFunctionArgumentConverter> _getArgumentConverter(SymbolType& parameter_symbol,
                                                                     const ASTNodeSubDataType& node_sub_data_type);
 
-  void _storeArgumentProcessor(ASTNode& parameter_variable,
+  void _storeArgumentConverter(ASTNode& parameter_variable,
                                ASTNodeSubDataType& node_sub_data_type,
                                FunctionProcessor& function_processor);
 
-  std::unique_ptr<FunctionProcessor> _buildArgumentProcessors(FunctionDescriptor& function_descriptor, ASTNode& node);
+  std::unique_ptr<FunctionProcessor> _buildArgumentConverter(FunctionDescriptor& function_descriptor, ASTNode& node);
 
   std::unique_ptr<INodeProcessor> _getFunctionProcessor(const ASTNodeDataType expression_value_type,
                                                         const ASTNodeDataType return_value_type,

src/language/node_processor/FunctionArgumentConverter.hpp

+#ifndef FUNCTION_ARGUMENT_CONVERTER_HPP
+#define FUNCTION_ARGUMENT_CONVERTER_HPP
+
+#include <DataVariant.hpp>
+#include <node_processor/ExecutionPolicy.hpp>
+
+class IFunctionArgumentConverter
+{
+ public:
+  virtual DataVariant convert(ExecutionPolicy& exec_policy, DataVariant&& value) = 0;
+
+  virtual ~IFunctionArgumentConverter() = default;
+};
+
+template <typename ExpectedValueType, typename ProvidedValueType>
+class FunctionArgumentConverter final : public IFunctionArgumentConverter
+{
+ private:
+  size_t m_argument_id;
+
+ public:
+  DataVariant
+  convert(ExecutionPolicy& exec_policy, DataVariant&& value)
+  {
+    if constexpr (std::is_same_v<ExpectedValueType, ProvidedValueType>) {
+      exec_policy.currentContext()[m_argument_id] = std::move(value);
+    } else if constexpr (std::is_same_v<ExpectedValueType, std::string>) {
+      exec_policy.currentContext()[m_argument_id] = std::move(std::to_string(std::get<ProvidedValueType>(value)));
+    } else {
+      exec_policy.currentContext()[m_argument_id] =
+        std::move(static_cast<ExpectedValueType>(std::get<ProvidedValueType>(value)));
+    }
+    return {};
+  }
+
+  FunctionArgumentConverter(size_t argument_id) : m_argument_id{argument_id} {}
+};
+
+#endif   // FUNCTION_ARGUMENT_CONVERTER_HPP

src/language/node_processor/FunctionProcessor.hpp

@@ -10,39 +10,7 @@
 
 #include <node_processor/ASTNodeExpressionListProcessor.hpp>
 
-class IFunctionArgumentConverter
-{
- public:
-  virtual DataVariant convert(ExecutionPolicy& exec_policy, DataVariant&& value) = 0;
-
-  virtual ~IFunctionArgumentConverter() = default;
-};
-
-template <typename ExpectedValueType, typename ProvidedValueType>
-class FunctionArgumentConverter final : public IFunctionArgumentConverter
-{
- private:
-  size_t m_symbol_id;
-
- public:
-  DataVariant
-  convert(ExecutionPolicy& exec_policy, DataVariant&& value)
-  {
-    if constexpr (std::is_same_v<ExpectedValueType, ProvidedValueType>) {
-      exec_policy.currentContext()[m_symbol_id] = std::move(value);
-    } else if constexpr (std::is_same_v<ExpectedValueType, std::string>) {
-      exec_policy.currentContext()[m_symbol_id] = std::move(std::to_string(std::get<ProvidedValueType>(value)));
-    } else {
-      exec_policy.currentContext()[m_symbol_id] =
-        std::move(static_cast<ExpectedValueType>(std::get<ProvidedValueType>(value)));
-    }
-    return {};
-  }
-
-  FunctionArgumentConverter(SymbolTable::Symbol& argument_symbol)
-    : m_symbol_id{std::get<size_t>(argument_symbol.attributes().value())}
-  {}
-};
+#include <node_processor/FunctionArgumentConverter.hpp>
 
 template <typename ReturnType, typename ExpressionValueType>
 class FunctionExpressionProcessor final : public INodeProcessor
@@ -81,7 +49,7 @@ class FunctionProcessor : public INodeProcessor
 
  public:
   void
-  addArgumentProcessor(std::unique_ptr<IFunctionArgumentConverter>&& argument_converter)
+  addArgumentConverter(std::unique_ptr<IFunctionArgumentConverter>&& argument_converter)
   {
     m_argument_converters.emplace_back(std::move(argument_converter));
   }