File indexing completed on 2024-05-12 05:39:28

 /***************************************************************************
  * 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 "executionnode.h"
 #include "result/scalarresult.h"
 #include "result/stringresult.h"
 #include <QDebug>
 #include <diceparser/diceparserhelper.h>
 #include <diceparser/parsingtoolbox.h>
 
 using InstructionSet= std::vector<ExecutionNode*>;
 
 QStringList allFirstResultAsString(const InstructionSet& startingNodes, bool& hasAlias)
 {
     ParsingToolBox parsingBox;
     // QStringList allResult;
     QStringList stringListResult;
     for(auto node : startingNodes)
     {
         auto pair= parsingBox.hasResultOfType(Dice::RESULT_TYPE::STRING, node);
         auto pairStr= parsingBox.hasResultOfType(Dice::RESULT_TYPE::SCALAR, node, true);
         if(pair.first)
         {
             stringListResult << pair.second.toString();
             hasAlias= true;
         }
         else if(pairStr.first)
         {
             stringListResult << QString::number(pairStr.second.toReal());
             hasAlias= true;
         }
     }
     return stringListResult;
 }
 
 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();
     if(!times)
         return;
 
     std::vector<InstructionSet> m_startingNodes;
     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)
     {
         m_startingNodes.push_back(cmd);
         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 listOfStrResult;
         for(auto instructions : m_startingNodes)
         {
             ParsingToolBox parsingBox;
             parsingBox.setStartNodes(instructions);
             auto finalString
                 = parsingBox.finalStringResult([](const QString& result, const QString&, bool) { return result; });
             listOfStrResult << finalString;
         }
         if(!listOfStrResult.isEmpty())
             string->addText(listOfStrResult.join('\n'));
 
         m_result= string;
 
         // qDebug().noquote() << listOfStrResult.join('\n');
     }
 
     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;
 }