blob: 9d159a86af65df747ddab62fc50bb1267f8ed3ab (
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
147
148
149
150
|
/**
* @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 INVOKERIMPL_H_8A15A102
#define INVOKERIMPL_H_8A15A102
#include "uscxml/config.h"
#include "uscxml/Common.h"
#include "uscxml/plugins/EventHandler.h"
#include "uscxml/messages/Event.h"
#include <set>
namespace XERCESC_NS {
class DOMElement;
class DOMDocument;
class DOMNode;
}
namespace uscxml {
class Interpreter;
class InterpreterMonitor;
class ActionLanguage;
class Logger;
/**
* @ingroup invoker
* @ingroup callback
* Callbacks available for every invoker.
*/
class USCXML_API InvokerCallbacks {
public:
virtual ~InvokerCallbacks() {} ///< silence virtual destructor warning from swig
virtual void enqueueInternal(const Event& event) = 0;
virtual void enqueueExternal(const Event& event) = 0;
virtual ActionLanguage getActionLanguage() = 0;
virtual std::set<InterpreterMonitor*> getMonitors() = 0;
virtual std::string getBaseURL() = 0;
virtual Logger getLogger() = 0;
};
/**
* @ingroup invoker
* @ingroup abstract
* Abstract base class for all invokers.
*/
class USCXML_API InvokerImpl : public EventHandlerImpl {
public:
InvokerImpl() : _finalize(NULL) {};
virtual ~InvokerImpl() {}
virtual std::list<std::string> getNames() = 0;
/**
* Factory demands a new instance.
* @param interpreter The imlementation of the associated Interpreter
* @todo We will eventually introduce callbacks and prevent complete access to the interpreter.
*/
virtual std::shared_ptr<InvokerImpl> create(InvokerCallbacks* callbacks) = 0;
/**
* Invoker's parent state became active at the end of a macro-step.
* @param source The content of the invoke's `src` or evaluated `srcexpr` attribute
* @param invokeEvent The invocation with all its data as an event
*/
virtual void invoke(const std::string& source, const Event& invokeEvent) = 0;
/**
* The invokers's parent state was left at the end of a macro-step.
*/
virtual void uninvoke() = 0;
/**
* Invoker received an event from the SCXML Interpreter.
*/
virtual void eventFromSCXML(const Event& event) = 0;
/**
* Return the finalize XML element associated with this invoker.
*/
virtual XERCESC_NS::DOMElement* getFinalize() {
return _finalize;
}
/**
* Set the finalize XML element associated with this invoker.
* @param finalize The finalize XMl element.
*/
virtual void setFinalize(XERCESC_NS::DOMElement* finalize) {
_finalize = finalize;
}
/**
* Set the invocation identifier as required when returning events.
* @param invokeId The invocation identifier.
*/
virtual void setInvokeId(const std::string& invokeId) {
_invokeId = invokeId;
}
/**
* Load a state from a Data object
* @param encodedState The state we returned somewhen else via serialize.
*/
virtual void deserialize(const Data& encodedState) {}
/**
* Save our state into a Data object
*/
virtual Data serialize() {
return Data();
}
protected:
/**
* Return an event to the SCXML Interpreter instance.
* @param event An event to enqueue at the interpreter's external queue.
* @param type The type of this I/O Processor for `event.origintype`.
* @param invokeId The invocation identifier of this invocation for `event.invokeid`.
* @param internal If the event is to be delivered to the Interpreter's internal queue instead.
*/
void eventToSCXML(Event& event, const std::string& type, const std::string& invokeId, bool internal = false);
XERCESC_NS::DOMElement* _finalize;
std::string _invokeId;
InvokerCallbacks* _callbacks;
};
}
#endif /* end of include guard: INVOKERIMPL_H_8A15A102 */
|
