1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
#include "executionnode.h"
#include <QUuid>
namespace
{
#ifdef QT_DEBUG
constexpr int WaitingTime{2 * 1000 * 60};
#else
constexpr int WaitingTime{30 * 60 * 1000};
#endif
} // namespace
ExecutionNode::ExecutionNode(const QString& label)
: m_previousNode(nullptr)
, m_result(nullptr)
, m_nextNode(nullptr)
, m_errors(QMap<Dice::ERROR_CODE, QString>())
, m_id(QString("\"%1\"").arg(QUuid::createUuid().toString()))
, m_label(label)
{
}
ExecutionNode::~ExecutionNode()
{
if(nullptr != m_result)
{
delete m_result;
m_result= nullptr;
}
if(nullptr != m_nextNode)
{
delete m_nextNode;
m_nextNode= nullptr;
}
}
Result* ExecutionNode::getResult()
{
return m_result;
}
void ExecutionNode::setNextNode(ExecutionNode* node)
{
m_nextNode= node;
}
void ExecutionNode::setPreviousNode(ExecutionNode* node)
{
m_previousNode= node;
}
QString ExecutionNode::toString(bool withLabel) const
{
if(withLabel)
{
return m_label.arg(m_id);
}
else
{
return m_id;
}
}
ExecutionNode* ExecutionNode::getNextNode()
{
return m_nextNode;
}
void ExecutionNode::execute(ExecutionNode* previous)
{
QElapsedTimer timer;
timer.start();
auto errorCount= m_errors.count();
run(previous);
auto timeLimit= timer.hasExpired(WaitingTime);
if(m_nextNode && errorCount == m_errors.count() && !timeLimit)
m_nextNode->execute(this);
else if(timeLimit)
qDebug() << "Error too long" << WaitingTime << timeLimit << timer.elapsed();
}
QMap<Dice::ERROR_CODE, QString> ExecutionNode::getExecutionErrorMap()
{
if(nullptr != m_nextNode)
{
auto const& keys= m_nextNode->getExecutionErrorMap().keys();
for(auto& key : keys)
{
m_errors.insert(key, m_nextNode->getExecutionErrorMap().value(key));
}
}
return m_errors;
}
QString ExecutionNode::getHelp()
{
return QString();
}
ExecutionNode* ExecutionNode::getPreviousNode() const
{
return m_previousNode;
}
void ExecutionNode::generateDotTree(QString& s)
{
auto str= toString(true);
if(s.contains(str))
return;
s.append(toString(true));
s.append(";\n");
if(nullptr != m_nextNode)
{
s.append(toString(false));
s.append(" -> ");
s.append(m_nextNode->toString(false));
s.append("[label=\"next\"];\n");
// s.append(" [label=\"nextNode\"];\n");
m_nextNode->generateDotTree(s);
}
else
{
s.append(toString(false));
s.append(" -> ");
s.append("nullptr;\n");
}
if(nullptr != m_result)
{
s.append(toString(false));
s.append(" ->");
s.append(m_result->toString(false));
s.append(" [label=\"Result\", style=\"dashed\"];\n");
if(nullptr == m_nextNode)
m_result->generateDotTree(s);
}
}
qint64 ExecutionNode::getScalarResult()
{
if(m_result == nullptr)
return 0;
return m_result->getResult(Dice::RESULT_TYPE::SCALAR).toInt();
}
bool ExecutionNode::isValid(bool condition, Dice::ERROR_CODE code, const QString& errorTxt, bool error)
{
if(condition)
error ? m_errors.insert(code, errorTxt) : m_warnings.insert(code, errorTxt);
return condition;
}
|