1 files changed, 75 insertions, 77 deletions

diff --git a/node/scalaroperatornode.cpp b/node/scalaroperatornode.cpp
index 9c86917..b85f23c 100644
--- a/node/scalaroperatornode.cpp
+++ b/node/scalaroperatornode.cpp
@@ -26,56 +26,49 @@
 
 
 ScalarOperatorNode::ScalarOperatorNode()
-    : m_internalNode(NULL),m_scalarResult(new ScalarResult()),m_arithmeticOperator(Die::PLUS)
+    : m_internalNode(nullptr),m_scalarResult(new ScalarResult()),m_arithmeticOperator(Die::PLUS)
 {
-    /*m_scalarOperationList.insert('+',PLUS);
-    m_scalarOperationList.insert('-',MINUS);
-    m_scalarOperationList.insert('x',MULTIPLICATION);
-    m_scalarOperationList.insert('*',MULTIPLICATION);
-    m_scalarOperationList.insert('/',DIVIDE);*/
-
     m_result = m_scalarResult;
 }
 ScalarOperatorNode::~ScalarOperatorNode()
 {
-	if(NULL!=m_internalNode)
-	{
-		delete m_internalNode;
-		m_internalNode = NULL;
-	}
+    if(nullptr!=m_internalNode)
+    {
+        delete m_internalNode;
+        m_internalNode = nullptr;
+    }
 }
 
 void ScalarOperatorNode::run(ExecutionNode* previous)
 {
     m_previousNode = previous;
-    if(NULL!=m_internalNode)
+    if(nullptr!=m_internalNode)
     {
-            m_internalNode->run(this);
+        m_internalNode->run(this);
     }
-    if(NULL!=previous)
+    if(nullptr!=previous)
     {
         DiceResult* previousResult = static_cast<DiceResult*>(previous->getResult());
 
-        if(NULL!=previousResult)
+        if(nullptr!=previousResult)
         {
             ExecutionNode* internal = m_internalNode;
-            if(NULL != internal)
+            if(nullptr != internal)
             {
-             while(NULL != internal->getNextNode() )
-             {
+                while(nullptr != internal->getNextNode() )
+                {
                     internal = internal->getNextNode();
-             }
-
+                }
 
-            Result* internalResult = internal->getResult();
-            m_result->setPrevious(internalResult);
-            if(NULL!=m_internalNode->getResult())
-            {
-                m_internalNode->getResult()->setPrevious(previousResult);
-            }
+                Result* internalResult = internal->getResult();
+                m_result->setPrevious(internalResult);
+                if(nullptr!=m_internalNode->getResult())
+                {
+                    m_internalNode->getResult()->setPrevious(previousResult);
+                }
 
-            switch(m_arithmeticOperator)
-            {
+                switch(m_arithmeticOperator)
+                {
                 case Die::PLUS:
                     m_scalarResult->setValue(add(previousResult->getResult(Result::SCALAR).toReal(),internalResult->getResult(Result::SCALAR).toReal()));
                     break;
@@ -88,13 +81,16 @@ void ScalarOperatorNode::run(ExecutionNode* previous)
                 case Die::DIVIDE:
                     m_scalarResult->setValue(divide(previousResult->getResult(Result::SCALAR).toReal(),internalResult->getResult(Result::SCALAR).toReal()));
                     break;
+                case Die::POWER:
+                    m_scalarResult->setValue(power(previousResult->getResult(Result::SCALAR).toReal(),internalResult->getResult(Result::SCALAR).toReal()));
+                    break;
                 default:
                     break;
 
-            }
+                }
             }
 
-            if(NULL!=m_nextNode)
+            if(nullptr!=m_nextNode)
             {
                 m_nextNode->run(this);
             }
@@ -102,15 +98,6 @@ void ScalarOperatorNode::run(ExecutionNode* previous)
     }
 
 }
-/*bool ScalarOperatorNode::setOperatorChar(QChar c)
-{
-    if(m_scalarOperationList.contains(c))
-    {
-		m_operator = m_scalarOperationList.value(c);
-        return true;
-    }
-    return false;
-}*/
 
 void ScalarOperatorNode::setInternalNode(ExecutionNode* node)
 {
@@ -133,10 +120,14 @@ qreal ScalarOperatorNode::divide(qint64 a,qint64 b)
     }
     return (qreal)a/b;
 }
