ultimatepp/uppsrc/Core/Callback5.h

template < class X, class T1, class T2, class T3, class T4, class T5, class HC = X >
struct CallbackActionCallArg5 : public CallbackAction {
	X         x;
	T1        arg1;
	T2        arg2;
	T3        arg3;
	T4        arg4;
	T5        arg5;
	void    Execute() { x ( arg1, arg2, arg3, arg4, arg5 ); }

	CallbackActionCallArg5 ( X x, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
	: x(x), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)), arg5(pick(arg5)) {}
};


template <class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
Callback callback5 ( void ( *fn ) ( Q1, Q2, Q3, Q4, Q5 ), T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
{
	return Callback(new CallbackActionCallArg5 < void (*)( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5, uintptr_t >
	               (fn, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5)));
}

template <class O, class M, class T1, class T2, class T3, class T4, class T5>
struct CallbackMethodActionArg5 : public CallbackAction {
	O  *object;
	M   method;
	T1        arg1;
	T2        arg2;
	T3        arg3;
	T4        arg4;
	T5        arg5;

	void    Execute()
	{
		( object->*method ) ( arg1, arg2, arg3, arg4, arg5 );
	}

	CallbackMethodActionArg5 ( O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
	: object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)), arg5(pick(arg5)) {}
};


template <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
Callback callback5 ( O *object, void ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ), T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
{
	return Callback(new CallbackMethodActionArg5 < O, void ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5 >
	                 (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5)));
}

template <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
Callback callback5 ( O *object, void ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
{
	return Callback ( new CallbackMethodActionArg5 < O, void ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1, T2, T3, T4, T5 >
	                 (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5)));
}

template <class O, class M, class T1, class T2, class T3, class T4, class T5>
struct CallbackMethodActionArg5Pte : public CallbackAction {
	Ptr<O>  object;
	M       method;
	T1      arg1;
	T2      arg2;
	T3      arg3;
	T4      arg4;
	T5      arg5;

	void    Execute()
	{
		( object->*method ) ( arg1, arg2, arg3, arg4, arg5 );
	}

	CallbackMethodActionArg5Pte ( O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
			: object ( object ), method ( method ), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)), arg5(pick(arg5)) {}
};

template <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
Callback pteback5 ( O *object, void ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ), T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
{
	return Callback(new CallbackMethodActionArg5Pte < O, void ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5 >
					(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5) ) );
}

template <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
Callback pteback5 ( O *object, void ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
{
	return Callback(new CallbackMethodActionArg5Pte < O, void ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1, T2, T3, T4, T5 >
					(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5) ) );
}

// -----------------------------------------------

template < class X, class T1, class T2, class T3, class T4, class T5, class HC = X >
struct GateActionCallArg5 : public GateAction {
	X         x;
	T1        arg1;
	T2        arg2;
	T3        arg3;
	T4        arg4;
	T5        arg5;
	bool      Execute() { return x ? x ( arg1, arg2, arg3, arg4, arg5 ) : false; }

	GateActionCallArg5 ( X x, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
	: x(x), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)), arg5(pick(arg5)) {}
};


template <class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
Gate callback5 ( bool ( *fn ) ( Q1, Q2, Q3, Q4, Q5 ), T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
{
	return Gate(new GateActionCallArg5 < bool (*)( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5, uintptr_t >
	               (fn, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5)));
}

template <class O, class M, class T1, class T2, class T3, class T4, class T5>
struct GateMethodActionArg5 : public GateAction {
	O        *object;
	M         method;
	T1        arg1;
	T2        arg2;
	T3        arg3;
	T4        arg4;
	T5        arg5;
	bool      Execute() { return object ? ( object->*method ) ( arg1, arg2, arg3, arg4, arg5 ) : false; }

	GateMethodActionArg5 ( O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
	: object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)), arg5(pick(arg5)) {}
};


template <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
Gate callback5 ( O *object, bool ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ), T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
{
	return Gate(new GateMethodActionArg5 < O, bool ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5 >
	                 (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5)));
}

template <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
Gate callback5 ( O *object, bool ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
{
	return Gate ( new GateMethodActionArg5 < O, bool ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1, T2, T3, T4, T5 >
	                 (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5)));
}

