root/trunk/src/framework/Utilities/Callback.h @ 102

Revision 102, 15.5 kB (checked in by yumileroy, 17 years ago)

[svn] Fixed copyright notices to comply with GPL.

Original author: w12x
Date: 2008-10-23 03:29:52-05:00
Line 
1/*
2 * Copyright (C) 2005-2008 MaNGOS <http://www.mangosproject.org/>
3 *
4 * Copyright (C) 2008 Trinity <http://www.trinitycore.org/>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21#ifndef TRINITY_CALLBACK_H
22#define TRINITY_CALLBACK_H
23
24/// ------------ BASE CLASSES ------------
25
26namespace Trinity
27{
28    template < class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void, typename ParamType4 = void >
29    class _Callback
30    {
31        protected:
32            typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3, ParamType4);
33            Class *m_object;
34            Method m_method;
35            ParamType1 m_param1;
36            ParamType2 m_param2;
37            ParamType3 m_param3;
38            ParamType4 m_param4;
39            void _Execute() { (m_object->*m_method)(m_param1, m_param2, m_param3, m_param4); }
40        public:
41            _Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
42                : m_object(object), m_method(method), m_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4) {}
43            _Callback(_Callback < Class, ParamType1, ParamType2, ParamType3, ParamType4> const& cb)
44                : m_object(cb.object), m_method(cb.m_method), m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3), m_param4(cb.m_param4) {}
45    };
46
47    template < class Class, typename ParamType1, typename ParamType2, typename ParamType3 >
48    class _Callback < Class, ParamType1, ParamType2, ParamType3 >
49    {
50        protected:
51            typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3);
52            Class *m_object;
53            Method m_method;
54            ParamType1 m_param1;
55            ParamType2 m_param2;
56            ParamType3 m_param3;
57            void _Execute() { (m_object->*m_method)(m_param1, m_param2, m_param3); }
58        public:
59            _Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
60                : m_object(object), m_method(method), m_param1(param1), m_param2(param2) {}
61            _Callback(_Callback < Class, ParamType1, ParamType2, ParamType3 > const& cb)
62                : m_object(cb.object), m_method(cb.m_method), m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3) {}
63    };
64
65    template < class Class, typename ParamType1, typename ParamType2 >
66    class _Callback < Class, ParamType1, ParamType2 >
67    {
68        protected:
69            typedef void (Class::*Method)(ParamType1, ParamType2);
70            Class *m_object;
71            Method m_method;
72            ParamType1 m_param1;
73            ParamType2 m_param2;
74            void _Execute() { (m_object->*m_method)(m_param1, m_param2); }
75        public:
76            _Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2)
77                : m_object(object), m_method(method), m_param1(param1), m_param2(param2) {}
78            _Callback(_Callback < Class, ParamType1, ParamType2 > const& cb)
79                : m_object(cb.m_object), m_method(cb.m_method), m_param1(cb.m_param1), m_param2(cb.m_param2) {}
80    };
81
82    template < class Class, typename ParamType1 >
83    class _Callback < Class, ParamType1 >
84    {
85        protected:
86            typedef void (Class::*Method)(ParamType1);
87            Class *m_object;
88            Method m_method;
89            ParamType1 m_param1;
90            void _Execute() { (m_object->*m_method)(m_param1); }
91        public:
92            _Callback(Class *object, Method method, ParamType1 param1)
93                : m_object(object), m_method(method), m_param1(param1) {}
94            _Callback(_Callback < Class, ParamType1 > const& cb)
95                : m_object(cb.m_object), m_method(cb.m_method), m_param1(cb.m_param1) {}
96    };
97
98    template < class Class >
99    class _Callback < Class >
100    {
101        protected:
102            typedef void (Class::*Method)();
103            Class *m_object;
104            Method m_method;
105            void _Execute() { (m_object->*m_method)(); }
106        public:
107            _Callback(Class *object, Method method)
108                : m_object(object), m_method(method) {}
109            _Callback(_Callback < Class > const& cb)
110                : m_object(cb.m_object), m_method(cb.m_method) {}
111    };
112
113    /// ---- Statics ----
114
115    template < typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void, typename ParamType4 = void >
116    class _SCallback
117    {
118        protected:
119            typedef void (*Method)(ParamType1, ParamType2, ParamType3, ParamType4);
120            Method m_method;
121            ParamType1 m_param1;
122            ParamType2 m_param2;
123            ParamType3 m_param3;
124            ParamType4 m_param4;
125            void _Execute() { (*m_method)(m_param1, m_param2, m_param3, m_param4); }
126        public:
127            _SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
128                : m_method(method), m_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4) {}
129            _SCallback(_SCallback < ParamType1, ParamType2, ParamType3, ParamType4> const& cb)
130                : m_method(cb.m_method), m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3), m_param4(cb.m_param4) {}
131    };
132
133    template < typename ParamType1, typename ParamType2, typename ParamType3 >
134    class _SCallback < ParamType1, ParamType2, ParamType3 >
135    {
136        protected:
137            typedef void (*Method)(ParamType1, ParamType2, ParamType3);
138            Method m_method;
139            ParamType1 m_param1;
140            ParamType2 m_param2;
141            ParamType3 m_param3;
142            void _Execute() { (*m_method)(m_param1, m_param2, m_param3); }
143        public:
144            _SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
145                : m_method(method), m_param1(param1), m_param2(param2) {}
146            _SCallback(_SCallback < ParamType1, ParamType2, ParamType3 > const& cb)
147                : m_method(cb.m_method), m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3) {}
148    };
149
150    template < typename ParamType1, typename ParamType2 >
151    class _SCallback < ParamType1, ParamType2 >
152    {
153        protected:
154            typedef void (*Method)(ParamType1, ParamType2);
155            Method m_method;
156            ParamType1 m_param1;
157            ParamType2 m_param2;
158            void _Execute() { (*m_method)(m_param1, m_param2); }
159        public:
160            _SCallback(Method method, ParamType1 param1, ParamType2 param2)
161                : m_method(method), m_param1(param1), m_param2(param2) {}
162            _SCallback(_SCallback < ParamType1, ParamType2 > const& cb)
163                : m_method(cb.m_method), m_param1(cb.m_param1), m_param2(cb.m_param2) {}
164    };
165
166    template < typename ParamType1 >
167    class _SCallback < ParamType1 >
168    {
169        protected:
170            typedef void (*Method)(ParamType1);
171            Method m_method;
172            ParamType1 m_param1;
173            void _Execute() { (*m_method)(m_param1); }
174        public:
175            _SCallback(Method method, ParamType1 param1)
176                : m_method(method), m_param1(param1) {}
177            _SCallback(_SCallback < ParamType1 > const& cb)
178                : m_method(cb.m_method), m_param1(cb.m_param1) {}
179    };
180
181    template < >
182    class _SCallback < >
183    {
184        protected:
185            typedef void (*Method)();
186            Method m_method;
187            void _Execute() { (*m_method)(); }
188        public:
189            _SCallback(Method method)
190                : m_method(method) {}
191            _SCallback(_SCallback <> const& cb)
192                : m_method(cb.m_method) {}
193    };
194}
195
196/// --------- GENERIC CALLBACKS ----------
197
198namespace Trinity
199{
200    class ICallback
201    {
202        public:
203            virtual void Execute() = 0;
204            virtual ~ICallback() {}
205    };
206
207    template < class CB >
208    class _ICallback : public CB, public ICallback
209    {
210        public:
211            _ICallback(CB const& cb) : CB(cb) {}
212            void Execute() { CB::_Execute(); }
213    };
214
215    template < class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void, typename ParamType4 = void >
216    class Callback :
217        public _ICallback< _Callback < Class, ParamType1, ParamType2, ParamType3, ParamType4 > >
218    {
219        private:
220            typedef _Callback < Class, ParamType1, ParamType2, ParamType3, ParamType4 > C4;
221        public:
222            Callback(Class *object, typename C4::Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
223                : _ICallback< C4 >(C4(object, method, param1, param2, param3, param4)) {}
224    };
225
226    template < class Class, typename ParamType1, typename ParamType2, typename ParamType3 >
227    class Callback < Class, ParamType1, ParamType2, ParamType3 > :
228        public _ICallback< _Callback < Class, ParamType1, ParamType2, ParamType3 > >
229    {
230        private:
231            typedef _Callback < Class, ParamType1, ParamType2, ParamType3 > C3;
232        public:
233            Callback(Class *object, typename C3::Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
234                : _ICallback< C3 >(C3(object, method, param1, param2, param3)) {}
235    };
236
237    template < class Class, typename ParamType1, typename ParamType2 >
238    class Callback < Class, ParamType1, ParamType2 > :
239        public _ICallback< _Callback < Class, ParamType1, ParamType2 > >
240    {
241        private:
242            typedef _Callback < Class, ParamType1, ParamType2 > C2;
243        public:
244            Callback(Class *object, typename C2::Method method, ParamType1 param1, ParamType2 param2)
245                : _ICallback< C2 >(C2(object, method, param1, param2)) {}
246    };
247
248    template < class Class, typename ParamType1 >
249    class Callback < Class, ParamType1 > :
250        public _ICallback< _Callback < Class, ParamType1 > >
251    {
252        private:
253            typedef _Callback < Class, ParamType1 > C1;
254        public:
255            Callback(Class *object, typename C1::Method method, ParamType1 param1)
256                : _ICallback< C1 >(C1(object, method, param1)) {}
257    };
258
259    template < class Class >
260    class Callback < Class > : public _ICallback< _Callback < Class > >
261    {
262        private:
263            typedef _Callback < Class > C0;
264        public:
265            Callback(Class *object, typename C0::Method method)
266                : _ICallback< C0 >(C0(object, method)) {}
267    };
268}
269
270/// ---------- QUERY CALLBACKS -----------
271
272class QueryResult;
273
274namespace Trinity
275{
276    class IQueryCallback
277    {
278        public:
279            virtual void Execute() = 0;
280            virtual ~IQueryCallback() {}
281            virtual void SetResult(QueryResult* result) = 0;
282            virtual QueryResult* GetResult() = 0;
283    };
284
285    template < class CB >
286    class _IQueryCallback : public CB, public IQueryCallback
287    {
288        public:
289            _IQueryCallback(CB const& cb) : CB(cb) {}
290            void Execute() { CB::_Execute(); }
291            void SetResult(QueryResult* result) { CB::m_param1 = result; }
292            QueryResult* GetResult() { return CB::m_param1; }
293    };
294
295    template < class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void >
296    class QueryCallback :
297        public _IQueryCallback< _Callback < Class, QueryResult*, ParamType1, ParamType2, ParamType3 > >
298    {
299        private:
300            typedef _Callback < Class, QueryResult*, ParamType1, ParamType2, ParamType3 > QC3;
301        public:
302            QueryCallback(Class *object, typename QC3::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2, ParamType3 param3)
303                : _IQueryCallback< QC3 >(QC3(object, method, result, param1, param2, param3)) {}
304    };
305
306    template < class Class, typename ParamType1, typename ParamType2 >
307    class QueryCallback < Class, ParamType1, ParamType2 > :
308        public _IQueryCallback< _Callback < Class, QueryResult*, ParamType1, ParamType2 > >
309    {
310        private:
311            typedef _Callback < Class, QueryResult*, ParamType1, ParamType2 > QC2;
312        public:
313            QueryCallback(Class *object, typename QC2::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2)
314                : _IQueryCallback< QC2 >(QC2(object, method, result, param1, param2)) {}
315    };
316
317    template < class Class, typename ParamType1 >
318    class QueryCallback < Class, ParamType1 > :
319        public _IQueryCallback< _Callback < Class, QueryResult*, ParamType1 > >
320    {
321        private:
322            typedef _Callback < Class, QueryResult*, ParamType1 > QC1;
323        public:
324            QueryCallback(Class *object, typename QC1::Method method, QueryResult* result, ParamType1 param1)
325                : _IQueryCallback< QC1 >(QC1(object, method, result, param1)) {}
326    };
327
328    template < class Class >
329    class QueryCallback < Class > : public _IQueryCallback< _Callback < Class, QueryResult* > >
330    {
331        private:
332            typedef _Callback < Class, QueryResult* > QC0;
333        public:
334            QueryCallback(Class *object, typename QC0::Method method, QueryResult* result)
335                : _IQueryCallback< QC0 >(QC0(object, method, result)) {}
336    };
337
338    /// ---- Statics ----
339
340    template < typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void >
341    class SQueryCallback :
342        public _IQueryCallback< _SCallback < QueryResult*, ParamType1, ParamType2, ParamType3 > >
343    {
344        private:
345            typedef _SCallback < QueryResult*, ParamType1, ParamType2, ParamType3 > QC3;
346        public:
347            SQueryCallback(typename QC3::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2, ParamType3 param3)
348                : _IQueryCallback< QC3 >(QC3(method, result, param1, param2, param3)) {}
349    };
350
351    template < typename ParamType1, typename ParamType2 >
352    class SQueryCallback < ParamType1, ParamType2 > :
353        public _IQueryCallback< _SCallback < QueryResult*, ParamType1, ParamType2 > >
354    {
355        private:
356            typedef _SCallback < QueryResult*, ParamType1, ParamType2 > QC2;
357        public:
358            SQueryCallback(typename QC2::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2)
359                : _IQueryCallback< QC2 >(QC2(method, result, param1, param2)) {}
360    };
361
362    template < typename ParamType1 >
363    class SQueryCallback < ParamType1 > :
364        public _IQueryCallback< _SCallback < QueryResult*, ParamType1 > >
365    {
366        private:
367            typedef _SCallback < QueryResult*, ParamType1 > QC1;
368        public:
369            SQueryCallback(typename QC1::Method method, QueryResult* result, ParamType1 param1)
370                : _IQueryCallback< QC1 >(QC1(method, result, param1)) {}
371    };
372
373    template < >
374    class SQueryCallback < > : public _IQueryCallback< _SCallback < QueryResult* > >
375    {
376        private:
377            typedef _SCallback < QueryResult* > QC0;
378        public:
379            SQueryCallback(QC0::Method method, QueryResult* result)
380                : _IQueryCallback< QC0 >(QC0(method, result)) {}
381    };
382}
383
384#endif
Note: See TracBrowser for help on using the browser.