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
|
#include "uscxml/Common.h"
#include "NULLDataModel.h"
#include "uscxml/Message.h"
#include <glog/logging.h>
#ifdef BUILD_AS_PLUGINS
#include <Pluma/Connector.hpp>
#endif
namespace uscxml {
#ifdef BUILD_AS_PLUGINS
PLUMA_CONNECTOR
bool connect(pluma::Host& host) {
host.add( new NULLDataModelProvider() );
return true;
}
#endif
NULLDataModel::NULLDataModel() {
}
boost::shared_ptr<DataModelImpl> NULLDataModel::create(InterpreterImpl* interpreter) {
boost::shared_ptr<NULLDataModel> dm = boost::shared_ptr<NULLDataModel>(new NULLDataModel());
dm->_interpreter = interpreter;
return dm;
}
NULLDataModel::~NULLDataModel() {
}
void NULLDataModel::pushContext() {
}
void NULLDataModel::popContext() {
}
void NULLDataModel::initialize() {
}
void NULLDataModel::setEvent(const Event& event) {
}
Data NULLDataModel::getStringAsData(const std::string& content) {
Data data;
return data;
}
bool NULLDataModel::validate(const std::string& location, const std::string& schema) {
return true;
}
uint32_t NULLDataModel::getLength(const std::string& expr) {
return 0;
}
void NULLDataModel::setForeach(const std::string& item,
const std::string& array,
const std::string& index,
uint32_t iteration) {
}
void NULLDataModel::eval(const std::string& expr) {
}
bool NULLDataModel::isDeclared(const std::string& expr) {
return true;
}
/**
* The boolean expression language consists of the In predicate only. It has the
* form 'In(id)', where id is the id of a state in the enclosing state machine.
* The predicate must return 'true' if and only if that state is in the current
* state configuration.
*/
bool NULLDataModel::evalAsBool(const std::string& expr) {
std::string trimmedExpr = expr;
boost::trim(trimmedExpr);
if (!boost::istarts_with(trimmedExpr, "in"))
return false;
// find string in between brackets
size_t start = trimmedExpr.find_first_of("(");
size_t end = trimmedExpr.find_last_of(")");
if (start == std::string::npos || end == std::string::npos || start >= end)
return false;
start++;
// split at comma
std::stringstream ss(trimmedExpr.substr(start, end - start));
std::vector<std::string> stateExprs;
std::string item;
while(std::getline(ss, item, ',')) {
stateExprs.push_back(item);
}
for (unsigned int i = 0; i < stateExprs.size(); i++) {
// remove ticks
size_t start = stateExprs[i].find_first_of("'");
size_t end = stateExprs[i].find_last_of("'");
std::string stateName;
if (start != std::string::npos && end != std::string::npos && start < end) {
start++;
stateName = stateExprs[i].substr(start, end - start);
} else {
stateName = stateExprs[i];
}
if (Interpreter::isMember(_interpreter->getState(stateName), _interpreter->getConfiguration())) {
continue;
}
return false;
}
return true;
}
std::string NULLDataModel::evalAsString(const std::string& expr) {
return expr;
}
double NULLDataModel::evalAsNumber(const std::string& expr) {
return 0;
}
}
|
