Minor polishing for Java bindings and first draft of JEXL datamodel

10 files changed, 715 insertions, 0 deletions

diff --git a/src/bindings/swig/wrapped/WrappedDataModel.cpp b/src/bindings/swig/wrapped/WrappedDataModel.cpp
new file mode 100644
index 0000000..8ba57be
--- /dev/null
+++ b/src/bindings/swig/wrapped/WrappedDataModel.cpp
@@ -0,0 +1,27 @@
+/**
+ *  @file
+ *  @author     2012-2014 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 "WrappedDataModel.h"
+
+namespace uscxml {
+
+WrappedDataModel::WrappedDataModel() {}
+WrappedDataModel::~WrappedDataModel() {}
+
+}
\ No newline at end of file
diff --git a/src/bindings/swig/wrapped/WrappedDataModel.h b/src/bindings/swig/wrapped/WrappedDataModel.h
new file mode 100644
index 0000000..49a3482
--- /dev/null
+++ b/src/bindings/swig/wrapped/WrappedDataModel.h
@@ -0,0 +1,98 @@
+/**
+ *  @file
+ *  @author     2012-2014 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
+ */
+
+#ifndef WRAPPEDDATAMODEL_H_DBAAD6AF
+#define WRAPPEDDATAMODEL_H_DBAAD6AF
+
+#include <vector>
+#include <list>
+#include <ostream>
+#include <string>
+#include <iostream>
+
+#include <xercesc/dom/DOM.hpp>
+
+#include "../../../uscxml/plugins/DataModelImpl.h"
+
+namespace uscxml {
+
+class WrappedDataModel : public DataModelImpl {
+public:
+
+    WrappedDataModel();
+    virtual ~WrappedDataModel();
+    
+    virtual std::shared_ptr<DataModelImpl> create(DataModelCallbacks* callbacks) {
+        std::shared_ptr<WrappedDataModel> dm(create());
+        dm->callbacks = callbacks;
+        return dm;
+    }
+        
+    virtual std::list<std::string> getNames() {
+        return std::list<std::string>();
+    }
+    
+		virtual WrappedDataModel* create() {
+			return new WrappedDataModel();
+		}
+		
+    virtual bool isValidSyntax(const std::string& expr) {
+        return true;
+    }
+    
+    virtual void setEvent(const Event& event) {}
+    
+    // foreach
+    virtual uint32_t getLength(const std::string& expr) {
+        return 0;
+    }
+    
+    virtual void setForeach(const std::string& item,
+                            const std::string& array,
+                            const std::string& index,
+                            uint32_t iteration) {}
+    
+    virtual Data getAsData(const std::string& content) {
+        return Data();
+    }
+    virtual Data evalAsData(const std::string& expr) {
+        return Data();
+    }
+    virtual bool evalAsBool(const std::string& expr) {
+        return true;
+    }
+    
+    virtual bool isDeclared(const std::string& expr) {
+        return true;
+    }
+    
+    virtual void assign(const std::string& location, const Data& data) {}
+    virtual void init(const std::string& location, const Data& data) {}
+    
+    virtual std::string andExpressions(std::list<std::string>) {
+        return "";
+    }
+
+protected:
+    DataModelCallbacks* callbacks;
+};
+
+}
+
+#endif /* end of include guard: WRAPPEDDATAMODEL_H_DBAAD6AF */
diff --git a/src/bindings/swig/wrapped/WrappedExecutableContent.cpp b/src/bindings/swig/wrapped/WrappedExecutableContent.cpp
new file mode 100644
index 0000000..09aa6fd
--- /dev/null
+++ b/src/bindings/swig/wrapped/WrappedExecutableContent.cpp
@@ -0,0 +1,43 @@
+/**
+ *  @file
+ *  @author     2012-2014 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 "WrappedExecutableContent.h"
+#include "uscxml/util/DOM.h"
+#include <xercesc/dom/DOM.hpp>
+#include <ostream>
+
+namespace uscxml {
+
+WrappedExecutableContent::WrappedExecutableContent() {}
+WrappedExecutableContent::~WrappedExecutableContent() {}
+
+void WrappedExecutableContent::enterElement(XERCESC_NS::DOMElement* element) {
+    std::stringstream ss;
+    ss << *element;
+    enterElement(ss.str());
+}
+
+void WrappedExecutableContent::exitElement(XERCESC_NS::DOMElement* element) {
+    std::stringstream ss;
+    ss << *element;
+    exitElement(ss.str());
+}
+
+    
+}
\ No newline at end of file
diff --git a/src/bindings/swig/wrapped/WrappedExecutableContent.h b/src/bindings/swig/wrapped/WrappedExecutableContent.h
new file mode 100644
index 0000000..0ba8d3e
--- /dev/null
+++ b/src/bindings/swig/wrapped/WrappedExecutableContent.h
@@ -0,0 +1,66 @@
+/**
+ *  @file
+ *  @author     2012-2014 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
+ */
+
+#ifndef WRAPPEDEXECUTABLECONTENT_H_F690F480
+#define WRAPPEDEXECUTABLECONTENT_H_F690F480
+
+#include <string>
+
+
+#include "../../../uscxml/messages/Event.h"
+#include "../../../uscxml/plugins/Factory.h"
+#include "../../../uscxml/plugins/ExecutableContentImpl.h"
+
+namespace uscxml {
+
+class WrappedExecutableContent : public ExecutableContentImpl {
+public:
+	WrappedExecutableContent();
+	virtual ~WrappedExecutableContent();
+
+	virtual std::shared_ptr<ExecutableContentImpl> create(InterpreterImpl* interpreter) {
+        std::shared_ptr<WrappedExecutableContent> ec(new WrappedExecutableContent());
+        return ec;
+    }
+
+	virtual std::string getLocalName() {
+		return "";
+	}
+
+	virtual std::string getNamespace() {
+		return "http://www.w3.org/2005/07/scxml";
+	}
+
+    
+    void enterElement(XERCESC_NS::DOMElement* element);
+    virtual void enterElement(const std::string& elementXML) {}
+    
+    void exitElement(XERCESC_NS::DOMElement* element);
+    virtual void exitElement(const std::string& elementXML) {}
+
+    virtual bool processChildren() {
+        return true;
+    }
+
+};
+
+}
+
+
+#endif /* end of include guard: WRAPPEDEXECUTABLECONTENT_H_F690F480 */
diff --git a/src/bindings/swig/wrapped/WrappedIOProcessor.cpp b/src/bindings/swig/wrapped/WrappedIOProcessor.cpp
new file mode 100644
index 0000000..d034bc3
--- /dev/null
+++ b/src/bindings/swig/wrapped/WrappedIOProcessor.cpp
@@ -0,0 +1,29 @@
+/**
+ *  @file
+ *  @author     2012-2014 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 "WrappedIOProcessor.h"
+
+namespace uscxml {
+
+WrappedIOProcessor::WrappedIOProcessor(InterpreterImpl* interpreter) {
+  _interpreter = interpreter;
+}
+WrappedIOProcessor::~WrappedIOProcessor() {}
+
+}
\ No newline at end of file
diff --git a/src/bindings/swig/wrapped/WrappedIOProcessor.h b/src/bindings/swig/wrapped/WrappedIOProcessor.h
new file mode 100644
index 0000000..aa5f967
--- /dev/null
+++ b/src/bindings/swig/wrapped/WrappedIOProcessor.h
@@ -0,0 +1,64 @@
+/**
+ *  @file
+ *  @author     2012-2014 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
+ */
+
+#ifndef WRAPPEDIOPROCESSOR_H_AE98064A
+#define WRAPPEDIOPROCESSOR_H_AE98064A
+
+#include <vector>
+#include <list>
+#include <ostream>
+#include <string>
+
+#include <xercesc/dom/DOM.hpp>
+
+#include "../../../uscxml/messages/Event.h"
+#include "../../../uscxml/plugins/Factory.h"
+#include "../../../uscxml/plugins/IOProcessorImpl.h"
+#include "../../../uscxml/Interpreter.h"
+
+namespace uscxml {
+
+class WrappedIOProcessor : public IOProcessorImpl {
+public:
+	WrappedIOProcessor(InterpreterImpl* interpreter);
+	virtual ~WrappedIOProcessor();
+
+    virtual std::list<std::string> getNames() {
+        return std::list<std::string>();
+    };
+
+    virtual std::shared_ptr<IOProcessorImpl> create(InterpreterImpl* interpreter) {
+    	std::shared_ptr<IOProcessorImpl> ioProc = std::shared_ptr<IOProcessorImpl>(new WrappedIOProcessor(interpreter));
+			return ioProc;
+    }
+    
+    virtual void eventFromSCXML(const std::string& target, const Event& event) {}
+    virtual bool isValidTarget(const std::string& target) {
+        return true;
+    }
+
+    virtual Data getDataModelVariables() {
+        return Data();
+    }
+};
+
+}
+
+
+#endif /* end of include guard: WRAPPEDIOPROCESSOR_H_AE98064A */
diff --git a/src/bindings/swig/wrapped/WrappedInterpreterMonitor.cpp b/src/bindings/swig/wrapped/WrappedInterpreterMonitor.cpp
new file mode 100644
index 0000000..f066a72
--- /dev/null
+++ b/src/bindings/swig/wrapped/WrappedInterpreterMonitor.cpp
@@ -0,0 +1,147 @@
+/**
+ *  @file
+ *  @author     2012-2014 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 "WrappedInterpreterMonitor.h"
+#include "uscxml/util/Predicates.h"
+#include "uscxml/util/DOM.h"
+#include <xercesc/dom/DOM.hpp>
+#include <ostream>
+
+namespace uscxml {
+
+using namespace XERCESC_NS;
+    
+WrappedInterpreterMonitor::WrappedInterpreterMonitor() {}
+WrappedInterpreterMonitor::~WrappedInterpreterMonitor() {}
+
+void WrappedInterpreterMonitor::beforeExitingState(const XERCESC_NS::DOMElement* state) {
+    std::stringstream ss;
+    ss << *state;
+    beforeExitingState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str());
+}
+
+void WrappedInterpreterMonitor::afterExitingState(const XERCESC_NS::DOMElement* state) {
+    std::stringstream ss;
+    ss << *state;
+    afterExitingState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str());
+}
+
+void WrappedInterpreterMonitor::beforeExecutingContent(const XERCESC_NS::DOMElement* content) {
+    std::stringstream ss;
+    ss << *content;
+    beforeExecutingContent(TAGNAME(content), DOMUtils::xPathForNode(content), ss.str());
+}
+
+void WrappedInterpreterMonitor::afterExecutingContent(const XERCESC_NS::DOMElement* content) {
+    std::stringstream ss;
+    ss << *content;
+    afterExecutingContent(TAGNAME(content), DOMUtils::xPathForNode(content), ss.str());
+}
+
+void WrappedInterpreterMonitor::beforeUninvoking(const XERCESC_NS::DOMElement* invoker, const std::string& invokeid) {
+    std::stringstream ss;
+    ss << *invoker;
+    std::string invokeId;
+    if (invoker->getUserData(X("invokeid")) != NULL) {
+        invokeId = (char*)invoker->getUserData(X("invokeid"));
+    }
+
+    beforeUninvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str());
+}
+
+void WrappedInterpreterMonitor::afterUninvoking(const XERCESC_NS::DOMElement* invoker, const std::string& invokeid) {
+    std::stringstream ss;
+    ss << *invoker;
+    std::string invokeId;
+    if (invoker->getUserData(X("invokeid")) != NULL) {
+        invokeId = (char*)invoker->getUserData(X("invokeid"));
+    }
+    
+    afterUninvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str());
+}
+
+void WrappedInterpreterMonitor::beforeTakingTransition(const XERCESC_NS::DOMElement* transition) {
+    XERCESC_NS::DOMElement* sourceState = getSourceState(transition);
+    const XERCESC_NS::DOMElement* root = DOMUtils::getNearestAncestor(transition, "scxml");
+
+    std::list<XERCESC_NS::DOMElement*> targetStates = getTargetStates(transition, root);
+    
+    std::stringstream ss;
+    ss << *transition;
+    
+    std::list<std::string> targets;
+    for (auto t : targetStates) {
+        targets.push_back(ATTR_CAST(t, "id"));
+    }
+    
+    beforeTakingTransition(DOMUtils::xPathForNode(transition), ATTR_CAST(sourceState, "id"), targets, ss.str());
+}
+
+void WrappedInterpreterMonitor::afterTakingTransition(const XERCESC_NS::DOMElement* transition) {
+    XERCESC_NS::DOMElement* sourceState = getSourceState(transition);
+    const XERCESC_NS::DOMElement* root = DOMUtils::getNearestAncestor(transition, "scxml");
+    
+    std::list<XERCESC_NS::DOMElement*> targetStates = getTargetStates(transition, root);
+    
+    std::stringstream ss;
+    ss << *transition;
+    
+    std::list<std::string> targets;
+    for (auto t : targetStates) {
+        targets.push_back(ATTR_CAST(t, "id"));
+    }
+    
+    afterTakingTransition(DOMUtils::xPathForNode(transition), ATTR_CAST(sourceState, "id"), targets, ss.str());
+}
+
+void WrappedInterpreterMonitor::beforeEnteringState(const XERCESC_NS::DOMElement* state) {
+    std::stringstream ss;
+    ss << *state;
+    beforeEnteringState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str());
+}
+
+void WrappedInterpreterMonitor::afterEnteringState(const XERCESC_NS::DOMElement* state) {
+    std::stringstream ss;
+    ss << *state;
+    afterEnteringState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str());
+}
+
+void WrappedInterpreterMonitor::beforeInvoking(const XERCESC_NS::DOMElement* invoker, const std::string& invokeid) {
+    std::stringstream ss;
+    ss << *invoker;
+    std::string invokeId;
+    if (invoker->getUserData(X("invokeid")) != NULL) {
+        invokeId = (char*)invoker->getUserData(X("invokeid"));
+    }
+    
+    beforeInvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str());
+}
+
+void WrappedInterpreterMonitor::afterInvoking(const XERCESC_NS::DOMElement* invoker, const std::string& invokeid) {
+    std::stringstream ss;
+    ss << *invoker;
+    std::string invokeId;
+    if (invoker->getUserData(X("invokeid")) != NULL) {
+        invokeId = (char*)invoker->getUserData(X("invokeid"));
+    }
+    
+    afterInvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str());
+}
+
+}
\ No newline at end of file
diff --git a/src/bindings/swig/wrapped/WrappedInterpreterMonitor.h b/src/bindings/swig/wrapped/WrappedInterpreterMonitor.h
new file mode 100644
index 0000000..e83c896
--- /dev/null
+++ b/src/bindings/swig/wrapped/WrappedInterpreterMonitor.h
@@ -0,0 +1,128 @@
+/**
+ *  @file
+ *  @author     2012-2014 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
+ */
+
+#ifndef WRAPPEDINTERPRETERMONITOR_H_F5C83A0D
+#define WRAPPEDINTERPRETERMONITOR_H_F5C83A0D
+
+#include <vector>
+#include <list>
+#include <ostream>
+#include <string>
+
+#include <xercesc/dom/DOM.hpp>
+
+#include "uscxml/config.h"
+#include "../../../uscxml/messages/Event.h"
+#include "../../../uscxml/interpreter/InterpreterMonitor.h"
+#include "../../../uscxml/util/DOM.h"
+
+// forward declare
+namespace XERCESC_NS {
+    class DOMElement;
+}
+
+namespace uscxml {
+
+class WrappedInterpreterMonitor : public InterpreterMonitor {
+public:
+	WrappedInterpreterMonitor();
+	virtual ~WrappedInterpreterMonitor();
+
+    void beforeExitingState(const XERCESC_NS::DOMElement* state);
+    virtual void beforeExitingState(const std::string& stateId,
+	                                const std::string& xpath,
+	                                const std::string& stateXML) {}
+
+
+    void afterExitingState(const XERCESC_NS::DOMElement* state);
+    virtual void afterExitingState(const std::string& stateId,
+                                   const std::string& xpath,
+                                   const std::string& stateXML) {}
+
+
+    void beforeExecutingContent(const XERCESC_NS::DOMElement* content);
+    virtual void beforeExecutingContent(const std::string& tagName,
+	                                    const std::string& xpath,
+	                                    const std::string& contentXML) {}
+
+
+    void afterExecutingContent(const XERCESC_NS::DOMElement* content);
+    virtual void afterExecutingContent(const std::string& tagName,
+	                                   const std::string& xpath,
+	                                   const std::string& contentXML) {}
+
+
+	void beforeUninvoking(const XERCESC_NS::DOMElement* invoker,
+                          const std::string& invokeid);
+	virtual void beforeUninvoking(const std::string& xpath,
+	                              const std::string& invokeid,
+	                              const std::string& invokerXML) {}
+
+
+	void afterUninvoking(const XERCESC_NS::DOMElement* invoker,
+                         const std::string& invokeid);
+    virtual void afterUninvoking(const std::string& xpath,
+	                             const std::string& invokeid,
+	                             const std::string& invokerXML) {}
+
+
+    void beforeTakingTransition(const XERCESC_NS::DOMElement* transition);
+	virtual void beforeTakingTransition(const std::string& xpath,
+	                                    const std::string& source,
+	                                    const std::list<std::string>& targets,
+	                                    const std::string& transitionXML) {}
+
+    void afterTakingTransition(const XERCESC_NS::DOMElement* transition);
+    virtual void afterTakingTransition(const std::string& xpath,
+	                                   const std::string& source,
+	                                   const std::list<std::string>& targets,
+	                                   const std::string& transitionXML) {}
+
+
+    void beforeEnteringState(const XERCESC_NS::DOMElement* state);
+    virtual void beforeEnteringState(const std::string& stateId,
+	                                 const std::string& xpath,
+	                                 const std::string& stateXML) {}
+
+
+    void afterEnteringState(const XERCESC_NS::DOMElement* state);
+    virtual void afterEnteringState(const std::string& stateId,
+	                                const std::string& xpath,
+	                                const std::string& stateXML) {}
+
+
+	void beforeInvoking(const XERCESC_NS::DOMElement* invoker,
+                        const std::string& invokeid);
+    virtual void beforeInvoking(const std::string& xpath,
+	                            const std::string& invokeid,
+	                            const std::string& invokerXML) {}
+
+    void afterInvoking(const XERCESC_NS::DOMElement* invoker,
+                       const std::string& invokeid);
+    virtual void afterInvoking(const std::string& xpath,
+	                           const std::string& invokeid,
+	                           const std::string& invokerXML) {}
+
+	virtual void reportIssue(const InterpreterIssue& issue) {}
+};
+
+}
+
+
+#endif /* end of include guard: WRAPPEDINTERPRETERMONITOR_H_F5C83A0D */
diff --git a/src/bindings/swig/wrapped/WrappedInvoker.cpp b/src/bindings/swig/wrapped/WrappedInvoker.cpp
new file mode 100644
index 0000000..ba76420
--- /dev/null
+++ b/src/bindings/swig/wrapped/WrappedInvoker.cpp
@@ -0,0 +1,29 @@
+/**
+ *  @file
+ *  @author     2012-2014 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 "WrappedInvoker.h"
+
+namespace uscxml {
+
+WrappedInvoker::WrappedInvoker(InterpreterImpl* interpreter) {
+  _interpreter = interpreter;
+}
+WrappedInvoker::~WrappedInvoker() {}
+
+}
\ No newline at end of file
diff --git a/src/bindings/swig/wrapped/WrappedInvoker.h b/src/bindings/swig/wrapped/WrappedInvoker.h
new file mode 100644
index 0000000..3eb4a22
--- /dev/null
+++ b/src/bindings/swig/wrapped/WrappedInvoker.h
@@ -0,0 +1,84 @@
+/**
+ *  @file
+ *  @author     2012-2014 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
+ */
+
+#ifndef WRAPPEDINVOKER_H_F9725D47
+#define WRAPPEDINVOKER_H_F9725D47
+
+#include <vector>
+#include <list>
+#include <ostream>
+#include <string>
+
+#include <xercesc/dom/DOM.hpp>
+
+#include "../../../uscxml/messages/Event.h"
+#include "../../../uscxml/plugins/Factory.h"
+#include "../../../uscxml/plugins/InvokerImpl.h"
+
+// forward declare
+namespace XERCESC_NS {
+    class DOMElement;
+}
+
+namespace uscxml {
+
+class WrappedInvoker : public InvokerImpl {
+public:
+	WrappedInvoker(InterpreterImpl* interpreter);
+	virtual ~WrappedInvoker();
+    
+    virtual std::list<std::string> getNames() {
+        return std::list<std::string>();
+    };
+
+    virtual std::shared_ptr<InvokerImpl> create(InterpreterImpl* interpreter) {
+    	std::shared_ptr<InvokerImpl> inv = std::shared_ptr<InvokerImpl>(new WrappedInvoker(interpreter));
+			return inv;
+    }
+    virtual void invoke(const std::string& source, const Event& invokeEvent) {}
+    virtual void uninvoke() {}
+
+    virtual void eventFromSCXML(const Event& event) {}
+    
+    virtual XERCESC_NS::DOMElement* getFinalize() {
+        return _finalize;
+    }
+    virtual void setFinalize(XERCESC_NS::DOMElement* finalize) {
+        _finalize = finalize;
+    }
+    virtual void setInvokeId(const std::string& invokeId) {
+        _invokeId = invokeId;
+    }
+		
+    virtual Data getDataModelVariables() {
+        return Data();
+    }
+		
+    void eventToSCXML(Event& event, const std::string& type, const std::string& invokeId, bool internal = false) {
+    	
+    }
+
+private:
+	InterpreterImpl* _interpreter;
+
+};
+
+}
+
+#endif /* end of include guard: WRAPPEDINVOKER_H_F9725D47 */