diff --git a/src/language/ASTNodeFunctionExpressionBuilder.cpp b/src/language/ASTNodeFunctionExpressionBuilder.cpp
index 7da5559d832b2be47d272d620a261e99274f721b..156811f7847b3e7e1f737181e1844dcf64b7e719 100644
--- a/src/language/ASTNodeFunctionExpressionBuilder.cpp
+++ b/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;
diff --git a/src/language/ASTNodeFunctionExpressionBuilder.hpp b/src/language/ASTNodeFunctionExpressionBuilder.hpp
index 8db494b2a4ebc6beb849b9671f0f3775d18f8752..54c3297c6e368d8824bb5e84f0ab5d805a1b24c8 100644
--- a/src/language/ASTNodeFunctionExpressionBuilder.hpp
+++ b/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,
diff --git a/src/language/node_processor/FunctionArgumentConverter.hpp b/src/language/node_processor/FunctionArgumentConverter.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..48455d0bd7f9e9ae429ab0546f109637a25d1887
--- /dev/null
+++ b/src/language/node_processor/FunctionArgumentConverter.hpp
@@ -0,0 +1,39 @@
+#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
diff --git a/src/language/node_processor/FunctionProcessor.hpp b/src/language/node_processor/FunctionProcessor.hpp
index be95d2affcd106307762c68f4cecf1ecc49d3ea4..2a8db08f29fa7ad061c46c7c1b7679a53138ea2b 100644
--- a/src/language/node_processor/FunctionProcessor.hpp
+++ b/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));
}