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
|
#include "Evaluation.hpp"
#include <queue>
namespace {
enum class EvaluationStatus {
Unevaluated,
Success,
Failed,
};
} // namespace
struct WorkflowEvaluationContext::RuntimeNode {
EvaluationStatus Status = EvaluationStatus::Unevaluated;
};
struct WorkflowEvaluationContext::RuntimeConnection {
std::unique_ptr<BaseValue> Value;
bool IsAvailableValue() const {
return Value != nullptr;
}
};
WorkflowEvaluationContext::WorkflowEvaluationContext(Workflow& workflow)
: mWorkflow{ &workflow } {
mRuntimeNodes.resize(workflow.mNodes.size());
mRuntimeConnections.resize(workflow.mConnections.size());
}
BaseValue* WorkflowEvaluationContext::GetConnectionValue(size_t id, bool constant) {
if (constant) {
return mWorkflow->GetConstantById(id);
} else {
return mRuntimeConnections[id].Value.get();
}
}
BaseValue* WorkflowEvaluationContext::GetConnectionValue(const WorkflowNode::InputPin& inputPin) {
if (inputPin.IsConnected()) {
return GetConnectionValue(inputPin.Connection, inputPin.IsConstantConnection());
} else {
return nullptr;
}
}
void WorkflowEvaluationContext::SetConnectionValue(size_t id, std::unique_ptr<BaseValue> value) {
mRuntimeConnections[id].Value = std::move(value);
}
void WorkflowEvaluationContext::SetConnectionValue(const WorkflowNode::OutputPin& outputPin, std::unique_ptr<BaseValue> value) {
if (outputPin.IsConnected()) {
SetConnectionValue(outputPin.Connection, std::move(value));
}
}
void WorkflowEvaluationContext::Run() {
int evaluatedCount = 0;
int erroredCount = 0;
for (auto& depthGroup : mWorkflow->GetDepthGroups()) {
for (size_t idx : depthGroup) {
auto& rn = mRuntimeNodes[idx];
auto& n = *mWorkflow->mNodes[idx];
// TODO
int preEvalErrors = mErrors.size();
n.Evaluate(*this);
if (preEvalErrors != mErrors.size()) {
erroredCount++;
} else {
evaluatedCount++;
}
}
}
for (size_t i = 0; i < mRuntimeNodes.size(); ++i) {
auto& rn = mRuntimeNodes[i];
auto& n = *mWorkflow->mNodes[i];
if (n.GetType() == WorkflowNode::OutputType) {
// TODO record outputs
}
}
}
void WorkflowEvaluationContext::ReportError(std::string message, const WorkflowNode& node, int pinId, bool inputPin) {
mErrors.push_back(WorkflowEvaluationError{
.Message = std::move(message),
.NodeId = node.GetId(),
.PinId = pinId,
.PinType = inputPin ? WorkflowEvaluationError::InputPin : WorkflowEvaluationError::OutputPin,
.Type = WorkflowEvaluationError::Error,
});
}
void WorkflowEvaluationContext::ReportError(std::string message, const WorkflowNode& node) {
mErrors.push_back(WorkflowEvaluationError{
.Message = std::move(message),
.NodeId = node.GetId(),
.PinId = -1,
.PinType = WorkflowEvaluationError::NoPin,
.Type = WorkflowEvaluationError::Error,
});
}
void WorkflowEvaluationContext::ReportWarning(std::string message, const WorkflowNode& node, int pinId, bool inputPin) {
mErrors.push_back(WorkflowEvaluationError{
.Message = std::move(message),
.NodeId = node.GetId(),
.PinId = pinId,
.PinType = inputPin ? WorkflowEvaluationError::InputPin : WorkflowEvaluationError::OutputPin,
.Type = WorkflowEvaluationError::Warning,
});
}
void WorkflowEvaluationContext::ReportWarning(std::string message, const WorkflowNode& node) {
mErrors.push_back(WorkflowEvaluationError{
.Message = std::move(message),
.NodeId = node.GetId(),
.PinId = -1,
.PinType = WorkflowEvaluationError::NoPin,
.Type = WorkflowEvaluationError::Warning,
});
}
|
