From f053853e87624a045438bacd4dd1494e91ae381f Mon Sep 17 00:00:00 2001 From: Renaud G Date: Fri, 27 Oct 2017 22:19:20 +0200 Subject: -c++11 update about for and nullptr. --- node/scalaroperatornode.cpp | 152 ++++++++++++++++++++++---------------------- 1 file changed, 75 insertions(+), 77 deletions(-) (limited to 'node/scalaroperatornode.cpp') 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(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 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()); } -- cgit v1.2.3-70-g09d2