blob: 083172e1e5ae792a1554335e1d7244d8ce2e59ce (
plain)
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
|
#include "NumericNodes.hpp"
#include "Model/Workflow/Evaluation.hpp"
#include "Model/Workflow/Values/BasicValues.hpp"
#include "Utils/Macros.hpp"
#include "Utils/RTTI.hpp"
#include <cassert>
#include <utility>
WorkflowNode::Kind NumericOperationNode::OperationTypeToNodeKind(OperationType type)
{
switch (type) {
case Addition: return KD_NumericAddition;
case Subtraction: return KD_NumericSubtraction;
case Multiplication: return KD_NumericMultiplication;
case Division: return KD_NumericDivision;
default: return InvalidKind;
}
}
NumericOperationNode::OperationType NumericOperationNode::NodeKindToOperationType(Kind kind)
{
switch (kind) {
case KD_NumericAddition: return Addition;
case KD_NumericSubtraction: return Subtraction;
case KD_NumericMultiplication: return Multiplication;
case KD_NumericDivision: return Division;
default: return InvalidType;
}
}
bool NumericOperationNode::IsInstance(const WorkflowNode* node)
{
return node->GetKind() >= KD_NumericAddition && node->GetKind() <= KD_NumericDivision;
}
NumericOperationNode::NumericOperationNode(OperationType type)
: WorkflowNode(OperationTypeToNodeKind(type))
, mType{ type }
{
mInputs.resize(2);
mInputs[0].MatchingType = BaseValue::KD_Numeric;
mInputs[1].MatchingType = BaseValue::KD_Numeric;
mOutputs.resize(1);
mOutputs[0].MatchingType = BaseValue::KD_Numeric;
}
void NumericOperationNode::Evaluate(WorkflowEvaluationContext& ctx)
{
auto lhsVal = dyn_cast<NumericValue>(ctx.GetConnectionValue(mInputs[0]));
if (!lhsVal) return;
double lhs = lhsVal->GetValue();
auto rhsVal = dyn_cast<NumericValue>(ctx.GetConnectionValue(mInputs[1]));
if (!rhsVal) return;
double rhs = rhsVal->GetValue();
double res;
switch (mType) {
case Addition: res = lhs + rhs; break;
case Subtraction: res = lhs - rhs; break;
case Multiplication: res = lhs * rhs; break;
case Division: {
if (rhs == 0.0) {
// TODO localize
ctx.ReportError("Error: division by 0", *this);
return;
}
res = lhs / rhs;
} break;
default: return;
}
auto value = std::make_unique<NumericValue>();
value->SetValue(res);
ctx.SetConnectionValue(mOutputs[0], std::move(value));
}
bool NumericExpressionNode::IsInstance(const WorkflowNode* node)
{
return node->GetKind() == KD_NumericExpression;
}
NumericExpressionNode::NumericExpressionNode()
: WorkflowNode(KD_NumericExpression)
{
}
void NumericExpressionNode::Evaluate(WorkflowEvaluationContext& ctx)
{
}
|
