Changed Monitor signature to take Interpreter facade

2 files changed, 75 insertions, 67 deletions

diff --git a/src/uscxml/debug/Debugger.cpp b/src/uscxml/debug/Debugger.cpp
index 09c21e7..1f13e40 100644
--- a/src/uscxml/debug/Debugger.cpp
+++ b/src/uscxml/debug/Debugger.cpp
@@ -24,7 +24,8 @@
 
 namespace uscxml {
 
-void Debugger::afterCompletion(InterpreterImpl* impl) {
+void Debugger::afterCompletion(Interpreter& interpreter) {
+    InterpreterImpl* impl = interpreter.getImpl().get();
 	std::shared_ptr<DebugSession> session = getSession(impl);
 	if (!session)
 		return;
@@ -34,7 +35,7 @@ void Debugger::afterCompletion(InterpreterImpl* impl) {
 	pushData(session, msg);
 }
 
-void Debugger::beforeCompletion(InterpreterImpl* impl) {}
+void Debugger::beforeCompletion(Interpreter& interpreter) {}
 
 std::list<Breakpoint> Debugger::getQualifiedStateBreakpoints(InterpreterImpl* impl, const XERCESC_NS::DOMElement* state, Breakpoint breakpointTemplate) {
 	std::list<Breakpoint> breakpoints;
@@ -87,59 +88,59 @@ std::list<Breakpoint> Debugger::getQualifiedTransBreakpoints(InterpreterImpl* im
 	return breakpoints;
 }
 
-void Debugger::beforeTakingTransition(InterpreterImpl* impl, const XERCESC_NS::DOMElement* transition) {
-	handleTransition(impl, transition, Breakpoint::BEFORE);
+void Debugger::beforeTakingTransition(Interpreter& interpreter, const XERCESC_NS::DOMElement* transition) {
+	handleTransition(interpreter, transition, Breakpoint::BEFORE);
 }
-void Debugger::afterTakingTransition(InterpreterImpl* impl, const XERCESC_NS::DOMElement* transition) {
-	handleTransition(impl, transition, Breakpoint::AFTER);
+void Debugger::afterTakingTransition(Interpreter& interpreter, const XERCESC_NS::DOMElement* transition) {
+	handleTransition(interpreter, transition, Breakpoint::AFTER);
 }
-void Debugger::beforeExecutingContent(InterpreterImpl* impl, const XERCESC_NS::DOMElement* execContent) {
-	handleExecutable(impl, execContent, Breakpoint::BEFORE);
+void Debugger::beforeExecutingContent(Interpreter& interpreter, const XERCESC_NS::DOMElement* execContent) {
+	handleExecutable(interpreter, execContent, Breakpoint::BEFORE);
 }
-void Debugger::afterExecutingContent(InterpreterImpl* impl, const XERCESC_NS::DOMElement* execContent) {
-	handleExecutable(impl, execContent, Breakpoint::AFTER);
+void Debugger::afterExecutingContent(Interpreter& interpreter, const XERCESC_NS::DOMElement* execContent) {
+	handleExecutable(interpreter, execContent, Breakpoint::AFTER);
 }
-void Debugger::beforeExitingState(InterpreterImpl* impl, const XERCESC_NS::DOMElement* state) {
-	handleState(impl, state, Breakpoint::BEFORE, Breakpoint::EXIT);
+void Debugger::beforeExitingState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state) {
+	handleState(interpreter, state, Breakpoint::BEFORE, Breakpoint::EXIT);
 }
-void Debugger::afterExitingState(InterpreterImpl* impl, const XERCESC_NS::DOMElement* state) {
-	handleState(impl, state, Breakpoint::AFTER, Breakpoint::EXIT);
+void Debugger::afterExitingState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state) {
+	handleState(interpreter, state, Breakpoint::AFTER, Breakpoint::EXIT);
 }
-void Debugger::beforeEnteringState(InterpreterImpl* impl, const XERCESC_NS::DOMElement* state) {
-	handleState(impl, state, Breakpoint::BEFORE, Breakpoint::ENTER);
+void Debugger::beforeEnteringState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state) {
+	handleState(interpreter, state, Breakpoint::BEFORE, Breakpoint::ENTER);
 }
-void Debugger::afterEnteringState(InterpreterImpl* impl, const XERCESC_NS::DOMElement* state) {
-	handleState(impl, state, Breakpoint::AFTER, Breakpoint::ENTER);
+void Debugger::afterEnteringState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state) {
+	handleState(interpreter, state, Breakpoint::AFTER, Breakpoint::ENTER);
 }
-void Debugger::beforeUninvoking(InterpreterImpl* impl, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid) {
-	handleInvoke(impl, invokeElem, invokeid, Breakpoint::BEFORE, Breakpoint::UNINVOKE);
+void Debugger::beforeUninvoking(Interpreter& interpreter, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid) {
+	handleInvoke(interpreter, invokeElem, invokeid, Breakpoint::BEFORE, Breakpoint::UNINVOKE);
 }
-void Debugger::afterUninvoking(InterpreterImpl* impl, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid) {
-	handleInvoke(impl, invokeElem, invokeid, Breakpoint::AFTER, Breakpoint::UNINVOKE);
+void Debugger::afterUninvoking(Interpreter& interpreter, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid) {
+	handleInvoke(interpreter, invokeElem, invokeid, Breakpoint::AFTER, Breakpoint::UNINVOKE);
 }
-void Debugger::beforeInvoking(InterpreterImpl* impl, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid) {
-	handleInvoke(impl, invokeElem, invokeid, Breakpoint::BEFORE, Breakpoint::INVOKE);
+void Debugger::beforeInvoking(Interpreter& interpreter, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid) {
+	handleInvoke(interpreter, invokeElem, invokeid, Breakpoint::BEFORE, Breakpoint::INVOKE);
 }
-void Debugger::afterInvoking(InterpreterImpl* impl, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid) {
-	handleInvoke(impl, invokeElem, invokeid, Breakpoint::AFTER, Breakpoint::INVOKE);
+void Debugger::afterInvoking(Interpreter& interpreter, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid) {
+	handleInvoke(interpreter, invokeElem, invokeid, Breakpoint::AFTER, Breakpoint::INVOKE);
 }
-void Debugger::onStableConfiguration(InterpreterImpl* impl) {
-	handleStable(impl, Breakpoint::ON);
+void Debugger::onStableConfiguration(Interpreter& interpreter) {
+	handleStable(interpreter, Breakpoint::ON);
 }
-void Debugger::beforeMicroStep(InterpreterImpl* impl) {
-	handleMicrostep(impl, Breakpoint::BEFORE);
+void Debugger::beforeMicroStep(Interpreter& interpreter) {
+	handleMicrostep(interpreter, Breakpoint::BEFORE);
 }
-void Debugger::afterMicroStep(InterpreterImpl* impl) {
-	handleMicrostep(impl, Breakpoint::AFTER);
+void Debugger::afterMicroStep(Interpreter& interpreter) {
+	handleMicrostep(interpreter, Breakpoint::AFTER);
 }
-void Debugger::beforeProcessingEvent(InterpreterImpl* impl, const Event& event) {
-	handleEvent(impl, event, Breakpoint::BEFORE);
+void Debugger::beforeProcessingEvent(Interpreter& interpreter, const Event& event) {
+	handleEvent(interpreter, event, Breakpoint::BEFORE);
 }
 
-void Debugger::handleExecutable(InterpreterImpl* impl,
+void Debugger::handleExecutable(Interpreter& interpreter,
                                 const XERCESC_NS::DOMElement* execContentElem,
                                 Breakpoint::When when) {
-	std::shared_ptr<DebugSession> session = getSession(impl);
+	std::shared_ptr<DebugSession> session = getSession(interpreter.getImpl().get());
 	if (!session)
 		return;
     if (!session->_isRunning)
@@ -158,7 +159,8 @@ void Debugger::handleExecutable(InterpreterImpl* impl,
 
 }
 
-void Debugger::handleEvent(InterpreterImpl* impl, const Event& event, Breakpoint::When when) {
+void Debugger::handleEvent(Interpreter& interpreter, const Event& event, Breakpoint::When when) {
+    InterpreterImpl* impl = interpreter.getImpl().get();
     std::shared_ptr<DebugSession> session = getSession(impl);
     if (!session)
         return;
@@ -177,7 +179,8 @@ void Debugger::handleEvent(InterpreterImpl* impl, const Event& event, Breakpoint
 
 }
 
-void Debugger::handleStable(InterpreterImpl* impl, Breakpoint::When when) {
+void Debugger::handleStable(Interpreter& interpreter, Breakpoint::When when) {
+    InterpreterImpl* impl = interpreter.getImpl().get();
     std::shared_ptr<DebugSession> session = getSession(impl);
     if (!session)
         return;
@@ -194,7 +197,8 @@ void Debugger::handleStable(InterpreterImpl* impl, Breakpoint::When when) {
 	session->checkBreakpoints(breakpoints);
 }
 
-void Debugger::handleMicrostep(InterpreterImpl* impl, Breakpoint::When when) {
+void Debugger::handleMicrostep(Interpreter& interpreter, Breakpoint::When when) {
+    InterpreterImpl* impl = interpreter.getImpl().get();
     std::shared_ptr<DebugSession> session = getSession(impl);
     if (!session)
         return;
@@ -211,7 +215,8 @@ void Debugger::handleMicrostep(InterpreterImpl* impl, Breakpoint::When when) {
 	session->checkBreakpoints(breakpoints);
 }
 
-void Debugger::handleTransition(InterpreterImpl* impl, const XERCESC_NS::DOMElement* transition, Breakpoint::When when) {
+void Debugger::handleTransition(Interpreter& interpreter, const XERCESC_NS::DOMElement* transition, Breakpoint::When when) {
+    InterpreterImpl* impl = interpreter.getImpl().get();
     std::shared_ptr<DebugSession> session = getSession(impl);
     if (!session)
         return;
@@ -224,7 +229,8 @@ void Debugger::handleTransition(InterpreterImpl* impl, const XERCESC_NS::DOMElem
 	session->checkBreakpoints(qualifiedBreakpoints);
 }
 
-void Debugger::handleState(InterpreterImpl* impl, const XERCESC_NS::DOMElement* state, Breakpoint::When when, Breakpoint::Action action) {
+void Debugger::handleState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state, Breakpoint::When when, Breakpoint::Action action) {
+    InterpreterImpl* impl = interpreter.getImpl().get();
     std::shared_ptr<DebugSession> session = getSession(impl);
     if (!session)
         return;
@@ -239,7 +245,8 @@ void Debugger::handleState(InterpreterImpl* impl, const XERCESC_NS::DOMElement*
 
 }
 
-void Debugger::handleInvoke(InterpreterImpl* impl, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeId, Breakpoint::When when, Breakpoint::Action action) {
+void Debugger::handleInvoke(Interpreter& interpreter, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeId, Breakpoint::When when, Breakpoint::Action action) {
+    InterpreterImpl* impl = interpreter.getImpl().get();
     std::shared_ptr<DebugSession> session = getSession(impl);
     if (!session)
         return;
diff --git a/src/uscxml/debug/Debugger.h b/src/uscxml/debug/Debugger.h
index 08136d6..4b564cb 100644
--- a/src/uscxml/debug/Debugger.h
+++ b/src/uscxml/debug/Debugger.h
@@ -55,45 +55,45 @@ public:
 	virtual void pushData(std::shared_ptr<DebugSession> session, Data pushData) = 0;
 
 	// InterpreterMonitor
-    virtual void beforeProcessingEvent(InterpreterImpl* impl, const Event& event);
-    virtual void beforeMicroStep(InterpreterImpl* impl);
-    virtual void beforeExitingState(InterpreterImpl* impl, const XERCESC_NS::DOMElement* state);
-    virtual void afterExitingState(InterpreterImpl* impl, const XERCESC_NS::DOMElement* state);
-    virtual void beforeExecutingContent(InterpreterImpl* impl, const XERCESC_NS::DOMElement* execContent);
-    virtual void afterExecutingContent(InterpreterImpl* impl, const XERCESC_NS::DOMElement* execContent);
-    virtual void beforeUninvoking(InterpreterImpl* impl, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid);
-    virtual void afterUninvoking(InterpreterImpl* impl, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid);
-    virtual void beforeTakingTransition(InterpreterImpl* impl, const XERCESC_NS::DOMElement* transition);
-    virtual void afterTakingTransition(InterpreterImpl* impl, const XERCESC_NS::DOMElement* transition);
-    virtual void beforeEnteringState(InterpreterImpl* impl, const XERCESC_NS::DOMElement* state);
-    virtual void afterEnteringState(InterpreterImpl* impl, const XERCESC_NS::DOMElement* state);
-    virtual void beforeInvoking(InterpreterImpl* impl, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid);
-    virtual void afterInvoking(InterpreterImpl* impl, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid);
-    virtual void afterMicroStep(InterpreterImpl* impl);
-    virtual void onStableConfiguration(InterpreterImpl* impl);
-    virtual void beforeCompletion(InterpreterImpl* impl);
-    virtual void afterCompletion(InterpreterImpl* impl);
+    virtual void beforeProcessingEvent(Interpreter& interpreter, const Event& event);
+    virtual void beforeMicroStep(Interpreter& interpreter);
+    virtual void beforeExitingState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state);
+    virtual void afterExitingState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state);
+    virtual void beforeExecutingContent(Interpreter& interpreter, const XERCESC_NS::DOMElement* execContent);
+    virtual void afterExecutingContent(Interpreter& interpreter, const XERCESC_NS::DOMElement* execContent);
+    virtual void beforeUninvoking(Interpreter& interpreter, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid);
+    virtual void afterUninvoking(Interpreter& interpreter, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid);
+    virtual void beforeTakingTransition(Interpreter& interpreter, const XERCESC_NS::DOMElement* transition);
+    virtual void afterTakingTransition(Interpreter& interpreter, const XERCESC_NS::DOMElement* transition);
+    virtual void beforeEnteringState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state);
+    virtual void afterEnteringState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state);
+    virtual void beforeInvoking(Interpreter& interpreter, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid);
+    virtual void afterInvoking(Interpreter& interpreter, const XERCESC_NS::DOMElement* invokeElem, const std::string& invokeid);
+    virtual void afterMicroStep(Interpreter& interpreter);
+    virtual void onStableConfiguration(Interpreter& interpreter);
+    virtual void beforeCompletion(Interpreter& interpreter);
+    virtual void afterCompletion(Interpreter& interpreter);
 
 protected:
 
-	void handleTransition(InterpreterImpl* impl,
+	void handleTransition(Interpreter& interpreter,
 	                      const XERCESC_NS::DOMElement* transition,
 	                      Breakpoint::When when);
-	void handleState(InterpreterImpl* impl,
+	void handleState(Interpreter& interpreter,
 	                 const XERCESC_NS::DOMElement* state,
 	                 Breakpoint::When when,
 	                 Breakpoint::Action action);
-	void handleInvoke(InterpreterImpl* impl,
+	void handleInvoke(Interpreter& interpreter,
 	                  const XERCESC_NS::DOMElement* invokeElem,
 	                  const std::string& invokeId,
 	                  Breakpoint::When when,
 	                  Breakpoint::Action action);
-	void handleExecutable(InterpreterImpl* impl,
+	void handleExecutable(Interpreter& interpreter,
 	                      const XERCESC_NS::DOMElement* execContentElem,
 	                      Breakpoint::When when);
-	void handleStable(InterpreterImpl* impl, Breakpoint::When when);
-	void handleMicrostep(InterpreterImpl* impl, Breakpoint::When when);
-	void handleEvent(InterpreterImpl* impl, const Event& event, Breakpoint::When when);
+	void handleStable(Interpreter& interpreter, Breakpoint::When when);
+	void handleMicrostep(Interpreter& interpreter, Breakpoint::When when);
+	void handleEvent(Interpreter& interpreter, const Event& event, Breakpoint::When when);
 
     std::list<Breakpoint> getQualifiedTransBreakpoints(InterpreterImpl* impl,
                                                        const XERCESC_NS::DOMElement* transition,
@@ -107,6 +107,7 @@ protected:
                                                         Breakpoint breakpointTemplate);
 
 	std::recursive_mutex _sessionMutex;
+    /// @todo: We ought to change form InterpreterImpl to Interpreter everywhere 
 	std::map<InterpreterImpl*, std::shared_ptr<DebugSession> > _sessionForInterpreter;
 };