template <class O, class M, class T1, class T2, class T3, class T4, class T5>
struct GateMethodActionArg5Pte : public GateAction {
	Ptr<O>  object;
	M       method;
	T1      arg1;
	T2      arg2;
	T3      arg3;
	T4      arg4;
	T5      arg5;
	bool    Execute() { return object ? ( object->*method ) ( arg1, arg2, arg3, arg4, arg5 ) : false; }

	GateMethodActionArg5Pte ( O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
			: object ( object ), method ( method ), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)), arg5(pick(arg5)) {}
};

template <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
Gate pteback5 ( O *object, bool ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ), T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
{
	return Gate(new GateMethodActionArg5Pte < O, bool ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5 >
					(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5) ) );
}

template <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
Gate pteback5 ( O *object, bool ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
{
	return Gate(new GateMethodActionArg5Pte < O, bool ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1, T2, T3, T4, T5 >
					(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5) ) );
}

// ----------------------------------------

template <class P1, class P2, class P3, class P4, class P5>
struct Callback5Action
{
	Atomic  count;

	virtual void Execute ( P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) = 0;
	virtual bool IsValid() const
	{
		return true;
	}

	Callback5Action()
	{
		count = 1;
	}

	virtual ~Callback5Action() {}
};

#ifdef HAS_LAMBDA
template <class P1, class P2, class P3, class P4, class P5>

struct LambdaCallback5 : public Callback5Action<P1, P2, P3, P4, P5>
{
	std::function < void ( P1, P2, P3, P4 , P5 ) > fn;
	virtual void Execute ( P1 p1, P2 p2, P3 p3, P4 p4 , P5 p5 )
	{
		fn ( p1, p2, p3, p4, p5 );
	}

	LambdaCallback5 ( std::function < void ( P1, P2, P3, P4, P5 ) > fn ) : fn ( fn ) {}
};

#endif

template <class P1, class P2, class P3, class P4, class P5>

class Callback5 : Moveable< Callback5<P1, P2, P3, P4, P5> >
{
		Callback5Action<P1, P2, P3, P4, P5> *action;

		void Retain() const
		{
			if ( action )
				AtomicInc ( action->count );
		}

		void Release()
		{
			if ( action  && AtomicDec ( action->count ) == 0 )
				delete action;
		}

		bool operator== ( const Callback5& );
		bool operator!= ( const Callback5& );

	public:
		typedef Callback5 CLASSNAME;

		Callback5& operator= ( const Callback5& c );
		Callback5 ( const Callback5& c );
		void Clear()
		{
			Release();
			action = NULL;
		}


		operator bool() const
		{
			return action && action->IsValid();
		}

		void Execute ( P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) const
		{
			if ( action )
				action->Execute ( p1, p2, p3, p4, p5 );
		}

		void operator() ( P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) const
		{
			Execute ( p1, p2, p3, p4, p5 );
		}

		explicit Callback5 ( Callback5Action <P1, P2, P3, P4, P5> *newaction )
		{
			action = newaction;
		}

		Callback5()
		{
			action = NULL;
		}

		Callback5 ( _CNULL )
		{
			action = NULL;
		}

		~Callback5();

#ifdef CPP_11
		template <class T>
		Callback5 ( AnyLambda<T> l )
		{
			action = new LambdaCallback5<P1, P2, P3, P4, P5> ( l.l );
		}

#endif

		static Callback5 Empty()
		{
			return CNULL;
		}
};

template <class P1, class P2, class P3, class P4, class P5>
Callback5<P1, P2, P3, P4, P5>& Callback5<P1, P2, P3, P4, P5>::operator= ( const Callback5 & c )
{
	c.Retain();
	Release();
	action = c.action;
	return *this;
}

template <class P1, class P2, class P3, class P4, class P5>
Callback5<P1, P2, P3, P4, P5>::Callback5 ( const Callback5& c )
{
	action = c.action;
	Retain();
}

template <class P1, class P2, class P3, class P4, class P5>
Callback5<P1, P2, P3, P4, P5>::~Callback5()
{
	Release();
}