-Add node as parameter of condition

4 files changed, 78 insertions, 28 deletions

diff --git a/booleancondition.cpp b/booleancondition.cpp
index 5b2212f..83e4ee9 100644
--- a/booleancondition.cpp
+++ b/booleancondition.cpp
@@ -26,6 +26,15 @@ BooleanCondition::BooleanCondition()
     : m_operator(Equal)
 {
 }
+
+BooleanCondition::~BooleanCondition()
+{
+    if(m_value!= nullptr)
+    {
+        delete m_value;
+        m_value = nullptr;
+    }
+}
 qint64 BooleanCondition::hasValid(Die* b,bool recursive,bool unhighlight) const
 {
     QList<qint64> listValues;
@@ -39,27 +48,28 @@ qint64 BooleanCondition::hasValid(Die* b,bool recursive,bool unhighlight) const
     }
 
     qint64 sum= 0;
+    auto valueScalar = valueToScalar();
     for(qint64 value: listValues)
     {
         switch(m_operator)
         {
             case Equal:
-                sum+=(value==m_value)?1:0;
+                sum+=(value==valueScalar)?1:0;
                 break;
             case GreaterThan:
-                sum+= (value>m_value)?1:0;
+                sum+= (value>valueScalar)?1:0;
                 break;
             case LesserThan:
-                sum+= (value<m_value)?1:0;
+                sum+= (value<valueScalar)?1:0;
                 break;
             case GreaterOrEqual:
-                sum+= (value>=m_value)?1:0;
+                sum+= (value>=valueScalar)?1:0;
                 break;
             case LesserOrEqual:
-                sum+= (value<=m_value)?1:0;
+                sum+= (value<=valueScalar)?1:0;
                 break;
             case Different:
-                sum+= (value!=m_value)?1:0;
+                sum+= (value!=valueScalar)?1:0;
                 break;
         }
     }
@@ -80,7 +90,7 @@ void BooleanCondition::setOperator(LogicOperator m)
     m_operator = m;
 }
 
-void BooleanCondition::setValue(qint64 v)
+void BooleanCondition::setValueNode(ExecutionNode* v)
 {
     m_value=v;
 }
@@ -108,7 +118,7 @@ QString BooleanCondition::toString()
         str.append(QStringLiteral("!="));
         break;
     }
-    return QStringLiteral("[%1%2]").arg(str).arg(m_value);
+    return QStringLiteral("[%1%2]").arg(str).arg(valueToScalar());
 }
 quint64 BooleanCondition::getValidRangeSize(quint64 faces) const
 {
@@ -117,13 +127,13 @@ quint64 BooleanCondition::getValidRangeSize(quint64 faces) const
     case Equal:
         return 1;
     case GreaterThan:
-        return faces-m_value;
+        return faces-valueToScalar();
     case LesserThan:
-        return m_value-1;
+        return valueToScalar()-1;
     case GreaterOrEqual:
-        return faces-(m_value-1);
+        return faces-(valueToScalar()-1);
     case LesserOrEqual:
-        return m_value;
+        return valueToScalar();
     case Different:
         return faces-1;
     }
@@ -133,9 +143,15 @@ Validator* BooleanCondition::getCopy() const
 {
     BooleanCondition* val = new BooleanCondition();
     val->setOperator(m_operator);
-    val->setValue(m_value);
-
-
+    val->setValueNode(m_value);
     return val;
+}
+qint64 BooleanCondition::valueToScalar() const
+{
+    if(m_value == nullptr)
+        return 0;
 
+    m_value->run(nullptr);
+    auto result = m_value->getResult();
+    return result->getResult(Result::SCALAR).toInt();
 }
diff --git a/booleancondition.h b/booleancondition.h
index 86dad72..b7282ad 100644
--- a/booleancondition.h
+++ b/booleancondition.h
@@ -24,6 +24,7 @@
 
 #include <Qt>
 #include "validator.h"
+#include "node/executionnode.h"
 /**
  * @brief The BooleanCondition class is a Validator class checking validity from logic expression.
  * It manages many operators (see : @ref LogicOperator).
@@ -33,11 +34,12 @@ class BooleanCondition : public Validator
 public:
     enum LogicOperator { Equal, GreaterThan, LesserThan, GreaterOrEqual, LesserOrEqual, Different};
     BooleanCondition();
+    virtual ~BooleanCondition();
 
     virtual qint64 hasValid(Die* b,bool recursive, bool unhighlight = false) const;
 
     void setOperator(LogicOperator m);
-    void setValue(qint64);
+    void setValueNode(ExecutionNode*);
     QString toString();
 
     virtual quint64 getValidRangeSize(quint64 faces) const;
@@ -46,10 +48,11 @@ public:
      * @return
      */
     virtual Validator* getCopy() const;
