From 64e9988ba715e6e196b84e4a69c871c761562bbd Mon Sep 17 00:00:00 2001 From: Renaud G Date: Mon, 27 Aug 2018 01:03:08 +0200 Subject: -New API for validating validor. Prevent endless loop in R operator. --- booleancondition.cpp | 25 +++++++++++++++++-------- booleancondition.h | 2 +- compositevalidator.cpp | 23 +++++------------------ compositevalidator.h | 2 +- node/dicerollernode.cpp | 9 ++++++--- node/dicerollernode.h | 3 ++- operationcondition.cpp | 15 ++++++++++----- operationcondition.h | 2 +- parsingtoolbox.cpp | 6 ++++-- range.cpp | 10 ++++++---- range.h | 2 +- validator.h | 2 +- 12 files changed, 55 insertions(+), 46 deletions(-) diff --git a/booleancondition.cpp b/booleancondition.cpp index 18e4305..8781039 100644 --- a/booleancondition.cpp +++ b/booleancondition.cpp @@ -119,24 +119,33 @@ QString BooleanCondition::toString() } return QStringLiteral("[%1%2]").arg(str).arg(valueToScalar()); } -quint64 BooleanCondition::getValidRangeSize(quint64 faces) const +bool BooleanCondition::isValidRangeSize(std::pair range) const { + bool isValid = false; + auto valueScalar = valueToScalar(); + qint64 boundValue = qBound(range.first,valueScalar,range.second); switch(m_operator) { case Equal: - return 1; + isValid = (boundValue == valueScalar); + break; case GreaterThan: - return faces - valueToScalar(); + isValid = range.first<=valueScalar; + break; case LesserThan: - return valueToScalar() - 1; + isValid = range.second>=valueScalar; + break; case GreaterOrEqual: - return faces - (valueToScalar() - 1); + isValid = range.firstvalueScalar; + break; case Different: - return faces - 1; + isValid = (boundValue == valueScalar); + break; } - return 0; + return isValid; } Validator* BooleanCondition::getCopy() const { diff --git a/booleancondition.h b/booleancondition.h index b7282ad..d169d57 100644 --- a/booleancondition.h +++ b/booleancondition.h @@ -42,7 +42,7 @@ public: void setValueNode(ExecutionNode*); QString toString(); - virtual quint64 getValidRangeSize(quint64 faces) const; + virtual bool isValidRangeSize(std::pair range) const; /** * @brief getCopy * @return diff --git a/compositevalidator.cpp b/compositevalidator.cpp index 56dc136..7e003a4 100644 --- a/compositevalidator.cpp +++ b/compositevalidator.cpp @@ -104,31 +104,18 @@ QString CompositeValidator::toString() return QString("[%1%2]").arg(str).arg(m_value);*/ return str; } -quint64 CompositeValidator::getValidRangeSize(quint64 faces) const +bool CompositeValidator::isValidRangeSize(std::pair range) const { - quint64 sum =0; + bool val = true; int i = -1; for(Validator* tmp :*m_validatorList) { - quint64 rel = tmp->getValidRangeSize(faces); - LogicOperation opt = NONE; - if(i>=0) - { - opt = m_operators->at(i); - } - if(opt == OR) - { - sum += rel; - } - else if((opt == AND)&&(opt == EXCLUSIVE_OR)) - { - sum = qMax(rel,sum); - } - + quint64 rel = tmp->isValidRangeSize(range); + val |= rel; ++i; } - return sum; + return val; } void CompositeValidator::setOperationList(QVector* m) { diff --git a/compositevalidator.h b/compositevalidator.h index c42cc34..0d36e45 100644 --- a/compositevalidator.h +++ b/compositevalidator.h @@ -47,7 +47,7 @@ public: QString toString(); - virtual quint64 getValidRangeSize(quint64 faces) const; + virtual bool isValidRangeSize(std::pair range) const; virtual Validator* getCopy() const; private: diff --git a/node/dicerollernode.cpp b/node/dicerollernode.cpp index 6691c38..1d842d6 100644 --- a/node/dicerollernode.cpp +++ b/node/dicerollernode.cpp @@ -22,7 +22,7 @@ void DiceRollerNode::run(ExecutionNode* previous) Result* result=previous->getResult(); if(nullptr!=result) { - m_diceCount = result->getResult(Result::SCALAR).toReal(); + m_diceCount = static_cast(result->getResult(Result::SCALAR).toReal()); m_result->setPrevious(result); if(m_diceCount == 0) @@ -67,6 +67,11 @@ quint64 DiceRollerNode::getFaces() const { return abs(m_max-m_min)+1; } + +std::pair DiceRollerNode::getRange() const +{ + return std::make_pair(m_min,m_max); +} QString DiceRollerNode::toString(bool wl) const { if(wl) @@ -85,8 +90,6 @@ qint64 DiceRollerNode::getPriority() const // { // priority = m_nextNode->getPriority(); // } - - return priority; } ExecutionNode* DiceRollerNode::getCopy() const diff --git a/node/dicerollernode.h b/node/dicerollernode.h index 2b4e3dd..8831c8e 100644 --- a/node/dicerollernode.h +++ b/node/dicerollernode.h @@ -5,7 +5,7 @@ #include "executionnode.h" #include "result/diceresult.h" - +#include /** * @brief The DiceRollerNode class rolls dice of one kind. */ @@ -28,6 +28,7 @@ public: * @return the face count */ quint64 getFaces() const; + std::pair getRange() const; /** * @brief toString diff --git a/operationcondition.cpp b/operationcondition.cpp index 86c013a..2a83fec 100644 --- a/operationcondition.cpp +++ b/operationcondition.cpp @@ -21,7 +21,7 @@ #include "operationcondition.h" OperationCondition::OperationCondition() - : m_operator(Modulo),m_boolean(nullptr),m_value(0) + : m_operator(Modulo),m_boolean(nullptr),m_value(nullptr) { } @@ -103,17 +103,22 @@ QString OperationCondition::toString() switch (m_operator) { case Modulo: - str.append(QStringLiteral("\%")); + str.append(QStringLiteral("\\%")); break; } return QStringLiteral("[%1%2%3]").arg(str).arg(valueToScalar()).arg(m_boolean->toString()); } -quint64 OperationCondition::getValidRangeSize(quint64 faces) const +bool OperationCondition::isValidRangeSize(std::pair range) const { auto value = valueToScalar(); + bool valid = true; + if(value==0) - return 0; - return faces/value; + valid = false; + /* else if(nullptr != m_boolean) + valid = m_boolean->isValidRangeSize(range);*/ + + return valid; } Validator* OperationCondition::getCopy() const diff --git a/operationcondition.h b/operationcondition.h index 2c4c4e7..c07255c 100644 --- a/operationcondition.h +++ b/operationcondition.h @@ -40,7 +40,7 @@ public: void setValueNode(ExecutionNode* node); QString toString(); - virtual quint64 getValidRangeSize(quint64 faces) const; + virtual bool isValidRangeSize(std::pair range) const; BooleanCondition* getBoolean() const; void setBoolean(BooleanCondition *boolean); diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp index bd326e2..a56c098 100644 --- a/parsingtoolbox.cpp +++ b/parsingtoolbox.cpp @@ -575,14 +575,16 @@ bool ParsingToolBox::readAscending(QString& str) bool ParsingToolBox::isValidValidator(ExecutionNode* previous, Validator* val) { DiceRollerNode* node = getDiceRollerNode(previous); + bool valid = false; if(nullptr!=node) { - return (val->getValidRangeSize(node->getFaces())getFaces()); + valid = val->isValidRangeSize(node->getRange()); } else { - return true; + valid = true; } + return valid; } DiceRollerNode* ParsingToolBox::getDiceRollerNode(ExecutionNode* previous) { diff --git a/range.cpp b/range.cpp index 51a59a7..867bb61 100644 --- a/range.cpp +++ b/range.cpp @@ -63,10 +63,12 @@ QString Range::toString() { return QStringLiteral("[%1-%2]").arg(m_start).arg(m_end); } -quint64 Range::getValidRangeSize(quint64 faces) const -{ - Q_UNUSED(faces); - return m_end-m_start; +bool Range::isValidRangeSize(std::pair range) const +{ + auto newStart = qBound(range.first, m_start, range.second); + auto newEnd = qBound(range.first, m_end, range.second); + + return (newStart==m_start && newEnd == m_end && m_end>=m_start); } void Range::setStart(qint64 start) { diff --git a/range.h b/range.h index d8c8ede..ba59872 100644 --- a/range.h +++ b/range.h @@ -38,7 +38,7 @@ public: virtual qint64 hasValid(Die* b,bool recursive,bool unlight = false) const; virtual QString toString(); - virtual quint64 getValidRangeSize(quint64 faces) const; + virtual bool isValidRangeSize(std::pair range) const; bool isFullyDefined() const; qint64 getStart() const; diff --git a/validator.h b/validator.h index edb72a3..b3fbbe5 100644 --- a/validator.h +++ b/validator.h @@ -58,7 +58,7 @@ public: * @param faces * @return */ - virtual quint64 getValidRangeSize(quint64 faces) const = 0 ; + virtual bool isValidRangeSize(std::pair range) const = 0 ; /** * @brief getCopy * @return return a copy of this validator -- cgit v1.2.3-70-g09d2