Rework of the component to be a proper lib

16 files changed, 48 insertions, 58 deletions

diff --git a/node/dicerollernode.cpp b/node/dicerollernode.cpp
index f57d3e3..f87908f 100644
--- a/node/dicerollernode.cpp
+++ b/node/dicerollernode.cpp
@@ -19,10 +19,10 @@ void DiceRollerNode::run(ExecutionNode* previous)
         Result* result= previous->getResult();
         if(nullptr != result)
         {
-            auto num= result->getResult(Result::SCALAR).toReal();
+            auto num= result->getResult(Dice::RESULT_TYPE::SCALAR).toReal();
             if(num <= 0)
             {
-                m_errors.insert(NO_DICE_TO_ROLL, QObject::tr("No dice to roll"));
+                m_errors.insert(Dice::ERROR_CODE::NO_DICE_TO_ROLL, QObject::tr("No dice to roll"));
             }
             m_diceCount= num > 0 ? static_cast<quint64>(num) : 0;
             m_result->setPrevious(result);
@@ -30,7 +30,7 @@ void DiceRollerNode::run(ExecutionNode* previous)
             auto possibleValue= static_cast<quint64>(std::abs((m_max - m_min) + 1));
             if(possibleValue < m_diceCount && m_unique)
             {
-                m_errors.insert(TOO_MANY_DICE,
+                m_errors.insert(Dice::ERROR_CODE::TOO_MANY_DICE,
                                 QObject::tr("More unique values asked than possible values (D operator)"));
                 return;
             }
@@ -62,7 +62,7 @@ void DiceRollerNode::run(ExecutionNode* previous)
 
 quint64 DiceRollerNode::getFaces() const
 {
-    return std::abs(m_max - m_min) + 1;
+    return static_cast<quint64>(std::abs(m_max - m_min) + 1);
 }
 
 std::pair<qint64, qint64> DiceRollerNode::getRange() const
diff --git a/node/executionnode.cpp b/node/executionnode.cpp
index 5bee091..4545934 100644
--- a/node/executionnode.cpp
+++ b/node/executionnode.cpp
@@ -6,7 +6,7 @@ ExecutionNode::ExecutionNode()
     : m_previousNode(nullptr)
     , m_result(nullptr)
     , m_nextNode(nullptr)
-    , m_errors(QMap<ExecutionNode::DICE_ERROR_CODE, QString>())
+    , m_errors(QMap<Dice::ERROR_CODE, QString>())
     , m_id(QString("\"%1\"").arg(QUuid::createUuid().toString()))
 {
 }
@@ -40,7 +40,7 @@ ExecutionNode* ExecutionNode::getNextNode()
 {
     return m_nextNode;
 }
-QMap<ExecutionNode::DICE_ERROR_CODE, QString> ExecutionNode::getExecutionErrorMap()
+QMap<Dice::ERROR_CODE, QString> ExecutionNode::getExecutionErrorMap()
 {
     if(nullptr != m_nextNode)
     {
@@ -97,5 +97,5 @@ qint64 ExecutionNode::getScalarResult()
 {
     if(m_result == nullptr)
         return 0;
-    return m_result->getResult(Result::SCALAR).toInt();
+    return m_result->getResult(Dice::RESULT_TYPE::SCALAR).toInt();
 }
diff --git a/node/executionnode.h b/node/executionnode.h
index e8eca1f..62bc5a5 100644
--- a/node/executionnode.h
+++ b/node/executionnode.h
@@ -1,8 +1,8 @@
 #ifndef EXECUTIONNODE_H
 #define EXECUTIONNODE_H
 
+#include "diceparserhelper.h"
 #include "result/result.h"
-#include <QDebug>
 
 /**
  * @brief The ExecutionNode class
@@ -10,21 +10,6 @@
 class ExecutionNode
 {
 public:
-    enum DICE_ERROR_CODE
-    {
-        NO_DICE_ERROR,
-        DIE_RESULT_EXPECTED,
-        BAD_SYNTAXE,
-        ENDLESS_LOOP_ERROR,
-        DIVIDE_BY_ZERO,
-        NOTHING_UNDERSTOOD,
-        NO_DICE_TO_ROLL,
-        TOO_MANY_DICE,
-        NO_VARIBALE,
-        INVALID_INDEX,
-        UNEXPECTED_CHARACTER,
-        NO_PREVIOUS_ERROR
-    };
     /**
      * @brief ExecutionNode
      */
@@ -72,7 +57,7 @@ public:
      * @brief getErrorList
      * @return
      */
-    virtual QMap<ExecutionNode::DICE_ERROR_CODE, QString> getExecutionErrorMap();
+    virtual QMap<Dice::ERROR_CODE, QString> getExecutionErrorMap();
 
     /**
      * @brief generateDotTree
@@ -109,7 +94,7 @@ protected:
     /**
      * @brief m_errors
      */
-    QMap<ExecutionNode::DICE_ERROR_CODE, QString> m_errors;
+    QMap<Dice::ERROR_CODE, QString> m_errors;
 
     QString m_id;
 };
diff --git a/node/forloopnode.cpp b/node/forloopnode.cpp
index f65a389..aba6ff4 100644
--- a/node/forloopnode.cpp
+++ b/node/forloopnode.cpp
@@ -58,7 +58,7 @@ void ForLoopNode::run(ExecutionNode* previous)
                     tmp= tmp->getNextNode();
                 }
                 Result* internalResult= tmp->getResult();
-                auto value= internalResult->getResult(Result::SCALAR).toInt();
+                auto value= internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toInt();
 
                 Die* neodie= new Die();
                 *neodie= *dice;
diff --git a/node/ifnode.cpp b/node/ifnode.cpp
index 5470e15..10b2f79 100644
--- a/node/ifnode.cpp
+++ b/node/ifnode.cpp
@@ -45,7 +45,7 @@ void IfNode::run(ExecutionNode* previous)
 
     if(nullptr != m_result)
     {
-        qreal value= previousResult->getResult(Result::SCALAR).toReal();
+        qreal value= previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal();
 
         if(nullptr != m_validator)
         {
diff --git a/node/jumpbackwardnode.cpp b/node/jumpbackwardnode.cpp
index 15c7063..2870854 100644
--- a/node/jumpbackwardnode.cpp
+++ b/node/jumpbackwardnode.cpp
@@ -96,7 +96,7 @@ void JumpBackwardNode::run(ExecutionNode* previous)
         if(nullptr != result)
         {
             //--i;
-            if(/*(i==0)&&*/ (result->hasResultOfType(Result::DICE_LIST)))
+            if(/*(i==0)&&*/ (result->hasResultOfType(Dice::RESULT_TYPE::DICE_LIST)))
             {
                 found= true;
                 m_backwardNode= parent;
@@ -118,7 +118,8 @@ void JumpBackwardNode::run(ExecutionNode* previous)
     }
     if(nullptr == result)
     {
-        m_errors.insert(DIE_RESULT_EXPECTED,
+        m_errors.insert(
+            Dice::ERROR_CODE::DIE_RESULT_EXPECTED,
             QObject::tr(" The @ operator expects dice result. Please check the documentation to fix your command."));
     }
     else
diff --git a/node/keepdiceexecnode.cpp b/node/keepdiceexecnode.cpp
index 42b4c40..688c27b 100644
--- a/node/keepdiceexecnode.cpp
+++ b/node/keepdiceexecnode.cpp
@@ -58,9 +58,10 @@ void KeepDiceExecNode::run(ExecutionNode* previous)
 
         if(m_numberOfDice > static_cast<qint64>(diceList.size()))
         {
-            m_errors.insert(TOO_MANY_DICE, QObject::tr(" You ask to keep %1 dice but the result only has %2")
-                                               .arg(m_numberOfDice)
-                                               .arg(diceList.size()));
+            m_errors.insert(Dice::ERROR_CODE::TOO_MANY_DICE,
+                            QObject::tr(" You ask to keep %1 dice but the result only has %2")
+                                .arg(m_numberOfDice)
+                                .arg(diceList.size()));
         }
 
         for(auto& tmp : diceList.mid(static_cast<int>(m_numberOfDice), -1))
diff --git a/node/listsetrollnode.cpp b/node/listsetrollnode.cpp
index ffa0f03..565a609 100644
--- a/node/listsetrollnode.cpp
+++ b/node/listsetrollnode.cpp
@@ -62,11 +62,11 @@ void ListSetRollNode::run(ExecutionNode* previous)
         Result* result= previous->getResult();
         if(nullptr != result)
         {
-            quint64 diceCount= result->getResult(Result::SCALAR).toReal();
+            quint64 diceCount= result->getResult(Dice::RESULT_TYPE::SCALAR).toReal();
             if(diceCount > static_cast<quint64>(m_values.size()) && m_unique)
             {
-                m_errors.insert(
-                    TOO_MANY_DICE, QObject::tr("More unique values asked than possible values (L operator)"));
+                m_errors.insert(Dice::ERROR_CODE::TOO_MANY_DICE,
+                                QObject::tr("More unique values asked than possible values (L operator)"));
             }
             else
             {
diff --git a/node/mergenode.cpp b/node/mergenode.cpp
index 4a11a76..c4c1543 100644
--- a/node/mergenode.cpp
+++ b/node/mergenode.cpp
@@ -29,7 +29,7 @@ void MergeNode::run(ExecutionNode* previous)
 {
     if(nullptr == previous)
     {
-        m_errors.insert(ExecutionNode::NO_PREVIOUS_ERROR, QObject::tr("No previous node before Merge operator"));
+        m_errors.insert(Dice::ERROR_CODE::NO_PREVIOUS_ERROR, QObject::tr("No previous node before Merge operator"));
         return;
     }
 
@@ -69,7 +69,7 @@ void MergeNode::run(ExecutionNode* previous)
                     }
                 }
                 auto it= std::find_if(pastResult.begin(), pastResult.end(),
-                    [tmpResult](const Result* a) { return (a == tmpResult->getPrevious()); });
+                                      [tmpResult](const Result* a) { return (a == tmpResult->getPrevious()); });
                 if(it == pastResult.end())
                 {
                     pastResult.push_back(previousLast->getResult());
diff --git a/node/occurencecountnode.cpp b/node/occurencecountnode.cpp
index e0117ef..0d69d2a 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 <QVector>
 
 OccurenceCountNode::OccurenceCountNode() : ExecutionNode() {}
 
diff --git a/node/paintnode.cpp b/node/paintnode.cpp
index 02c7230..fe5a324 100644
--- a/node/paintnode.cpp
+++ b/node/paintnode.cpp
@@ -61,7 +61,7 @@ void PainterNode::run(ExecutionNode* previous)
     m_previousNode= previous;
     if(nullptr == previous)
     {
-        m_errors.insert(ExecutionNode::NO_PREVIOUS_ERROR, QObject::tr("No previous node before Paint operator"));
+        m_errors.insert(Dice::ERROR_CODE::NO_PREVIOUS_ERROR, QObject::tr("No previous node before Paint operator"));
         return;
     }
     Result* previousResult= previous->getResult();
diff --git a/node/rerolldicenode.cpp b/node/rerolldicenode.cpp
index 56ee6d9..18e8bba 100644
--- a/node/rerolldicenode.cpp
+++ b/node/rerolldicenode.cpp
@@ -79,7 +79,8 @@ void RerollDiceNode::run(ExecutionNode* previous)
         }
         else
         {
-            m_errors.insert(ExecutionNode::DIE_RESULT_EXPECTED,
+            m_errors.insert(
+                Dice::ERROR_CODE::DIE_RESULT_EXPECTED,
                 QObject::tr(
                     " The a operator expects dice result. Please check the documentation and fix your command."));
         }
diff --git a/node/scalaroperatornode.cpp b/node/scalaroperatornode.cpp
index 3a26fc7..9edbcdc 100644
--- a/node/scalaroperatornode.cpp
+++ b/node/scalaroperatornode.cpp
@@ -69,28 +69,29 @@ void ScalarOperatorNode::run(ExecutionNode* previous)
                 switch(m_arithmeticOperator)
                 {
                 case Die::PLUS:
-                    m_scalarResult->setValue(add(previousResult->getResult(Result::SCALAR).toReal(),
-                        internalResult->getResult(Result::SCALAR).toReal()));
+                    m_scalarResult->setValue(add(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(),
+                                                 internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal()));
                     break;
                 case Die::MINUS:
-                    m_scalarResult->setValue(substract(previousResult->getResult(Result::SCALAR).toReal(),
-                        internalResult->getResult(Result::SCALAR).toReal()));
+                    m_scalarResult->setValue(substract(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(),
+                                                       internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal()));
                     break;
                 case Die::MULTIPLICATION:
-                    m_scalarResult->setValue(multiple(previousResult->getResult(Result::SCALAR).toReal(),
-                        internalResult->getResult(Result::SCALAR).toReal()));
+                    m_scalarResult->setValue(multiple(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(),
+                                                      internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal()));
                     break;
                 case Die::DIVIDE:
-                    m_scalarResult->setValue(divide(previousResult->getResult(Result::SCALAR).toReal(),
-                        internalResult->getResult(Result::SCALAR).toReal()));
+                    m_scalarResult->setValue(divide(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(),
+                                                    internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal()));
                     break;
                 case Die::INTEGER_DIVIDE:
-                    m_scalarResult->setValue(static_cast<int>(divide(previousResult->getResult(Result::SCALAR).toReal(),
-                        internalResult->getResult(Result::SCALAR).toReal())));
+                    m_scalarResult->setValue(
+                        static_cast<int>(divide(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(),
+                                                internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal())));
                     break;
                 case Die::POW:
-                    m_scalarResult->setValue(pow(previousResult->getResult(Result::SCALAR).toReal(),
-                        internalResult->getResult(Result::SCALAR).toReal()));
+                    m_scalarResult->setValue(pow(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(),
+                                                 internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal()));
                     break;
                 }
             }
@@ -128,7 +129,7 @@ qreal ScalarOperatorNode::divide(qreal a, qreal b)
 {
     if(qFuzzyCompare(b, 0))
     {
-        m_errors.insert(DIVIDE_BY_ZERO, QObject::tr("Division by zero"));
+        m_errors.insert(Dice::ERROR_CODE::DIVIDE_BY_ZERO, QObject::tr("Division by zero"));
         return 0;
     }
     return static_cast<qreal>(a / b);
@@ -240,12 +241,12 @@ void ScalarOperatorNode::generateDotTree(QString& s)
     }
     s.append(str);
 }
-QMap<ExecutionNode::DICE_ERROR_CODE, QString> ScalarOperatorNode::getExecutionErrorMap()
+QMap<Dice::ERROR_CODE, QString> ScalarOperatorNode::getExecutionErrorMap()
 {
     if(nullptr != m_internalNode)
     {
         auto keys= m_internalNode->getExecutionErrorMap().keys();
-        for(ExecutionNode::DICE_ERROR_CODE& key : keys)
+        for(const auto& key : keys)
         {
             m_errors.insert(key, m_internalNode->getExecutionErrorMap().value(key));
         }
@@ -253,7 +254,7 @@ QMap<ExecutionNode::DICE_ERROR_CODE, QString> ScalarOperatorNode::getExecutionEr
     if(nullptr != m_nextNode)
     {
         auto keys= m_nextNode->getExecutionErrorMap().keys();
-        for(ExecutionNode::DICE_ERROR_CODE& key : keys)
+        for(auto const& key : keys)
         {
             m_errors.insert(key, m_nextNode->getExecutionErrorMap().value(key));
         }
diff --git a/node/scalaroperatornode.h b/node/scalaroperatornode.h
index 2ac89b0..a58a8d3 100644
--- a/node/scalaroperatornode.h
+++ b/node/scalaroperatornode.h
@@ -76,7 +76,7 @@ public:
      * @brief getErrorList
      * @return
      */
-    virtual QMap<ExecutionNode::DICE_ERROR_CODE, QString> getExecutionErrorMap();
+    virtual QMap<Dice::ERROR_CODE, QString> getExecutionErrorMap();
     /**
      * @brief getArithmeticOperator
      * @return
diff --git a/node/valueslistnode.cpp b/node/valueslistnode.cpp
index b31ee84..d378350 100644
--- a/node/valueslistnode.cpp
+++ b/node/valueslistnode.cpp
@@ -16,7 +16,7 @@ void ValuesListNode::run(ExecutionNode* previous)
         auto result= node->getResult();
         if(!result)
             continue;
-        auto val= result->getResult(Result::SCALAR).toInt();
+        auto val= result->getResult(Dice::RESULT_TYPE::SCALAR).toInt();
         Die* die= new Die();
         auto dyna= dynamic_cast<VariableNode*>(node);
         if(nullptr != dyna)
diff --git a/node/variablenode.cpp b/node/variablenode.cpp
index 1d13a2c..e45214d 100644
--- a/node/variablenode.cpp
+++ b/node/variablenode.cpp
@@ -24,7 +24,7 @@ void VariableNode::run(ExecutionNode* previous)
     }
     else
     {
-        m_errors.insert(NO_VARIBALE, QObject::tr("No variable at index:%1").arg(m_index + 1));
+        m_errors.insert(Dice::ERROR_CODE::NO_VARIBALE, QObject::tr("No variable at index:%1").arg(m_index + 1));
     }
 }