clang format

1 files changed, 74 insertions, 83 deletions

diff --git a/node/groupnode.cpp b/node/groupnode.cpp
index 00bb15e..681db47 100644
--- a/node/groupnode.cpp
+++ b/node/groupnode.cpp
@@ -1,40 +1,40 @@
 /***************************************************************************
-* Copyright (C) 2014 by Renaud Guezennec                                   *
-* http://www.rolisteam.org/contact                      *
-*                                                                          *
-*  This file is part of DiceParser                                         *
-*                                                                          *
-* DiceParser is free software; you can redistribute it and/or modify       *
-* it under the terms of the GNU General Public License as published by     *
-* the Free Software Foundation; either version 2 of the License, or        *
-* (at your option) any later version.                                      *
-*                                                                          *
-* This program is distributed in the hope that it will be useful,          *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of           *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the             *
-* GNU General Public License for more details.                             *
-*                                                                          *
-* You should have received a copy of the GNU General Public License        *
-* along with this program; if not, write to the                            *
-* Free Software Foundation, Inc.,                                          *
-* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.                 *
-***************************************************************************/
+ * Copyright (C) 2014 by Renaud Guezennec                                   *
+ * http://www.rolisteam.org/contact                      *
+ *                                                                          *
+ *  This file is part of DiceParser                                         *
+ *                                                                          *
+ * DiceParser is free software; you can redistribute it and/or modify       *
+ * it under the terms of the GNU General Public License as published by     *
+ * the Free Software Foundation; either version 2 of the License, or        *
+ * (at your option) any later version.                                      *
+ *                                                                          *
+ * This program is distributed in the hope that it will be useful,          *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of           *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the             *
+ * GNU General Public License for more details.                             *
+ *                                                                          *
+ * You should have received a copy of the GNU General Public License        *
+ * along with this program; if not, write to the                            *
+ * Free Software Foundation, Inc.,                                          *
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.                 *
+ ***************************************************************************/
 #include "groupnode.h"
 #include "result/diceresult.h"
 //-------------------------------
 int DieGroup::getSum() const
 {
-    int sum =0;
+    int sum= 0;
     for(int i : *this)
     {
-        sum += i;
+        sum+= i;
     }
     return sum;
 }
 
 void DieGroup::removeValue(DieGroup i)
 {
-    for(auto x : i )
+    for(auto x : i)
     {
         removeOne(x);
     }
@@ -42,7 +42,7 @@ void DieGroup::removeValue(DieGroup i)
 
 int DieGroup::getLost() const
 {
-    return getSum()-m_exceptedValue;
+    return getSum() - m_exceptedValue;
 }
 
 qint64 DieGroup::getExceptedValue() const
@@ -52,40 +52,36 @@ qint64 DieGroup::getExceptedValue() const
 
 void DieGroup::setExceptedValue(qint64 exceptedValue)
 {
-    m_exceptedValue = exceptedValue;
+    m_exceptedValue= exceptedValue;
 }
 
-
-
-
 //---------------------
-GroupNode::GroupNode()
-    : m_scalarResult(new ScalarResult())
+GroupNode::GroupNode() : m_scalarResult(new ScalarResult())
 {
-    m_result = m_scalarResult;
+    m_result= m_scalarResult;
 }
 void GroupNode::run(ExecutionNode* previous)
 {
-    m_previousNode = previous;
+    m_previousNode= previous;
     if(nullptr != previous)
     {
         m_result->setPrevious(previous->getResult());
-        Result* tmpResult = previous->getResult();
+        Result* tmpResult= previous->getResult();
         if(nullptr != tmpResult)
         {
-            DiceResult* dice = dynamic_cast<DiceResult*>(tmpResult);
+            DiceResult* dice= dynamic_cast<DiceResult*>(tmpResult);
             if(nullptr != dice)
             {
-                auto list = dice->getResultList();
+                auto list= dice->getResultList();
                 DieGroup allResult;
                 for(auto& die : list)
                 {
                     allResult << die->getListValue();
                 }
-                std::sort(allResult.begin(),allResult.end(), std::greater<qint64>());
+                std::sort(allResult.begin(), allResult.end(), std::greater<qint64>());
                 if(allResult.getSum() > m_groupValue)
                 {
-                    auto const die =getGroup(allResult);
+                    auto const die= getGroup(allResult);
                     m_scalarResult->setValue(die.size());
                 }
                 else
@@ -95,7 +91,7 @@ void GroupNode::run(ExecutionNode* previous)
             }
         }
     }
-    if(nullptr!=m_nextNode)
+    if(nullptr != m_nextNode)
     {
         m_nextNode->run(this);
     }
@@ -114,22 +110,21 @@ QString GroupNode::toString(bool withLabel) const
 }
 qint64 GroupNode::getPriority() const
 {
-    qint64 priority=0;
-    if(nullptr!=m_nextNode)
+    qint64 priority= 0;
+    if(nullptr != m_nextNode)
     {
-        priority = m_nextNode->getPriority();
+        priority= m_nextNode->getPriority();
     }
     return priority;
 }
 ExecutionNode* GroupNode::getCopy() const
 {
-    GroupNode* node = new GroupNode();
-    if(nullptr!=m_nextNode)
+    GroupNode* node= new GroupNode();
+    if(nullptr != m_nextNode)
     {
         node->setNextNode(m_nextNode->getCopy());
     }
     return node;
-
 }
 
 int GroupNode::getGroupValue() const
@@ -139,12 +134,12 @@ int GroupNode::getGroupValue() const
 
 void GroupNode::setGroupValue(qint64 groupValue)
 {
-    m_groupValue = groupValue;
+    m_groupValue= groupValue;
 }
 
 bool GroupNode::composeWithPrevious(DieGroup previous, qint64 first, qint64 current, DieGroup& addValue)
 {
-    if(previous.getSum()+first+current == m_groupValue)
+    if(previous.getSum() + first + current == m_groupValue)
     {
         addValue.append(previous);
         addValue.append(first);
@@ -155,8 +150,8 @@ bool GroupNode::composeWithPrevious(DieGroup previous, qint64 first, qint64 curr
     if(previous.isEmpty())
         return false;
 
-    int maxComboLength = previous.size();
-    bool hasReachMax = false;
+    int maxComboLength= previous.size();
+    bool hasReachMax= false;
 
     QList<DieGroup> possibleUnion;
     for(auto va : previous)
@@ -168,7 +163,7 @@ bool GroupNode::composeWithPrevious(DieGroup previous, qint64 first, qint64 curr
 
     while(!hasReachMax)
     {
-        auto tmpValues = previous;
+        auto tmpValues= previous;
         QList<DieGroup> possibleTmp;
         for(auto& diaG : possibleUnion)
         {
@@ -181,31 +176,30 @@ bool GroupNode::composeWithPrevious(DieGroup previous, qint64 first, qint64 curr
                 DieGroup dia;
                 dia.append(diaG);
                 dia.append(value);
-                if(dia.size() >= maxComboLength-1)
-                    hasReachMax = true;
+                if(dia.size() >= maxComboLength - 1)
+                    hasReachMax= true;
                 else
                     possibleTmp.append(dia);
             }
         }
         if(possibleTmp.isEmpty())
-            hasReachMax = true;
+            hasReachMax= true;
         else
         {
             possibleTmp.append(possibleUnion);
-            possibleUnion = possibleTmp;
+            possibleUnion= possibleTmp;
         }
     }
-    std::sort(possibleUnion.begin(),possibleUnion.end(),[=](const DieGroup& a, const DieGroup& b){
-        return a.getLost() > b.getLost();
-    });
-    bool found = false;
-    for(int i = 0;(!found && i < possibleUnion.size()); ++i)
+    std::sort(possibleUnion.begin(), possibleUnion.end(),
+        [=](const DieGroup& a, const DieGroup& b) { return a.getLost() > b.getLost(); });
+    bool found= false;
+    for(int i= 0; (!found && i < possibleUnion.size()); ++i)
     {
-        auto& value = possibleUnion.at(i);
+        auto& value= possibleUnion.at(i);
         if(value.getSum() + current + first >= m_groupValue)
         {
             addValue << value << current << first;
-            found = true;
+            found= true;
         }
     }
     return found;
@@ -216,62 +210,62 @@ QList<DieGroup> GroupNode::getGroup(DieGroup values)
     if(values.isEmpty())
         return {};
 
-    auto first = values.takeFirst();
+    auto first= values.takeFirst();
 
     QList<DieGroup> result;
-    QMap<qint64,DieGroup> loseMap;
+    QMap<qint64, DieGroup> loseMap;
     if(first >= m_groupValue)
     {
         DieGroup group;
-        group << first ;
-        loseMap[0] = group;
+        group << first;
+        loseMap[0]= group;
     }
     else
     {
-        DieGroup::reverse_iterator it = values.rbegin();
-        bool foundPerfect = false;
-        qint64 cumuledValue = 0;
+        DieGroup::reverse_iterator it= values.rbegin();
+        bool foundPerfect= false;
+        qint64 cumuledValue= 0;
         DieGroup previousValue;
         while((values.rend() != it) && !foundPerfect)
         {
-            if(first+*it == m_groupValue)
+            if(first + *it == m_groupValue)
             {
-                foundPerfect = true;
+                foundPerfect= true;
                 DieGroup group;
                 group << first << *it;
-                loseMap[0] = group;
+                loseMap[0]= group;
             }
-            else if(first+*it > m_groupValue)
+            else if(first + *it > m_groupValue)
             {
                 DieGroup group;
                 group << first << *it;
-                loseMap[first+*it-m_groupValue]=group;
+                loseMap[first + *it - m_groupValue]= group;
             }
-            else if(first+*it+cumuledValue == m_groupValue)
+            else if(first + *it + cumuledValue == m_groupValue)
             {
                 DieGroup group;
                 group << first << *it << previousValue;
-                foundPerfect = true;
-                loseMap[0] = group;
+                foundPerfect= true;
+                loseMap[0]= group;
             }
-            else if(first+*it+cumuledValue > m_groupValue)
+            else if(first + *it + cumuledValue > m_groupValue)
             {
                 DieGroup group;
                 group.setExceptedValue(m_groupValue);
-                auto b = composeWithPrevious(previousValue,first, *it, group);
+                auto b= composeWithPrevious(previousValue, first, *it, group);
                 if(b)
                     loseMap[group.getLost()]= group;
             }
             previousValue << *it;
-            cumuledValue += *it;
+            cumuledValue+= *it;
             ++it;
         }
     }
     if(!loseMap.isEmpty())
     {
-        DieGroup die = loseMap.first();
+        DieGroup die= loseMap.first();
         result.append(die);
-        DieGroup valueToRemove = die;
+        DieGroup valueToRemove= die;
         if(!valueToRemove.isEmpty())
         {
             valueToRemove.removeFirst();
@@ -284,7 +278,4 @@ QList<DieGroup> GroupNode::getGroup(DieGroup values)
         }
     }
     return result;
-
 }
-
-