Major Refactoring v2.0

1 files changed, 361 insertions, 0 deletions

diff --git a/src/uscxml/interpreter/InterpreterImpl.cpp b/src/uscxml/interpreter/InterpreterImpl.cpp
new file mode 100644
index 0000000..ba75ab8
--- /dev/null
+++ b/src/uscxml/interpreter/InterpreterImpl.cpp
@@ -0,0 +1,361 @@
+/**
+ *  @file
+ *  @author     2012-2013 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de)
+ *  @copyright  Simplified BSD
+ *
+ *  @cond
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the FreeBSD license as published by the FreeBSD
+ *  project.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *  You should have received a copy of the FreeBSD license along with this
+ *  program. If not, see <http://www.opensource.org/licenses/bsd-license>.
+ *  @endcond
+ */
+
+#include "uscxml/Common.h"
+#include "uscxml/util/UUID.h"
+#include "uscxml/Interpreter.h"
+#include "uscxml/messages/Event.h"
+#include "uscxml/util/String.h"
+#include "uscxml/util/Predicates.h"
+
+#include "easylogging++.h"
+
+#include <iostream>
+
+#include <assert.h>
+#include <algorithm>
+#include <memory>
+#include <mutex>
+
+#include "uscxml/interpreter/MicroStepFast.h"
+
+#define VERBOSE 0
+
+namespace uscxml {
+
+using namespace xercesc;
+
+std::map<std::string, std::weak_ptr<InterpreterImpl> > InterpreterImpl::_instances;
+std::recursive_mutex InterpreterImpl::_instanceMutex;
+
+std::map<std::string, std::weak_ptr<InterpreterImpl> > InterpreterImpl::getInstances() {
+	std::lock_guard<std::recursive_mutex> lock(_instanceMutex);
+	std::map<std::string, std::weak_ptr<InterpreterImpl> >::iterator instIter = _instances.begin();
+	while(instIter != _instances.end()) {
+		if (!instIter->second.lock()) {
+			_instances.erase(instIter++);
+		} else {
+			instIter++;
+		}
+	}
+	return _instances;
+}
+
+void InterpreterImpl::addInstance(std::shared_ptr<InterpreterImpl> interpreterImpl) {
+	std::lock_guard<std::recursive_mutex> lock(_instanceMutex);
+	assert(_instances.find(interpreterImpl->getSessionId()) == _instances.end());
+	_instances[interpreterImpl->getSessionId()] = interpreterImpl;
+}
+
+InterpreterImpl::InterpreterImpl() : _isInitialized(false), _document(NULL), _scxml(NULL), _state(USCXML_INSTANTIATED), _monitor(NULL) {
+	try {
+		xercesc::XMLPlatformUtils::Initialize();
+	} catch (const xercesc::XMLException& toCatch) {
+		ERROR_PLATFORM_THROW("Cannot initialize XercesC: " + X(toCatch.getMessage()).str());
+	}
+
+	_sessionId = UUID::getUUID();
+	_factory = Factory::getInstance();
+}
+
+
+InterpreterImpl::~InterpreterImpl() {
+	if (_delayQueue)
+		_delayQueue.cancelAllDelayed();
+	if (_document)
+		delete _document;
+	{
+		std::lock_guard<std::recursive_mutex> lock(_instanceMutex);
+		_instances.erase(getSessionId());
+	}
+}
+
+void InterpreterImpl::cancel() {
+	_microStepper.markAsCancelled();
+	Event unblock;
+	enqueueExternal(unblock);
+}
+
+
+void InterpreterImpl::setupDOM() {
+
+	if (!_document) {
+		ERROR_PLATFORM_THROW("Interpreter has no XML document");
+	}
+
+	if (!_scxml) {
+		// find scxml element
+		DOMNodeList* scxmls = NULL;
+
+		// proper namespace
+		scxmls = _document->getElementsByTagNameNS(X("http://www.w3.org/2005/07/scxml"), X("scxml"));
+		if (scxmls->getLength() > 0)
+			goto SCXML_STOP_SEARCH;
+
+		// no namespace
+		scxmls = _document->getElementsByTagName(X("scxml"));
+		if (scxmls->getLength() > 0)
+			goto SCXML_STOP_SEARCH;
+
+SCXML_STOP_SEARCH:
+		if (scxmls->getLength() == 0) {
+			ERROR_PLATFORM_THROW("Cannot find SCXML element in DOM");
+			return;
+		}
+
+		_scxml = dynamic_cast<DOMElement*>(scxmls->item(0));
+
+		_xmlPrefix = _scxml->getPrefix();
+		_xmlNS = _scxml->getNamespaceURI();
+		if (_xmlPrefix) {
+			_xmlPrefix = std::string(_xmlPrefix) + ":";
+		}
+		if (HAS_ATTR(_scxml, "name")) {
+			_name = ATTR(_scxml, "name");
+		} else {
+			_name = _baseURL.pathComponents().back();
+		}
+
+		_binding = (HAS_ATTR(_scxml, "binding") && iequals(ATTR(_scxml, "binding"), "late") ? LATE : EARLY);
+
+	}
+
+}
+
+void InterpreterImpl::init() {
+
+	if (_isInitialized)
+		return;
+
+	setupDOM();
+
+	// register io processors
+	std::map<std::string, IOProcessorImpl*> ioProcs = _factory->getIOProcessors();
+	for (auto ioProcIter = ioProcs.begin(); ioProcIter != ioProcs.end(); ioProcIter++) {
+
+		// do not override if already set
+		if (_ioProcs.find(ioProcIter->first) != _ioProcs.end()) {
+			ioProcIter++;
+			continue;
+		}
+
+		// this might throw error.execution
+		_ioProcs[ioProcIter->first] = _factory->createIOProcessor(ioProcIter->first, this);
+
+		// register aliases
+		std::list<std::string> names = _ioProcs[ioProcIter->first].getNames();
+		for (auto nameIter = names.begin(); nameIter != names.end(); nameIter++) {
+			// do not override
+			if (!iequals(*nameIter, ioProcIter->first) && _ioProcs.find(*nameIter) == _ioProcs.end()) {
+				_ioProcs[*nameIter] = _ioProcs[ioProcIter->first];
+			}
+		}
+
+	}
+
+	if (!_microStepper) {
+		_microStepper = MicroStep(std::shared_ptr<MicroStepImpl>(new MicroStepFast(this)));
+	}
+	_microStepper.init(_scxml);
+
+	if (!_dataModel) {
+		_dataModel = _factory->createDataModel(HAS_ATTR(_scxml, "datamodel") ? ATTR(_scxml, "datamodel") : "null", this);
+	}
+	if (!_execContent) {
+		_execContent = ContentExecutor(std::shared_ptr<ContentExecutorImpl>(new BasicContentExecutorImpl(this)));
+	}
+
+	if (!_externalQueue) {
+		_externalQueue = EventQueue(std::shared_ptr<EventQueueImpl>(new EventQueueImpl()));
+	}
+	if (!_internalQueue) {
+		_internalQueue = EventQueue(std::shared_ptr<EventQueueImpl>(new EventQueueImpl()));
+	}
+	if (!_delayQueue) {
+		_delayQueue = DelayedEventQueue(std::shared_ptr<DelayedEventQueueImpl>(new DelayedEventQueueImpl(this)));
+	}
+
+	_isInitialized = true;
+}
+
+void InterpreterImpl::initData(xercesc::DOMElement* root) {
+	std::string id = ATTR(root, "id");
+	Data d;
+	try {
+		if (Event::getParam(_invokeReq.params, id, d)) {
+			_dataModel.init(id, d);
+		} else if (_invokeReq.namelist.find(id) != _invokeReq.namelist.end()) {
+			_dataModel.init(id, _invokeReq.namelist[id]);
+		} else {
+			_dataModel.init(id, _execContent.elementAsData(root));
+		}
+	} catch(ErrorEvent e) {
+		// test 277
+		enqueueInternal(e);
+	}
+}
+
+void InterpreterImpl::assign(const std::string& location, const Data& data) {
+	_dataModel.assign(location, data);
+}
+
+bool InterpreterImpl::isMatched(const Event& event, const std::string& eventDesc) {
+	return nameMatch(eventDesc, event.name);
+}
+
+bool InterpreterImpl::isTrue(const std::string& expr) {
+	try {
+		return _dataModel.evalAsBool(expr);
+	} catch (ErrorEvent e) {
+		// test 244: deliver error execution
+
+		LOG(ERROR) << e;
+
+		// test 344
+		enqueueInternal(e);
+		// test 245: undefined is false
+		return false;
+
+	}
+}
+
+
+bool InterpreterImpl::checkValidSendType(const std::string& type, const std::string& target) {
+
+	// this is the responsibility of the calling method
+	assert(type.size() > 0);
+
+	if (_ioProcs.find(type) == _ioProcs.end()) {
+		ERROR_EXECUTION_THROW("Type '" + type + "' not supported for sending");
+	}
+
+	if (!_ioProcs[type].isValidTarget(target)) {
+		ERROR_COMMUNICATION_THROW("Target '" + target + "' not supported in send");
+	}
+
+	return true;
+}
+
+Event InterpreterImpl::dequeueExternal(bool blocking) {
+	_currEvent = _externalQueue.dequeue(blocking);
+	if (_currEvent) {
+		_dataModel.setEvent(_currEvent);
+
+//		LOG(ERROR) << e.name;
+
+		// test 233
+		if (_currEvent.invokeid.size() > 0 &&
+		        _invokers.find(_currEvent.invokeid) != _invokers.end() &&
+		        _invokers[_currEvent.invokeid].getFinalize() != NULL) {
+			_execContent.process(_invokers[_currEvent.invokeid].getFinalize(), _xmlPrefix);
+		}
+
+		for (auto invIter = _invokers.begin(); invIter != _invokers.end(); invIter++) {
+			// test 229
+			if (_autoForwarders.find(invIter->first) != _autoForwarders.end()) {
+				invIter->second.eventFromSCXML(_currEvent);
+			}
+		}
+	}
+	return _currEvent;
+}
+
+void InterpreterImpl::enqueue(const std::string& type, const std::string& target, size_t delayMs, const Event& sendEvent) {
+	std::lock_guard<std::recursive_mutex> lock(_delayMutex);
+
+	assert(sendEvent.uuid.length() > 0);
+	assert(_delayedEventTargets.find(sendEvent.uuid) == _delayedEventTargets.end());
+
+	_delayedEventTargets[sendEvent.uuid] = std::tuple<std::string, std::string, std::string>(sendEvent.sendid, type, target);
+	if (delayMs == 0) {
+		Event copy(sendEvent);
+		return eventReady(copy, sendEvent.uuid);
+	} else {
+		return _delayQueue.enqueueDelayed(sendEvent, delayMs, sendEvent.uuid);
+	}
+}
+
+void InterpreterImpl::cancelDelayed(const std::string& sendId) {
+	std::lock_guard<std::recursive_mutex> lock(_delayMutex);
+
+	// we need to find the uuids for the given sendid
+	for (auto evIter = _delayedEventTargets.begin(); evIter != _delayedEventTargets.end();) {
+		// inline deletion for maps: http://stackoverflow.com/a/263958/990120
+		if (std::get<0>(evIter->second) == sendId) {
+			_delayQueue.cancelDelayed(evIter->first);
+			evIter = _delayedEventTargets.erase(evIter);
+		} else {
+			evIter++;
+		}
+	}
+}
+
+void InterpreterImpl::eventReady(Event& sendEvent, const std::string& eventUUID) {
+	std::lock_guard<std::recursive_mutex> lock(_delayMutex);
+
+	// we only arrive here after the delay already passed!
+	assert(_delayedEventTargets.find(eventUUID) != _delayedEventTargets.end());
+
+	std::string type = std::get<1>(_delayedEventTargets[eventUUID]);
+	std::string target = std::get<2>(_delayedEventTargets[eventUUID]);
+
+	// test 172
+	if (type.size() == 0) {
+		type = "http://www.w3.org/TR/scxml/#SCXMLEventProcessor";
+	}
+
+	_delayedEventTargets.erase(eventUUID);
+
+	if (_ioProcs.find(type) != _ioProcs.end()) {
+		_ioProcs[type].eventFromSCXML(target, sendEvent);
+	} else {
+		ERROR_PLATFORM_THROW("No IO processor " + type + " known");
+	}
+}
+
+void InterpreterImpl::invoke(const std::string& type, const std::string& src, bool autoForward, xercesc::DOMElement* finalize, const Event& invokeEvent) {
+
+	std::string tmp;
+	if (src.size() > 0) {
+		URL url(src);
+		if (!url.isAbsolute()) {
+			url = URL::resolve(url, _baseURL);
+		}
+		tmp = (std::string)url;
+	}
+
+	std::shared_ptr<InvokerImpl> invokerImpl = _factory->createInvoker(type, this);
+	invokerImpl->setFinalize(finalize);
+	_invokers[invokeEvent.invokeid] = invokerImpl;
+	_invokers[invokeEvent.invokeid].invoke(tmp, invokeEvent);
+
+	if (autoForward) {
+		_autoForwarders.insert(invokeEvent.invokeid);
+	}
+}
+
+void InterpreterImpl::uninvoke(const std::string& invokeId) {
+	if (_invokers.find(invokeId) != _invokers.end()) {
+		_invokers[invokeId].uninvoke();
+		_autoForwarders.erase(invokeId);
+	}
+
+}
+
+}