From de55ac4c76ef3f6dbdc6fd2d03e3484bcfccdb0e Mon Sep 17 00:00:00 2001 From: Renaud G Date: Sat, 13 Feb 2021 12:37:44 +0100 Subject: Add replace value node. Move definition of CaseInfo struct. Fix small things from switchcasenode. --- CMakeLists.txt | 1 + include/diceparserhelper.h | 10 +++- include/parsingtoolbox.h | 41 +++++++------- node/replacevaluenode.cpp | 134 +++++++++++++++++++++++++++++++++++++++++++++ node/replacevaluenode.h | 50 +++++++++++++++++ node/switchcasenode.cpp | 2 +- node/switchcasenode.h | 8 +-- parsingtoolbox.cpp | 31 +++++++++++ 8 files changed, 250 insertions(+), 27 deletions(-) create mode 100644 node/replacevaluenode.cpp create mode 100644 node/replacevaluenode.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 9afc512..af3816b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -55,6 +55,7 @@ SET( dice_sources ${CMAKE_CURRENT_SOURCE_DIR}/node/valueslistnode.cpp ${CMAKE_CURRENT_SOURCE_DIR}/node/repeaternode.cpp ${CMAKE_CURRENT_SOURCE_DIR}/node/switchcasenode.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/node/replacevaluenode.cpp ) IF(STATIC_BUILD) diff --git a/include/diceparserhelper.h b/include/diceparserhelper.h index 4a481c1..1ae5c3f 100644 --- a/include/diceparserhelper.h +++ b/include/diceparserhelper.h @@ -1,9 +1,11 @@ #ifndef DICEPARSERHELPER_H #define DICEPARSERHELPER_H +class ValidatorList; +class ExecutionNode; + namespace Dice { - enum class CONDITION_STATE : int { ERROR_STATE, @@ -51,5 +53,11 @@ enum ConditionType AllOfThem, OnScalar }; + +struct CaseInfo +{ + ValidatorList* validatorList; + ExecutionNode* node; +}; } // namespace Dice #endif // DICEPARSERHELPER_H diff --git a/include/parsingtoolbox.h b/include/parsingtoolbox.h index d83e063..595e5e1 100644 --- a/include/parsingtoolbox.h +++ b/include/parsingtoolbox.h @@ -41,6 +41,7 @@ class RepeaterNode; class DiceAlias; class ExplodeDiceNode; class SwitchCaseNode; +class ReplaceValueNode; class SubtituteInfo { @@ -90,25 +91,26 @@ public: }; enum OptionOperator { - KeepAndExplode, // K - Keep, // k - Reroll, // r - RerollUntil, // R - Explode, // e - Sort, // s - Count, // c - RerollAndAdd, // a - Merge, // m - ifOperator, // i - Painter, // p - Filter, // f - Split, // y - Group, // g - Occurences, // o - Unique, // u - Bind, // b - AllSameExplode, // t - SwitchCaseOption // S + KeepAndExplode, // K + Keep, // k + Reroll, // r + RerollUntil, // R + Explode, // e + Sort, // s + Count, // c + RerollAndAdd, // a + Merge, // m + ifOperator, // i + Painter, // p + Filter, // f + Split, // y + Group, // g + Occurences, // o + Unique, // u + Bind, // b + AllSameExplode, // t + SwitchCaseOption, // S + TransformOption // T }; enum DiceOperator { @@ -185,6 +187,7 @@ public: bool readOption(QString&, ExecutionNode* node); // OptionOperator& option, bool readValuesList(QString& str, ExecutionNode*& node); bool readSwitchCaseNode(QString& str, SwitchCaseNode* node); + bool readReplaceValueNode(QString& str, ReplaceValueNode* node); // Error bool hasError() const; diff --git a/node/replacevaluenode.cpp b/node/replacevaluenode.cpp new file mode 100644 index 0000000..fbad5df --- /dev/null +++ b/node/replacevaluenode.cpp @@ -0,0 +1,134 @@ +/*************************************************************************** + * Copyright (C) 2021 by Renaud Guezennec * + * http://www.rolisteam.org/contact * + * * + * This software 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 "replacevaluenode.h" + +#include "diceresult.h" +#include "parsingtoolbox.h" +#include + +ReplaceValueNode::ReplaceValueNode() : m_diceResult(new DiceResult) +{ + m_result= m_diceResult; +} + +void ReplaceValueNode::setStopAtFirt(bool b) +{ + m_stopAtFirst= b; +} + +void ReplaceValueNode::run(ExecutionNode* previous) +{ + m_previousNode= previous; + if(nullptr == previous) + { + m_errors.insert(Dice::ERROR_CODE::NO_PREVIOUS_ERROR, + QStringLiteral("No previous node before Switch/Case operator")); + return; + } + auto previousResult= previous->getResult(); + m_result->setPrevious(previousResult); + + if(nullptr == previousResult + || (!previousResult->hasResultOfType(Dice::RESULT_TYPE::SCALAR) + && !previousResult->hasResultOfType(Dice::RESULT_TYPE::DICE_LIST))) + { + m_errors.insert(Dice::ERROR_CODE::NO_VALID_RESULT, + QStringLiteral("No scalar or dice result before Switch/Case operator")); + return; + } + + QList dieList; + if(previousResult->hasResultOfType(Dice::RESULT_TYPE::DICE_LIST)) + { + auto diceResult= dynamic_cast(previousResult); + if(diceResult) + dieList.append(diceResult->getResultList()); + } + + for(auto die : dieList) + { + QStringList resultList; + for(auto const& info : qAsConst(m_branchList)) + { + if(info->validatorList) + { + auto res= info->validatorList->hasValid(die, false); + if(!res) + continue; + } + else if(!resultList.isEmpty()) + break; + + auto replaceValresult= info->node->getResult(); + if(replaceValresult) + die->replaceLastValue(replaceValresult->getResult(Dice::RESULT_TYPE::SCALAR).toInt()); + break; + } + m_diceResult->insertResult(die); + } + + if(nullptr != m_nextNode) + { + m_nextNode->run(this); + } +} + +QString ReplaceValueNode::toString(bool withLabel) const +{ + if(withLabel) + { + return QString("%1 [label=\"ReplaceValueNode\"]").arg(m_id); + } + else + { + return m_id; + } +} + +qint64 ReplaceValueNode::getPriority() const +{ + qint64 priority= 0; + if(nullptr != m_previousNode) + { + priority= m_previousNode->getPriority(); + } + return priority; +} + +ExecutionNode* ReplaceValueNode::getCopy() const +{ + ReplaceValueNode* node= new ReplaceValueNode(); + for(auto const& info : qAsConst(m_branchList)) + { + node->insertCase(info->node, info->validatorList); + } + + if(nullptr != m_nextNode) + { + node->setNextNode(m_nextNode->getCopy()); + } + return node; +} + +void ReplaceValueNode::insertCase(ExecutionNode* node, ValidatorList* validator) +{ + std::unique_ptr info(new Dice::CaseInfo{validator, node}); + m_branchList.push_back(std::move(info)); +} diff --git a/node/replacevaluenode.h b/node/replacevaluenode.h new file mode 100644 index 0000000..36bdec2 --- /dev/null +++ b/node/replacevaluenode.h @@ -0,0 +1,50 @@ +/*************************************************************************** + * Copyright (C) 2021 by Renaud Guezennec * + * http://www.rolisteam.org/contact * + * * + * This software 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. * + ***************************************************************************/ +#ifndef REPLACEVALUENODE_H +#define REPLACEVALUENODE_H + +#include +#include + +#include "executionnode.h" +#include "validatorlist.h" + +class DiceResult; +class ReplaceValueNode : public ExecutionNode +{ +public: + ReplaceValueNode(); + void setStopAtFirt(bool b); + + void run(ExecutionNode* previous= nullptr) override; + + QString toString(bool withLabel) const override; + qint64 getPriority() const override; + ExecutionNode* getCopy() const override; + + void insertCase(ExecutionNode* node, ValidatorList* validator); + +private: + std::vector> m_branchList; + DiceResult* m_diceResult= nullptr; + bool m_stopAtFirst= false; +}; + +#endif // REPLACEVALUENODE_H diff --git a/node/switchcasenode.cpp b/node/switchcasenode.cpp index 9b15ec0..0928dd2 100644 --- a/node/switchcasenode.cpp +++ b/node/switchcasenode.cpp @@ -147,6 +147,6 @@ ExecutionNode* SwitchCaseNode::getCopy() const void SwitchCaseNode::insertCase(ExecutionNode* node, ValidatorList* validator) { - std::unique_ptr info(new CaseInfo{validator, node}); + std::unique_ptr info(new Dice::CaseInfo{validator, node}); m_branchList.push_back(std::move(info)); } diff --git a/node/switchcasenode.h b/node/switchcasenode.h index 719da90..a0f658d 100644 --- a/node/switchcasenode.h +++ b/node/switchcasenode.h @@ -21,15 +21,11 @@ #define SWITCHCASENODE_H #include +#include #include "executionnode.h" #include "validatorlist.h" -struct CaseInfo -{ - ValidatorList* validatorList; - ExecutionNode* node; -}; class StringResult; class SwitchCaseNode : public ExecutionNode { @@ -46,7 +42,7 @@ public: void insertCase(ExecutionNode* node, ValidatorList* validator); private: - std::vector> m_branchList; + std::vector> m_branchList; StringResult* m_stringResult; bool m_stopAtFirst= false; }; diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp index 2656fca..d371e9b 100644 --- a/parsingtoolbox.cpp +++ b/parsingtoolbox.cpp @@ -48,6 +48,7 @@ #include "node/paintnode.h" #include "node/parenthesesnode.h" #include "node/repeaternode.h" +#include "node/replacevaluenode.h" #include "node/rerolldicenode.h" #include "node/scalaroperatornode.h" #include "node/sortresult.h" @@ -111,6 +112,7 @@ ParsingToolBox::ParsingToolBox() m_OptionOp.insert(QStringLiteral("b"), Bind); m_OptionOp.insert(QStringLiteral("o"), Occurences); m_OptionOp.insert(QStringLiteral("S"), SwitchCaseOption); + m_OptionOp.insert(QStringLiteral("T"), TransformOption); m_functionMap.insert({QStringLiteral("repeat"), REPEAT}); @@ -1768,6 +1770,15 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //, node= scNode; } break; + case TransformOption: + { + auto scNode= new ReplaceValueNode(); + found= readReplaceValueNode(str, scNode); + previous->setNextNode(scNode); + if(found) + node= scNode; + } + break; case Bind: { BindNode* bindNode= new BindNode(); @@ -1963,6 +1974,26 @@ bool ParsingToolBox::readSwitchCaseNode(QString& str, SwitchCaseNode* node) return res; } +bool ParsingToolBox::readReplaceValueNode(QString& str, ReplaceValueNode* node) +{ + bool res= false; + bool hasInstructionBloc= false; + do + { + auto validator= readValidatorList(str); + ExecutionNode* exeNode= nullptr; + hasInstructionBloc= readBlocInstruction(str, exeNode); + if(hasInstructionBloc) + { + node->insertCase(exeNode, validator); + res= true; + } + + } while(hasInstructionBloc); + + return res; +} + bool ParsingToolBox::readBlocInstruction(QString& str, ExecutionNode*& resultnode) { if(str.startsWith('{')) -- cgit v1.2.3-70-g09d2