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

Revision 2, 15.4 kB (checked in by yumileroy, 17 years ago)

[svn] * Proper SVN structure

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