1 files changed, 140 insertions, 0 deletions
diff --git a/node/repeaternode.cpp b/node/repeaternode.cpp
new file mode 100644
index 0000000..26fab8f
--- /dev/null
+++ b/node/repeaternode.cpp
@@ -0,0 +1,140 @@
+/***************************************************************************
+ * Copyright (C) 2019 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 "node/repeaternode.h"
+
+#include "diceparserhelper.h"
+#include "executionnode.h"
+#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= makeCopy(m_cmd);
+    std::vector<Result*> resultVec;
+    for(int i= 0; i < timeCount; ++i)
+    {
+        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 == leafResult)
+                return;
+
+            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
+            {
+                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(",")));
+            }
+        });
+        string->setText(list.join('\n'));
+        m_result= string;
+    }
+
+    if(nullptr != m_nextNode)
+        m_nextNode->run(this);
+}
+
+QString RepeaterNode::toString(bool withLabel) const
+{
+    return withLabel ? QStringLiteral("") : QStringLiteral("");
+}
+
+qint64 RepeaterNode::getPriority() const
+{
+    return 4;
+}
+
+ExecutionNode* RepeaterNode::getCopy() const
+{
+    return nullptr;
+}
+
+void RepeaterNode::setCommand(const std::vector<ExecutionNode*>& cmd)
+{
+    m_cmd= cmd;
+}
+
+void RepeaterNode::setTimeNode(ExecutionNode* time)
+{
+    m_times= time;
+}
+
+void RepeaterNode::setSumAll(bool b)
+{
+    m_sumAll= b;
+}