add unicity and repeat function part2

16 files changed, 214 insertions, 217 deletions

diff --git a/node/countexecutenode.cpp b/node/countexecutenode.cpp
index c9b78b2..7d684c6 100644
--- a/node/countexecutenode.cpp
+++ b/node/countexecutenode.cpp
@@ -1,19 +1,20 @@
 #include "countexecutenode.h"
 #include "result/diceresult.h"
+#include "validatorlist.h"
 
-CountExecuteNode::CountExecuteNode() : m_scalarResult(new ScalarResult()), m_validator(nullptr)
+CountExecuteNode::CountExecuteNode() : m_scalarResult(new ScalarResult()), m_validatorList(nullptr)
 {
     m_result= m_scalarResult;
 }
-void CountExecuteNode::setValidator(Validator* validator)
+void CountExecuteNode::setValidatorList(ValidatorList* validatorlist)
 {
-    m_validator= validator;
+    m_validatorList= validatorlist;
 }
 CountExecuteNode::~CountExecuteNode()
 {
-    if(nullptr != m_validator)
+    if(nullptr != m_validatorList)
     {
-        delete m_validator;
+        delete m_validatorList;
     }
 }
 
@@ -28,17 +29,10 @@ void CountExecuteNode::run(ExecutionNode* previous)
     if(nullptr != previousResult)
     {
         m_result->setPrevious(previousResult);
-        QList<Die*> diceList= previousResult->getResultList();
         qint64 sum= 0;
-        for(Die* dice : diceList)
-        {
-            if(nullptr != m_validator)
-            {
-                sum+= m_validator->hasValid(dice, true, true);
-            }
-        }
+        std::function<void(Die*, qint64)> f= [&sum](const Die*, qint64 score) { sum+= score; };
+        m_validatorList->validResult(previousResult, true, true, f);
         m_scalarResult->setValue(sum);
-
         if(nullptr != m_nextNode)
         {
             m_nextNode->run(this);
@@ -49,7 +43,7 @@ QString CountExecuteNode::toString(bool withlabel) const
 {
     if(withlabel)
     {
-        return QString("%1 [label=\"CountExecuteNode %2\"]").arg(m_id, m_validator->toString());
+        return QString("%1 [label=\"CountExecuteNode %2\"]").arg(m_id, m_validatorList->toString());
     }
     else
     {
@@ -69,9 +63,9 @@ qint64 CountExecuteNode::getPriority() const
 ExecutionNode* CountExecuteNode::getCopy() const
 {
     CountExecuteNode* node= new CountExecuteNode();
-    if(nullptr != m_validator)
+    if(nullptr != m_validatorList)
     {
-        node->setValidator(m_validator->getCopy());
+        node->setValidatorList(m_validatorList->getCopy());
     }
     if(nullptr != m_nextNode)
     {
diff --git a/node/countexecutenode.h b/node/countexecutenode.h
index 8969a41..37b7a4f 100644
--- a/node/countexecutenode.h
+++ b/node/countexecutenode.h
@@ -4,8 +4,8 @@
 #include "executionnode.h"
 
 #include "result/scalarresult.h"
-#include "validator.h"
 
+class ValidatorList;
 /**
  * @brief The CountExecuteNode class
  */
@@ -25,7 +25,7 @@ public:
     /**
      * @brief setValidator
      */
-    virtual void setValidator(Validator*);
+    virtual void setValidatorList(ValidatorList*);
     /**
      * @brief toString
      * @return
@@ -44,7 +44,7 @@ public:
 
 private:
     ScalarResult* m_scalarResult;
-    Validator* m_validator;
+    ValidatorList* m_validatorList;
 };
 
 #endif // COUNTEXECUTENODE_H
diff --git a/node/explodedicenode.cpp b/node/explodedicenode.cpp
index 2292a05..1546883 100644
--- a/node/explodedicenode.cpp
+++ b/node/explodedicenode.cpp
@@ -1,6 +1,7 @@
 #include "explodedicenode.h"
+#include "validatorlist.h"
 
-ExplodeDiceNode::ExplodeDiceNode() : m_diceResult(new DiceResult()), m_validator(nullptr)
+ExplodeDiceNode::ExplodeDiceNode() : m_diceResult(new DiceResult())
 {
     m_result= m_diceResult;
 }
@@ -13,19 +14,22 @@ void ExplodeDiceNode::run(ExecutionNode* previous)
         m_result->setPrevious(previous_result);
         if(nullptr != previous_result)
         {
+            Die* exampleDie;
             for(auto& die : previous_result->getResultList())
             {
                 Die* tmpdie= new Die(*die);
                 m_diceResult->insertResult(tmpdie);
                 die->displayed();
+                exampleDie= tmpdie;
             }
 
-            QList<Die*> list= m_diceResult->getResultList();
+            // QList<Die*> list= m_diceResult->getResultList();
 
-            for(auto& die : list)
-            {
+            bool hasExploded= false;
+            std::function<void(Die*, qint64)> f= [&hasExploded, this](Die* die, qint64) {
                 if(Dice::CONDITION_STATE::ALWAYSTRUE
-                   == m_validator->isValidRangeSize(std::make_pair<qint64, qint64>(die->getBase(), die->getMaxValue())))
+                   == m_validatorList->isValidRangeSize(
+                          std::make_pair<qint64, qint64>(die->getBase(), die->getMaxValue())))
                 {
                     m_errors.insert(Dice::ERROR_CODE::ENDLESS_LOOP_ERROR,
                                     QObject::tr("Condition (%1) cause an endless loop with this dice: %2")
@@ -33,14 +37,31 @@ void ExplodeDiceNode::run(ExecutionNode* previous)
                                         .arg(QStringLiteral("d[%1,%2]")
                                                  .arg(static_cast<int>(die->getBase()))
                                                  .arg(static_cast<int>(die->getMaxValue()))));
+                }
+                hasExploded= true;
+                die->roll(true);
+            };
+            do
+            {
+                hasExploded= false;
+                m_validatorList->validResult(m_diceResult, false, false, f);
+            } while(hasExploded);
+
+            /*for(auto& die : list)
+            {
+                if(Dice::CONDITION_STATE::ALWAYSTRUE
+                   == m_validatorList->isValidRangeSize(
+                          std::make_pair<qint64, qint64>(die->getBase(), die->getMaxValue())))
+                {
+
                     continue;
                 }
 
-                while(m_validator->hasValid(die, false))
+                while(m_validatorList->hasValid(die, false))
                 {
                     die->roll(true);
                 }
-            }
+            }*/
 
             if(nullptr != m_nextNode)
             {
@@ -51,20 +72,20 @@ void ExplodeDiceNode::run(ExecutionNode* previous)
 }
 ExplodeDiceNode::~ExplodeDiceNode()
 {
-    if(nullptr != m_validator)
+    if(nullptr != m_validatorList)
     {
-        delete m_validator;
+        delete m_validatorList;
     }
 }
-void ExplodeDiceNode::setValidator(Validator* val)
+void ExplodeDiceNode::setValidatorList(ValidatorList* val)
 {
-    m_validator= val;
+    m_validatorList= val;
 }
 QString ExplodeDiceNode::toString(bool withlabel) const
 {
     if(withlabel)
     {
-        return QString("%1 [label=\"ExplodeDiceNode %2\"]").arg(m_id, m_validator->toString());
+        return QString("%1 [label=\"ExplodeDiceNode %2\"]").arg(m_id, m_validatorList->toString());
     }
     else
     {
@@ -84,9 +105,9 @@ qint64 ExplodeDiceNode::getPriority() const
 ExecutionNode* ExplodeDiceNode::getCopy() const
 {
     ExplodeDiceNode* node= new ExplodeDiceNode();
-    if(nullptr != m_validator)
+    if(nullptr != m_validatorList)
     {
-        node->setValidator(m_validator->getCopy());
+        node->setValidatorList(m_validatorList->getCopy());
     }
     if(nullptr != m_nextNode)
     {
diff --git a/node/explodedicenode.h b/node/explodedicenode.h
index e72298a..77b4a44 100644
--- a/node/explodedicenode.h
+++ b/node/explodedicenode.h
@@ -3,8 +3,8 @@
 
 #include "executionnode.h"
 #include "result/diceresult.h"
-#include "validator.h"
-#include <QDebug>
+
+class ValidatorList;
 
 /**
  * @brief The ExplodeDiceNode class explode dice while is valid by the validator.
@@ -15,7 +15,7 @@ public:
     ExplodeDiceNode();
     virtual ~ExplodeDiceNode();
     virtual void run(ExecutionNode* previous= nullptr);
-    virtual void setValidator(Validator*);
+    virtual void setValidatorList(ValidatorList*);
     virtual QString toString(bool) const;
     virtual qint64 getPriority() const;
 
@@ -23,7 +23,7 @@ public:
 
 protected:
     DiceResult* m_diceResult;
-    Validator* m_validator;
+    ValidatorList* m_validatorList= nullptr;
 };
 
 #endif // EXPLOSEDICENODE_H
diff --git a/node/filternode.cpp b/node/filternode.cpp
index d5d155a..4424b4b 100644
--- a/node/filternode.cpp
+++ b/node/filternode.cpp
@@ -1,4 +1,5 @@
 #include "filternode.h"
+#include "validatorlist.h"
 
 FilterNode::FilterNode() : m_diceResult(new DiceResult()), m_eachValue(false)
 {
@@ -7,14 +8,14 @@ FilterNode::FilterNode() : m_diceResult(new DiceResult()), m_eachValue(false)
 
 FilterNode::~FilterNode()
 {
-    if(nullptr != m_validator)
+    if(nullptr != m_validatorList)
     {
-        delete m_validator;
+        delete m_validatorList;
     }
 }
-void FilterNode::setValidator(Validator* validator)
+void FilterNode::setValidatorList(ValidatorList* validatorlist)
 {
-    m_validator= validator;
+    m_validatorList= validatorlist;
 }
 void FilterNode::run(ExecutionNode* previous)
 {
@@ -25,24 +26,27 @@ void FilterNode::run(ExecutionNode* previous)
     }
     DiceResult* previousDiceResult= dynamic_cast<DiceResult*>(previous->getResult());
     m_result->setPrevious(previousDiceResult);
+
     if(nullptr != previousDiceResult)
     {
-        QList<Die*> diceList= previousDiceResult->getResultList();
         QList<Die*> diceList2;
+        std::function<void(Die*, qint64)> f= [&diceList2](Die* die, qint64) {
+            if(die == nullptr)
+                return;
+            Die* tmpdie= new Die(*die);
+            diceList2.append(tmpdie);
+            die->displayed();
+        };
+        m_validatorList->validResult(previousDiceResult, true, true, f);
+
+        QList<Die*> diceList= previousDiceResult->getResultList();
 
+        diceList.erase(std::remove_if(diceList.begin(), diceList.end(),
+                                      [&diceList2](Die* die) { return diceList2.contains(die); }),
+                       diceList.end());
         for(Die* tmp : diceList)
         {
-            if(m_validator->hasValid(tmp, m_eachValue))
-            {
-                Die* tmpdie= new Die(*tmp);
-                //*tmpdie= *tmp;
-                diceList2.append(tmpdie);
-                tmp->displayed();
-            }
-            else
-            {
-                tmp->setHighlighted(false);
-            }
+            tmp->setHighlighted(false);
         }
 
         m_diceResult->setResultList(diceList2);
@@ -77,9 +81,9 @@ qint64 FilterNode::getPriority() const
 ExecutionNode* FilterNode::getCopy() const
 {
     FilterNode* node= new FilterNode();
-    if(nullptr != m_validator)
+    if(nullptr != m_validatorList)
     {
-        node->setValidator(m_validator->getCopy());
+        node->setValidatorList(m_validatorList->getCopy());
     }
     if(nullptr != m_nextNode)
     {
diff --git a/node/filternode.h b/node/filternode.h
index 77ae7b6..7af6fe2 100644
--- a/node/filternode.h
+++ b/node/filternode.h
@@ -4,7 +4,8 @@
 #include "executionnode.h"
 
 #include "result/diceresult.h"
-#include "validator.h"
+
+class ValidatorList;
 
 class FilterNode : public ExecutionNode
 {
@@ -16,7 +17,7 @@ public:
     /**
      * @brief setValidator
      */
-    virtual void setValidator(Validator*);
+    virtual void setValidatorList(ValidatorList*);
     /**
      * @brief toString
      * @return
@@ -32,7 +33,7 @@ public:
 
 private:
     DiceResult* m_diceResult;
-    Validator* m_validator;
+    ValidatorList* m_validatorList;
     bool m_eachValue;
 };
 
diff --git a/node/ifnode.cpp b/node/ifnode.cpp
index 5fa68b0..b2f183c 100644
--- a/node/ifnode.cpp
+++ b/node/ifnode.cpp
@@ -19,7 +19,7 @@
  ***************************************************************************/
 #include "ifnode.h"
 #include "result/diceresult.h"
-#include "result/stringresult.h"
+#include "validatorlist.h"
 
 PartialDiceRollNode::PartialDiceRollNode() : m_diceResult(new DiceResult)
 {
@@ -80,9 +80,8 @@ DiceResult* getFirstDiceResult(Result* result)
 
     return found;
 }
-//
 
-IfNode::IfNode() : m_validator(nullptr), m_conditionType(AllOfThem), m_true(nullptr), m_false(nullptr)
+IfNode::IfNode() : m_conditionType(Dice::AllOfThem), m_true(nullptr), m_false(nullptr)
 {
     // m_result = new DiceResult();
 }
@@ -109,24 +108,20 @@ void IfNode::run(ExecutionNode* previous)
     {
         qreal value= previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal();
 
-        if(nullptr != m_validator)
+        if(nullptr != m_validatorList)
         {
             DiceResult* previousDiceResult= getFirstDiceResult(previousResult);
             if(nullptr != previousDiceResult)
             {
                 QList<Die*> diceList= previousDiceResult->getResultList();
 
-                if(m_conditionType == OnEach)
+                if(m_conditionType == Dice::OnEach)
                 {
-                    auto resultOnEach= m_result;
                     for(Die* dice : diceList)
                     {
-                        auto diceResult= new DiceResult;
-                        StringResult* stringResult= nullptr;
                         auto diceNode= new PartialDiceRollNode();
-                        auto cpyDice= new Die(*dice);
-                        diceNode->insertDie(cpyDice);
-                        if(m_validator->hasValid(dice, true, true))
+                        diceNode->insertDie(new Die(*dice));
+                        if(m_validatorList->hasValid(dice, true, true))
                         {
                             nextNode= (nullptr == m_true) ? nullptr : m_true->getCopy();
                         }
@@ -141,49 +136,17 @@ void IfNode::run(ExecutionNode* previous)
                             {
                                 previousLoop->setNextNode(nextNode);
                             }
+                            if(nullptr == m_nextNode)
+                            {
+                                m_nextNode= nextNode;
+                            }
                             diceNode->setNextNode(nextNode);
                             diceNode->run(previousLoop);
                             previousLoop= getLeafNode(nextNode);
                         }
-
-                        if(nullptr == nextNode)
-                        {
-                            diceResult->insertResult(cpyDice);
-                        }
-                        else
-                        {
-                            delete cpyDice;
-                            auto branchResult= previousLoop->getResult();
-                            if(branchResult->hasResultOfType(Dice::RESULT_TYPE::SCALAR))
-                            {
-                                auto val= branchResult->getResult(Dice::RESULT_TYPE::SCALAR).toInt();
-                                auto valDie= new Die();
-                                valDie->insertRollValue(val);
-                                diceResult->insertResult(valDie);
-                            }
-                            else if(branchResult->hasResultOfType(Dice::RESULT_TYPE::STRING))
-                            {
-                                auto val= branchResult->getResult(Dice::RESULT_TYPE::STRING).toString();
-                                stringResult= new StringResult;
-                                stringResult->setText(val);
-                            }
-                        }
-                        if(nullptr != stringResult)
-                        {
-                            stringResult->setPrevious(resultOnEach);
-                            resultOnEach= stringResult;
-                            delete diceResult;
-                        }
-                        else
-                        {
-                            diceResult->setPrevious(resultOnEach);
-                            resultOnEach= diceResult;
-                        }
                     }
-
-                    m_result= resultOnEach;
                 }
-                else if((m_conditionType == OneOfThem) || (m_conditionType == AllOfThem))
+                else if((m_conditionType == Dice::OneOfThem) || (m_conditionType == Dice::AllOfThem))
                 {
                     bool trueForAll= true;
                     bool falseForAll= true;
@@ -193,14 +156,14 @@ void IfNode::run(ExecutionNode* previous)
 
                     for(Die* dice : diceList)
                     {
-                        bool result= m_validator->hasValid(dice, true, true);
+                        bool result= m_validatorList->hasValid(dice, true, true);
                         trueForAll= trueForAll ? result : false;
                         falseForAll= falseForAll ? result : false;
 
                         oneIsTrue|= result;
                         oneIsFalse= !result ? true : oneIsFalse;
                     }
-                    if(m_conditionType == OneOfThem)
+                    if(m_conditionType == Dice::OneOfThem)
                     {
                         if(oneIsTrue)
                         {
@@ -211,7 +174,7 @@ void IfNode::run(ExecutionNode* previous)
                             nextNode= (nullptr == m_false) ? nullptr : m_false->getCopy();
                         }
                     }
-                    else if(m_conditionType == AllOfThem)
+                    else if(m_conditionType == Dice::AllOfThem)
                     {
                         if(trueForAll)
                         {
@@ -235,14 +198,14 @@ void IfNode::run(ExecutionNode* previous)
                 }
             }
 
-            if(m_conditionType == OnScalar)
+            if(m_conditionType == Dice::OnScalar)
             {
                 Die dice;
                 auto val= static_cast<qint64>(value);
                 dice.setValue(val);
                 dice.insertRollValue(val);
                 dice.setMaxValue(val);
-                if(m_validator->hasValid(&dice, true, true))
+                if(m_validatorList->hasValid(&dice, true, true))
                 {
                     nextNode= m_true;
                 }
@@ -269,9 +232,9 @@ void IfNode::run(ExecutionNode* previous)
     }
 }
 
-void IfNode::setValidator(Validator* val)
+void IfNode::setValidatorList(ValidatorList* val)
 {
-    m_validator= val;
+    m_validatorList= val;
 }
 void IfNode::setInstructionTrue(ExecutionNode* node)
 {
@@ -292,7 +255,7 @@ void IfNode::generateDotTree(QString& s)
         s.append(toString(false));
         s.append(" -> ");
         s.append(m_true->toString(false));
-        s.append("[label=\"true" + m_validator->toString() + "\"];\n");
+        s.append("[label=\"true" + m_validatorList->toString() + "\"];\n");
 
         m_true->generateDotTree(s);
     }
@@ -357,12 +320,12 @@ ExecutionNode* IfNode::getLeafNode(ExecutionNode* node)
     return next;
 }
 
-IfNode::ConditionType IfNode::getConditionType() const
+Dice::ConditionType IfNode::getConditionType() const
 {
     return m_conditionType;
 }
 
-void IfNode::setConditionType(const IfNode::ConditionType& conditionType)
+void IfNode::setConditionType(const Dice::ConditionType& conditionType)
 {
     m_conditionType= conditionType;
 }
@@ -371,9 +334,9 @@ ExecutionNode* IfNode::getCopy() const
     IfNode* node= new IfNode();
 
     node->setConditionType(m_conditionType);
-    if(nullptr != m_validator)
+    if(nullptr != m_validatorList)
     {
-        node->setValidator(m_validator->getCopy());
+        node->setValidatorList(m_validatorList->getCopy());
     }
     if(nullptr != m_false)
     {
diff --git a/node/ifnode.h b/node/ifnode.h
index 55a6051..f0046f0 100644
--- a/node/ifnode.h
+++ b/node/ifnode.h
@@ -20,10 +20,11 @@
 #ifndef IFNODE_H
 #define IFNODE_H
 
+#include "diceparserhelper.h"
 #include "executionnode.h"
 #include "result/diceresult.h"
-#include "validator.h"
-#include <QDebug>
+
+class ValidatorList;
 class PartialDiceRollNode : public ExecutionNode
 {
 public:
@@ -46,16 +47,6 @@ class IfNode : public ExecutionNode
 {
 public:
     /**
-     * @brief The ConditionType enum
-     */
-    enum ConditionType
-    {
-        OnEach,
-        OneOfThem,
-        AllOfThem,
-        OnScalar
-    };
-    /**
      * @brief IfNode
      */
     IfNode();
@@ -71,7 +62,7 @@ public:
     /**
      * @brief setValidator
      */
-    virtual void setValidator(Validator*);
+    virtual void setValidatorList(ValidatorList*);
     /**
      * @brief setInstructionTrue
      */
@@ -105,20 +96,20 @@ public:
      * @brief getConditionType
      * @return
      */
-    ConditionType getConditionType() const;
+    Dice::ConditionType getConditionType() const;
 
     /**
      * @brief setConditionType
      * @param conditionType
      */
-    void setConditionType(const IfNode::ConditionType& conditionType);
+    void setConditionType(const Dice::ConditionType& conditionType);
 
 protected:
     ExecutionNode* getLeafNode(ExecutionNode* node);
 
 protected:
-    Validator* m_validator;
-    ConditionType m_conditionType;
+    ValidatorList* m_validatorList= nullptr;
+    Dice::ConditionType m_conditionType;
 
     ExecutionNode* m_true;
     ExecutionNode* m_false;
diff --git a/node/mergenode.cpp b/node/mergenode.cpp
index 575613f..15f2fa7 100644
--- a/node/mergenode.cpp
+++ b/node/mergenode.cpp
@@ -40,25 +40,22 @@ void MergeNode::run(ExecutionNode* previous)
     for(auto start : *m_startList)
     {
         ExecutionNode* last= getLatestNode(start);
-        if(nullptr == last)
+        if(nullptr == last || nullptr == previousLast)
             continue;
 
         auto startResult= start->getResult();
         if(nullptr == startResult)
             continue;
 
-        if(nullptr != previousLast)
-        {
-            startResult->setPrevious(previousLast->getResult());
-            previousLast->setNextNode(start);
-        }
+        startResult->setPrevious(previousLast->getResult());
+        previousLast->setNextNode(start);
 
         previousLast= last;
         Result* tmpResult= last->getResult();
         while(nullptr != tmpResult)
         {
             DiceResult* dice= dynamic_cast<DiceResult*>(tmpResult);
-            if(nullptr != dice)
+            if(nullptr == dice)
             {
                 ///@todo TODO improve here to set homogeneous while is really
                 m_diceResult->setHomogeneous(false);
diff --git a/node/occurencecountnode.cpp b/node/occurencecountnode.cpp
index 0d69d2a..f82fa35 100644
--- a/node/occurencecountnode.cpp
+++ b/node/occurencecountnode.cpp
@@ -20,6 +20,7 @@
 #include "occurencecountnode.h"
 #include "result/diceresult.h"
 #include "result/stringresult.h"
+#include "validatorlist.h"
 #include <QVector>
 
 OccurenceCountNode::OccurenceCountNode() : ExecutionNode() {}
@@ -106,14 +107,14 @@ void OccurenceCountNode::setHeight(const qint64& height)
     m_height= height;
 }
 
-Validator* OccurenceCountNode::getValidator() const
+ValidatorList* OccurenceCountNode::getValidatorList() const
 {
-    return m_validator;
+    return m_validatorList;
 }
 
-void OccurenceCountNode::setValidator(Validator* validator)
+void OccurenceCountNode::setValidatorList(ValidatorList* validatorlist)
 {
-    m_validator= validator;
+    m_validatorList= validatorlist;
 }
 void OccurenceCountNode::runForStringResult(const std::map<qint64, qint64>& mapOccurence, QVector<qint64>& vec)
 {
@@ -122,11 +123,11 @@ void OccurenceCountNode::runForStringResult(const std::map<qint64, qint64>& mapO
     QStringList list;
     for(auto key : mapOccurence)
     {
-        if(nullptr != m_validator)
+        if(nullptr != m_validatorList)
         {
             Die die;
             die.insertRollValue(key.first);
-            if(!m_validator->hasValid(&die, true))
+            if(!m_validatorList->hasValid(&die, true))
                 continue;
         }
 
@@ -156,11 +157,11 @@ void OccurenceCountNode::runForDiceResult(const std::map<qint64, qint64>& mapOcc
     QStringList list;
     for(auto key : mapOccurence)
     {
-        if(nullptr != m_validator)
+        if(nullptr != m_validatorList)
         {
             Die die;
             die.insertRollValue(key.first);
-            if(!m_validator->hasValid(&die, true))
+            if(!m_validatorList->hasValid(&die, true))
                 continue;
         }
 
diff --git a/node/occurencecountnode.h b/node/occurencecountnode.h
index 492b295..aa5c2de 100644
--- a/node/occurencecountnode.h
+++ b/node/occurencecountnode.h
@@ -21,8 +21,8 @@
 #define OCCURENCECOUNTNODE_H
 
 #include "executionnode.h"
-#include "validator.h"
 
+class ValidatorList;
 class StringResult;
 class DiceResult;
 class OccurenceCountNode : public ExecutionNode
@@ -42,8 +42,8 @@ public:
     qint64 getHeight() const;
     void setHeight(const qint64& height);
 
-    Validator* getValidator() const;
-    void setValidator(Validator* validator);
+    ValidatorList* getValidatorList() const;
+    void setValidatorList(ValidatorList* validator);
 
 private:
     void runForStringResult(const std::map<qint64, qint64>& mapOccurence, QVector<qint64>& vec);
@@ -52,7 +52,7 @@ private:
 private:
     qint64 m_width= 1;
     qint64 m_height= 0;
-    Validator* m_validator= nullptr;
+    ValidatorList* m_validatorList= nullptr;
     StringResult* m_stringResult= nullptr;
     DiceResult* m_diceResult= nullptr;
 };
diff --git a/node/repeaternode.cpp b/node/repeaternode.cpp
index 09e88bd..26fab8f 100644
--- a/node/repeaternode.cpp
+++ b/node/repeaternode.cpp
@@ -26,63 +26,87 @@
 #include "parsingtoolbox.h"
 #include "result/stringresult.h"
 
+std::vector<ExecutionNode*> makeCopy(std::vector<ExecutionNode*> cmds)
+{
+    std::vector<ExecutionNode*> copy;
+    std::transform(cmds.begin(), cmds.end(), std::back_inserter(copy),
+                   [](ExecutionNode* node) { return node->getCopy(); });
+    return copy;
+}
+
 RepeaterNode::RepeaterNode() {}
 
 void RepeaterNode::run(ExecutionNode* previousNode)
 {
     m_previousNode= previousNode;
+
+    if(nullptr == m_times || m_cmd.empty())
+        return;
+
     m_times->run(this);
     m_times= ParsingToolBox::getLeafNode(m_times);
     auto times= m_times->getResult();
     auto timeCount= times->getResult(Dice::RESULT_TYPE::SCALAR).toInt();
-    auto cmd= m_cmd->getCopy();
+    auto cmd= makeCopy(m_cmd);
+    std::vector<Result*> resultVec;
     for(int i= 0; i < timeCount; ++i)
     {
-        m_cmd->run(this);
-        auto end= ParsingToolBox::getLeafNode(cmd);
-        auto result= end->getResult();
+        std::for_each(cmd.begin(), cmd.end(), [this, &resultVec](ExecutionNode* node) {
+            node->run(this);
+            auto end= ParsingToolBox::getLeafNode(node);
+            auto leafResult= end->getResult();
 
-        if(nullptr == result)
-            continue;
+            if(nullptr == leafResult)
+                return;
 
-        if(result->hasResultOfType(Dice::RESULT_TYPE::SCALAR))
-        {
-            if(m_sumAll)
-            {
-                auto res= new ScalarResult();
-
-                m_result= res;
-            }
-            else
-            {
-                auto res= new StringResult();
-                m_result= res;
-            }
-        }
-        else if(result->hasResultOfType(Dice::RESULT_TYPE::STRING))
-        {
-            auto res= new StringResult();
-
-            m_result= res;
-        }
-        else if(result->hasResultOfType(Dice::RESULT_TYPE::DICE_LIST))
-        {
-            if(m_sumAll)
-            {
-                auto res= new ScalarResult();
-
-                m_result= res;
-            }
+            resultVec.push_back(leafResult);
+        });
+        cmd= makeCopy(m_cmd);
+    }
+    if(m_sumAll)
+    {
+        auto scalar= new ScalarResult();
+        qreal value= 0.0;
+        std::for_each(resultVec.begin(), resultVec.end(),
+                      [&value](Result* result) { value+= result->getResult(Dice::RESULT_TYPE::SCALAR).toDouble(); });
+        scalar->setValue(value);
+        m_result= scalar;
+    }
+    else
+    {
+        auto string= new StringResult();
+        QStringList list;
+        std::for_each(resultVec.begin(), resultVec.end(), [&list](Result* result) {
+            auto value= result->getResult(Dice::RESULT_TYPE::SCALAR).toDouble();
+            auto diceList= result->getResult(Dice::RESULT_TYPE::DICE_LIST).value<QList<Die*>>();
+            auto string= result->getResult(Dice::RESULT_TYPE::STRING).toString();
+
+            if(!string.isEmpty())
+                list.append(string);
             else
             {
-                auto res= new StringResult();
-
-                m_result= res;
+                QStringList diceStr;
+                std::transform(diceList.begin(), diceList.end(), std::back_inserter(diceStr), [](Die* die) {
+                    auto values= die->getListValue();
+
+                    QStringList valuesStr;
+                    std::transform(values.begin(), values.end(), std::back_inserter(valuesStr),
+                                   [](qint64 val) { return QString::number(val); });
+
+                    if(valuesStr.size() == 1)
+                        return QStringLiteral("%1").arg(die->getValue());
+                    else
+                        return QStringLiteral("%1 [%2]").arg(die->getValue()).arg(valuesStr.join(","));
+                });
+                list.append(QStringLiteral("%1 - Details [%2]").arg(value).arg(diceStr.join(",")));
             }
-        }
-
-        cmd= m_cmd->getCopy();
+        });
+        string->setText(list.join('\n'));
+        m_result= string;
     }
+
+    if(nullptr != m_nextNode)
+        m_nextNode->run(this);
 }
 
 QString RepeaterNode::toString(bool withLabel) const
@@ -100,9 +124,9 @@ ExecutionNode* RepeaterNode::getCopy() const
     return nullptr;
 }
 
-void RepeaterNode::setCommand(ExecutionNode* cmd)
+void RepeaterNode::setCommand(const std::vector<ExecutionNode*>& cmd)
 {
-    m_cmd.reset(cmd);
+    m_cmd= cmd;
 }
 
 void RepeaterNode::setTimeNode(ExecutionNode* time)
diff --git a/node/repeaternode.h b/node/repeaternode.h
index 847db17..fa1a50a 100644
--- a/node/repeaternode.h
+++ b/node/repeaternode.h
@@ -35,12 +35,12 @@ public:
 
     virtual ExecutionNode* getCopy() const override;
 
-    void setCommand(ExecutionNode* node);
+    void setCommand(const std::vector<ExecutionNode*>& node);
     void setTimeNode(ExecutionNode* times);
     void setSumAll(bool b);
 
 private:
-    std::unique_ptr<ExecutionNode> m_cmd;
+    std::vector<ExecutionNode*> m_cmd;
     ExecutionNode* m_times= nullptr;
     bool m_sumAll= false;
 };
diff --git a/node/rerolldicenode.cpp b/node/rerolldicenode.cpp
index 70475a5..370e95e 100644
--- a/node/rerolldicenode.cpp
+++ b/node/rerolldicenode.cpp
@@ -3,16 +3,16 @@
 #include <utility>
 
 RerollDiceNode::RerollDiceNode(bool reroll, bool addingMode)
-    : m_diceResult(new DiceResult()), m_validator(nullptr), m_reroll(reroll), m_adding(addingMode)
+    : m_diceResult(new DiceResult()), m_validatorList(nullptr), m_reroll(reroll), m_adding(addingMode)
 {
     m_result= m_diceResult;
 }
 RerollDiceNode::~RerollDiceNode()
 {
-    if(nullptr != m_validator)
+    if(nullptr != m_validatorList)
     {
-        delete m_validator;
-        m_validator= nullptr;
+        delete m_validatorList;
+        m_validatorList= nullptr;
     }
 }
 void RerollDiceNode::run(ExecutionNode* previous)
@@ -38,8 +38,8 @@ void RerollDiceNode::run(ExecutionNode* previous)
             for(auto& die : list)
             {
                 bool finished= false;
-                auto state
-                    = m_validator->isValidRangeSize(std::make_pair<qint64, qint64>(die->getBase(), die->getMaxValue()));
+                auto state= m_validatorList->isValidRangeSize(
+                    std::make_pair<qint64, qint64>(die->getBase(), die->getMaxValue()));
                 if((Dice::CONDITION_STATE::ALWAYSTRUE == state && m_adding)
                    || (!m_reroll && !m_adding && state == Dice::CONDITION_STATE::UNREACHABLE))
                 {
@@ -51,7 +51,7 @@ void RerollDiceNode::run(ExecutionNode* previous)
                                                  .arg(static_cast<int>(die->getMaxValue()))));
                     continue;
                 }
-                while(m_validator->hasValid(die, false) && !finished)
+                while(m_validatorList->hasValid(die, false) && !finished)
                 {
                     if(m_instruction != nullptr)
                     {
@@ -98,15 +98,15 @@ void RerollDiceNode::run(ExecutionNode* previous)
         }
     }
 }
-void RerollDiceNode::setValidator(Validator* val)
+void RerollDiceNode::setValidatorList(ValidatorList* val)
 {
-    m_validator= val;
+    m_validatorList= val;
 }
 QString RerollDiceNode::toString(bool wl) const
 {
     if(wl)
     {
-        return QString("%1 [label=\"RerollDiceNode validatior: %2\"]").arg(m_id, m_validator->toString());
+        return QString("%1 [label=\"RerollDiceNode validatior: %2\"]").arg(m_id, m_validatorList->toString());
     }
     else
     {
@@ -127,7 +127,7 @@ qint64 RerollDiceNode::getPriority() const
 ExecutionNode* RerollDiceNode::getCopy() const
 {
     RerollDiceNode* node= new RerollDiceNode(m_reroll, m_adding);
-    node->setValidator(m_validator);
+    node->setValidatorList(m_validatorList);
     if(nullptr != m_nextNode)
     {
         node->setNextNode(m_nextNode->getCopy());
diff --git a/node/rerolldicenode.h b/node/rerolldicenode.h
index 32fad79..68b732e 100644
--- a/node/rerolldicenode.h
+++ b/node/rerolldicenode.h
@@ -3,7 +3,8 @@
 
 #include "executionnode.h"
 #include "result/diceresult.h"
-#include "validator.h"
+
+class ValidatorList;
 /**
  * @brief The RerollDiceNode class reroll dice given a condition and replace(or add) the result.
  */
@@ -38,7 +39,7 @@ public:
     /**
      * @brief setValidator
      */
-    virtual void setValidator(Validator*);
+    virtual void setValidatorList(ValidatorList*);
     /**
      * @brief toString
      * @return
@@ -61,7 +62,7 @@ public:
 
 private:
     DiceResult* m_diceResult= nullptr;
-    Validator* m_validator= nullptr;
+    ValidatorList* m_validatorList= nullptr;
     ExecutionNode* m_instruction= nullptr;
 
     const bool m_reroll;
diff --git a/node/variablenode.h b/node/variablenode.h
index 45133c6..5306ddb 100644
--- a/node/variablenode.h
+++ b/node/variablenode.h
@@ -11,14 +11,14 @@ class VariableNode : public ExecutionNode
 {
 public:
     VariableNode();
-    void run(ExecutionNode* previous);
-    virtual QString toString(bool withLabel) const;
-    virtual qint64 getPriority() const;
+    void run(ExecutionNode* previous) override;
+    virtual QString toString(bool withLabel) const override;
+    virtual qint64 getPriority() const override;
     /**
      * @brief getCopy
      * @return
      */
-    virtual ExecutionNode* getCopy() const;
+    virtual ExecutionNode* getCopy() const override;
     quint64 getIndex() const;
     void setIndex(quint64 index);