summaryrefslogtreecommitdiffstats
path: root/src/uscxml/plugins/datamodel/null/NULLDataModel.cpp
blob: 691148014d4b2b64cdccbeb74ca71791fd297fd5 (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
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
#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::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;
}

}