diff options
44 files changed, 379 insertions, 464 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index da59749..ff96097 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -16,6 +16,16 @@ option(BUILD_IRC OFF) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(dice_header_path include/diceparser) + +set(dice_public_headers ${dice_header_path}/diceparser_global.h +${dice_header_path}/dicealias.h +${dice_header_path}/diceparser.h +${dice_header_path}/diceparserhelper.h +${dice_header_path}/highlightdice.h +${dice_header_path}/parsingtoolbox.h # should no be public… +) + SET( dice_sources ${CMAKE_CURRENT_SOURCE_DIR}/diceparser.cpp @@ -75,10 +85,14 @@ endif() set(documentation README.md HelpMe.md CHANGELOG) -add_library(diceparser_shared SHARED ${dice_sources} ${documentation}) - -target_include_directories(diceparser_shared PRIVATE include ./) +add_library(diceparser_shared SHARED ${dice_sources} ${documentation} ${dice_public_headers}) +set_target_properties(diceparser_shared PROPERTIES PUBLIC_HEADER "${public_header_widget}") +target_compile_definitions(diceparser_shared PRIVATE DICEPARSER_LIBRARY) +target_include_directories(diceparser_shared PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} + PUBLIC + $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include> + $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>) SET_TARGET_PROPERTIES(diceparser_shared PROPERTIES OUTPUT_NAME diceparser CLEAN_DIRECT_OUTPUT 1) target_link_libraries(diceparser_shared PUBLIC Qt${QT_VERSION_MAJOR}::Core Qt${QT_VERSION_MAJOR}::Gui Qt${QT_VERSION_MAJOR}::Svg) @@ -86,8 +100,6 @@ target_link_libraries(diceparser_shared PUBLIC Qt${QT_VERSION_MAJOR}::Core Qt${Q set_target_properties(diceparser_shared PROPERTIES VERSION ${PROJECT_VERSION}) set_target_properties(diceparser_shared PROPERTIES SOVERSION 1) -set_target_properties(diceparser_shared PROPERTIES PUBLIC_HEADER "include/diceparser.h;include/highlightdice.h;include/parsingtoolbox.h;include/dicealias.h;include/diceparserhelper.h") - IF(BUILD_CLI) add_subdirectory(cli) ENDIF() @@ -96,7 +108,9 @@ IF(BUILD_IRC) add_subdirectory(irc) ENDIF() +if(TESTS) add_subdirectory( tests ) +endif() include(GNUInstallDirs) @@ -109,15 +123,21 @@ configure_file(diceparser.pc.in diceparser.pc @ONLY) install(FILES ${CMAKE_BINARY_DIR}/diceparser.pc DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/pkgconfig) -if(Qt6Qml_FOUND) -set(dice_header_qobject qmltypesregister.h diceroller.h) -set(dice_source_qobject qmltypesregister.cpp diceroller.cpp) -set(CMAKE_AUTOMOC ON) -set(CMAKE_AUTOUIC ON) -set(CMAKE_AUTORCC ON) -set(CMAKE_INCLUDE_CURRENT_DIR ON) -add_library(diceparser_qobject SHARED ${dice_header_qobject} ${dice_source_qobject}) -target_link_libraries(diceparser_qobject PUBLIC Qt${QT_VERSION_MAJOR}::Core Qt${QT_VERSION_MAJOR}::Gui Qt${QT_VERSION_MAJOR}::Svg Qt${QT_VERSION_MAJOR}::Qml Qt${QT_VERSION_MAJOR}::Concurrent PRIVATE diceparser_shared) -message("Messages diceparser ${CMAKE_CURRENT_SOURCE_DIR}/include") -target_include_directories(diceparser_qobject PRIVATE include ./ ${CMAKE_CURRENT_SOURCE_DIR}/include) +if(Qt${QT_VERSION_MAJOR}Qml_FOUND) + set(dice_header_qobject include/diceparser_qobject/diceparser_qobject_global.h include/diceparser_qobject/qmltypesregister.h include/diceparser_qobject/diceroller.h) + set(dice_source_qobject qmltypesregister.cpp diceroller.cpp) + set(CMAKE_AUTOMOC ON) + set(CMAKE_AUTOUIC ON) + set(CMAKE_AUTORCC ON) + set(CMAKE_INCLUDE_CURRENT_DIR ON) + add_library(diceparser_qobject SHARED ${dice_header_qobject} ${dice_source_qobject}) + set_target_properties(diceparser_qobject PROPERTIES PUBLIC_HEADER "${dice_header_qobject}") + target_compile_definitions(diceparser_qobject PRIVATE DICEPARSER_QOBJECT_LIBRARY) + target_link_libraries(diceparser_qobject PUBLIC Qt${QT_VERSION_MAJOR}::Core Qt${QT_VERSION_MAJOR}::Gui Qt${QT_VERSION_MAJOR}::Svg Qt${QT_VERSION_MAJOR}::Qml Qt${QT_VERSION_MAJOR}::Concurrent PRIVATE diceparser_shared) + message("Messages diceparser ${CMAKE_CURRENT_SOURCE_DIR}/include") + + target_include_directories(diceparser_qobject PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} + PUBLIC + $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include> + $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>) endif() diff --git a/booleancondition.cpp b/booleancondition.cpp index 1c992c2..91be35c 100644 --- a/booleancondition.cpp +++ b/booleancondition.cpp @@ -81,7 +81,7 @@ Dice::CONDITION_STATE testDifferent(bool inside, const std::pair<qint64, qint64> return Dice::CONDITION_STATE::REACHABLE; } -BooleanCondition::BooleanCondition() : m_operator(Equal) {} +BooleanCondition::BooleanCondition() : m_operator(Dice::CompareOperator::Equal) {} BooleanCondition::~BooleanCondition() { @@ -113,22 +113,22 @@ qint64 BooleanCondition::hasValid(Die* b, bool recursive, bool unhighlight) cons { switch(m_operator) { - case Equal: + case Dice::CompareOperator::Equal: sum+= (value == valueScalar) ? 1 : 0; break; - case GreaterThan: + case Dice::CompareOperator::GreaterThan: sum+= (value > valueScalar) ? 1 : 0; break; - case LesserThan: + case Dice::CompareOperator::LesserThan: sum+= (value < valueScalar) ? 1 : 0; break; - case GreaterOrEqual: + case Dice::CompareOperator::GreaterOrEqual: sum+= (value >= valueScalar) ? 1 : 0; break; - case LesserOrEqual: + case Dice::CompareOperator::LesserOrEqual: sum+= (value <= valueScalar) ? 1 : 0; break; - case Different: + case Dice::CompareOperator::Different: sum+= (value != valueScalar) ? 1 : 0; break; } @@ -145,7 +145,7 @@ qint64 BooleanCondition::hasValid(Die* b, bool recursive, bool unhighlight) cons return sum; } -void BooleanCondition::setOperator(LogicOperator m) +void BooleanCondition::setOperator(Dice::CompareOperator m) { m_operator= m; } @@ -159,22 +159,22 @@ QString BooleanCondition::toString() QString str(""); switch(m_operator) { - case Equal: + case Dice::CompareOperator::Equal: str.append(QStringLiteral("=")); break; - case GreaterThan: + case Dice::CompareOperator::GreaterThan: str.append(QStringLiteral(">")); break; - case LesserThan: + case Dice::CompareOperator::LesserThan: str.append(QStringLiteral("<")); break; - case GreaterOrEqual: + case Dice::CompareOperator::GreaterOrEqual: str.append(QStringLiteral(">=")); break; - case LesserOrEqual: + case Dice::CompareOperator::LesserOrEqual: str.append(QStringLiteral("<=")); break; - case Different: + case Dice::CompareOperator::Different: str.append(QStringLiteral("!=")); break; } @@ -189,22 +189,22 @@ Dice::CONDITION_STATE BooleanCondition::isValidRangeSize(const std::pair<qint64, bool isInsideRange= (boundValue == valueScalar); switch(m_operator) { - case Equal: + case Dice::CompareOperator::Equal: state= testEqual(isInsideRange, range); //(isInsideRange && (range.first != range.second)) ? ; break; - case GreaterThan: + case Dice::CompareOperator::GreaterThan: state= testGreatherThan(valueScalar, range); break; - case LesserThan: + case Dice::CompareOperator::LesserThan: state= testLesserThan(valueScalar, range); break; - case GreaterOrEqual: + case Dice::CompareOperator::GreaterOrEqual: state= testGreaterOrEqual(valueScalar, range); break; - case LesserOrEqual: + case Dice::CompareOperator::LesserOrEqual: state= testLesserOrEqual(valueScalar, range); break; - case Different: + case Dice::CompareOperator::Different: state= testDifferent(isInsideRange, range); break; } diff --git a/booleancondition.h b/booleancondition.h index 88bab30..d49c5fe 100644 --- a/booleancondition.h +++ b/booleancondition.h @@ -22,6 +22,7 @@ #ifndef BOOLEANCONDITION_H #define BOOLEANCONDITION_H +#include "diceparser/diceparserhelper.h" #include "node/executionnode.h" #include "validator.h" #include <Qt> @@ -32,22 +33,12 @@ class BooleanCondition : public Validator { public: - enum LogicOperator - { - Equal, - GreaterThan, - LesserThan, - GreaterOrEqual, - LesserOrEqual, - Different - }; - BooleanCondition(); virtual ~BooleanCondition() override; virtual qint64 hasValid(Die* b, bool recursive, bool unhighlight= false) const override; - void setOperator(LogicOperator m); + void setOperator(Dice::CompareOperator m); void setValueNode(ExecutionNode*); QString toString() override; @@ -62,9 +53,9 @@ private: qint64 valueToScalar() const; private: - LogicOperator m_operator; + Dice::CompareOperator m_operator; ExecutionNode* m_value= nullptr; }; -Q_DECLARE_METATYPE(BooleanCondition::LogicOperator) +// Q_DECLARE_METATYPE(BooleanCondition::LogicOperator) #endif // BOOLEANCONDITION_H diff --git a/diceParser.pro b/diceParser.pro deleted file mode 100644 index 2b5f3fd..0000000 --- a/diceParser.pro +++ /dev/null @@ -1,71 +0,0 @@ -#------------------------------------------------- -# -# Project created by QtCreator 2013-12-24T13:06:36 -# -#------------------------------------------------- - -QT += core - -QT -= gui - -include(node/node.pri) - -TARGET = diceParser -CONFIG += console -CONFIG -= app_bundle - -TEMPLATE = app - -#CONFIG+= IRC -#CONFIG+= GUI -CONFIG+= CLI -CLI { -DEFINES += CLI -include(cli/cli.pri) -} -IRC { -include(irc/irc.pri) -QT += gui widgets -DEFINES+= HAVE_IRC -message("test") -} -GUI { -include(gui/gui.pri) -QT += gui widgets -DEFINES+= HAVE_GUI -} - - -SOURCES += diceparser.cpp \ - result/diceresult.cpp \ - range.cpp \ - booleancondition.cpp \ - validator.cpp \ - die.cpp \ - result/result.cpp \ - result/scalarresult.cpp \ - parsingtoolbox.cpp \ - result/stringresult.cpp \ - dicealias.cpp \ - mobile/mainwindow.cpp - - -HEADERS += \ - diceparser.h \ - result/diceresult.h \ - range.h \ - booleancondition.h \ - validator.h \ - die.h \ - result/result.h \ - result/scalarresult.h \ - result/parsingtoolbox.h \ - result/stringresult.h \ - dicealias.h \ - mobile/mainwindow.h - -OTHER_FILES += README.md \ - HelpMe.md - - -#QMAKE_CXXFLAGS += -O0 diff --git a/dicealias.cpp b/dicealias.cpp index 2bc07be..3bce75d 100644 --- a/dicealias.cpp +++ b/dicealias.cpp @@ -19,8 +19,8 @@ * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ -#include "dicealias.h" #include <QRegularExpression> +#include <diceparser/dicealias.h> #include <QDebug> diff --git a/diceparser.cpp b/diceparser.cpp index 5b91994..af86acc 100644 --- a/diceparser.cpp +++ b/diceparser.cpp @@ -19,7 +19,8 @@ * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ -#include "diceparser.h" +#include <diceparser/diceparser.h> + #include <QDebug> #include <QFile> #include <QJsonArray> @@ -31,11 +32,11 @@ #include <numeric> #include "booleancondition.h" -#include "dicealias.h" -#include "parsingtoolbox.h" #include "range.h" #include "result/stringresult.h" #include "validator.h" +#include <diceparser/dicealias.h> +#include <diceparser/parsingtoolbox.h> #define DEFAULT_FACES_NUMBER 10 @@ -176,17 +177,21 @@ QString DiceParser::humanReadableError() const { auto parsingError= m_parsingToolbox->getErrorList(); QString str; - std::for_each(parsingError.begin(), parsingError.end(), [&str](const QString& text) { - str.append(text); - str.append(QStringLiteral("\n")); - }); + std::for_each(parsingError.begin(), parsingError.end(), + [&str](const QString& text) + { + str.append(text); + str.append(QStringLiteral("\n")); + }); /// list auto errMap= errorMap(); - std::for_each(errMap.begin(), errMap.end(), [&str](const QString& text) { - str.append(text); - str.append(QStringLiteral("\n")); - }); + std::for_each(errMap.begin(), errMap.end(), + [&str](const QString& text) + { + str.append(text); + str.append(QStringLiteral("\n")); + }); return str; } diff --git a/diceparser.pri b/diceparser.pri deleted file mode 100644 index 80c84f1..0000000 --- a/diceparser.pri +++ /dev/null @@ -1,108 +0,0 @@ - -INCLUDEPATH += $$PWD/result -INCLUDEPATH += $$PWD/node -INCLUDEPATH += $$PWD/include -INCLUDEPATH += $$PWD - -SOURCES += $$PWD/diceparser.cpp \ - $$PWD/result/diceresult.cpp \ - $$PWD/range.cpp \ - $$PWD/highlightdice.cpp \ - $$PWD/booleancondition.cpp \ - $$PWD/validator.cpp \ - $$PWD/die.cpp \ - $$PWD/result/result.cpp \ - $$PWD/result/scalarresult.cpp \ - $$PWD/parsingtoolbox.cpp \ - $$PWD/result/stringresult.cpp \ - $$PWD/compositevalidator.cpp \ - $$PWD/dicealias.cpp \ - $$PWD/operationcondition.cpp \ - $$PWD/node/stringnode.cpp \ - $$PWD/node/filternode.cpp \ - $$PWD/node/allsamenode.cpp \ - $$PWD/node/groupnode.cpp \ - $$PWD/node/dicerollernode.cpp \ - $$PWD/node/executionnode.cpp \ - $$PWD/node/startingnode.cpp \ - $$PWD/node/rerolldicenode.cpp \ - $$PWD/node/scalaroperatornode.cpp \ - $$PWD/node/numbernode.cpp \ - $$PWD/node/sortresult.cpp \ - $$PWD/node/keepdiceexecnode.cpp \ - $$PWD/node/countexecutenode.cpp \ - $$PWD/node/explodedicenode.cpp \ - $$PWD/node/parenthesesnode.cpp \ - $$PWD/node/helpnode.cpp \ - $$PWD/node/jumpbackwardnode.cpp \ - $$PWD/node/mergenode.cpp \ - $$PWD/node/listaliasnode.cpp \ - $$PWD/node/paintnode.cpp \ - $$PWD/node/ifnode.cpp \ - $$PWD/node/splitnode.cpp \ - $$PWD/node/valueslistnode.cpp \ - $$PWD/node/uniquenode.cpp \ - $$PWD/node/repeaternode.cpp \ - $$PWD/node/listsetrollnode.cpp\ - $$PWD/node/variablenode.cpp\ - $$PWD/node/bind.cpp\ - $$PWD/node/occurencecountnode.cpp\ - $$PWD/diceroller.cpp\ - $$PWD/validatorlist.cpp\ - $$PWD/qmltypesregister.cpp - - -HEADERS += \ - $$PWD/include/diceparser.h \ - $$PWD/result/diceresult.h \ - $$PWD/range.h \ - $$PWD/booleancondition.h \ - $$PWD/include/highlightdice.h \ - $$PWD/validator.h \ - $$PWD/die.h \ - $$PWD/result/result.h \ - $$PWD/result/scalarresult.h \ - $$PWD/include/parsingtoolbox.h \ - $$PWD/result/stringresult.h \ - $$PWD/compositevalidator.h \ - $$PWD/include/dicealias.h \ - $$PWD/operationcondition.h \ - $$PWD/node/stringnode.h \ - $$PWD/node/filternode.h\ - $$PWD/node/allsamenode.h\ - $$PWD/node/groupnode.h \ - $$PWD/node/variablenode.h\ - $$PWD/node/dicerollernode.h \ - $$PWD/node/executionnode.h \ - $$PWD/node/rerolldicenode.h \ - $$PWD/node/startingnode.h \ - $$PWD/node/scalaroperatornode.h \ - $$PWD/node/numbernode.h \ - $$PWD/node/sortresult.h \ - $$PWD/node/keepdiceexecnode.h \ - $$PWD/node/countexecutenode.h \ - $$PWD/node/explodedicenode.h \ - $$PWD/node/valueslistnode.h \ - $$PWD/node/parenthesesnode.h \ - $$PWD/node/helpnode.h \ - $$PWD/node/jumpbackwardnode.h \ - $$PWD/node/mergenode.h \ - $$PWD/node/listaliasnode.h \ - $$PWD/node/ifnode.h \ - $$PWD/node/bind.h\ - $$PWD/node/splitnode.h \ - $$PWD/node/repeaternode.h \ - $$PWD/node/uniquenode.h \ - $$PWD/node/paintnode.h \ - $$PWD/node/listsetrollnode.h \ - $$PWD/node/occurencecountnode.h\ - $$PWD/diceroller.h \ - $$PWD/validatorlist.cpp\ - $$PWD/include/diceparserhelper.h \ - $$PWD/qmltypesregister.h - - - - -OTHER_FILES += \ - $$PWD/HelpMe.md diff --git a/diceroller.cpp b/diceroller.cpp index af6921c..e1c8ded 100644 --- a/diceroller.cpp +++ b/diceroller.cpp @@ -17,7 +17,7 @@ * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ -#include "diceroller.h" +#include <diceparser_qobject/diceroller.h> #include <QJsonObject> #include <QtConcurrent> @@ -61,18 +61,21 @@ void DiceRoller::readErrorAndWarning() void DiceRoller::start() { - auto future= QtConcurrent::run([this]() { - if(m_diceparser.parseLine(m_command)) + auto future= QtConcurrent::run( + [this]() { - m_diceparser.start(); - readErrorAndWarning(); - auto jsonstr= m_diceparser.resultAsJSon([](const QString& value, const QString&, bool) { return value; }); - QJsonDocument doc= QJsonDocument::fromJson(jsonstr.toLocal8Bit()); - auto json= doc.object(); - m_result= json["scalar"].toString().toDouble(); - emit resultChanged(); - } - }); + if(m_diceparser.parseLine(m_command)) + { + m_diceparser.start(); + readErrorAndWarning(); + auto jsonstr + = m_diceparser.resultAsJSon([](const QString& value, const QString&, bool) { return value; }); + QJsonDocument doc= QJsonDocument::fromJson(jsonstr.toLocal8Bit()); + auto json= doc.object(); + m_result= json["scalar"].toString().toDouble(); + emit resultChanged(); + } + }); } QString DiceRoller::error() const @@ -51,7 +51,7 @@ Die::Die() , m_highlighted(true) , m_base(1) , m_color("") - , m_op(Die::PLUS) //,m_mt(m_randomDevice) + , m_op(Dice::ArithmeticOperator::PLUS) //,m_mt(m_randomDevice) { buildSeed(); } @@ -109,17 +109,17 @@ qint64 Die::getValue() const { switch(m_op) { - case PLUS: + case Dice::ArithmeticOperator::PLUS: value+= tmp; break; - case MULTIPLICATION: + case Dice::ArithmeticOperator::MULTIPLICATION: value*= tmp; break; - case MINUS: + case Dice::ArithmeticOperator::MINUS: value-= tmp; break; - case INTEGER_DIVIDE: - case DIVIDE: + case Dice::ArithmeticOperator::INTEGER_DIVIDE: + case Dice::ArithmeticOperator::DIVIDE: if(tmp != 0) { value/= tmp; @@ -129,7 +129,7 @@ qint64 Die::getValue() const // error(); } break; - case POW: + case Dice::ArithmeticOperator::POW: value= static_cast<qint64>(std::pow(value, tmp)); break; } @@ -237,12 +237,12 @@ void Die::setMaxValue(const qint64& maxValue) m_maxValue= maxValue; } -Die::ArithmeticOperator Die::getOp() const +Dice::ArithmeticOperator Die::getOp() const { return m_op; } -void Die::setOp(const Die::ArithmeticOperator& op) +void Die::setOp(const Dice::ArithmeticOperator& op) { m_op= op; } @@ -25,6 +25,8 @@ #include <QList> #include <QString> #include <random> + +#include "diceparser/diceparserhelper.h" /** * @brief The Die class implements all methods required from a die. You must set the Faces first, then you can roll it * and roll it again, to add or replace the previous result. @@ -33,18 +35,6 @@ class Die { public: /** - * @brief The ArithmeticOperator enum - */ - enum ArithmeticOperator - { - PLUS, - MINUS, - DIVIDE, - MULTIPLICATION, - INTEGER_DIVIDE, - POW - }; - /** * @brief Die */ Die(); @@ -140,8 +130,8 @@ public: qint64 getMaxValue() const; void setMaxValue(const qint64& maxValue); - Die::ArithmeticOperator getOp() const; - void setOp(const Die::ArithmeticOperator& op); + Dice::ArithmeticOperator getOp() const; + void setOp(const Dice::ArithmeticOperator& op); void setDisplayed(bool b); QString getUuid() const; @@ -162,7 +152,7 @@ private: qint64 m_occurence{1}; QString m_color; - Die::ArithmeticOperator m_op; + Dice::ArithmeticOperator m_op; static std::mt19937 s_rng; }; diff --git a/highlightdice.cpp b/highlightdice.cpp index d0c9faa..e92451f 100644 --- a/highlightdice.cpp +++ b/highlightdice.cpp @@ -17,7 +17,7 @@ * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ -#include "include/highlightdice.h" +#include <diceparser/highlightdice.h> HighLightDice::HighLightDice(QList<qint64> result, bool isHighlighted, QString color, bool displayed, quint64 faces, const QString& uuid) diff --git a/include/dicealias.h b/include/diceparser/dicealias.h index c390d21..05d5a0b 100644 --- a/include/dicealias.h +++ b/include/diceparser/dicealias.h @@ -23,11 +23,13 @@ #define DICEALIAS_H #include <QString> + +#include <diceparser/diceparser_global.h> /** * @brief The DiceAlias class is dedicated to store aliases, alias is mainly two QString. The Alias and its replacement. * The replacement can be a simple QString or a RegExp. */ -class DiceAlias +class DICEPARSER_EXPORT DiceAlias { public: enum RESOLUTION_TYPE diff --git a/include/diceparser.h b/include/diceparser/diceparser.h index 3c42bcc..bf2d570 100644 --- a/include/diceparser.h +++ b/include/diceparser/diceparser.h @@ -29,9 +29,10 @@ #include <memory> #include <vector> -#include "diceparserhelper.h" -#include "highlightdice.h" -//#include "node/executionnode.h" +#include <diceparser/diceparser_global.h> + +#include <diceparser/diceparserhelper.h> +#include <diceparser/highlightdice.h> class ExplodeDiceNode; class ParsingToolBox; @@ -52,7 +53,7 @@ class ExecutionNode; /** * @brief The DiceParser class facade class, it receives a command and return a DiceResult class (not yet implemented). */ -class DiceParser +class DICEPARSER_EXPORT DiceParser { public: /** diff --git a/include/diceparser/diceparser_global.h b/include/diceparser/diceparser_global.h new file mode 100644 index 0000000..47829cc --- /dev/null +++ b/include/diceparser/diceparser_global.h @@ -0,0 +1,11 @@ +#ifndef DICEPARSER_GLOBAL_H +#define DICEPARSER_GLOBAL_H + +#include <QtCore/qglobal.h> + +#if defined(DICEPARSER_LIBRARY) +#define DICEPARSER_EXPORT Q_DECL_EXPORT +#else +#define DICEPARSER_EXPORT Q_DECL_IMPORT +#endif +#endif // DICEPARSER_GLOBAL_H diff --git a/include/diceparserhelper.h b/include/diceparser/diceparserhelper.h index 1ae5c3f..6190df2 100644 --- a/include/diceparserhelper.h +++ b/include/diceparser/diceparserhelper.h @@ -4,6 +4,8 @@ class ValidatorList; class ExecutionNode; +#include <diceparser/diceparser_global.h> + namespace Dice { enum class CONDITION_STATE : int @@ -54,7 +56,38 @@ enum ConditionType OnScalar }; -struct CaseInfo +enum class CompareOperator +{ + Equal, + GreaterThan, + LesserThan, + GreaterOrEqual, + LesserOrEqual, + Different +}; +enum class ArithmeticOperator +{ + PLUS, + MINUS, + DIVIDE, + MULTIPLICATION, + INTEGER_DIVIDE, + POW +}; +enum class LogicOperation +{ + OR, + EXCLUSIVE_OR, + AND, + NONE +}; + +enum class ConditionOperator +{ + Modulo +}; + +struct DICEPARSER_EXPORT CaseInfo { ValidatorList* validatorList; ExecutionNode* node; diff --git a/include/highlightdice.h b/include/diceparser/highlightdice.h index 66bd445..a3928a1 100644 --- a/include/highlightdice.h +++ b/include/diceparser/highlightdice.h @@ -24,7 +24,9 @@ #include <QMap> #include <QString> -class HighLightDice +#include <diceparser/diceparser_global.h> + +class DICEPARSER_EXPORT HighLightDice { public: HighLightDice(QList<qint64> result, bool isHighlighted, QString color, bool displayed, quint64 faces, diff --git a/include/parsingtoolbox.h b/include/diceparser/parsingtoolbox.h index 08e876a..69f433a 100644 --- a/include/parsingtoolbox.h +++ b/include/diceparser/parsingtoolbox.h @@ -22,28 +22,38 @@ #ifndef PARSINGTOOLBOX_H #define PARSINGTOOLBOX_H +#include <QJsonArray> +#include <QJsonDocument> +#include <QJsonObject> #include <QMap> +#include <QVariant> #include <functional> #include <vector> -#include "booleancondition.h" +#include "diceparserhelper.h" #include "highlightdice.h" -#include "node/dicerollernode.h" -#include "node/executionnode.h" -#include "node/ifnode.h" -#include "node/paintnode.h" -#include "node/scalaroperatornode.h" -#include "operationcondition.h" -#include "range.h" -#include "validatorlist.h" +//#include "dicerollernode.h" +//#include "executionnode.h" +//#include "node/ifnode.h" +//#include "node/paintnode.h" +//#include "node/scalaroperatornode.h" +//#include "operationcondition.h" +//#include "range.h" +//#include "validatorlist.h" +#include <diceparser/diceparser_global.h> +class Range; class RepeaterNode; class DiceAlias; class ExplodeDiceNode; class SwitchCaseNode; class ReplaceValueNode; - -class SubtituteInfo +class PainterNode; +class ValidatorList; +class Validator; +class DiceRollerNode; +class ExecutionNode; +class DICEPARSER_EXPORT SubtituteInfo { public: SubtituteInfo(); @@ -77,7 +87,7 @@ private: * @brief The ParsingToolBox is gathering many useful methods for dice parsing. * Its goal is to make the diceparser a bit lighter. */ -class ParsingToolBox +class DICEPARSER_EXPORT ParsingToolBox { public: enum LIST_OPERATOR @@ -139,7 +149,7 @@ public: // parsing tools static bool readAscending(QString& str); static bool readStopAtFirst(QString& str); - bool readLogicOperator(QString& str, BooleanCondition::LogicOperator& op); + bool readLogicOperator(QString& str, Dice::CompareOperator& op); Validator* readValidator(QString& str, bool hasSquare= false); ValidatorList* readValidatorList(QString& str); static bool readNumber(QString& str, qint64& myNumber); @@ -153,9 +163,9 @@ public: bool readDiceRange(QString& str, qint64& start, qint64& end); static LIST_OPERATOR readListOperator(QString& str); void readProbability(QStringList& str, QList<Range>& ranges); - bool readLogicOperation(QString& str, ValidatorList::LogicOperation& op); - bool readDiceLogicOperator(QString& str, OperationCondition::ConditionOperator& op); - bool readArithmeticOperator(QString& str, Die::ArithmeticOperator& op); + bool readLogicOperation(QString& str, Dice::LogicOperation& op); + bool readDiceLogicOperator(QString& str, Dice::ConditionOperator& op); + bool readArithmeticOperator(QString& str, Dice::ArithmeticOperator& op); std::vector<ExecutionNode*> readInstructionList(QString& str, bool startNode); static Dice::ConditionType readConditionType(QString& str); bool readComment(QString& str, QString&, QString&); @@ -250,10 +260,10 @@ public: static QString replacePlaceHolderFromJson(const QString& source, const QJsonObject& obj); private: - QMap<QString, BooleanCondition::LogicOperator> m_logicOp; - QMap<QString, ValidatorList::LogicOperation> m_logicOperation; - QMap<QString, OperationCondition::ConditionOperator> m_conditionOperation; - std::vector<std::pair<QString, Die::ArithmeticOperator>> m_arithmeticOperation; + QMap<QString, Dice::CompareOperator> m_logicOp; + QMap<QString, Dice::LogicOperation> m_logicOperation; + QMap<QString, Dice::ConditionOperator> m_conditionOperation; + std::vector<std::pair<QString, Dice::ArithmeticOperator>> m_arithmeticOperation; QMap<QString, DiceOperator> m_mapDiceOp; QMap<QString, OptionOperator> m_OptionOp; QMap<QString, NodeAction> m_nodeActionMap; diff --git a/include/diceparser_qobject/diceparser_qobject_global.h b/include/diceparser_qobject/diceparser_qobject_global.h new file mode 100644 index 0000000..ea49727 --- /dev/null +++ b/include/diceparser_qobject/diceparser_qobject_global.h @@ -0,0 +1,11 @@ +#ifndef DICEPARSER_QOBJECT_GLOBAL_H +#define DICEPARSER_QOBJECT_GLOBAL_H + +#include <QtCore/qglobal.h> + +#if defined(DICEPARSER_QOBJECT_LIBRARY) +#define DICEPARSER_QOBJECT_EXPORT Q_DECL_EXPORT +#else +#define DICEPARSER_QOBJECT_EXPORT Q_DECL_IMPORT +#endif +#endif // DICEPARSER_QOBJECT_GLOBAL_H diff --git a/diceroller.h b/include/diceparser_qobject/diceroller.h index 02d8e3e..72c4e10 100644 --- a/diceroller.h +++ b/include/diceparser_qobject/diceroller.h @@ -20,10 +20,12 @@ #ifndef DICEROLLER_H #define DICEROLLER_H -#include "diceparser.h" #include <QObject> +#include <diceparser/diceparser.h> -class DiceRoller : public QObject +#include <diceparser_qobject/diceparser_qobject_global.h> + +class DICEPARSER_QOBJECT_EXPORT DiceRoller : public QObject { Q_OBJECT Q_PROPERTY(qreal result READ result NOTIFY resultChanged) diff --git a/qmltypesregister.h b/include/diceparser_qobject/qmltypesregister.h index 485c697..e0b1a09 100644 --- a/qmltypesregister.h +++ b/include/diceparser_qobject/qmltypesregister.h @@ -20,6 +20,8 @@ #ifndef REGISTER_QML_TYPE_H #define REGISTER_QML_TYPE_H -void registerQmlTypes(); +#include <diceparser_qobject/diceparser_qobject_global.h> + +DICEPARSER_QOBJECT_EXPORT void registerQmlTypes(); #endif // REGISTER_QML_TYPE_H diff --git a/node/dicerollernode.cpp b/node/dicerollernode.cpp index f87908f..2b00c0a 100644 --- a/node/dicerollernode.cpp +++ b/node/dicerollernode.cpp @@ -7,7 +7,7 @@ #include <QTime> DiceRollerNode::DiceRollerNode(qint64 max, qint64 min) - : m_max(max), m_diceResult(new DiceResult()), m_min(min), m_operator(Die::PLUS) + : m_max(max), m_diceResult(new DiceResult()), m_min(min), m_operator(Dice::ArithmeticOperator::PLUS) { m_result= m_diceResult; } @@ -99,12 +99,12 @@ ExecutionNode* DiceRollerNode::getCopy() const return node; } -Die::ArithmeticOperator DiceRollerNode::getOperator() const +Dice::ArithmeticOperator DiceRollerNode::getOperator() const { return m_operator; } -void DiceRollerNode::setOperator(const Die::ArithmeticOperator& dieOperator) +void DiceRollerNode::setOperator(const Dice::ArithmeticOperator& dieOperator) { m_operator= dieOperator; m_diceResult->setOperator(dieOperator); diff --git a/node/dicerollernode.h b/node/dicerollernode.h index 67d4074..52178cb 100644 --- a/node/dicerollernode.h +++ b/node/dicerollernode.h @@ -45,8 +45,8 @@ public: virtual ExecutionNode* getCopy() const; // private members - Die::ArithmeticOperator getOperator() const; - void setOperator(const Die::ArithmeticOperator& dieOperator); + Dice::ArithmeticOperator getOperator() const; + void setOperator(const Dice::ArithmeticOperator& dieOperator); bool getUnique() const; void setUnique(bool unique); @@ -54,10 +54,10 @@ public: private: quint64 m_diceCount; qint64 m_max; /// faces - DiceResult* m_diceResult; + DiceResult* m_diceResult{nullptr}; qint64 m_min; - Die::ArithmeticOperator m_operator; - bool m_unique = false; + Dice::ArithmeticOperator m_operator; + bool m_unique{false}; }; #endif // DICEROLLERNODE_H diff --git a/node/executionnode.h b/node/executionnode.h index 6321c83..d1bdf66 100644 --- a/node/executionnode.h +++ b/node/executionnode.h @@ -1,8 +1,8 @@ #ifndef EXECUTIONNODE_H #define EXECUTIONNODE_H -#include "diceparserhelper.h" #include "result/result.h" +#include <diceparser/diceparserhelper.h> /** * @brief The ExecutionNode class diff --git a/node/ifnode.h b/node/ifnode.h index f0046f0..912d65c 100644 --- a/node/ifnode.h +++ b/node/ifnode.h @@ -20,9 +20,9 @@ #ifndef IFNODE_H #define IFNODE_H -#include "diceparserhelper.h" #include "executionnode.h" #include "result/diceresult.h" +#include <diceparser/diceparserhelper.h> class ValidatorList; class PartialDiceRollNode : public ExecutionNode diff --git a/node/listaliasnode.h b/node/listaliasnode.h index b8b549c..2a6f96e 100644 --- a/node/listaliasnode.h +++ b/node/listaliasnode.h @@ -21,7 +21,8 @@ #ifndef LISTALIASNODE_H #define LISTALIASNODE_H -#include "dicealias.h" +#include <diceparser/dicealias.h> + #include "executionnode.h" #include "result/stringresult.h" diff --git a/node/mergenode.cpp b/node/mergenode.cpp index 7a521e3..096bb8c 100644 --- a/node/mergenode.cpp +++ b/node/mergenode.cpp @@ -21,7 +21,7 @@ ***************************************************************************/ #include "mergenode.h" -#include "parsingtoolbox.h" +#include <diceparser/parsingtoolbox.h> MergeNode::MergeNode() : m_diceResult(new DiceResult()) { diff --git a/node/repeaternode.cpp b/node/repeaternode.cpp index 2010118..f93a9fe 100644 --- a/node/repeaternode.cpp +++ b/node/repeaternode.cpp @@ -21,11 +21,12 @@ ***************************************************************************/ #include "node/repeaternode.h" -#include "diceparserhelper.h" #include "executionnode.h" -#include "parsingtoolbox.h" +#include "result/scalarresult.h" #include "result/stringresult.h" #include <QDebug> +#include <diceparser/diceparserhelper.h> +#include <diceparser/parsingtoolbox.h> using InstructionSet= std::vector<ExecutionNode*>; @@ -82,16 +83,18 @@ void RepeaterNode::run(ExecutionNode* previousNode) 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); - }); + 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) @@ -121,7 +124,7 @@ void RepeaterNode::run(ExecutionNode* previousNode) m_result= string; - //qDebug().noquote() << listOfStrResult.join('\n'); + // qDebug().noquote() << listOfStrResult.join('\n'); } if(nullptr != m_nextNode) diff --git a/node/replacevaluenode.cpp b/node/replacevaluenode.cpp index fbad5df..c313fb0 100644 --- a/node/replacevaluenode.cpp +++ b/node/replacevaluenode.cpp @@ -20,8 +20,8 @@ #include "replacevaluenode.h" #include "diceresult.h" -#include "parsingtoolbox.h" #include <QDebug> +#include <diceparser/parsingtoolbox.h> ReplaceValueNode::ReplaceValueNode() : m_diceResult(new DiceResult) { diff --git a/node/rerolldicenode.cpp b/node/rerolldicenode.cpp index e7bf0f0..fd8c258 100644 --- a/node/rerolldicenode.cpp +++ b/node/rerolldicenode.cpp @@ -1,5 +1,7 @@ +#include <diceparser/parsingtoolbox.h> + #include "rerolldicenode.h" -#include "parsingtoolbox.h" +#include "validatorlist.h" #include <utility> RerollDiceNode::RerollDiceNode(bool reroll, bool addingMode) diff --git a/node/scalaroperatornode.cpp b/node/scalaroperatornode.cpp index 268d6b8..c1c4dc5 100644 --- a/node/scalaroperatornode.cpp +++ b/node/scalaroperatornode.cpp @@ -25,7 +25,7 @@ #include <QDebug> ScalarOperatorNode::ScalarOperatorNode() - : m_internalNode(nullptr), m_scalarResult(new ScalarResult()), m_arithmeticOperator(Die::PLUS) + : m_internalNode(nullptr), m_scalarResult(new ScalarResult()), m_arithmeticOperator(Dice::ArithmeticOperator::PLUS) { m_result= m_scalarResult; } @@ -75,28 +75,28 @@ void ScalarOperatorNode::run(ExecutionNode* previous) switch(m_arithmeticOperator) { - case Die::PLUS: + case Dice::ArithmeticOperator::PLUS: m_scalarResult->setValue(add(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(), internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal())); break; - case Die::MINUS: + case Dice::ArithmeticOperator::MINUS: m_scalarResult->setValue(substract(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(), internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal())); break; - case Die::MULTIPLICATION: + case Dice::ArithmeticOperator::MULTIPLICATION: m_scalarResult->setValue(multiple(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(), internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal())); break; - case Die::DIVIDE: + case Dice::ArithmeticOperator::DIVIDE: m_scalarResult->setValue(divide(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(), internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal())); break; - case Die::INTEGER_DIVIDE: + case Dice::ArithmeticOperator::INTEGER_DIVIDE: m_scalarResult->setValue( static_cast<int>(divide(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(), internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal()))); break; - case Die::POW: + case Dice::ArithmeticOperator::POW: m_scalarResult->setValue(pow(previousResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal(), internalResult->getResult(Dice::RESULT_TYPE::SCALAR).toReal())); break; @@ -149,12 +149,12 @@ qint64 ScalarOperatorNode::pow(qreal a, qreal b) { return static_cast<qint64>(std::pow(a, b)); } -Die::ArithmeticOperator ScalarOperatorNode::getArithmeticOperator() const +Dice::ArithmeticOperator ScalarOperatorNode::getArithmeticOperator() const { return m_arithmeticOperator; } -void ScalarOperatorNode::setArithmeticOperator(const Die::ArithmeticOperator& arithmeticOperator) +void ScalarOperatorNode::setArithmeticOperator(const Dice::ArithmeticOperator& arithmeticOperator) { m_arithmeticOperator= arithmeticOperator; } @@ -164,22 +164,22 @@ QString ScalarOperatorNode::toString(bool wl) const QString op= ""; switch(m_arithmeticOperator) { - case Die::PLUS: + case Dice::ArithmeticOperator::PLUS: op= "+"; break; - case Die::MINUS: + case Dice::ArithmeticOperator::MINUS: op= "-"; break; - case Die::MULTIPLICATION: + case Dice::ArithmeticOperator::MULTIPLICATION: op= "*"; break; - case Die::DIVIDE: + case Dice::ArithmeticOperator::DIVIDE: op= "/"; break; - case Die::INTEGER_DIVIDE: + case Dice::ArithmeticOperator::INTEGER_DIVIDE: op= "|"; break; - case Die::POW: + case Dice::ArithmeticOperator::POW: op= "^"; break; } @@ -194,11 +194,12 @@ QString ScalarOperatorNode::toString(bool wl) const } qint64 ScalarOperatorNode::getPriority() const { - if((m_arithmeticOperator == Die::PLUS) || (m_arithmeticOperator == Die::MINUS)) + if((m_arithmeticOperator == Dice::ArithmeticOperator::PLUS) + || (m_arithmeticOperator == Dice::ArithmeticOperator::MINUS)) { return 1; } - else if(m_arithmeticOperator == Die::POW) + else if(m_arithmeticOperator == Dice::ArithmeticOperator::POW) { return 3; } diff --git a/node/scalaroperatornode.h b/node/scalaroperatornode.h index 5902433..57a1049 100644 --- a/node/scalaroperatornode.h +++ b/node/scalaroperatornode.h @@ -81,12 +81,12 @@ public: * @brief getArithmeticOperator * @return */ - Die::ArithmeticOperator getArithmeticOperator() const; + Dice::ArithmeticOperator getArithmeticOperator() const; /** * @brief setArithmeticOperator * @param arithmeticOperator */ - void setArithmeticOperator(const Die::ArithmeticOperator& arithmeticOperator); + void setArithmeticOperator(const Dice::ArithmeticOperator& arithmeticOperator); /** * @brief getCopy @@ -121,7 +121,7 @@ private: private: ExecutionNode* m_internalNode; ScalarResult* m_scalarResult; - Die::ArithmeticOperator m_arithmeticOperator; + Dice::ArithmeticOperator m_arithmeticOperator; }; #endif // SCALAROPERATORNODE_H diff --git a/node/switchcasenode.cpp b/node/switchcasenode.cpp index 61938a9..880fa4d 100644 --- a/node/switchcasenode.cpp +++ b/node/switchcasenode.cpp @@ -19,9 +19,9 @@ ***************************************************************************/ #include "switchcasenode.h" -#include "parsingtoolbox.h" #include "stringresult.h" #include <QDebug> +#include <diceparser/parsingtoolbox.h> SwitchCaseNode::SwitchCaseNode() : m_stringResult(new StringResult) { diff --git a/node/variablenode.cpp b/node/variablenode.cpp index ce8af29..709ab46 100644 --- a/node/variablenode.cpp +++ b/node/variablenode.cpp @@ -1,5 +1,7 @@ #include "variablenode.h" -#include "parsingtoolbox.h" + +#include "diceresult.h" +#include <diceparser/parsingtoolbox.h> VariableNode::VariableNode() {} diff --git a/operationcondition.cpp b/operationcondition.cpp index 22e6b0b..70ebab4 100644 --- a/operationcondition.cpp +++ b/operationcondition.cpp @@ -20,7 +20,10 @@ #include "operationcondition.h" -OperationCondition::OperationCondition() : m_operator(Modulo), m_boolean(nullptr), m_value(nullptr) {} +OperationCondition::OperationCondition() + : m_operator(Dice::ConditionOperator::Modulo), m_boolean(nullptr), m_value(nullptr) +{ +} OperationCondition::~OperationCondition() { if(m_value != nullptr) @@ -60,7 +63,7 @@ qint64 OperationCondition::hasValid(Die* b, bool recursive, bool unhighlight) co { switch(m_operator) { - case Modulo: + case Dice::ConditionOperator::Modulo: { Die die; die.setMaxValue(b->getMaxValue()); @@ -85,7 +88,7 @@ qint64 OperationCondition::hasValid(Die* b, bool recursive, bool unhighlight) co return sum; } -void OperationCondition::setOperator(ConditionOperator m) +void OperationCondition::setOperator(Dice::ConditionOperator m) { m_operator= m; } @@ -100,7 +103,7 @@ QString OperationCondition::toString() QString str(""); switch(m_operator) { - case Modulo: + case Dice::ConditionOperator::Modulo: str.append(QStringLiteral("\\%")); break; } diff --git a/operationcondition.h b/operationcondition.h index d9653cc..719624f 100644 --- a/operationcondition.h +++ b/operationcondition.h @@ -29,16 +29,12 @@ class OperationCondition : public Validator { public: - enum ConditionOperator - { - Modulo - }; OperationCondition(); virtual ~OperationCondition() override; virtual qint64 hasValid(Die* b, bool recursive, bool unhighlight= false) const override; - void setOperator(ConditionOperator m); + void setOperator(Dice::ConditionOperator m); // void setValue(qint64); void setValueNode(ExecutionNode* node); QString toString() override; @@ -56,7 +52,7 @@ private: qint64 valueToScalar() const; private: - ConditionOperator m_operator= Modulo; + Dice::ConditionOperator m_operator{Dice::ConditionOperator::Modulo}; BooleanCondition* m_boolean= nullptr; // qint64 m_value; ExecutionNode* m_value= nullptr; diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp index e5bb579..dfde37f 100644 --- a/parsingtoolbox.cpp +++ b/parsingtoolbox.cpp @@ -19,7 +19,7 @@ * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ -#include "parsingtoolbox.h" +#include "diceparser/parsingtoolbox.h" #include <QDebug> #include <QJsonArray> @@ -59,36 +59,39 @@ #include "node/uniquenode.h" #include "node/valueslistnode.h" #include "node/variablenode.h" +#include "operationcondition.h" +#include "range.h" +#include "validatorlist.h" QHash<QString, QString> ParsingToolBox::m_variableHash; ParsingToolBox::ParsingToolBox() { // m_logicOp = ; - m_logicOp.insert(">=", BooleanCondition::GreaterOrEqual); - m_logicOp.insert("<=", BooleanCondition::LesserOrEqual); - m_logicOp.insert("<", BooleanCondition::LesserThan); - m_logicOp.insert("=", BooleanCondition::Equal); - m_logicOp.insert(">", BooleanCondition::GreaterThan); - m_logicOp.insert("!=", BooleanCondition::Different); + m_logicOp.insert(">=", Dice::CompareOperator::GreaterOrEqual); + m_logicOp.insert("<=", Dice::CompareOperator::LesserOrEqual); + m_logicOp.insert("<", Dice::CompareOperator::LesserThan); + m_logicOp.insert("=", Dice::CompareOperator::Equal); + m_logicOp.insert(">", Dice::CompareOperator::GreaterThan); + m_logicOp.insert("!=", Dice::CompareOperator::Different); // m_logicOperation = ; - m_logicOperation.insert("|", ValidatorList::OR); - m_logicOperation.insert("^", ValidatorList::EXCLUSIVE_OR); - m_logicOperation.insert("&", ValidatorList::AND); + m_logicOperation.insert("|", Dice::LogicOperation::OR); + m_logicOperation.insert("^", Dice::LogicOperation::EXCLUSIVE_OR); + m_logicOperation.insert("&", Dice::LogicOperation::AND); // m_conditionOperation = ; - m_conditionOperation.insert("%", OperationCondition::Modulo); + m_conditionOperation.insert("%", Dice::ConditionOperator::Modulo); // m_arithmeticOperation = new QHash<QString,ScalarOperatorNode::ArithmeticOperator>(); - m_arithmeticOperation.push_back({QStringLiteral("**"), Die::POW}); - m_arithmeticOperation.push_back({QStringLiteral("+"), Die::PLUS}); - m_arithmeticOperation.push_back({QStringLiteral("-"), Die::MINUS}); - m_arithmeticOperation.push_back({QStringLiteral("*"), Die::MULTIPLICATION}); - m_arithmeticOperation.push_back({QStringLiteral("x"), Die::MULTIPLICATION}); - m_arithmeticOperation.push_back({QStringLiteral("|"), Die::INTEGER_DIVIDE}); - m_arithmeticOperation.push_back({QStringLiteral("/"), Die::DIVIDE}); - m_arithmeticOperation.push_back({QStringLiteral("÷"), Die::DIVIDE}); + m_arithmeticOperation.push_back({QStringLiteral("**"), Dice::ArithmeticOperator::POW}); + m_arithmeticOperation.push_back({QStringLiteral("+"), Dice::ArithmeticOperator::PLUS}); + m_arithmeticOperation.push_back({QStringLiteral("-"), Dice::ArithmeticOperator::MINUS}); + m_arithmeticOperation.push_back({QStringLiteral("*"), Dice::ArithmeticOperator::MULTIPLICATION}); + m_arithmeticOperation.push_back({QStringLiteral("x"), Dice::ArithmeticOperator::MULTIPLICATION}); + m_arithmeticOperation.push_back({QStringLiteral("|"), Dice::ArithmeticOperator::INTEGER_DIVIDE}); + m_arithmeticOperation.push_back({QStringLiteral("/"), Dice::ArithmeticOperator::DIVIDE}); + m_arithmeticOperation.push_back({QStringLiteral("÷"), Dice::ArithmeticOperator::DIVIDE}); m_mapDiceOp.insert(QStringLiteral("D"), D); m_mapDiceOp.insert(QStringLiteral("L"), L); @@ -153,7 +156,7 @@ void ParsingToolBox::addWarning(Dice::ERROR_CODE code, const QString& msg) { m_warningMap.insert(code, msg); } -bool ParsingToolBox::readDiceLogicOperator(QString& str, OperationCondition::ConditionOperator& op) +bool ParsingToolBox::readDiceLogicOperator(QString& str, Dice::ConditionOperator& op) { QString longKey; auto const& keys= m_conditionOperation.keys(); @@ -177,12 +180,12 @@ bool ParsingToolBox::readDiceLogicOperator(QString& str, OperationCondition::Con return false; } -bool ParsingToolBox::readArithmeticOperator(QString& str, Die::ArithmeticOperator& op) +bool ParsingToolBox::readArithmeticOperator(QString& str, Dice::ArithmeticOperator& op) { - auto it= std::find_if( - m_arithmeticOperation.begin(), m_arithmeticOperation.end(), - [str](const std::pair<QString, Die::ArithmeticOperator>& pair) { return str.startsWith(pair.first); }); + auto it= std::find_if(m_arithmeticOperation.begin(), m_arithmeticOperation.end(), + [str](const std::pair<QString, Dice::ArithmeticOperator>& pair) + { return str.startsWith(pair.first); }); if(it == m_arithmeticOperation.end()) return false; @@ -191,7 +194,7 @@ bool ParsingToolBox::readArithmeticOperator(QString& str, Die::ArithmeticOperato return true; } -bool ParsingToolBox::readLogicOperator(QString& str, BooleanCondition::LogicOperator& op) +bool ParsingToolBox::readLogicOperator(QString& str, Dice::CompareOperator& op) { QString longKey; auto const& keys= m_logicOp.keys(); @@ -264,10 +267,10 @@ Validator* ParsingToolBox::readValidator(QString& str, bool hasSquare) { Validator* returnVal= nullptr; auto opCompare= readConditionType(str); - BooleanCondition::LogicOperator myLogicOp= BooleanCondition::Equal; + Dice::CompareOperator myLogicOp{Dice::CompareOperator::Equal}; readLogicOperator(str, myLogicOp); - OperationCondition::ConditionOperator condiOp= OperationCondition::Modulo; + Dice::ConditionOperator condiOp{Dice::ConditionOperator::Modulo}; bool hasDiceLogicOperator= readDiceLogicOperator(str, condiOp); ExecutionNode* operandNode= nullptr; if(hasDiceLogicOperator) @@ -359,9 +362,9 @@ ValidatorList* ParsingToolBox::readValidatorList(QString& str) expectSquareBrasket= true; } Validator* tmp= readValidator(str, expectSquareBrasket); - ValidatorList::LogicOperation opLogic; + Dice::LogicOperation opLogic; - QVector<ValidatorList::LogicOperation> operators; + QVector<Dice::LogicOperation> operators; QList<Validator*> validatorList; while(nullptr != tmp) @@ -396,7 +399,7 @@ ValidatorList* ParsingToolBox::readValidatorList(QString& str) return nullptr; } } -bool ParsingToolBox::readLogicOperation(QString& str, ValidatorList::LogicOperation& op) +bool ParsingToolBox::readLogicOperation(QString& str, Dice::LogicOperation& op) { QString longKey; auto const& keys= m_logicOperation.keys(); @@ -711,11 +714,13 @@ QString ParsingToolBox::finalStringResult(std::function<QString(const QString&, auto listFull= diceResultFromEachInstruction(); QStringList resultWithPlaceHolder; - std::for_each(allStringlist.begin(), allStringlist.end(), [&resultWithPlaceHolder](const QString& sub) { - QRegularExpression ex("%[1-3]?|\\$[1-9]+|@[1-9]+"); - if(sub.contains(ex)) - resultWithPlaceHolder.append(sub); - }); + std::for_each(allStringlist.begin(), allStringlist.end(), + [&resultWithPlaceHolder](const QString& sub) + { + QRegularExpression ex("%[1-3]?|\\$[1-9]+|@[1-9]+"); + if(sub.contains(ex)) + resultWithPlaceHolder.append(sub); + }); auto stringResult= resultWithPlaceHolder.isEmpty() ? allStringlist.join(",") : resultWithPlaceHolder.join(","); auto pairScalar= finalScalarResult(); @@ -1236,7 +1241,8 @@ QString ParsingToolBox::replacePlaceHolderFromJson(const QString& source, const instructionResult.push_back(map); } std::transform(std::begin(instructionResult), std::end(instructionResult), std::back_inserter(resultList), - [](const std::vector<std::pair<int, QList<QStringList>>>& map) { + [](const std::vector<std::pair<int, QList<QStringList>>>& map) + { QStringList valuesStr; auto multiKey= (map.size() > 1); for(auto item : map) @@ -1284,18 +1290,21 @@ QString ParsingToolBox::replacePlaceHolderToValue(const QString& source, const Q QStringList resultList; std::transform( std::begin(list), std::end(list), std::back_inserter(resultList), - [removeUnhighlighted, colorize](const ExportedDiceResult& dice) { + [removeUnhighlighted, colorize](const ExportedDiceResult& dice) + { QStringList valuesStr; if(dice.size() == 1) { auto values= dice.values(); std::transform( std::begin(values), std::end(values), std::back_inserter(valuesStr), - [removeUnhighlighted, colorize](const QList<ListDiceResult>& dice) { + [removeUnhighlighted, colorize](const QList<ListDiceResult>& dice) + { QStringList textList; std::transform( std::begin(dice), std::end(dice), std::back_inserter(textList), - [removeUnhighlighted, colorize](const ListDiceResult& dice) { + [removeUnhighlighted, colorize](const ListDiceResult& dice) + { QStringList list; ListDiceResult values= dice; if(removeUnhighlighted) @@ -1306,9 +1315,8 @@ QString ParsingToolBox::replacePlaceHolderToValue(const QString& source, const Q } std::transform(std::begin(values), std::end(values), std::back_inserter(list), - [colorize](const HighLightDice& hl) { - return colorize(hl.getResultString(), {}, hl.isHighlighted()); - }); + [colorize](const HighLightDice& hl) + { return colorize(hl.getResultString(), {}, hl.isHighlighted()); }); return list.join(","); }); textList.removeAll(QString()); @@ -1931,7 +1939,7 @@ ExplodeDiceNode* ParsingToolBox::addExplodeDiceNode(qint64 value, ExecutionNode* BooleanCondition* condition= new BooleanCondition(); condition->setConditionType(Dice::OnEach); condition->setValueNode(node); - condition->setOperator(BooleanCondition::Equal); + condition->setOperator(Dice::CompareOperator::Equal); auto valList= new ValidatorList(); valList->setValidators(QList<Validator*>() << condition); auto validity= isValidValidator(previous, valList); @@ -2003,7 +2011,7 @@ bool ParsingToolBox::readBlocInstruction(QString& str, ExecutionNode*& resultnod { str= str.remove(0, 1); ExecutionNode* node= nullptr; - Die::ArithmeticOperator op; + Dice::ArithmeticOperator op; ScalarOperatorNode* scalarNode= nullptr; if(readArithmeticOperator(str, op)) { @@ -2041,7 +2049,7 @@ bool ParsingToolBox::readDice(QString& str, ExecutionNode*& node) qint64 max; qint64 min; bool unique= (ParsingToolBox::UNIQUE == readListOperator(str)) ? true : false; - Die::ArithmeticOperator op; + Dice::ArithmeticOperator op; bool hasOp= readArithmeticOperator(str, op); if(readNumber(str, max)) @@ -2201,7 +2209,7 @@ bool ParsingToolBox::readOperator(QString& str, ExecutionNode* previous) return result; } - Die::ArithmeticOperator op; + Dice::ArithmeticOperator op; if(readArithmeticOperator(str, op)) { ScalarOperatorNode* node= new ScalarOperatorNode(); diff --git a/qmltypesregister.cpp b/qmltypesregister.cpp index cc207e9..dbd2ac9 100644 --- a/qmltypesregister.cpp +++ b/qmltypesregister.cpp @@ -17,11 +17,11 @@ * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ -#include "qmltypesregister.h" +#include <diceparser_qobject/qmltypesregister.h> #include <QQmlEngine> -#include "diceroller.h" +#include <diceparser_qobject/diceroller.h> #if !defined(UNIT_TEST) && defined(RCSE) #include "field.h" #endif diff --git a/result/diceresult.cpp b/result/diceresult.cpp index 2f13210..31e316b 100644 --- a/result/diceresult.cpp +++ b/result/diceresult.cpp @@ -23,7 +23,7 @@ #include "diceresult.h" #include <QDebug> -DiceResult::DiceResult() : m_operator(Die::PLUS) +DiceResult::DiceResult() { m_resultTypes= (static_cast<int>(Dice::RESULT_TYPE::DICE_LIST) | static_cast<int>(Dice::RESULT_TYPE::SCALAR)); m_homogeneous= true; @@ -107,20 +107,20 @@ qreal DiceResult::getScalarResult() { switch(m_operator) { - case Die::PLUS: + case Dice::ArithmeticOperator::PLUS: scalar+= tmp->getValue(); break; - case Die::MULTIPLICATION: + case Dice::ArithmeticOperator::MULTIPLICATION: scalar*= tmp->getValue(); break; - case Die::MINUS: + case Dice::ArithmeticOperator::MINUS: scalar-= tmp->getValue(); break; - case Die::POW: + case Dice::ArithmeticOperator::POW: scalar= static_cast<int>(pow(static_cast<double>(scalar), static_cast<double>(tmp->getValue()))); break; - case Die::DIVIDE: - case Die::INTEGER_DIVIDE: + case Dice::ArithmeticOperator::DIVIDE: + case Dice::ArithmeticOperator::INTEGER_DIVIDE: if(tmp->getValue() != 0) { scalar/= tmp->getValue(); @@ -142,7 +142,7 @@ qreal DiceResult::getScalarResult() } } -Die::ArithmeticOperator DiceResult::getOperator() const +Dice::ArithmeticOperator DiceResult::getOperator() const { return m_operator; } @@ -152,7 +152,7 @@ void DiceResult::clear() m_diceValues.clear(); } -void DiceResult::setOperator(const Die::ArithmeticOperator& dieOperator) +void DiceResult::setOperator(const Dice::ArithmeticOperator& dieOperator) { m_operator= dieOperator; } diff --git a/result/diceresult.h b/result/diceresult.h index 8f15d3b..1b35b7e 100644 --- a/result/diceresult.h +++ b/result/diceresult.h @@ -24,6 +24,7 @@ #include <QList> #include <functional> +#include "diceparser/diceparserhelper.h" #include "die.h" #include "result.h" /** @@ -76,8 +77,8 @@ public: */ virtual void setHomogeneous(bool); - Die::ArithmeticOperator getOperator() const; - void setOperator(const Die::ArithmeticOperator& dieOperator); + Dice::ArithmeticOperator getOperator() const; + void setOperator(const Dice::ArithmeticOperator& dieOperator); bool contains(Die* die, const std::function<bool(const Die*, const Die*)> equal); void clear() override; @@ -90,7 +91,7 @@ protected: protected: QList<Die*> m_diceValues; bool m_homogeneous; - Die::ArithmeticOperator m_operator= Die::ArithmeticOperator::PLUS; + Dice::ArithmeticOperator m_operator{Dice::ArithmeticOperator::PLUS}; }; Q_DECLARE_METATYPE(QList<Die*>) #endif // DICERESULT_H diff --git a/result/result.h b/result/result.h index e86ed1f..4432682 100644 --- a/result/result.h +++ b/result/result.h @@ -22,9 +22,9 @@ #ifndef RESULT_H #define RESULT_H -#include "diceparserhelper.h" #include <QString> #include <QVariant> +#include <diceparser/diceparserhelper.h> /** * @brief The Result class */ diff --git a/tests/dice/CMakeLists.txt b/tests/dice/CMakeLists.txt index 35f255b..f07fa71 100644 --- a/tests/dice/CMakeLists.txt +++ b/tests/dice/CMakeLists.txt @@ -1,4 +1,4 @@ -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-permissive -pedantic -Wall -Wextra") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-permissive -pedantic -Wall") set(CMAKE_AUTOMOC ON) find_package(Qt6 ${QT_REQUIRED_VERSION} CONFIG REQUIRED COMPONENTS Core Gui Svg Test) diff --git a/validator.h b/validator.h index 7180bac..ca15f67 100644 --- a/validator.h +++ b/validator.h @@ -22,7 +22,8 @@ #ifndef VALIDATOR_H #define VALIDATOR_H -#include "diceparserhelper.h" +#include <diceparser/diceparserhelper.h> + #include "die.h" #include <QString> #include <Qt> diff --git a/validatorlist.cpp b/validatorlist.cpp index cb650df..f1d1ba4 100644 --- a/validatorlist.cpp +++ b/validatorlist.cpp @@ -140,7 +140,7 @@ qint64 ValidatorList::hasValid(Die* b, bool recursive, bool unhighlight) const { switch(m_operators.at(i - 1)) { - case OR: + case Dice::LogicOperation::OR: sum|= val; if(highLight) @@ -148,10 +148,10 @@ qint64 ValidatorList::hasValid(Die* b, bool recursive, bool unhighlight) const b->setHighlighted(highLight); } break; - case EXCLUSIVE_OR: + case Dice::LogicOperation::EXCLUSIVE_OR: sum^= val; /// @todo may required to be done by hand break; - case AND: + case Dice::LogicOperation::AND: sum&= val; break; default: @@ -227,9 +227,9 @@ Dice::CONDITION_STATE testXOR(Dice::CONDITION_STATE before, Dice::CONDITION_STAT Dice::CONDITION_STATE ValidatorList::isValidRangeSize(const std::pair<qint64, qint64>& range) const { std::vector<Dice::CONDITION_STATE> vec; - std::transform( - m_validatorList.begin(), m_validatorList.end(), std::back_inserter(vec), - [range](Validator* validator) -> Dice::CONDITION_STATE { return validator->isValidRangeSize(range); }); + std::transform(m_validatorList.begin(), m_validatorList.end(), std::back_inserter(vec), + [range](Validator* validator) -> Dice::CONDITION_STATE + { return validator->isValidRangeSize(range); }); auto itError= std::find(vec.begin(), vec.end(), Dice::CONDITION_STATE::ERROR_STATE); @@ -252,16 +252,16 @@ Dice::CONDITION_STATE ValidatorList::isValidRangeSize(const std::pair<qint64, qi } switch(op) { - case OR: + case Dice::LogicOperation::OR: val= testAND(val, currentState); break; - case EXCLUSIVE_OR: + case Dice::LogicOperation::EXCLUSIVE_OR: val= testOR(val, currentState); break; - case AND: + case Dice::LogicOperation::AND: val= testXOR(val, currentState); break; - case NONE: + case Dice::LogicOperation::NONE: val= Dice::CONDITION_STATE::ERROR_STATE; break; } @@ -271,7 +271,7 @@ Dice::CONDITION_STATE ValidatorList::isValidRangeSize(const std::pair<qint64, qi return val; } -void ValidatorList::setOperationList(const QVector<LogicOperation>& m) +void ValidatorList::setOperationList(const QVector<Dice::LogicOperation>& m) { m_operators= m; } @@ -353,9 +353,9 @@ void ValidatorList::validResult(Result* result, bool recursive, bool unlight, if(nullptr == diceResult) break; auto diceList= diceResult->getResultList(); - auto all= std::all_of(diceList.begin(), diceList.end(), [validator, recursive, unlight](Die* die) { - return validator->hasValid(die, recursive, unlight); - }); + auto all= std::all_of(diceList.begin(), diceList.end(), + [validator, recursive, unlight](Die* die) + { return validator->hasValid(die, recursive, unlight); }); if(all) { validResult.setAllTrue(true); @@ -372,9 +372,9 @@ void ValidatorList::validResult(Result* result, bool recursive, bool unlight, if(nullptr == diceResult) break; auto diceList= diceResult->getResultList(); - auto any= std::any_of(diceList.begin(), diceList.end(), [validator, recursive, unlight](Die* die) { - return validator->hasValid(die, recursive, unlight); - }); + auto any= std::any_of(diceList.begin(), diceList.end(), + [validator, recursive, unlight](Die* die) + { return validator->hasValid(die, recursive, unlight); }); if(any) { validResult.setAllTrue(true); @@ -409,16 +409,16 @@ void ValidatorList::validResult(Result* result, bool recursive, bool unlight, auto op= m_operators.at(id); switch(op) { - case OR: + case Dice::LogicOperation::OR: std::copy(diceList.begin(), diceList.end(), std::back_inserter(finalResult.validDiceRef())); break; - case AND: + case Dice::LogicOperation::AND: mergeResultsAsAND(vec, finalResult); break; - case EXCLUSIVE_OR: + case Dice::LogicOperation::EXCLUSIVE_OR: mergeResultsAsExeclusiveOR(vec, finalResult); break; - case NONE: + case Dice::LogicOperation::NONE: break; } } @@ -432,9 +432,10 @@ void ValidatorList::validResult(Result* result, bool recursive, bool unlight, if(nullptr == diceResult) return; auto diceList= diceResult->getResultList(); - std::transform(diceList.begin(), diceList.end(), std::back_inserter(finalResult.validDiceRef()), [](Die* die) { - return std::pair<Die*, qint64>({die, 0}); - }); + std::transform(diceList.begin(), diceList.end(), std::back_inserter(finalResult.validDiceRef()), + [](Die* die) { + return std::pair<Die*, qint64>({die, 0}); + }); } for(auto die : finalResult.validDice()) diff --git a/validatorlist.h b/validatorlist.h index 1faf7e6..ad2c9d4 100644 --- a/validatorlist.h +++ b/validatorlist.h @@ -27,7 +27,7 @@ #include <QVector> #include <Qt> -#include "diceparserhelper.h" +#include <diceparser/diceparserhelper.h> #include <functional> class Validator; @@ -75,20 +75,12 @@ private: class ValidatorList { public: - enum LogicOperation - { - OR, - EXCLUSIVE_OR, - AND, - NONE - }; - ValidatorList(); virtual ~ValidatorList(); virtual qint64 hasValid(Die* b, bool recursive, bool unhighlight= false) const; - void setOperationList(const QVector<LogicOperation>& m); + void setOperationList(const QVector<Dice::LogicOperation>& m); void setValidators(const QList<Validator*>& valids); QString toString(); @@ -100,7 +92,7 @@ public: void validResult(Result* result, bool recursive, bool unlight, std::function<void(Die*, qint64)> functor) const; private: - QVector<LogicOperation> m_operators; + QVector<Dice::LogicOperation> m_operators; QList<Validator*> m_validatorList; }; |