From 67fd3b480f543f2f18bd632ea85d829ba2102a20 Mon Sep 17 00:00:00 2001 From: Renaud G Date: Thu, 2 Apr 2015 23:44:42 +0200 Subject: Add list for warnings Remove data where reading list. --- parsingtoolbox.cpp | 1 + 1 file changed, 1 insertion(+) (limited to 'parsingtoolbox.cpp') diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp index e03690e..63b5739 100644 --- a/parsingtoolbox.cpp +++ b/parsingtoolbox.cpp @@ -181,6 +181,7 @@ bool ParsingToolBox::readList(QString& str,QStringList& list) { QString liststr = str.left(pos); list = liststr.split(","); + str=str.remove(0,liststr.size()+1); return true; } } -- cgit v1.2.3-70-g09d2 From 2d9fe10724dc1d5de86e63670536b9a1b6599ba1 Mon Sep 17 00:00:00 2001 From: Renaud G Date: Tue, 9 Jun 2015 08:44:49 +0200 Subject: -add method to read list with probability value. It sets range for all values in List node. --- diceparser.cpp | 9 ++++- node/listsetrollnode.cpp | 74 ++++++++++++++++++++++++++++++-------- node/listsetrollnode.h | 11 +++++- parsingtoolbox.cpp | 94 ++++++++++++++++++++++++++++++++++++++++++++++-- parsingtoolbox.h | 12 ++++++- range.cpp | 27 ++++++++++++++ range.h | 9 ++++- 7 files changed, 215 insertions(+), 21 deletions(-) (limited to 'parsingtoolbox.cpp') diff --git a/diceparser.cpp b/diceparser.cpp index 570c96b..4f0645e 100644 --- a/diceparser.cpp +++ b/diceparser.cpp @@ -555,9 +555,16 @@ bool DiceParser::readDice(QString& str,ExecutionNode* & node) else if(currentOperator ==L) { QStringList list; - if(m_parsingToolbox->readList(str,list)) + QList listRange; + ParsingToolBox::LIST_OPERATOR op = m_parsingToolbox->readListOperator(str); + if(m_parsingToolbox->readList(str,list,listRange)) { ListSetRollNode* lsrNode = new ListSetRollNode(); + lsrNode->setRangeList(listRange); + if(op == ParsingToolBox::UNIQUE) + { + lsrNode->setUnique(true); + } lsrNode->setListValue(list); node = lsrNode; return true; diff --git a/node/listsetrollnode.cpp b/node/listsetrollnode.cpp index fdc17a5..c7f2c45 100644 --- a/node/listsetrollnode.cpp +++ b/node/listsetrollnode.cpp @@ -22,7 +22,7 @@ #include "die.h" ListSetRollNode::ListSetRollNode() - :m_diceResult(new DiceResult()),m_stringResult(new StringResult()) + :m_diceResult(new DiceResult()),m_stringResult(new StringResult()),m_unique(false) { m_result = m_stringResult; } @@ -46,12 +46,6 @@ QString ListSetRollNode::toString() const qint64 ListSetRollNode::getPriority() const { qint64 priority=4; -// if(NULL!=m_nextNode) -// { -// priority = m_nextNode->getPriority(); -// } - - return priority; } void ListSetRollNode::run(ExecutionNode* previous) @@ -68,13 +62,11 @@ void ListSetRollNode::run(ExecutionNode* previous) for(quint64 i=0; i < diceCount ; ++i) { Die* die = new Die(); - die->setFaces(m_values.size()); + //die->setFaces(m_values.size()); + computeFacesNumber(die); die->roll(); m_diceResult->insertResult(die); - if(die->getValue()-1getValue()-1]; - } + getValueFromDie(die,rollResult); } m_stringResult->setText(rollResult.join(",")); if(NULL!=m_nextNode) @@ -83,11 +75,63 @@ void ListSetRollNode::run(ExecutionNode* previous) } } } - - - } void ListSetRollNode::setListValue(QStringList lirs) { m_values = lirs; } +void ListSetRollNode::setUnique(bool u) +{ + m_unique = u; +} +void ListSetRollNode::setRangeList(QList& ranges) +{ + m_rangeList = ranges; +} +void ListSetRollNode::computeFacesNumber(Die* die) +{ + if(m_rangeList.isEmpty()) + { + die->setFaces(m_values.size()); + } + else + { + Q_ASSERT(m_values.size() == m_rangeList.size()); + qint64 max; + int i=0; + foreach(Range range, m_rangeList) + { + if((i==0)||(maxsetFaces(max); + } + +} +void ListSetRollNode::getValueFromDie(Die* die,QStringList& rollResult) +{ + if(m_rangeList.isEmpty()) + { + if(die->getValue()-1getValue()-1]; + } + } + else + { + Q_ASSERT(m_values.size() == m_rangeList.size()); + int i=0; + foreach (Range range, m_rangeList) + { + qDebug() << range.toString()<< die->getValue(); + if(range.hasValid(die,false)) + { + rollResult << m_values[i]; + } + ++i; + } + } +} diff --git a/node/listsetrollnode.h b/node/listsetrollnode.h index 3102ade..4a11da2 100644 --- a/node/listsetrollnode.h +++ b/node/listsetrollnode.h @@ -27,6 +27,7 @@ #include "executionnode.h" #include "result/diceresult.h" #include "result/stringresult.h" +#include "range.h" /** * @brief The ListSetRollNode class is dedicated to pick up item from list. */ @@ -41,12 +42,20 @@ public: QStringList getList(); void setListValue(QStringList); + void setUnique(bool ); + void setRangeList(QList&); + + +private: + void getValueFromDie(Die* die,QStringList& rollResult); + void computeFacesNumber(Die* die); private: QStringList m_values; DiceResult* m_diceResult; StringResult* m_stringResult; - + bool m_unique; + QList m_rangeList; }; #endif // LISTSETROLLNODE_H diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp index f6b1f12..696d330 100644 --- a/parsingtoolbox.cpp +++ b/parsingtoolbox.cpp @@ -179,17 +179,20 @@ bool ParsingToolBox::readCloseParentheses(QString& str) else return false; } -bool ParsingToolBox::readList(QString& str,QStringList& list) +bool ParsingToolBox::readList(QString& str,QStringList& list,QList& ranges) { if(str.startsWith("[")) { str=str.remove(0,1); - int pos = str.indexOf("]"); + int pos = str.lastIndexOf("]"); if(-1!=pos) { QString liststr = str.left(pos); list = liststr.split(","); str=str.remove(0,pos+1); + readProbability(list,ranges); + + return true; } } @@ -270,4 +273,91 @@ bool ParsingToolBox::readDiceRange(QString& str,int& start, int& end) } } +} +ParsingToolBox::LIST_OPERATOR ParsingToolBox::readListOperator(QString& str) +{ + + if(str.startsWith('u')) + { + return UNIQUE; + } + return NONE; +} +void ParsingToolBox::readProbability(QStringList& str,QList& ranges) +{ + quint64 totalDistance=0; + quint64 undefDistance = 0; + int undefCount=0; + int maxValue = 0; + int i=0; + int j=0; + //range + foreach(QString line,str) + { + int pos = line.indexOf('['); + if(-1!=pos) + { + QString range = line.right(line.length()-pos); + line = line.left(pos); + str[j]=line; + int start; + int end; + if(readDiceRange(range,start,end)) + { + Range range; + range.setValue(start,end); + ranges.append(range); + totalDistance += end-start+1; + ++i; + } + else + { + Range range; + range.setStart(start); + ranges.append(range); + ++undefCount; + undefDistance +=start; + } + if((end>maxValue)||(i==1)) + { + maxValue = end; + } + } + ++j; + + } + + + + + ///Normalize list +// qDebug() << 100 - undefDistance; +// qDebug() << totalDistance; + + qint64 totalDistPourcent = totalDistance * undefDistance / (100-undefDistance); + + if(totalDistPourcent& ranges); /** * @brief isValidValidator * @param previous @@ -123,6 +124,15 @@ public: * @return */ bool readDiceRange(QString& str,int& start, int& end); + /** + * @brief readListOperator + * @param str + * @return + */ + LIST_OPERATOR readListOperator(QString& str); + + void readProbability(QStringList& str,QList& ranges); + private: QMap* m_logicOp; diff --git a/range.cpp b/range.cpp index 909c96c..2332d7d 100644 --- a/range.cpp +++ b/range.cpp @@ -22,6 +22,7 @@ #include "range.h" Range::Range() + : m_hasEnd(false),m_hasStart(false) { @@ -30,6 +31,9 @@ void Range::setValue(qint64 s,qint64 e) { m_start = s; m_end=e; + + m_hasEnd = true; + m_hasStart = true; } qint64 Range::hasValid(Die* m,bool recursive, bool unhighlight) const @@ -64,3 +68,26 @@ quint8 Range::getValidRangeSize(quint64 faces) const Q_UNUSED(faces); return m_end-m_start; } +void Range::setStart(qint64 start) +{ + m_start = start; + m_hasStart = true; +} +void Range::setEnd(qint64 end) +{ + m_end = end; + m_hasEnd = true; +} + +bool Range::isFullyDefined() +{ + return (m_hasEnd & m_hasStart); +} +qint64 Range::getStart() const +{ + return m_start; +} +qint64 Range::getEnd() const +{ + return m_end; +} diff --git a/range.h b/range.h index e50a48e..eca8c85 100644 --- a/range.h +++ b/range.h @@ -33,15 +33,22 @@ class Range : public Validator public: Range(); void setValue(qint64,qint64); - + void setStart(qint64); + void setEnd(qint64); virtual qint64 hasValid(Die* b,bool recursive,bool unlight = false) const; virtual QString toString(); virtual quint8 getValidRangeSize(quint64 faces) const; + bool isFullyDefined(); + qint64 getStart() const; + qint64 getEnd() const; + private: qint64 m_start; qint64 m_end; + bool m_hasEnd; + bool m_hasStart; }; #endif // RANGE_H -- cgit v1.2.3-70-g09d2 From b5c5cfadeb8546274048c1e3c1d97f7c2223a042 Mon Sep 17 00:00:00 2001 From: Renaud G Date: Thu, 11 Jun 2015 11:16:04 +0200 Subject: remove debug message --- parsingtoolbox.cpp | 8 -------- 1 file changed, 8 deletions(-) (limited to 'parsingtoolbox.cpp') diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp index 696d330..e7c603c 100644 --- a/parsingtoolbox.cpp +++ b/parsingtoolbox.cpp @@ -327,13 +327,6 @@ void ParsingToolBox::readProbability(QStringList& str,QList& ranges) } - - - - ///Normalize list -// qDebug() << 100 - undefDistance; -// qDebug() << totalDistance; - qint64 totalDistPourcent = totalDistance * undefDistance / (100-undefDistance); if(totalDistPourcent& ranges) tmp.setEnd(maxValue+(truc*totalDistPourcent)); maxValue = maxValue+(truc*totalDistPourcent); - qDebug() << truc << totalDistPourcent << undefDistance << totalDistance << maxValue << dist << totalDistPourcent << tmp.toString(); ranges[i]=tmp; } } -- cgit v1.2.3-70-g09d2 From f3ed92235184ec754bbf96eadf0693ae67e5de1b Mon Sep 17 00:00:00 2001 From: Renaud G Date: Thu, 20 Aug 2015 00:30:15 +0200 Subject: Add compositevalidator to explose operator. --- parsingtoolbox.cpp | 114 +++++++++++++++++++++++++++++++++++++++++++---------- parsingtoolbox.h | 14 +++++-- 2 files changed, 104 insertions(+), 24 deletions(-) (limited to 'parsingtoolbox.cpp') diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp index e7c603c..50b166a 100644 --- a/parsingtoolbox.cpp +++ b/parsingtoolbox.cpp @@ -33,6 +33,12 @@ ParsingToolBox::ParsingToolBox() m_logicOp->insert("<",BooleanCondition::LesserThan); m_logicOp->insert("=",BooleanCondition::Equal); m_logicOp->insert(">",BooleanCondition::GreaterThan); + + + m_logicOperation = new QMap(); + m_logicOperation->insert("|",CompositeValidator::OR); + m_logicOperation->insert("^",CompositeValidator::EXCLUSIVE_OR); + m_logicOperation->insert("&",CompositeValidator::AND); } ExecutionNode* ParsingToolBox::addSort(ExecutionNode* e,bool b) { @@ -74,27 +80,23 @@ ParsingToolBox::~ParsingToolBox() Validator* ParsingToolBox::readValidator(QString& str) { Validator* returnVal=NULL; - bool expectSquareBrasket=false; + bool isOk = true; - if((str.startsWith("["))) - { - str=str.remove(0,1); - expectSquareBrasket = true; - } + BooleanCondition::LogicOperator myLogicOp = BooleanCondition::Equal; bool hasReadLogicOperator = readLogicOperator(str,myLogicOp); - int value=0; + qint64 value=0; if(readNumber(str,value)) { if(str.startsWith("-")) { str=str.remove(0,1); - int end=0; + qint64 end=0; if(readNumber(str,end)) { - if(expectSquareBrasket) + /* if(expectSquareBrasket) { if(str.startsWith("]")) { @@ -105,7 +107,7 @@ Validator* ParsingToolBox::readValidator(QString& str) { isOk=false; } - } + }*/ if(isOk) { str=str.remove(0,1); @@ -117,12 +119,12 @@ Validator* ParsingToolBox::readValidator(QString& str) } else { - if((expectSquareBrasket)&&(str.startsWith("]"))) + /* if((expectSquareBrasket)&&(str.startsWith("]"))) { str=str.remove(0,1); isOk=true; - } - if(isOk) + }*/ + //if(isOk) { BooleanCondition* condition = new BooleanCondition(); condition->setValue(value); @@ -133,14 +135,86 @@ Validator* ParsingToolBox::readValidator(QString& str) } return returnVal; } -bool ParsingToolBox::readNumber(QString& str, int& myNumber) +Validator* ParsingToolBox::readCompositeValidator(QString& str) +{ + bool expectSquareBrasket=false; + if((str.startsWith("["))) + { + str=str.remove(0,1); + expectSquareBrasket = true; + } + + Validator* tmp = readValidator(str); + CompositeValidator::LogicOperation opLogic; + + QVector* operators = new QVector(); + QList* validatorList = new QList(); + + while(NULL!=tmp) + { + bool hasOperator = readLogicOperation(str,opLogic); + if( hasOperator ) + { + operators->append(opLogic); + validatorList->append(tmp); + tmp = readValidator(str); + } + else + { + if((expectSquareBrasket)&&(str.startsWith("]"))) + { + str=str.remove(0,1); + //isOk=true; + } + + if(!validatorList->isEmpty()) + { + validatorList->append(tmp); + } + else + { + return tmp; + } + tmp = NULL; + } + + } + CompositeValidator* validator = new CompositeValidator(); + validator->setOperationList(operators); + validator->setValidatorList(validatorList); + + return validator; +} +bool ParsingToolBox::readLogicOperation(QString& str,CompositeValidator::LogicOperation& op) +{ + QString longKey; + foreach(QString tmp, m_logicOperation->keys()) + { + if(str.startsWith(tmp)) + { + if(longKey.size()0) + { + str=str.remove(0,longKey.size()); + op = m_logicOperation->value(longKey); + return true; + } + + return false; +} + +bool ParsingToolBox::readNumber(QString& str, qint64& myNumber) { if(str.isEmpty()) return false; QString number; int i=0; - while(igetPreviousNode(); } } -bool ParsingToolBox::readDiceRange(QString& str,int& start, int& end) +bool ParsingToolBox::readDiceRange(QString& str,qint64& start, qint64& end) { bool expectSquareBrasket=false; @@ -300,8 +372,8 @@ void ParsingToolBox::readProbability(QStringList& str,QList& ranges) QString range = line.right(line.length()-pos); line = line.left(pos); str[j]=line; - int start; - int end; + qint64 start; + qint64 end; if(readDiceRange(range,start,end)) { Range range; diff --git a/parsingtoolbox.h b/parsingtoolbox.h index cb97708..3d37f7b 100644 --- a/parsingtoolbox.h +++ b/parsingtoolbox.h @@ -27,6 +27,7 @@ #include "node/executionnode.h" #include "node/dicerollernode.h" #include "booleancondition.h" +#include "compositevalidator.h" #include "range.h" /** @@ -71,7 +72,12 @@ public: * @return */ Validator* readValidator(QString& str); - + /** + * @brief readCompositeValidator + * @param str + * @return + */ + Validator* readCompositeValidator(QString& str); /** * @brief readNumber read number in the given str and remove from the string the read character. @@ -79,7 +85,7 @@ public: * @param myNumber reference to the found number * @return true, succeed to read number, false otherwise. */ - bool readNumber(QString& str, int& myNumber); + bool readNumber(QString& str, qint64& myNumber); /** @@ -123,7 +129,7 @@ public: * @param end * @return */ - bool readDiceRange(QString& str,int& start, int& end); + bool readDiceRange(QString& str,qint64& start, qint64& end); /** * @brief readListOperator * @param str @@ -133,9 +139,11 @@ public: void readProbability(QStringList& str,QList& ranges); + bool readLogicOperation(QString& str,CompositeValidator::LogicOperation& op); private: QMap* m_logicOp; + QMap* m_logicOperation; }; #endif // PARSINGTOOLBOX_H -- cgit v1.2.3-70-g09d2 From 1d917b23671b2cd64d37410344db3d2876af5b98 Mon Sep 17 00:00:00 2001 From: Renaud G Date: Sun, 11 Oct 2015 16:28:17 +0200 Subject: fix indentation --- parsingtoolbox.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'parsingtoolbox.cpp') diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp index 00072c9..4bcc5bb 100644 --- a/parsingtoolbox.cpp +++ b/parsingtoolbox.cpp @@ -137,7 +137,7 @@ Validator* ParsingToolBox::readValidator(QString& str) } Validator* ParsingToolBox::readCompositeValidator(QString& str) { - bool expectSquareBrasket=false; + bool expectSquareBrasket=false; if((str.startsWith("["))) { str=str.remove(0,1); -- cgit v1.2.3-70-g09d2 From cd6dca205ea76a76aa38a2a220d360ba687a4fbb Mon Sep 17 00:00:00 2001 From: Renaud G Date: Sun, 11 Oct 2015 17:45:15 +0200 Subject: -Fix issue while no validator --- parsingtoolbox.cpp | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) (limited to 'parsingtoolbox.cpp') diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp index 4bcc5bb..d511e44 100644 --- a/parsingtoolbox.cpp +++ b/parsingtoolbox.cpp @@ -179,11 +179,17 @@ Validator* ParsingToolBox::readCompositeValidator(QString& str) } } - CompositeValidator* validator = new CompositeValidator(); - validator->setOperationList(operators); - validator->setValidatorList(validatorList); - - return validator; + if(!validatorList->isEmpty()) + { + CompositeValidator* validator = new CompositeValidator(); + validator->setOperationList(operators); + validator->setValidatorList(validatorList); + return validator; + } + else + { + return NULL; + } } bool ParsingToolBox::readLogicOperation(QString& str,CompositeValidator::LogicOperation& op) { -- cgit v1.2.3-70-g09d2