-qint64 ScalarOperatorNode::multiple(qint64 a,qint64 b)
+qint64 ScalarOperatorNode::multiple(qint64 a, qint64 b)
 {
     return a*b;
 }
+qint64 ScalarOperatorNode::power(qint64 a, qint64 b)
+{
+    return std::pow(a,b);
+}
 Die::ArithmeticOperator ScalarOperatorNode::getArithmeticOperator() const
 {
     return m_arithmeticOperator;
@@ -157,64 +148,71 @@ QString ScalarOperatorNode::toString(bool wl) const
         break;
     case Die::MINUS:
         op="-";
-            break;
-        case Die::MULTIPLICATION:
-            op="*";
-            break;
-        case Die::DIVIDE:
-            op="/";
-            break;
-        default:
-            break;
+        break;
+    case Die::MULTIPLICATION:
+        op="*";
+        break;
+    case Die::DIVIDE:
+        op="/";
+        break;
+    case Die::POWER:
+        op="^";
+        break;
+    default:
+        break;
 
     }
-	if(wl)
-	{
-		return QString("%1 [label=\"ScalarOperatorNode %2\"]").arg(m_id).arg(op);
-	}
-	else
-	{
-		return m_id;
-	}
+    if(wl)
+    {
+        return QString("%1 [label=\"ScalarOperatorNode %2\"]").arg(m_id).arg(op);
+    }
+    else
+    {
+        return m_id;
+    }
 }
 qint64 ScalarOperatorNode::getPriority() const
 {
     if((m_arithmeticOperator==Die::PLUS)||(m_arithmeticOperator==Die::MINUS))
-	{
+    {
         return 1;
-	}
-    else
-	{
+    }
+    else if((m_arithmeticOperator==Die::MULTIPLICATION)||(m_arithmeticOperator==Die::DIVIDE))
+    {
         return 2;
-	}
+    }
+    else
+    {
+        return 3;
+    }
 }
 void ScalarOperatorNode::generateDotTree(QString& s)
 {
-	s.append(toString(true));
-	s.append(";\n");
+    s.append(toString(true));
+    s.append(";\n");
 
-    if(NULL!=m_nextNode)
+    if(nullptr!=m_nextNode)
     {
-		s.append(toString(false));
+        s.append(toString(false));
         s.append(" -> ");
-		s.append(m_nextNode->toString(false));
+        s.append(m_nextNode->toString(false));
         s.append("[label=\"nextNode\"];\n");
         m_nextNode->generateDotTree(s);
     }
     else
     {
-		s.append(toString(false));
+        s.append(toString(false));
         s.append(" -> ");
-		s.append("NULL");
-		s.append(" [label=\"nextNode\"];\n");
+        s.append("nullptr");
+        s.append(" [label=\"nextNode\"];\n");
     }
     QString str;
     str.append("\n");
-    if(NULL!=m_internalNode)
+    if(nullptr!=m_internalNode)
     {
-		str.append(toString(false));
+        str.append(toString(false));
         str.append(" -> ");
-		str.append(m_internalNode->toString(false));
+        str.append(m_internalNode->toString(false));
         str.append(" [label=\"internalNode\"];\n");
         m_internalNode->generateDotTree(str);
     }
@@ -222,14 +220,14 @@ void ScalarOperatorNode::generateDotTree(QString& s)
 }
 QMap<ExecutionNode::DICE_ERROR_CODE,QString> ScalarOperatorNode::getExecutionErrorMap()
 {
-    if(NULL!=m_internalNode)
+    if(nullptr!=m_internalNode)
     {
         for (ExecutionNode::DICE_ERROR_CODE key: m_internalNode->getExecutionErrorMap().keys())
         {
             m_errors.insert(key,m_internalNode->getExecutionErrorMap().value(key));
         }
     }
-    if(NULL!=m_nextNode)
+    if(nullptr!=m_nextNode)
     {
         for (ExecutionNode::DICE_ERROR_CODE key: m_nextNode->getExecutionErrorMap().keys())
         {
@@ -243,7 +241,7 @@ ExecutionNode* ScalarOperatorNode::getCopy() const
     ScalarOperatorNode* node = new ScalarOperatorNode();
     node->setInternalNode(m_internalNode->getCopy());
     node->setArithmeticOperator(m_arithmeticOperator);
-    if(NULL!=m_nextNode)
+    if(nullptr!=m_nextNode)
     {
         node->setNextNode(m_nextNode->getCopy());
     }