New API for isValidRangeSize

8 files changed, 54 insertions, 26 deletions

diff --git a/include/diceparserhelper.h b/include/diceparserhelper.h
index 5013ebe..00b9362 100644
--- a/include/diceparserhelper.h
+++ b/include/diceparserhelper.h
@@ -4,6 +4,14 @@
 namespace Dice
 {
 
+enum class CONDITION_STATE : int
+{
+    ERROR,
+    ALWAYSTRUE,
+    UNREACHABLE,
+    REACHABLE
+};
+
 enum class ERROR_CODE : int
 {
    NO_DICE_ERROR,
diff --git a/include/parsingtoolbox.h b/include/parsingtoolbox.h
index b91db1a..9e246d6 100644
--- a/include/parsingtoolbox.h
+++ b/include/parsingtoolbox.h
@@ -175,7 +175,7 @@ public:
      * @param val
      * @return
      */
-    bool isValidValidator(ExecutionNode* previous, Validator* val);
+    Dice::CONDITION_STATE isValidValidator(ExecutionNode* previous, Validator* val);
     /**
      * @brief getDiceRollerNode
      * @param previous
diff --git a/node/explodedicenode.cpp b/node/explodedicenode.cpp
index 704ac8a..2292a05 100644
--- a/node/explodedicenode.cpp
+++ b/node/explodedicenode.cpp
@@ -16,7 +16,6 @@ void ExplodeDiceNode::run(ExecutionNode* previous)
             for(auto& die : previous_result->getResultList())
             {
                 Die* tmpdie= new Die(*die);
-//                *tmpdie= *die;
                 m_diceResult->insertResult(tmpdie);
                 die->displayed();
             }
@@ -25,12 +24,23 @@ void ExplodeDiceNode::run(ExecutionNode* previous)
 
             for(auto& die : list)
             {
+                if(Dice::CONDITION_STATE::ALWAYSTRUE
+                   == m_validator->isValidRangeSize(std::make_pair<qint64, qint64>(die->getBase(), die->getMaxValue())))
+                {
+                    m_errors.insert(Dice::ERROR_CODE::ENDLESS_LOOP_ERROR,
+                                    QObject::tr("Condition (%1) cause an endless loop with this dice: %2")
+                                        .arg(toString(true))
+                                        .arg(QStringLiteral("d[%1,%2]")
+                                                 .arg(static_cast<int>(die->getBase()))
+                                                 .arg(static_cast<int>(die->getMaxValue()))));
+                    continue;
+                }
+
                 while(m_validator->hasValid(die, false))
                 {
                     die->roll(true);
                 }
             }
-            // m_diceResult->setResultList(list);
 
             if(nullptr != m_nextNode)
             {
diff --git a/operationcondition.cpp b/operationcondition.cpp
index 507416d..97c7bce 100644
--- a/operationcondition.cpp
+++ b/operationcondition.cpp
@@ -106,15 +106,22 @@ QString OperationCondition::toString()
     }
     return QStringLiteral("[%1%2%3]").arg(str).arg(valueToScalar()).arg(m_boolean->toString());
 }
-bool OperationCondition::isValidRangeSize(std::pair<qint64, qint64>) const
+Dice::CONDITION_STATE OperationCondition::isValidRangeSize(const std::pair<qint64, qint64>& range) const
 {
-    auto value= valueToScalar();
-    bool valid= true;
+    Dice::CONDITION_STATE valid= Dice::CONDITION_STATE::REACHABLE;
 
-    if(value == 0)
-        valid= false;
-    /*  else if(nullptr != m_boolean)
-          valid = m_boolean->isValidRangeSize(range);*/
+    auto rangeIsClose= (range.first == range.second);
+
+    Die die;
+    die.insertRollValue(range.first);
+
+    if(nullptr == m_boolean)
+        return Dice::CONDITION_STATE::ERROR;
+
+    if(rangeIsClose && m_boolean->hasValid(&die, false, false))
+        valid= Dice::CONDITION_STATE::ALWAYSTRUE;
+    else if(rangeIsClose && !m_boolean->hasValid(&die, false, false))
+        valid= Dice::CONDITION_STATE::UNREACHABLE;
 
     return valid;
 }
diff --git a/operationcondition.h b/operationcondition.h
index 86562e6..8b5a411 100644
--- a/operationcondition.h
+++ b/operationcondition.h
@@ -43,7 +43,7 @@ public:
     void setValueNode(ExecutionNode* node);
     QString toString();
 
-    virtual bool isValidRangeSize(std::pair<qint64, qint64> range) const;
+    virtual Dice::CONDITION_STATE isValidRangeSize(const std::pair<qint64, qint64>& range) const override;
 
     BooleanCondition* getBoolean() const;
     void setBoolean(BooleanCondition* boolean);
diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp
index 2453eb7..4084825 100644
--- a/parsingtoolbox.cpp
+++ b/parsingtoolbox.cpp
@@ -601,19 +601,13 @@ bool ParsingToolBox::readAscending(QString& str)
     }
     return false;
 }
-bool ParsingToolBox::isValidValidator(ExecutionNode* previous, Validator* val)
+Dice::CONDITION_STATE ParsingToolBox::isValidValidator(ExecutionNode* previous, Validator* val)
 {
     DiceRollerNode* node= getDiceRollerNode(previous);
-    bool valid= false;
-    if(nullptr != node)
-    {
-        valid= val->isValidRangeSize(node->getRange());
-    }
-    else
-    {
-        valid= true;
-    }
-    return valid;
+    if(nullptr == node)
+        return Dice::CONDITION_STATE::ERROR;
+
+    return val->isValidRangeSize(node->getRange());
 }
 DiceRollerNode* ParsingToolBox::getDiceRollerNode(ExecutionNode* previous)
 {
diff --git a/range.cpp b/range.cpp
index 471784c..8eeff4e 100644
--- a/range.cpp
+++ b/range.cpp
@@ -58,12 +58,20 @@ QString Range::toString()
 {
     return QStringLiteral("[%1-%2]").arg(m_start).arg(m_end);
 }
-bool Range::isValidRangeSize(std::pair<qint64, qint64> range) const
+Dice::CONDITION_STATE Range::isValidRangeSize(const std::pair<qint64, qint64>& range) const
 {
-    auto newStart= qBound(range.first, m_start, range.second);
-    auto newEnd= qBound(range.first, m_end, range.second);
+    auto minRange= std::min(m_start, m_end);
+    auto minPossibleValue= std::min(range.first, range.second);
 
-    return (newStart == m_start && newEnd == m_end && m_end >= m_start);
+    auto maxRange= std::max(m_start, m_end);
+    auto maxPossibleValue= std::max(range.first, range.second);
+
+    if(minRange == minPossibleValue && maxRange == maxPossibleValue)
+        return Dice::CONDITION_STATE::ALWAYSTRUE;
+    else if(maxRange < minPossibleValue || minRange > maxPossibleValue)
+        return Dice::CONDITION_STATE::UNREACHABLE;
+    else
+        return Dice::CONDITION_STATE::UNREACHABLE;
 }
 void Range::setStart(qint64 start)
 {
diff --git a/range.h b/range.h
index 17cc9ad..596d8f3 100644
--- a/range.h
+++ b/range.h
@@ -39,6 +39,7 @@ public:
 
     virtual QString toString();
     virtual bool isValidRangeSize(std::pair<qint64, qint64> range) const;
+    virtual Dice::CONDITION_STATE isValidRangeSize(const std::pair<qint64, qint64>& range) const override;
 
     bool isFullyDefined() const;
     qint64 getStart() const;