#if !defined( INCLUDED_ISIGNAL_H )
#define INCLUDED_ISIGNAL_H

#include "generic/callback.h"
#include "signal/signalfwd.h"

class SignalHandlerResult
{
bool value;
public:
explicit SignalHandlerResult( bool value ) : value( value ){
}
bool operator==( SignalHandlerResult other ) const {
	return value == other.value;
}
bool operator!=( SignalHandlerResult other ) const {
	return !operator==( other );
}
};

const SignalHandlerResult SIGNAL_CONTINUE_EMISSION = SignalHandlerResult( false );
const SignalHandlerResult SIGNAL_STOP_EMISSION = SignalHandlerResult( true );

template<typename Caller>
class SignalHandlerCaller1
{
public:
typedef typename Caller::first_argument_type first_argument_type;
typedef SignalHandlerResult result_type;
static result_type call( first_argument_type a1 ){
	Caller::call( a1 );
	return SIGNAL_CONTINUE_EMISSION;
}
};

template<typename Caller>
class SignalHandlerCaller2
{
public:
typedef typename Caller::first_argument_type first_argument_type;
typedef typename Caller::second_argument_type second_argument_type;
typedef SignalHandlerResult result_type;
static result_type call( first_argument_type a1, second_argument_type a2 ){
	Caller::call( a1, a2 );
	return SIGNAL_CONTINUE_EMISSION;
}
};

template<typename Caller>
class SignalHandlerCaller3
{
public:
typedef typename Caller::first_argument_type first_argument_type;
typedef typename Caller::second_argument_type second_argument_type;
typedef typename Caller::third_argument_type third_argument_type;
typedef SignalHandlerResult result_type;
static result_type call( first_argument_type a1, second_argument_type a2, third_argument_type a3 ){
	Caller::call( a1, a2, a3 );
	return SIGNAL_CONTINUE_EMISSION;
}
};

template<typename Caller>
class SignalHandlerCaller4
{
public:
typedef typename Caller::first_argument_type first_argument_type;
typedef typename Caller::second_argument_type second_argument_type;
typedef typename Caller::third_argument_type third_argument_type;
typedef typename Caller::fourth_argument_type fourth_argument_type;
typedef SignalHandlerResult result_type;
static result_type call( first_argument_type a1, second_argument_type a2, third_argument_type a3, fourth_argument_type a4 ){
	Caller::call( a1, a2, a3, a4 );
	return SIGNAL_CONTINUE_EMISSION;
}
};

class SignalHandler : public Callback0<SignalHandlerResult>
{
public:
template<typename Caller>
SignalHandler( const BindFirstOpaque<Caller>& caller )
	: Callback0<SignalHandlerResult>( BindFirstOpaque<typename TypeEqual<
														  SignalHandlerResult,
														  Caller,
														  SignalHandlerCaller1<Caller>,
														  typename Caller::result_type
														  >::type>( caller.getBound() ) ){
}
};

template<typename Caller>
inline SignalHandler makeSignalHandler( const BindFirstOpaque<Caller>& caller ){
	return SignalHandler( caller );
}
template<typename Caller>
inline SignalHandler makeSignalHandler( const Caller& caller, typename Caller::first_argument_type callee ){
	return SignalHandler( BindFirstOpaque<Caller>( callee ) );
}


template<typename FirstArgument>
class SignalHandler1 : public Callback1<FirstArgument, SignalHandlerResult>
{
public:
template<typename Caller>
SignalHandler1( const BindFirstOpaque1<Caller>& caller )
	: Callback1<FirstArgument, SignalHandlerResult>( BindFirstOpaque1<typename TypeEqual<
																		  SignalHandlerResult,
																		  Caller,
																		  SignalHandlerCaller2<Caller>,
																		  typename Caller::result_type
																		  >::type>( caller.getBound() ) ){
}
};

template<typename Caller>
inline SignalHandler1<typename Caller::second_argument_type> makeSignalHandler1( const BindFirstOpaque1<Caller>& caller ){
	return SignalHandler1<typename Caller::second_argument_type>( caller );
}
template<typename Caller>
inline SignalHandler1<typename Caller::second_argument_type> makeSignalHandler1( const Caller& caller, typename Caller::first_argument_type callee ){
	return SignalHandler1<typename Caller::second_argument_type>( BindFirstOpaque1<Caller>( callee ) );
}


template<typename FirstArgument, typename SecondArgument>
class SignalHandler2 : public Callback2<FirstArgument, SecondArgument, SignalHandlerResult>
{
public:
template<typename Caller>
SignalHandler2( const BindFirstOpaque2<Caller>& caller )
	: Callback2<FirstArgument, SecondArgument, SignalHandlerResult>( BindFirstOpaque2<typename TypeEqual<
																						  SignalHandlerResult,
																						  Caller,
																						  SignalHandlerCaller3<Caller>,
																						  typename Caller::result_type
																						  >::type>( caller.getBound() ) ){
}
};

template<typename Caller>
inline SignalHandler2<
	typename Caller::second_argument_type,
	typename Caller::third_argument_type
	> makeSignalHandler2( const BindFirstOpaque2<Caller>& caller ){
	return SignalHandler2<
			   typename Caller::second_argument_type,
			   typename Caller::third_argument_type
			   >( caller );
}
template<typename Caller>
inline SignalHandler2<
	typename Caller::second_argument_type,
	typename Caller::third_argument_type
	> makeSignalHandler2( const Caller& caller, typename Caller::first_argument_type callee ){
	return SignalHandler2<
			   typename Caller::second_argument_type,
			   typename Caller::third_argument_type
			   >( BindFirstOpaque2<Caller>( callee ) );
}


template<typename FirstArgument, typename SecondArgument, typename ThirdArgument>
class SignalHandler3 : public Callback3<FirstArgument, SecondArgument, ThirdArgument, SignalHandlerResult>
{
public:
template<typename Caller>
SignalHandler3( const BindFirstOpaque3<Caller>& caller )
	: Callback3<FirstArgument, SecondArgument, ThirdArgument, SignalHandlerResult>( BindFirstOpaque3<typename TypeEqual<
																										 SignalHandlerResult,
																										 Caller,
																										 SignalHandlerCaller4<Caller>,
																										 typename Caller::result_type
																										 >::type>( caller.getBound() ) ){
}
};

template<typename Caller>
inline SignalHandler3<
	typename Caller::second_argument_type,
	typename Caller::third_argument_type,
	typename Caller::fourth_argument_type
	> makeSignalHandler3( const BindFirstOpaque3<Caller>& caller ){
	return SignalHandler3<
			   typename Caller::second_argument_type,
			   typename Caller::third_argument_type,
			   typename Caller::fourth_argument_type
			   >( caller );
}
template<typename Caller>
inline SignalHandler3<
	typename Caller::second_argument_type,
	typename Caller::third_argument_type,
	typename Caller::fourth_argument_type
	> makeSignalHandler3( const Caller& caller, typename Caller::first_argument_type callee ){
	return SignalHandler3<
			   typename Caller::second_argument_type,
			   typename Caller::third_argument_type,
			   typename Caller::fourth_argument_type
			   >( BindFirstOpaque3<Caller>( callee ) );
}

#endif