mirror of
https://github.com/mangosfour/server.git
synced 2025-12-13 04:37:00 +00:00
557 lines
17 KiB
C++
557 lines
17 KiB
C++
/*
|
|
* Copyright (C) 2005-2012 MaNGOS <http://getmangos.com/>
|
|
*
|
|
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#ifndef MANGOS_CALLBACK_H
|
|
#define MANGOS_CALLBACK_H
|
|
|
|
//defines to simplify multi param templates code and readablity
|
|
#define TYPENAMES_1 typename T1
|
|
#define TYPENAMES_2 TYPENAMES_1, typename T2
|
|
#define TYPENAMES_3 TYPENAMES_2, typename T3
|
|
#define TYPENAMES_4 TYPENAMES_3, typename T4
|
|
#define TYPENAMES_5 TYPENAMES_4, typename T5
|
|
#define TYPENAMES_6 TYPENAMES_5, typename T6
|
|
#define TYPENAMES_7 TYPENAMES_6, typename T7
|
|
#define TYPENAMES_8 TYPENAMES_7, typename T8
|
|
#define TYPENAMES_9 TYPENAMES_8, typename T9
|
|
#define TYPENAMES_10 TYPENAMES_9, typename T10
|
|
|
|
#define PARAMS_1 T1 param1
|
|
#define PARAMS_2 PARAMS_1, T2 param2
|
|
#define PARAMS_3 PARAMS_2, T3 param3
|
|
#define PARAMS_4 PARAMS_3, T4 param4
|
|
#define PARAMS_5 PARAMS_4, T5 param5
|
|
#define PARAMS_6 PARAMS_5, T6 param6
|
|
#define PARAMS_7 PARAMS_6, T7 param7
|
|
#define PARAMS_8 PARAMS_7, T8 param8
|
|
#define PARAMS_9 PARAMS_8, T9 param9
|
|
#define PARAMS_10 PARAMS_9, T10 param10
|
|
|
|
//empty struct to use in templates instead of void type
|
|
struct null { null() {} };
|
|
/// ------------ BASE CLASSES ------------
|
|
|
|
namespace MaNGOS
|
|
{
|
|
template<class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void, typename ParamType4 = void>
|
|
class _Callback
|
|
{
|
|
protected:
|
|
|
|
typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3, ParamType4);
|
|
Class *m_object;
|
|
Method m_method;
|
|
ParamType1 m_param1;
|
|
ParamType2 m_param2;
|
|
ParamType3 m_param3;
|
|
ParamType4 m_param4;
|
|
void _Execute() { (m_object->*m_method)(m_param1, m_param2, m_param3, m_param4); }
|
|
|
|
public:
|
|
|
|
_Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
|
|
: m_object(object), m_method(method),
|
|
m_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4)
|
|
{
|
|
}
|
|
|
|
_Callback(_Callback<Class, ParamType1, ParamType2, ParamType3, ParamType4> const& cb)
|
|
: m_object(cb.m_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)
|
|
{
|
|
}
|
|
};
|
|
|
|
template<class Class, typename ParamType1, typename ParamType2, typename ParamType3>
|
|
class _Callback<Class, ParamType1, ParamType2, ParamType3>
|
|
{
|
|
protected:
|
|
|
|
typedef void (Class::*Method)(ParamType1, ParamType2, ParamType3);
|
|
Class *m_object;
|
|
Method m_method;
|
|
ParamType1 m_param1;
|
|
ParamType2 m_param2;
|
|
ParamType3 m_param3;
|
|
void _Execute() { (m_object->*m_method)(m_param1, m_param2, m_param3); }
|
|
|
|
public:
|
|
_Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
|
|
: m_object(object), m_method(method),
|
|
m_param1(param1), m_param2(param2), m_param3(param3)
|
|
{
|
|
}
|
|
|
|
_Callback(_Callback<Class, ParamType1, ParamType2, ParamType3> const& cb)
|
|
: m_object(cb.m_object), m_method(cb.m_method),
|
|
m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3)
|
|
{
|
|
}
|
|
};
|
|
|
|
template<class Class, typename ParamType1, typename ParamType2>
|
|
class _Callback<Class, ParamType1, ParamType2>
|
|
{
|
|
protected:
|
|
|
|
typedef void (Class::*Method)(ParamType1, ParamType2);
|
|
Class *m_object;
|
|
Method m_method;
|
|
ParamType1 m_param1;
|
|
ParamType2 m_param2;
|
|
void _Execute() { (m_object->*m_method)(m_param1, m_param2); }
|
|
|
|
public:
|
|
|
|
_Callback(Class *object, Method method, ParamType1 param1, ParamType2 param2)
|
|
: m_object(object), m_method(method),
|
|
m_param1(param1), m_param2(param2)
|
|
{
|
|
}
|
|
|
|
_Callback(_Callback<Class, ParamType1, ParamType2> const& cb)
|
|
: m_object(cb.m_object), m_method(cb.m_method),
|
|
m_param1(cb.m_param1), m_param2(cb.m_param2)
|
|
{
|
|
}
|
|
};
|
|
|
|
template<class Class, typename ParamType1>
|
|
class _Callback<Class, ParamType1>
|
|
{
|
|
protected:
|
|
|
|
typedef void (Class::*Method)(ParamType1);
|
|
Class *m_object;
|
|
Method m_method;
|
|
ParamType1 m_param1;
|
|
void _Execute() { (m_object->*m_method)(m_param1); }
|
|
|
|
public:
|
|
|
|
_Callback(Class *object, Method method, ParamType1 param1)
|
|
: m_object(object), m_method(method),
|
|
m_param1(param1)
|
|
{
|
|
}
|
|
|
|
_Callback(_Callback<Class, ParamType1> const& cb)
|
|
: m_object(cb.m_object), m_method(cb.m_method),
|
|
m_param1(cb.m_param1)
|
|
{
|
|
}
|
|
};
|
|
|
|
template<class Class>
|
|
class _Callback<Class>
|
|
{
|
|
protected:
|
|
|
|
typedef void (Class::*Method)();
|
|
Class *m_object;
|
|
Method m_method;
|
|
void _Execute() { (m_object->*m_method)(); }
|
|
|
|
public:
|
|
_Callback(Class *object, Method method)
|
|
: m_object(object), m_method(method)
|
|
{
|
|
}
|
|
_Callback(_Callback<Class> const& cb)
|
|
: m_object(cb.m_object), m_method(cb.m_method)
|
|
{
|
|
}
|
|
};
|
|
|
|
/// ---- Statics ----
|
|
|
|
template<typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void, typename ParamType4 = void>
|
|
class _SCallback
|
|
{
|
|
protected:
|
|
|
|
typedef void (*Method)(ParamType1, ParamType2, ParamType3, ParamType4);
|
|
Method m_method;
|
|
ParamType1 m_param1;
|
|
ParamType2 m_param2;
|
|
ParamType3 m_param3;
|
|
ParamType4 m_param4;
|
|
void _Execute() { (*m_method)(m_param1, m_param2, m_param3, m_param4); }
|
|
|
|
public:
|
|
|
|
_SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
|
|
: m_method(method),
|
|
m_param1(param1), m_param2(param2), m_param3(param3), m_param4(param4)
|
|
{
|
|
}
|
|
|
|
_SCallback(_SCallback<ParamType1, ParamType2, ParamType3, ParamType4> const& cb)
|
|
: 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)
|
|
{
|
|
}
|
|
};
|
|
|
|
template<typename ParamType1, typename ParamType2, typename ParamType3>
|
|
class _SCallback<ParamType1, ParamType2, ParamType3>
|
|
{
|
|
protected:
|
|
|
|
typedef void (*Method)(ParamType1, ParamType2, ParamType3);
|
|
Method m_method;
|
|
ParamType1 m_param1;
|
|
ParamType2 m_param2;
|
|
ParamType3 m_param3;
|
|
void _Execute() { (*m_method)(m_param1, m_param2, m_param3); }
|
|
|
|
public:
|
|
_SCallback(Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
|
|
: m_method(method),
|
|
m_param1(param1), m_param2(param2), m_param3(param3)
|
|
{
|
|
}
|
|
_SCallback(_SCallback<ParamType1, ParamType2, ParamType3> const& cb)
|
|
: m_method(cb.m_method),
|
|
m_param1(cb.m_param1), m_param2(cb.m_param2), m_param3(cb.m_param3)
|
|
{
|
|
}
|
|
};
|
|
|
|
template<typename ParamType1, typename ParamType2>
|
|
class _SCallback<ParamType1, ParamType2>
|
|
{
|
|
protected:
|
|
|
|
typedef void (*Method)(ParamType1, ParamType2);
|
|
Method m_method;
|
|
ParamType1 m_param1;
|
|
ParamType2 m_param2;
|
|
void _Execute() { (*m_method)(m_param1, m_param2); }
|
|
|
|
public:
|
|
_SCallback(Method method, ParamType1 param1, ParamType2 param2)
|
|
: m_method(method),
|
|
m_param1(param1), m_param2(param2)
|
|
{
|
|
}
|
|
|
|
_SCallback(_SCallback<ParamType1, ParamType2> const& cb)
|
|
: m_method(cb.m_method),
|
|
m_param1(cb.m_param1), m_param2(cb.m_param2)
|
|
{
|
|
}
|
|
};
|
|
|
|
template<typename ParamType1>
|
|
class _SCallback<ParamType1>
|
|
{
|
|
protected:
|
|
|
|
typedef void (*Method)(ParamType1);
|
|
Method m_method;
|
|
ParamType1 m_param1;
|
|
void _Execute() { (*m_method)(m_param1); }
|
|
|
|
public:
|
|
_SCallback(Method method, ParamType1 param1)
|
|
: m_method(method),
|
|
m_param1(param1)
|
|
{
|
|
}
|
|
|
|
_SCallback(_SCallback<ParamType1> const& cb)
|
|
: m_method(cb.m_method),
|
|
m_param1(cb.m_param1)
|
|
{
|
|
}
|
|
};
|
|
|
|
template<>
|
|
class _SCallback<>
|
|
{
|
|
protected:
|
|
|
|
typedef void (*Method)();
|
|
Method m_method;
|
|
void _Execute() { (*m_method)(); }
|
|
|
|
public:
|
|
|
|
_SCallback(Method method)
|
|
: m_method(method)
|
|
{
|
|
}
|
|
|
|
_SCallback(_SCallback<> const& cb)
|
|
: m_method(cb.m_method)
|
|
{
|
|
}
|
|
};
|
|
}
|
|
|
|
/// --------- GENERIC CALLBACKS ----------
|
|
|
|
namespace MaNGOS
|
|
{
|
|
class ICallback
|
|
{
|
|
public:
|
|
|
|
virtual void Execute() = 0;
|
|
virtual ~ICallback() {}
|
|
};
|
|
|
|
template<class CB>
|
|
class _ICallback : public CB, public ICallback
|
|
{
|
|
public:
|
|
|
|
_ICallback(CB const& cb) : CB(cb)
|
|
{
|
|
}
|
|
|
|
void Execute() { CB::_Execute(); }
|
|
};
|
|
|
|
template<class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void, typename ParamType4 = void>
|
|
class Callback : public _ICallback<_Callback<Class, ParamType1, ParamType2, ParamType3, ParamType4> >
|
|
{
|
|
private:
|
|
|
|
typedef _Callback<Class, ParamType1, ParamType2, ParamType3, ParamType4> C4;
|
|
public:
|
|
|
|
Callback(Class *object, typename C4::Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3, ParamType4 param4)
|
|
: _ICallback<C4>(C4(object, method, param1, param2, param3, param4))
|
|
{
|
|
}
|
|
};
|
|
|
|
template<class Class, typename ParamType1, typename ParamType2, typename ParamType3>
|
|
class Callback<Class, ParamType1, ParamType2, ParamType3> : public _ICallback<_Callback<Class, ParamType1, ParamType2, ParamType3> >
|
|
{
|
|
private:
|
|
|
|
typedef _Callback<Class, ParamType1, ParamType2, ParamType3> C3;
|
|
public:
|
|
|
|
Callback(Class *object, typename C3::Method method, ParamType1 param1, ParamType2 param2, ParamType3 param3)
|
|
: _ICallback<C3>(C3(object, method, param1, param2, param3))
|
|
{
|
|
}
|
|
};
|
|
|
|
template<class Class, typename ParamType1, typename ParamType2>
|
|
class Callback<Class, ParamType1, ParamType2> : public _ICallback<_Callback<Class, ParamType1, ParamType2> >
|
|
{
|
|
private:
|
|
|
|
typedef _Callback<Class, ParamType1, ParamType2> C2;
|
|
|
|
public:
|
|
Callback(Class *object, typename C2::Method method, ParamType1 param1, ParamType2 param2)
|
|
: _ICallback<C2>(C2(object, method, param1, param2))
|
|
{
|
|
}
|
|
};
|
|
|
|
template<class Class, typename ParamType1>
|
|
class Callback<Class, ParamType1> : public _ICallback<_Callback<Class, ParamType1> >
|
|
{
|
|
private:
|
|
|
|
typedef _Callback<Class, ParamType1> C1;
|
|
|
|
public:
|
|
|
|
Callback(Class *object, typename C1::Method method, ParamType1 param1)
|
|
: _ICallback<C1>(C1(object, method, param1))
|
|
{
|
|
}
|
|
};
|
|
|
|
template<class Class>
|
|
class Callback<Class> : public _ICallback<_Callback<Class> >
|
|
{
|
|
private:
|
|
|
|
typedef _Callback<Class> C0;
|
|
|
|
public:
|
|
|
|
Callback(Class *object, typename C0::Method method)
|
|
: _ICallback<C0>(C0(object, method))
|
|
{
|
|
}
|
|
};
|
|
}
|
|
|
|
/// ---------- QUERY CALLBACKS -----------
|
|
|
|
class QueryResult;
|
|
|
|
namespace MaNGOS
|
|
{
|
|
class IQueryCallback
|
|
{
|
|
public:
|
|
|
|
virtual void Execute() = 0;
|
|
virtual ~IQueryCallback() {}
|
|
virtual void SetResult(QueryResult* result) = 0;
|
|
virtual QueryResult* GetResult() = 0;
|
|
};
|
|
|
|
template<class CB>
|
|
class _IQueryCallback : public CB, public IQueryCallback
|
|
{
|
|
public:
|
|
|
|
_IQueryCallback(CB const& cb) : CB(cb)
|
|
{
|
|
}
|
|
|
|
void Execute() { CB::_Execute(); }
|
|
void SetResult(QueryResult* result) { CB::m_param1 = result; }
|
|
QueryResult* GetResult() { return CB::m_param1; }
|
|
};
|
|
|
|
template<class Class, typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void>
|
|
class QueryCallback : public _IQueryCallback<_Callback<Class, QueryResult*, ParamType1, ParamType2, ParamType3> >
|
|
{
|
|
private:
|
|
|
|
typedef _Callback<Class, QueryResult*, ParamType1, ParamType2, ParamType3> QC3;
|
|
|
|
public:
|
|
|
|
QueryCallback(Class *object, typename QC3::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2, ParamType3 param3)
|
|
: _IQueryCallback<QC3>(QC3(object, method, result, param1, param2, param3))
|
|
{
|
|
}
|
|
};
|
|
|
|
template<class Class, typename ParamType1, typename ParamType2>
|
|
class QueryCallback<Class, ParamType1, ParamType2> : public _IQueryCallback<_Callback<Class, QueryResult*, ParamType1, ParamType2> >
|
|
{
|
|
private:
|
|
|
|
typedef _Callback<Class, QueryResult*, ParamType1, ParamType2> QC2;
|
|
|
|
public:
|
|
|
|
QueryCallback(Class *object, typename QC2::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2)
|
|
: _IQueryCallback<QC2>(QC2(object, method, result, param1, param2))
|
|
{
|
|
}
|
|
};
|
|
|
|
template<class Class, typename ParamType1>
|
|
class QueryCallback<Class, ParamType1> : public _IQueryCallback<_Callback<Class, QueryResult*, ParamType1> >
|
|
{
|
|
private:
|
|
|
|
typedef _Callback<Class, QueryResult*, ParamType1> QC1;
|
|
|
|
public:
|
|
|
|
QueryCallback(Class *object, typename QC1::Method method, QueryResult* result, ParamType1 param1)
|
|
: _IQueryCallback<QC1>(QC1(object, method, result, param1))
|
|
{
|
|
}
|
|
};
|
|
|
|
template<class Class>
|
|
class QueryCallback<Class> : public _IQueryCallback<_Callback<Class, QueryResult*> >
|
|
{
|
|
private:
|
|
|
|
typedef _Callback<Class, QueryResult*> QC0;
|
|
|
|
public:
|
|
QueryCallback(Class *object, typename QC0::Method method, QueryResult* result)
|
|
: _IQueryCallback<QC0>(QC0(object, method, result))
|
|
{
|
|
}
|
|
};
|
|
|
|
/// ---- Statics ----
|
|
|
|
template<typename ParamType1 = void, typename ParamType2 = void, typename ParamType3 = void>
|
|
class SQueryCallback : public _IQueryCallback<_SCallback<QueryResult*, ParamType1, ParamType2, ParamType3> >
|
|
{
|
|
private:
|
|
|
|
typedef _SCallback<QueryResult*, ParamType1, ParamType2, ParamType3> QC3;
|
|
|
|
public:
|
|
|
|
SQueryCallback(typename QC3::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2, ParamType3 param3)
|
|
: _IQueryCallback<QC3>(QC3(method, result, param1, param2, param3))
|
|
{
|
|
}
|
|
};
|
|
|
|
template<typename ParamType1, typename ParamType2>
|
|
class SQueryCallback < ParamType1, ParamType2 > : public _IQueryCallback<_SCallback<QueryResult*, ParamType1, ParamType2> >
|
|
{
|
|
private:
|
|
|
|
typedef _SCallback<QueryResult*, ParamType1, ParamType2> QC2;
|
|
|
|
public:
|
|
|
|
SQueryCallback(typename QC2::Method method, QueryResult* result, ParamType1 param1, ParamType2 param2)
|
|
: _IQueryCallback<QC2>(QC2(method, result, param1, param2))
|
|
{
|
|
}
|
|
};
|
|
|
|
template<typename ParamType1>
|
|
class SQueryCallback<ParamType1> : public _IQueryCallback<_SCallback<QueryResult*, ParamType1> >
|
|
{
|
|
private:
|
|
|
|
typedef _SCallback<QueryResult*, ParamType1> QC1;
|
|
|
|
public:
|
|
|
|
SQueryCallback(typename QC1::Method method, QueryResult* result, ParamType1 param1)
|
|
: _IQueryCallback<QC1>(QC1(method, result, param1))
|
|
{
|
|
}
|
|
};
|
|
|
|
template<>
|
|
class SQueryCallback<> : public _IQueryCallback<_SCallback<QueryResult*> >
|
|
{
|
|
private:
|
|
|
|
typedef _SCallback<QueryResult*> QC0;
|
|
|
|
public:
|
|
|
|
SQueryCallback(QC0::Method method, QueryResult* result)
|
|
: _IQueryCallback<QC0>(QC0(method, result))
|
|
{
|
|
}
|
|
};
|
|
}
|
|
|
|
#endif
|