Remove class ParentNode : removal from BinaryNode + removal from code

AntaresSimulatorTeam · Aug 14, 2024 · b34d575 · b34d575
1 parent c4e212a
commit b34d575
Show file tree

Hide file tree

Showing 9 changed files with 49 additions and 109 deletions.
diff --git a/src/solver/expressions/CMakeLists.txt b/src/solver/expressions/CMakeLists.txt
@@ -13,7 +13,6 @@ set(SRC_Expressions
         visitors/LinearityVisitor.cpp
         visitors/EvaluationContext.cpp
 
-        include/antares/solver/expressions/nodes/ParentNode.h
         include/antares/solver/expressions/nodes/UnaryNode.h
         include/antares/solver/expressions/nodes/BinaryNode.h
         include/antares/solver/expressions/nodes/AddNode.h

diff --git a/src/solver/expressions/include/antares/solver/expressions/nodes/BinaryNode.h b/src/solver/expressions/include/antares/solver/expressions/nodes/BinaryNode.h
@@ -20,13 +20,18 @@
 */
 #pragma once
 
-#include <antares/solver/expressions/nodes/ParentNode.h>
+#include <antares/solver/expressions/nodes/Node.h>
 
 namespace Antares::Solver::Nodes
 {
-class BinaryNode: public ParentNode<2>
+class BinaryNode: public Node
 {
 public:
-    explicit BinaryNode(Node* n1, Node* n2);
+    explicit BinaryNode(Node* left, Node* right);
+    Node* left() const;
+    Node* right() const;
+private:
+    Node* leftOperand_ = nullptr;
+    Node* rightOperand_ = nullptr;
 };
 } // namespace Antares::Solver::Nodes
diff --git a/src/solver/expressions/include/antares/solver/expressions/nodes/ParentNode.h b/src/solver/expressions/include/antares/solver/expressions/nodes/ParentNode.h
diff --git a/src/solver/expressions/nodes/BinaryNode.cpp b/src/solver/expressions/nodes/BinaryNode.cpp
@@ -22,8 +22,19 @@
 
 namespace Antares::Solver::Nodes
 {
-BinaryNode::BinaryNode(Node* n1, Node* n2):
-    ParentNode<2>({n1, n2})
+BinaryNode::BinaryNode(Node* left, Node* right):
+        leftOperand_(left), rightOperand_(right)
 {
 }
+
+Node* BinaryNode::right() const
+{
+    return  rightOperand_;
+}
+
+Node* BinaryNode::left() const
+{
+    return leftOperand_;
+}
+
 } // namespace Antares::Solver::Nodes
diff --git a/src/solver/expressions/visitors/CloneVisitor.cpp b/src/solver/expressions/visitors/CloneVisitor.cpp
@@ -30,42 +30,42 @@ CloneVisitor::CloneVisitor(Registry<Nodes::Node>& mem):
 
 Nodes::Node* CloneVisitor::visit(const Nodes::AddNode& input_node)
 {
-    return registry_.create<Nodes::AddNode>(dispatch(*input_node[0]), dispatch(*input_node[1]));
+    return registry_.create<Nodes::AddNode>(dispatch(*input_node.left()), dispatch(*input_node.right()));
 }
 
 Nodes::Node* CloneVisitor::visit(const Nodes::SubtractionNode& input_node)
 {
-    return registry_.create<Nodes::SubtractionNode>(dispatch(*input_node[0]),
-                                                    dispatch(*input_node[1]));
+    return registry_.create<Nodes::SubtractionNode>(dispatch(*input_node.left()),
+                                                    dispatch(*input_node.right()));
 }
 
 Nodes::Node* CloneVisitor::visit(const Nodes::MultiplicationNode& input_node)
 {
-    return registry_.create<Nodes::MultiplicationNode>(dispatch(*input_node[0]),
-                                                       dispatch(*input_node[1]));
+    return registry_.create<Nodes::MultiplicationNode>(dispatch(*input_node.left()),
+                                                       dispatch(*input_node.right()));
 }
 
 Nodes::Node* CloneVisitor::visit(const Nodes::DivisionNode& input_node)
 {
-    return registry_.create<Nodes::DivisionNode>(dispatch(*input_node[0]),
-                                                 dispatch(*input_node[1]));
+    return registry_.create<Nodes::DivisionNode>(dispatch(*input_node.left()),
+                                                 dispatch(*input_node.right()));
 }
 
 Nodes::Node* CloneVisitor::visit(const Nodes::EqualNode& input_node)
 {
-    return registry_.create<Nodes::EqualNode>(dispatch(*input_node[0]), dispatch(*input_node[1]));
+    return registry_.create<Nodes::EqualNode>(dispatch(*input_node.left()), dispatch(*input_node.right()));
 }
 
 Nodes::Node* CloneVisitor::visit(const Nodes::LessThanOrEqualNode& input_node)
 {
-    return registry_.create<Nodes::LessThanOrEqualNode>(dispatch(*input_node[0]),
-                                                        dispatch(*input_node[1]));
+    return registry_.create<Nodes::LessThanOrEqualNode>(dispatch(*input_node.left()),
+                                                        dispatch(*input_node.right()));
 }
 
 Nodes::Node* CloneVisitor::visit(const Nodes::GreaterThanOrEqualNode& input_node)
 {
-    return registry_.create<Nodes::GreaterThanOrEqualNode>(dispatch(*input_node[0]),
-                                                           dispatch(*input_node[1]));
+    return registry_.create<Nodes::GreaterThanOrEqualNode>(dispatch(*input_node.left()),
+                                                           dispatch(*input_node.right()));
 }
 
 Nodes::Node* CloneVisitor::visit(const Nodes::NegationNode& neg)

diff --git a/src/solver/expressions/visitors/EvalVisitor.cpp b/src/solver/expressions/visitors/EvalVisitor.cpp
@@ -32,28 +32,28 @@ EvalVisitor::EvalVisitor(EvaluationContext context):
 
 double EvalVisitor::visit(const Nodes::AddNode& add)
 {
-    return dispatch(*add[0]) + dispatch(*add[1]);
+    return dispatch(*add.left()) + dispatch(*add.right());
 }
 
 double EvalVisitor::visit(const Nodes::SubtractionNode& sub)
 {
-    return dispatch(*sub[0]) - dispatch(*sub[1]);
+    return dispatch(*sub.left()) - dispatch(*sub.right());
 }
 
 double EvalVisitor::visit(const Nodes::MultiplicationNode& mult)
 {
-    return dispatch(*mult[0]) * dispatch(*mult[1]);
+    return dispatch(*mult.left()) * dispatch(*mult.right());
 }
 
 double EvalVisitor::visit(const Nodes::DivisionNode& div)
 {
-    if (auto divisor = dispatch(*div[1]); divisor == 0.0)
+    if (auto divisor = dispatch(*div.right()); divisor == 0.0)
     {
         throw EvalVisitorDivisionException("DivisionNode Division by zero");
     }
     else
     {
-        return dispatch(*div[0]) / divisor;
+        return dispatch(*div.left()) / divisor;
     }
 }
 

diff --git a/src/solver/expressions/visitors/LinearityVisitor.cpp b/src/solver/expressions/visitors/LinearityVisitor.cpp
@@ -29,22 +29,22 @@ namespace Antares::Solver::Visitors
 
 LinearStatus LinearityVisitor::visit(const Nodes::AddNode& add)
 {
-    return dispatch(*add[0]) + dispatch(*add[1]);
+    return dispatch(*add.left()) + dispatch(*add.right());
 }
 
 LinearStatus LinearityVisitor::visit(const Nodes::SubtractionNode& sub)
 {
-    return dispatch(*sub[0]) - dispatch(*sub[1]);
+    return dispatch(*sub.left()) - dispatch(*sub.right());
 }
 
 LinearStatus LinearityVisitor::visit(const Nodes::MultiplicationNode& mult)
 {
-    return dispatch(*mult[0]) * dispatch(*mult[1]);
+    return dispatch(*mult.left()) * dispatch(*mult.right());
 }
 
 LinearStatus LinearityVisitor::visit(const Nodes::DivisionNode& div)
 {
-    return dispatch(*div[0]) / dispatch(*div[1]);
+    return dispatch(*div.left()) / dispatch(*div.right());
 }
 
 LinearStatus LinearityVisitor::visit(const Nodes::EqualNode& equ)

diff --git a/src/solver/expressions/visitors/PrintVisitor.cpp b/src/solver/expressions/visitors/PrintVisitor.cpp
@@ -29,37 +29,37 @@ std::string PrintVisitor::visit(const Nodes::AddNode& add)
 {
     // Ici le compilateur (g++) a besoin de savoir qu'on veut le visit du type de base
     // sinon erreur de compil 'fonction non trouvée'
-    return "(" + dispatch(*add[0]) + "+" + dispatch(*add[1]) + ")";
+    return "(" + dispatch(*add.left()) + "+" + dispatch(*add.right()) + ")";
 }
 
 std::string PrintVisitor::visit(const Nodes::SubtractionNode& sub)
 {
-    return "(" + dispatch(*sub[0]) + "-" + dispatch(*sub[1]) + ")";
+    return "(" + dispatch(*sub.left()) + "-" + dispatch(*sub.right()) + ")";
 }
 
 std::string PrintVisitor::visit(const Nodes::MultiplicationNode& mult)
 {
-    return "(" + dispatch(*mult[0]) + "*" + dispatch(*mult[1]) + ")";
+    return "(" + dispatch(*mult.left()) + "*" + dispatch(*mult.right()) + ")";
 }
 
 std::string PrintVisitor::visit(const Nodes::DivisionNode& div)
 {
-    return "(" + dispatch(*div[0]) + "/" + dispatch(*div[1]) + ")";
+    return "(" + dispatch(*div.left()) + "/" + dispatch(*div.right()) + ")";
 }
 
 std::string PrintVisitor::visit(const Nodes::EqualNode& equ)
 {
-    return dispatch(*equ[0]) + "==" + dispatch(*equ[1]);
+    return dispatch(*equ.left()) + "==" + dispatch(*equ.right());
 }
 
 std::string PrintVisitor::visit(const Nodes::LessThanOrEqualNode& lt)
 {
-    return dispatch(*lt[0]) + "<=" + dispatch(*lt[1]);
+    return dispatch(*lt.left()) + "<=" + dispatch(*lt.right());
 }
 
 std::string PrintVisitor::visit(const Nodes::GreaterThanOrEqualNode& gt)
 {
-    return dispatch(*gt[0]) + ">=" + dispatch(*gt[1]);
+    return dispatch(*gt.left()) + ">=" + dispatch(*gt.right());
 }
 
 std::string PrintVisitor::visit(const Nodes::NegationNode& neg)

diff --git a/src/tests/src/solver/expressions/test_expressions.cpp b/src/tests/src/solver/expressions/test_expressions.cpp
@@ -237,20 +237,6 @@ BOOST_FIXTURE_TEST_CASE(subtraction_node, Registry<Node>)
     BOOST_CHECK_EQUAL(evalVisitor.dispatch(*sub), num1 - num2);
 }
 
-BOOST_FIXTURE_TEST_CASE(Parent_node, Registry<Node>)
-{
-    double num1 = 22.0, num2 = 8;
-    SubtractionNode sub(create<LiteralNode>(num1), create<LiteralNode>(num2));
-
-    PrintVisitor printVisitor;
-    Node* child1 = sub[0];
-    const auto printed = printVisitor.dispatch(*child1);
-
-    // try to get child at pos 1202 from a binary node ...
-    size_t pos = 1202;
-    BOOST_CHECK_THROW(sub[pos], ParentNodeException);
-}
-
 BOOST_FIXTURE_TEST_CASE(comparison_node, Registry<Node>)
 {
     double num1 = 22.0, num2 = 8;