From d1893e01fe3b8fb6fcffa959a517c1a76216e118 Mon Sep 17 00:00:00 2001 From: Stephane Del Pino <stephane.delpino44@gmail.com> Date: Mon, 5 Jun 2023 00:04:18 +0200 Subject: [PATCH] Modernize bunch of code --- ...STNodeBuiltinFunctionExpressionBuilder.cpp | 67 +++++----- .../ast/ASTNodeFunctionExpressionBuilder.cpp | 126 ++++++++---------- ...STNodeListAffectationExpressionBuilder.cpp | 47 +++---- 3 files changed, 109 insertions(+), 131 deletions(-) diff --git a/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp b/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp index e2b4a947f..169540df2 100644 --- a/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp +++ b/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp @@ -13,9 +13,7 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData const ASTNodeSubDataType& argument_node_sub_data_type, const size_t argument_number) { - auto get_function_argument_converter_for = - [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> { - using ParameterT = std::decay_t<decltype(parameter_v)>; + auto get_function_argument_converter_for = [&]<typename ParameterT>() -> std::unique_ptr<IFunctionArgumentConverter> { switch (argument_node_sub_data_type.m_data_type) { case ASTNodeDataType::bool_t: { return std::make_unique<FunctionArgumentConverter<ParameterT, bool>>(argument_number); @@ -39,9 +37,7 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData }; auto get_function_argument_converter_for_vector = - [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> { - using ParameterT = std::decay_t<decltype(parameter_v)>; - + [&]<typename ParameterT>() -> std::unique_ptr<IFunctionArgumentConverter> { if constexpr (std::is_same_v<ParameterT, TinyVector<1>>) { switch (argument_node_sub_data_type.m_data_type) { case ASTNodeDataType::vector_t: { @@ -76,7 +72,7 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData } else { switch (argument_node_sub_data_type.m_data_type) { case ASTNodeDataType::vector_t: { - if (argument_node_sub_data_type.m_data_type.dimension() == parameter_v.dimension()) { + if (argument_node_sub_data_type.m_data_type.dimension() == ParameterT::Dimension) { return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, ParameterT>>(argument_number); } else { // LCOV_EXCL_START @@ -104,9 +100,7 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData }; auto get_function_argument_converter_for_matrix = - [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> { - using ParameterT = std::decay_t<decltype(parameter_v)>; - + [&]<typename ParameterT>() -> std::unique_ptr<IFunctionArgumentConverter> { if constexpr (std::is_same_v<ParameterT, TinyMatrix<1>>) { switch (argument_node_sub_data_type.m_data_type) { case ASTNodeDataType::matrix_t: { @@ -142,8 +136,8 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData } else { switch (argument_node_sub_data_type.m_data_type) { case ASTNodeDataType::matrix_t: { - if ((argument_node_sub_data_type.m_data_type.numberOfRows() == parameter_v.numberOfRows()) and - (argument_node_sub_data_type.m_data_type.numberOfColumns() == parameter_v.numberOfColumns())) { + if ((argument_node_sub_data_type.m_data_type.numberOfRows() == ParameterT::NumberOfRows) and + (argument_node_sub_data_type.m_data_type.numberOfColumns() == ParameterT::NumberOfColumns)) { return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, ParameterT>>(argument_number); } else { // LCOV_EXCL_START @@ -189,8 +183,7 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData }; auto get_function_argument_to_tuple_converter = - [&](const auto& parameter_content_v) -> std::unique_ptr<IFunctionArgumentConverter> { - using ParameterContentT = std::decay_t<decltype(parameter_content_v)>; + [&]<typename ParameterContentT>() -> std::unique_ptr<IFunctionArgumentConverter> { const auto& arg_data_type = argument_node_sub_data_type.m_data_type; switch (arg_data_type) { case ASTNodeDataType::tuple_t: { @@ -321,27 +314,27 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData auto get_function_argument_converter_for_argument_type = [&]() { switch (parameter_type) { case ASTNodeDataType::bool_t: { - return get_function_argument_converter_for(bool{}); + return get_function_argument_converter_for.template operator()<bool>(); } case ASTNodeDataType::unsigned_int_t: { - return get_function_argument_converter_for(uint64_t{}); + return get_function_argument_converter_for.template operator()<uint64_t>(); } case ASTNodeDataType::int_t: { - return get_function_argument_converter_for(int64_t{}); + return get_function_argument_converter_for.template operator()<int64_t>(); } case ASTNodeDataType::double_t: { - return get_function_argument_converter_for(double{}); + return get_function_argument_converter_for.template operator()<double>(); } case ASTNodeDataType::vector_t: { switch (parameter_type.dimension()) { case 1: { - return get_function_argument_converter_for_vector(TinyVector<1>{}); + return get_function_argument_converter_for_vector.template operator()<TinyVector<1>>(); } case 2: { - return get_function_argument_converter_for_vector(TinyVector<2>{}); + return get_function_argument_converter_for_vector.template operator()<TinyVector<2>>(); } case 3: { - return get_function_argument_converter_for_vector(TinyVector<3>{}); + return get_function_argument_converter_for_vector.template operator()<TinyVector<3>>(); } // LCOV_EXCL_START default: { @@ -355,13 +348,13 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData Assert(parameter_type.numberOfRows() == parameter_type.numberOfColumns()); switch (parameter_type.numberOfRows()) { case 1: { - return get_function_argument_converter_for_matrix(TinyMatrix<1>{}); + return get_function_argument_converter_for_matrix.template operator()<TinyMatrix<1>>(); } case 2: { - return get_function_argument_converter_for_matrix(TinyMatrix<2>{}); + return get_function_argument_converter_for_matrix.template operator()<TinyMatrix<2>>(); } case 3: { - return get_function_argument_converter_for_matrix(TinyMatrix<3>{}); + return get_function_argument_converter_for_matrix.template operator()<TinyMatrix<3>>(); } // LCOV_EXCL_START default: { @@ -383,33 +376,33 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData case ASTNodeDataType::tuple_t: { switch (parameter_type.contentType()) { case ASTNodeDataType::type_id_t: { - return get_function_argument_to_tuple_converter(EmbeddedData{}); + return get_function_argument_to_tuple_converter.template operator()<EmbeddedData>(); } case ASTNodeDataType::bool_t: { - return get_function_argument_to_tuple_converter(bool{}); + return get_function_argument_to_tuple_converter.template operator()<bool>(); } case ASTNodeDataType::unsigned_int_t: { - return get_function_argument_to_tuple_converter(uint64_t{}); + return get_function_argument_to_tuple_converter.template operator()<uint64_t>(); } case ASTNodeDataType::int_t: { - return get_function_argument_to_tuple_converter(int64_t{}); + return get_function_argument_to_tuple_converter.template operator()<int64_t>(); } case ASTNodeDataType::double_t: { - return get_function_argument_to_tuple_converter(double{}); + return get_function_argument_to_tuple_converter.template operator()<double>(); } case ASTNodeDataType::function_t: { - return get_function_argument_to_tuple_converter(FunctionSymbolId{}); + return get_function_argument_to_tuple_converter.template operator()<FunctionSymbolId>(); } case ASTNodeDataType::vector_t: { switch (parameter_type.contentType().dimension()) { case 1: { - return get_function_argument_to_tuple_converter(TinyVector<1>{}); + return get_function_argument_to_tuple_converter.template operator()<TinyVector<1>>(); } case 2: { - return get_function_argument_to_tuple_converter(TinyVector<2>{}); + return get_function_argument_to_tuple_converter.template operator()<TinyVector<2>>(); } case 3: { - return get_function_argument_to_tuple_converter(TinyVector<3>{}); + return get_function_argument_to_tuple_converter.template operator()<TinyVector<3>>(); } // LCOV_EXCL_START default: { @@ -424,13 +417,13 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData Assert(parameter_type.contentType().numberOfRows() == parameter_type.contentType().numberOfColumns()); switch (parameter_type.contentType().numberOfRows()) { case 1: { - return get_function_argument_to_tuple_converter(TinyMatrix<1>{}); + return get_function_argument_to_tuple_converter.template operator()<TinyMatrix<1>>(); } case 2: { - return get_function_argument_to_tuple_converter(TinyMatrix<2>{}); + return get_function_argument_to_tuple_converter.template operator()<TinyMatrix<2>>(); } case 3: { - return get_function_argument_to_tuple_converter(TinyMatrix<3>{}); + return get_function_argument_to_tuple_converter.template operator()<TinyMatrix<3>>(); } // LCOV_EXCL_START default: { @@ -442,7 +435,7 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData } } case ASTNodeDataType::string_t: { - return get_function_argument_to_tuple_converter(std::string{}); + return get_function_argument_to_tuple_converter.template operator()<std::string>(); } // LCOV_EXCL_START default: { diff --git a/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp b/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp index 7e0d981c3..ade274716 100644 --- a/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp +++ b/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp @@ -17,9 +17,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy ASTNodeNaturalConversionChecker<AllowRToR1Conversion>{node_sub_data_type, parameter_symbol.attributes().dataType()}; - auto get_function_argument_converter_for = - [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> { - using ParameterT = std::decay_t<decltype(parameter_v)>; + auto get_function_argument_converter_for = [&]<typename ParameterT>() -> std::unique_ptr<IFunctionArgumentConverter> { switch (node_sub_data_type.m_data_type) { case ASTNodeDataType::bool_t: { return std::make_unique<FunctionArgumentConverter<ParameterT, bool>>(parameter_id); @@ -65,11 +63,10 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy }; auto get_function_argument_converter_for_vector = - [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> { - using ParameterT = std::decay_t<decltype(parameter_v)>; + [&]<typename ParameterT>() -> std::unique_ptr<IFunctionArgumentConverter> { switch (node_sub_data_type.m_data_type) { case ASTNodeDataType::vector_t: { - if (node_sub_data_type.m_data_type.dimension() == parameter_v.dimension()) { + if (node_sub_data_type.m_data_type.dimension() == ParameterT::Dimension) { return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, ParameterT>>(parameter_id); } else { // LCOV_EXCL_START @@ -79,7 +76,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy } } case ASTNodeDataType::bool_t: { - if ((parameter_v.dimension() == 1)) { + if constexpr (ParameterT::Dimension == 1) { return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, bool>>(parameter_id); } else { // LCOV_EXCL_START @@ -89,7 +86,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy } } case ASTNodeDataType::int_t: { - if ((parameter_v.dimension() == 1)) { + if constexpr (ParameterT::Dimension == 1) { return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, int64_t>>(parameter_id); } 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) { @@ -102,7 +99,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy // LCOV_EXCL_STOP } case ASTNodeDataType::unsigned_int_t: { - if ((parameter_v.dimension() == 1)) { + if constexpr (ParameterT::Dimension == 1) { return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, uint64_t>>(parameter_id); } else { // LCOV_EXCL_START @@ -112,7 +109,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy } } case ASTNodeDataType::double_t: { - if ((parameter_v.dimension() == 1)) { + if constexpr (ParameterT::Dimension == 1) { return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, double>>(parameter_id); } else { // LCOV_EXCL_START @@ -131,12 +128,11 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy }; auto get_function_argument_converter_for_matrix = - [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> { - using ParameterT = std::decay_t<decltype(parameter_v)>; + [&]<typename ParameterT>() -> std::unique_ptr<IFunctionArgumentConverter> { switch (node_sub_data_type.m_data_type) { case ASTNodeDataType::matrix_t: { - if ((node_sub_data_type.m_data_type.numberOfRows() == parameter_v.numberOfRows()) and - (node_sub_data_type.m_data_type.numberOfColumns() == parameter_v.numberOfColumns())) { + if ((node_sub_data_type.m_data_type.numberOfRows() == ParameterT::NumberOfRows) and + (node_sub_data_type.m_data_type.numberOfColumns() == ParameterT::NumberOfColumns)) { return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, ParameterT>>(parameter_id); } else { // LCOV_EXCL_START @@ -146,7 +142,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy } } case ASTNodeDataType::bool_t: { - if ((parameter_v.numberOfRows() == 1) and (parameter_v.numberOfColumns() == 1)) { + if constexpr ((ParameterT::NumberOfRows == 1) and (ParameterT::NumberOfColumns == 1)) { return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, bool>>(parameter_id); } else { // LCOV_EXCL_START @@ -156,7 +152,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy } } case ASTNodeDataType::int_t: { - if ((parameter_v.numberOfRows() == 1) and (parameter_v.numberOfColumns() == 1)) { + if constexpr ((ParameterT::NumberOfRows == 1) and (ParameterT::NumberOfColumns == 1)) { return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, int64_t>>(parameter_id); } 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) { @@ -169,7 +165,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy // LCOV_EXCL_STOP } case ASTNodeDataType::unsigned_int_t: { - if ((parameter_v.numberOfRows() == 1) and (parameter_v.numberOfColumns() == 1)) { + if constexpr ((ParameterT::NumberOfRows == 1) and (ParameterT::NumberOfColumns == 1)) { return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, uint64_t>>(parameter_id); } else { // LCOV_EXCL_START @@ -179,7 +175,7 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy } } case ASTNodeDataType::double_t: { - if ((parameter_v.numberOfRows() == 1) and (parameter_v.numberOfColumns() == 1)) { + if constexpr ((ParameterT::NumberOfRows == 1) and (ParameterT::NumberOfColumns == 1)) { return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, double>>(parameter_id); } else { // LCOV_EXCL_START @@ -204,16 +200,16 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy auto get_function_argument_converter_for_parameter_type = [&]() { switch (parameter_symbol.attributes().dataType()) { case ASTNodeDataType::bool_t: { - return get_function_argument_converter_for(bool{}); + return get_function_argument_converter_for.template operator()<bool>(); } case ASTNodeDataType::unsigned_int_t: { - return get_function_argument_converter_for(uint64_t{}); + return get_function_argument_converter_for.template operator()<uint64_t>(); } case ASTNodeDataType::int_t: { - return get_function_argument_converter_for(int64_t{}); + return get_function_argument_converter_for.template operator()<int64_t>(); } case ASTNodeDataType::double_t: { - return get_function_argument_converter_for(double{}); + return get_function_argument_converter_for.template operator()<double>(); } case ASTNodeDataType::string_t: { return get_function_argument_converter_for_string(); @@ -221,13 +217,13 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy case ASTNodeDataType::vector_t: { switch (parameter_symbol.attributes().dataType().dimension()) { case 1: { - return get_function_argument_converter_for_vector(TinyVector<1>{}); + return get_function_argument_converter_for_vector.template operator()<TinyVector<1>>(); } case 2: { - return get_function_argument_converter_for_vector(TinyVector<2>{}); + return get_function_argument_converter_for_vector.template operator()<TinyVector<2>>(); } case 3: { - return get_function_argument_converter_for_vector(TinyVector<3>{}); + return get_function_argument_converter_for_vector.template operator()<TinyVector<3>>(); } } // LCOV_EXCL_START @@ -240,13 +236,13 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy switch (parameter_symbol.attributes().dataType().numberOfRows()) { case 1: { - return get_function_argument_converter_for_matrix(TinyMatrix<1>{}); + return get_function_argument_converter_for_matrix.template operator()<TinyMatrix<1>>(); } case 2: { - return get_function_argument_converter_for_matrix(TinyMatrix<2>{}); + return get_function_argument_converter_for_matrix.template operator()<TinyMatrix<2>>(); } case 3: { - return get_function_argument_converter_for_matrix(TinyMatrix<3>{}); + return get_function_argument_converter_for_matrix.template operator()<TinyMatrix<3>>(); } } // LCOV_EXCL_START @@ -335,8 +331,7 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r ASTNode& node, ASTNode& function_component_expression) { - auto get_function_processor_for_expression_value = [&](const auto& return_v) -> std::unique_ptr<INodeProcessor> { - using ReturnT = std::decay_t<decltype(return_v)>; + auto get_function_processor_for_expression_value = [&]<typename ReturnT>() -> std::unique_ptr<INodeProcessor> { switch (function_component_expression.m_data_type) { case ASTNodeDataType::bool_t: { return std::make_unique<FunctionExpressionProcessor<ReturnT, bool>>(function_component_expression); @@ -368,11 +363,10 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r } }; - auto get_function_processor_for_expression_vector = [&](const auto& return_v) -> std::unique_ptr<INodeProcessor> { - using ReturnT = std::decay_t<decltype(return_v)>; + auto get_function_processor_for_expression_vector = [&]<typename ReturnT>() -> std::unique_ptr<INodeProcessor> { switch (function_component_expression.m_data_type) { case ASTNodeDataType::vector_t: { - if (function_component_expression.m_data_type.dimension() == return_v.dimension()) { + if (function_component_expression.m_data_type.dimension() == ReturnT::Dimension) { return std::make_unique<FunctionExpressionProcessor<ReturnT, ReturnT>>(function_component_expression); } else { // LCOV_EXCL_START @@ -401,12 +395,11 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r } }; - auto get_function_processor_for_expression_matrix = [&](const auto& return_v) -> std::unique_ptr<INodeProcessor> { - using ReturnT = std::decay_t<decltype(return_v)>; + auto get_function_processor_for_expression_matrix = [&]<typename ReturnT>() -> std::unique_ptr<INodeProcessor> { switch (function_component_expression.m_data_type) { case ASTNodeDataType::matrix_t: { - if ((function_component_expression.m_data_type.numberOfRows() == return_v.numberOfRows()) and - (function_component_expression.m_data_type.numberOfColumns() == return_v.numberOfColumns())) { + if ((function_component_expression.m_data_type.numberOfRows() == ReturnT::NumberOfRows) and + (function_component_expression.m_data_type.numberOfColumns() == ReturnT::NumberOfColumns)) { return std::make_unique<FunctionExpressionProcessor<ReturnT, ReturnT>>(function_component_expression); } else { // LCOV_EXCL_START @@ -458,8 +451,7 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r }; auto get_function_processor_for_expression_tuple_of_value = - [&](const auto& tuple_content_v) -> std::unique_ptr<INodeProcessor> { - using TupleContentT = std::decay_t<decltype(tuple_content_v)>; + [&]<typename TupleContentT>() -> std::unique_ptr<INodeProcessor> { switch (function_component_expression.m_data_type) { case ASTNodeDataType::bool_t: { return std::make_unique<FunctionExpressionProcessor<std::vector<TupleContentT>, bool>>( @@ -632,8 +624,7 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r }; auto get_function_processor_for_expression_tuple_of_vector = - [&](const auto& tuple_content_v) -> std::unique_ptr<INodeProcessor> { - using TupleContentT = std::decay_t<decltype(tuple_content_v)>; + [&]<typename TupleContentT>() -> std::unique_ptr<INodeProcessor> { if constexpr (TupleContentT::Dimension == 1) { switch (function_component_expression.m_data_type) { case ASTNodeDataType::bool_t: { @@ -774,8 +765,7 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r }; auto get_function_processor_for_expression_tuple_of_matrix = - [&](const auto& tuple_content_v) -> std::unique_ptr<INodeProcessor> { - using TupleContentT = std::decay_t<decltype(tuple_content_v)>; + [&]<typename TupleContentT>() -> std::unique_ptr<INodeProcessor> { static_assert(TupleContentT::NumberOfColumns == TupleContentT::NumberOfRows); if constexpr (TupleContentT::NumberOfRows == 1) { @@ -930,13 +920,13 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r case ASTNodeDataType::vector_t: { switch (tuple_content_v.dimension()) { case 1: { - return get_function_processor_for_expression_tuple_of_vector(TinyVector<1>{}); + return get_function_processor_for_expression_tuple_of_vector.template operator()<TinyVector<1>>(); } case 2: { - return get_function_processor_for_expression_tuple_of_vector(TinyVector<2>{}); + return get_function_processor_for_expression_tuple_of_vector.template operator()<TinyVector<2>>(); } case 3: { - return get_function_processor_for_expression_tuple_of_vector(TinyVector<3>{}); + return get_function_processor_for_expression_tuple_of_vector.template operator()<TinyVector<3>>(); } // LCOV_EXCL_START default: { @@ -950,13 +940,13 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r if (tuple_content_v.numberOfRows() == tuple_content_v.numberOfColumns()) { switch (tuple_content_v.numberOfRows()) { case 1: { - return get_function_processor_for_expression_tuple_of_matrix(TinyMatrix<1>{}); + return get_function_processor_for_expression_tuple_of_matrix.template operator()<TinyMatrix<1>>(); } case 2: { - return get_function_processor_for_expression_tuple_of_matrix(TinyMatrix<2>{}); + return get_function_processor_for_expression_tuple_of_matrix.template operator()<TinyMatrix<2>>(); } case 3: { - return get_function_processor_for_expression_tuple_of_matrix(TinyMatrix<3>{}); + return get_function_processor_for_expression_tuple_of_matrix.template operator()<TinyMatrix<3>>(); } // LCOV_EXCL_START default: { @@ -973,22 +963,22 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r } } case ASTNodeDataType::bool_t: { - return get_function_processor_for_expression_tuple_of_value(bool{}); + return get_function_processor_for_expression_tuple_of_value.template operator()<bool>(); } case ASTNodeDataType::unsigned_int_t: { - return get_function_processor_for_expression_tuple_of_value(uint64_t{}); + return get_function_processor_for_expression_tuple_of_value.template operator()<uint64_t>(); } case ASTNodeDataType::int_t: { - return get_function_processor_for_expression_tuple_of_value(int64_t{}); + return get_function_processor_for_expression_tuple_of_value.template operator()<int64_t>(); } case ASTNodeDataType::double_t: { - return get_function_processor_for_expression_tuple_of_value(double{}); + return get_function_processor_for_expression_tuple_of_value.template operator()<double>(); } case ASTNodeDataType::type_id_t: { - return get_function_processor_for_expression_tuple_of_value(EmbeddedData{}); + return get_function_processor_for_expression_tuple_of_value.template operator()<EmbeddedData>(); } case ASTNodeDataType::string_t: { - return get_function_processor_for_expression_tuple_of_value(std::string{}); + return get_function_processor_for_expression_tuple_of_value.template operator()<std::string>(); } // LCOV_EXCL_START default: { @@ -1001,31 +991,31 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r auto get_function_processor_for_value = [&]() { switch (return_value_type) { case ASTNodeDataType::bool_t: { - return get_function_processor_for_expression_value(bool{}); + return get_function_processor_for_expression_value.template operator()<bool>(); } case ASTNodeDataType::unsigned_int_t: { - return get_function_processor_for_expression_value(uint64_t{}); + return get_function_processor_for_expression_value.template operator()<uint64_t>(); } case ASTNodeDataType::int_t: { - return get_function_processor_for_expression_value(int64_t{}); + return get_function_processor_for_expression_value.template operator()<int64_t>(); } case ASTNodeDataType::double_t: { - return get_function_processor_for_expression_value(double{}); + return get_function_processor_for_expression_value.template operator()<double>(); } case ASTNodeDataType::vector_t: { switch (return_value_type.dimension()) { case 1: { if (function_component_expression.m_data_type == ASTNodeDataType::vector_t) { - return get_function_processor_for_expression_vector(TinyVector<1>{}); + return get_function_processor_for_expression_vector.template operator()<TinyVector<1>>(); } else { - return get_function_processor_for_expression_value(TinyVector<1>{}); + return get_function_processor_for_expression_value.template operator()<TinyVector<1>>(); } } case 2: { - return get_function_processor_for_expression_vector(TinyVector<2>{}); + return get_function_processor_for_expression_vector.template operator()<TinyVector<2>>(); } case 3: { - return get_function_processor_for_expression_vector(TinyVector<3>{}); + return get_function_processor_for_expression_vector.template operator()<TinyVector<3>>(); } // LCOV_EXCL_START default: { @@ -1040,16 +1030,16 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r switch (return_value_type.numberOfRows()) { case 1: { if (function_component_expression.m_data_type == ASTNodeDataType::matrix_t) { - return get_function_processor_for_expression_matrix(TinyMatrix<1>{}); + return get_function_processor_for_expression_matrix.template operator()<TinyMatrix<1>>(); } else { - return get_function_processor_for_expression_value(TinyMatrix<1>{}); + return get_function_processor_for_expression_value.template operator()<TinyMatrix<1>>(); } } case 2: { - return get_function_processor_for_expression_matrix(TinyMatrix<2>{}); + return get_function_processor_for_expression_matrix.template operator()<TinyMatrix<2>>(); } case 3: { - return get_function_processor_for_expression_matrix(TinyMatrix<3>{}); + return get_function_processor_for_expression_matrix.template operator()<TinyMatrix<3>>(); } // LCOV_EXCL_START default: { @@ -1059,7 +1049,7 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r } } case ASTNodeDataType::string_t: { - return get_function_processor_for_expression_value(std::string{}); + return get_function_processor_for_expression_value.template operator()<std::string>(); } case ASTNodeDataType::type_id_t: { return get_function_processor_for_expression_type_id(return_value_type.nameOfTypeId()); diff --git a/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp b/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp index ec499edb3..fc3df0d17 100644 --- a/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp +++ b/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp @@ -381,8 +381,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( 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)>; + auto add_affectation_processor_for_data = [&]<typename ValueT>(const ASTNodeSubDataType& node_sub_data_type) { switch (node_sub_data_type.m_data_type) { case ASTNodeDataType::bool_t: { list_affectation_processor->template add<ValueT, bool>(value_node); @@ -408,19 +407,17 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( } }; - auto add_affectation_processor_for_vector_data = [&](const auto& value, - const ASTNodeSubDataType& node_sub_data_type) { - using ValueT = std::decay_t<decltype(value)>; + auto add_affectation_processor_for_vector_data = [&]<typename ValueT>(const ASTNodeSubDataType& node_sub_data_type) { 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())) { + (node_sub_data_type.m_data_type.dimension() == ValueT::Dimension)) { list_affectation_processor->template add<ValueT, ValueT>(value_node); } else { - add_affectation_processor_for_data(value, node_sub_data_type); + add_affectation_processor_for_data.template operator()<TinyVector<1>>(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())) { + (node_sub_data_type.m_data_type.dimension() == ValueT::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) { @@ -440,21 +437,19 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( } }; - auto add_affectation_processor_for_matrix_data = [&](const auto& value, - const ASTNodeSubDataType& node_sub_data_type) { - using ValueT = std::decay_t<decltype(value)>; + auto add_affectation_processor_for_matrix_data = [&]<typename ValueT>(const ASTNodeSubDataType& node_sub_data_type) { if constexpr (std::is_same_v<ValueT, TinyMatrix<1>>) { if ((node_sub_data_type.m_data_type == ASTNodeDataType::matrix_t) and - (node_sub_data_type.m_data_type.numberOfRows() == value.numberOfRows()) and - (node_sub_data_type.m_data_type.numberOfColumns() == value.numberOfColumns())) { + (node_sub_data_type.m_data_type.numberOfRows() == ValueT::NumberOfRows) and + (node_sub_data_type.m_data_type.numberOfColumns() == ValueT::NumberOfColumns)) { list_affectation_processor->template add<ValueT, ValueT>(value_node); } else { - add_affectation_processor_for_data(value, node_sub_data_type); + add_affectation_processor_for_data.template operator()<TinyMatrix<1>>(node_sub_data_type); } } else if constexpr (std::is_same_v<ValueT, TinyMatrix<2>> or std::is_same_v<ValueT, TinyMatrix<3>>) { if ((node_sub_data_type.m_data_type == ASTNodeDataType::matrix_t) and - (node_sub_data_type.m_data_type.numberOfRows() == value.numberOfRows()) and - (node_sub_data_type.m_data_type.numberOfColumns() == value.numberOfColumns())) { + (node_sub_data_type.m_data_type.numberOfRows() == ValueT::NumberOfRows) and + (node_sub_data_type.m_data_type.numberOfColumns() == ValueT::NumberOfColumns)) { 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) { @@ -1140,19 +1135,19 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( const ASTNodeSubDataType& node_sub_data_type) { switch (value_type) { case ASTNodeDataType::bool_t: { - add_affectation_processor_for_data(bool{}, node_sub_data_type); + add_affectation_processor_for_data.template operator()<bool>(node_sub_data_type); break; } case ASTNodeDataType::unsigned_int_t: { - add_affectation_processor_for_data(uint64_t{}, node_sub_data_type); + add_affectation_processor_for_data.template operator()<uint64_t>(node_sub_data_type); break; } case ASTNodeDataType::int_t: { - add_affectation_processor_for_data(int64_t{}, node_sub_data_type); + add_affectation_processor_for_data.template operator()<int64_t>(node_sub_data_type); break; } case ASTNodeDataType::double_t: { - add_affectation_processor_for_data(double{}, node_sub_data_type); + add_affectation_processor_for_data.template operator()<double>(node_sub_data_type); break; } case ASTNodeDataType::type_id_t: { @@ -1162,15 +1157,15 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( case ASTNodeDataType::vector_t: { switch (value_type.dimension()) { case 1: { - add_affectation_processor_for_vector_data(TinyVector<1>{}, node_sub_data_type); + add_affectation_processor_for_vector_data.template operator()<TinyVector<1>>(node_sub_data_type); break; } case 2: { - add_affectation_processor_for_vector_data(TinyVector<2>{}, node_sub_data_type); + add_affectation_processor_for_vector_data.template operator()<TinyVector<2>>(node_sub_data_type); break; } case 3: { - add_affectation_processor_for_vector_data(TinyVector<3>{}, node_sub_data_type); + add_affectation_processor_for_vector_data.template operator()<TinyVector<3>>(node_sub_data_type); break; } // LCOV_EXCL_START @@ -1185,15 +1180,15 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor( Assert(value_type.numberOfRows() == value_type.numberOfColumns()); switch (value_type.numberOfRows()) { case 1: { - add_affectation_processor_for_matrix_data(TinyMatrix<1>{}, node_sub_data_type); + add_affectation_processor_for_matrix_data.template operator()<TinyMatrix<1>>(node_sub_data_type); break; } case 2: { - add_affectation_processor_for_matrix_data(TinyMatrix<2>{}, node_sub_data_type); + add_affectation_processor_for_matrix_data.template operator()<TinyMatrix<2>>(node_sub_data_type); break; } case 3: { - add_affectation_processor_for_matrix_data(TinyMatrix<3>{}, node_sub_data_type); + add_affectation_processor_for_matrix_data.template operator()<TinyMatrix<3>>(node_sub_data_type); break; } // LCOV_EXCL_START -- GitLab