-
+private:
+    qint64 valueToScalar() const;
 private:
     LogicOperator m_operator;
-    qint64 m_value;
+    ExecutionNode* m_value;
 };
 
 #endif // BOOLEANCONDITION_H
diff --git a/operationcondition.cpp b/operationcondition.cpp
index 220e810..86c013a 100644
--- a/operationcondition.cpp
+++ b/operationcondition.cpp
@@ -25,7 +25,14 @@ OperationCondition::OperationCondition()
 {
 
 }
-
+OperationCondition::~OperationCondition()
+{
+    if(m_value!= nullptr)
+    {
+        delete m_value;
+        m_value = nullptr;
+    }
+}
 BooleanCondition *OperationCondition::getBoolean() const
 {
     return m_boolean;
@@ -58,7 +65,10 @@ qint64 OperationCondition::hasValid(Die* b,bool recursive,bool unhighlight) cons
             {
                 Die die;
                 die.setMaxValue(b->getMaxValue());
-                die.insertRollValue(value%m_value);
+                auto valueScalar = valueToScalar();
+                if(valueScalar==0)
+                    valueScalar = 1;
+                die.insertRollValue(value%valueScalar);
                 sum+=m_boolean->hasValid(&die,recursive,false);
             }
             break;
@@ -82,10 +92,11 @@ void OperationCondition::setOperator(ConditionOperator m)
     m_operator = m;
 }
 
-void OperationCondition::setValue(qint64 v)
+void OperationCondition::setValueNode(ExecutionNode *node)
 {
-    m_value=v;
+    m_value = node;
 }
+
 QString OperationCondition::toString()
 {
     QString str(QStringLiteral(""));
@@ -95,19 +106,33 @@ QString OperationCondition::toString()
         str.append(QStringLiteral("\%"));
         break;
     }
-    return QStringLiteral("[%1%2%3]").arg(str).arg(m_value).arg(m_boolean->toString());
+    return QStringLiteral("[%1%2%3]").arg(str).arg(valueToScalar()).arg(m_boolean->toString());
 }
 quint64 OperationCondition::getValidRangeSize(quint64 faces) const
 {
-   return faces/m_value;
+   auto value = valueToScalar();
+   if(value==0)
+       return 0;
+   return faces/value;
+
 }
 Validator* OperationCondition::getCopy() const
 {
     OperationCondition* val = new OperationCondition();
     val->setOperator(m_operator);
-    val->setValue(m_value);
+    val->setValueNode(m_value->getCopy());
     BooleanCondition* boolean = dynamic_cast<BooleanCondition*>(m_boolean->getCopy());
     val->setBoolean(boolean);
     return val;
 
 }
+
+qint64 OperationCondition::valueToScalar() const
+{
+    if(m_value == nullptr)
+        return 0;
+
+    m_value->run(nullptr);
+    auto result = m_value->getResult();
+    return result->getResult(Result::SCALAR).toInt();
+}
diff --git a/operationcondition.h b/operationcondition.h
index c3da827..2c4c4e7 100644
--- a/operationcondition.h
+++ b/operationcondition.h
@@ -24,17 +24,20 @@
 #include <Qt>
 #include "validator.h"
 #include "booleancondition.h"
+#include "node/executionnode.h"
 
 class OperationCondition : public Validator
 {
 public:
     enum ConditionOperator { Modulo };
     OperationCondition();
+    virtual ~OperationCondition();
 
     virtual qint64 hasValid(Die* b,bool recursive, bool unhighlight = false) const;
 
     void setOperator(ConditionOperator m);
-    void setValue(qint64);
+    //void setValue(qint64);
+    void setValueNode(ExecutionNode* node);
     QString toString();
 
     virtual quint64 getValidRangeSize(quint64 faces) const;
@@ -44,9 +47,12 @@ public:
 
     virtual Validator* getCopy() const;
 private:
+    qint64 valueToScalar() const;
+private:
     ConditionOperator m_operator;
-    BooleanCondition* m_boolean;
-    qint64 m_value;
+    BooleanCondition* m_boolean = nullptr;
+    //qint64 m_value;
+    ExecutionNode* m_value = nullptr;
 };
 
 #endif // OPERATIONCONDITION_H