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
|
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* 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. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#ifndef COMMON_CALLBACK_H
#define COMMON_CALLBACK_H
namespace Common {
/**
* BaseCallback<S> is a simple base class for object-oriented callbacks.
*
* Object-oriented callbacks are such callbacks that know exact instance
* which method must be called.
*
* For backwards compatibility purposes, there is a GlobalFunctionCallback,
* which is BaseCallback<void *>, so it can be used with global C-like
* functions too.
*
* <S> is the type, which is passed to operator() of this callback.
* This allows you to specify that you accept a callback, which wants
* to receive an <S> object.
*/
template<typename S = void *> class BaseCallback {
public:
BaseCallback() {}
virtual ~BaseCallback() {}
virtual void operator()(S data) = 0;
};
/**
* GlobalFunctionCallback<T> is a simple wrapper for global C functions.
*
* If there is a method, which accepts BaseCallback<T>, you can
* easily pass your C function by passing
* new GlobalFunctionCallback<T>(yourFunction)
*/
template<typename T> class GlobalFunctionCallback: public BaseCallback<T> {
typedef void(*GlobalFunction)(T result);
GlobalFunction _callback;
public:
GlobalFunctionCallback(GlobalFunction cb): _callback(cb) {}
virtual ~GlobalFunctionCallback() {}
virtual void operator()(T data) {
if (_callback) _callback(data);
}
};
/**
* Callback<T, S> implements an object-oriented callback.
*
* <T> stands for a class which method you want to call.
* <S>, again, is the type of an object passed to operator().
*
* So, if you have void MyClass::myMethod(AnotherClass) method,
* the corresponding callback is Callback<MyClass, AnotherClass>.
* You create it similarly to this:
* new Callback<MyClass, AnotherClass>(
* pointerToMyClassObject,
* &MyClass::myMethod
* )
*/
template<class T, typename S = void *> class Callback: public BaseCallback<S> {
protected:
typedef void(T::*TMethod)(S);
T *_object;
TMethod _method;
public:
Callback(T *object, TMethod method): _object(object), _method(method) {}
virtual ~Callback() {}
void operator()(S data) { (_object->*_method)(data); }
};
/**
* CallbackBridge<T, OS, S> helps you to chain callbacks.
*
* CallbackBridge keeps a pointer to BaseCallback<OS>.
* When its operator() is called, it passes this pointer
* along with the actual data (of type <S>) to the method
* of <T> class.
*
* This is needed when you have to call a callback only
* when your own callback is called. So, your callback
* is "inner" and the other one is "outer".
*
* CallbackBridge implements the "inner" one and calls
* the method you wanted. It passes the "outer", so you
* can call it from your method. You can ignore it, but
* probably there is no point in using CallbackBridge then.
*
* So, if you receive a BaseCallback<SomeClass> callback
* and you want to call it from your MyClass::myMethod method,
* you should create CallbackBridge<MyClass, SomeClass, S>,
* where <S> is data type you want to receive in MyClass::myMethod.
*
* You create it similarly to this:
* new Callback<MyClass, SomeClass, AnotherClass>(
* pointerToMyClassObject,
* &MyClass::myMethod,
* outerCallback
* )
* where `outerCallback` is BaseCallback<SomeClass> and `myMethod` is:
* void MyClass::myMethod(BaseCallback<SomeClass> *, AnotherClass)
*/
template<class T, typename OS, typename S = void *> class CallbackBridge: public BaseCallback<S> {
typedef void(T::*TCallbackMethod)(BaseCallback<OS> *, S);
T *_object;
TCallbackMethod _method;
BaseCallback<OS> *_outerCallback;
public:
CallbackBridge(T *object, TCallbackMethod method, BaseCallback<OS> *outerCallback):
_object(object), _method(method), _outerCallback(outerCallback) {}
virtual ~CallbackBridge() {}
void operator()(S data) { (_object->*_method)(_outerCallback, data); }
};
} // End of namespace Common
#endif
|
