summaryrefslogtreecommitdiffstats
path: root/src/bindings/swig/wrapped/WrappedInterpreterMonitor.h
blob: 697a420e34a69af9229a524723a97cbe47c8a8c4 (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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
/**
 *  @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();

	virtual void beforeProcessingEvent(Interpreter& interpreter, const Event& event) {}
	virtual void beforeMicroStep(Interpreter& interpreter) {}

	void beforeExitingState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state);
	virtual void beforeExitingState(const std::string& stateId,
	                                const std::string& xpath,
	                                const std::string& stateXML) {}


	void afterExitingState(Interpreter& interpreter, const XERCESC_NS::DOMElement* state);
	virtual void afterExitingState(const std::string& stateId,
	                               const std::string& xpath,
	                               const std::string& stateXML) {}


	void beforeExecutingContent(Interpreter& interpreter, const XERCESC_NS::DOMElement* content);
	virtual void beforeExecutingContent(const std::string& tagName,
	                                    const std::string& xpath,
	                                    const std::string& contentXML) {}


	void afterExecutingContent(Interpreter& interpreter, const XERCESC_NS::DOMElement* content);
	virtual void afterExecutingContent(const std::string& tagName,
	                                   const std::string& xpath,
	                                   const std::string& contentXML) {}


	void beforeUninvoking(Interpreter& interpreter,
	                      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(Interpreter& interpreter,
	                     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(Interpreter& interpreter,
	                            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(Interpreter& interpreter,
	                           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(Interpreter& interpreter,
	                         const XERCESC_NS::DOMElement* state);
	virtual void beforeEnteringState(const std::string& stateId,
	                                 const std::string& xpath,
	                                 const std::string& stateXML) {}


	void afterEnteringState(Interpreter& interpreter,
	                        const XERCESC_NS::DOMElement* state);
	virtual void afterEnteringState(const std::string& stateId,
	                                const std::string& xpath,
	                                const std::string& stateXML) {}


	void beforeInvoking(Interpreter& interpreter,
	                    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(Interpreter& interpreter,
	                   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 afterMicroStep(Interpreter& interpreter) {}
	virtual void onStableConfiguration(Interpreter& interpreter) {}

	virtual void beforeCompletion(Interpreter& interpreter) {}
	virtual void afterCompletion(Interpreter& interpreter) {}

	virtual void reportIssue(Interpreter& interpreter,
	                         const InterpreterIssue& issue) {}
};

}


#endif /* end of include guard: WRAPPEDINTERPRETERMONITOR_H_F5C83A0D */