/// Traits structure specialized for defined events using the event definition macros.
template< typename T >
struct ArgumentTraits
{
};

template< typename T >
class Event : Noncopyable // Cannot copy events.
{
public:

	/// Arguments typedef for convenience.
	typedef ArgumentTraits< T > Arguments;
	/// Listener function pointer type.
	typedef void ( * ListenerFunc )( Arguments const & );
	
	/// Get global event.
	static Event< T > & Global();

	/// Empty constructor.
	Event() {}

	/// Empty destructor.
	~Event() {}

	/// Raise an event with arguments.
	void Raise( Arguments const & args );

	/// Register a listener function to the event.
	void Register( ListenerFunc func );

	/// Increment operator used to register a listener function to the event.
	void operator += ( ListenerFunc func );

	/// Unregister a listener function from the event.
	void Unregister( ListenerFunc func );

	/// Decrement operator used to unregister a listener function from the event.
	void operator -= ( ListenerFunc func );

	/// Register a listener object to the event.
	template< typename O >
	void Register( O & obj );
	
	/// Increment operator used to register a listener object to the event.
	template< typename O >
	void operator += ( O & obj );

	/// Unregister a listener object from the event.
	template< typename O >
	void Unregister( O & obj );

	/// Decrement operator used to unregister a listener object from the event.
	template< typename O >
	void operator -= ( O & obj );

	/// Clears all registered event listeners.
	void Clear();

private:

	fd::delegate1< void, Arguments const & > mDelegate; ///< Event delegate.
};

template< typename T >
Event< T > & Event< T >::Global()
{
	static Event< T > global;
	return global;
}

template< typename T >
void Event< T >::Raise( Arguments const & args )
{
	if( mDelegate.count() )
		mDelegate( args );
}

template< typename T >
void Event< T >::operator += ( ListenerFunc func )
{
	Register( func );
}

template< typename T >
void Event< T >::operator -= ( ListenerFunc func )
{
	Unregister( func );
}

template< typename T >
void Event< T >::Register( ListenerFunc func )
{
	mDelegate.add( func );
}

template< typename T >
void Event< T >::Unregister( ListenerFunc func )
{
	mDelegate.remove( func );
}

template< typename T >
template< typename O >
void Event< T >::Register( O & obj )
{
	mDelegate.add( boost::ref( obj ) );
}

template< typename T >
template< typename O >
void Event< T >::operator += ( O & obj )
{
	Register( obj );
}

template< typename T >
template< typename O >
void Event< T >::Unregister( O & obj )
{
	mDelegate.remove( boost::ref( obj ) );
}

template< typename T >
template< typename O >
void Event< T >::operator -= ( O & obj )
{
	Unregister( obj );
}

/// Macro to define a new event.
/// Arguments is typedef-ed for convenience, as seen below.
#define BEGIN_EVENT_DEF( eventName ) 	struct eventName { typedef ::ArgumentTraits< eventName > Arguments; }; 	template<> struct ::ArgumentTraits< eventName > {

/// Close event definition.
#define END_EVENT_DEF };

BEGIN_EVENT_DEF( OnTest )
	int x;
	int y;
END_EVENT_DEF

class TestListener
{
public:
	void operator () ( OnTest::Arguments const & args )
	{
		printf( "[Object] %d, %d", args.x, args.y );
	}
};

void TestFunction( OnTest::Arguments const & args )
{
	printf( "[Function] %d, %d", args.x, args.y );
}

Event< OnTest > evt;
TestListener listener;

evt.Register( listener );
evt.Register( TestFunction );
evt.Raise( data );
evt.Unregister( listener );
evt.Unregister( TestFunction );
evt.Raise( data );

// OR

evt += listener;
evt += TestFunction ;
evt.Raise( data );
evt -= listener;
evt -= TestFunction;
evt.Raise( data );

class Listener{public:	void operator () ( OnTest::Arguments const & args )	{		DoSomething( args );		DoSomethingElse( args );	}		void DoSomething( OnTest::Arguments const & args );	void DoSomethingElse( OnTest::Arguments const & args );};

    class Slot    {    public:        virtual Slot *clone() const = 0;        virtual void operator()(void *emitter) = 0;    };    class FunctionSlot: public Slot    {        typedef void (*FUNCTION)(); // no parameters, but you could use your Argument class for this    public:        FunctionSlot(FUNCTION ifunction);        FunctionSlot(const FunctionSlot &instance);        FunctionSlot *clone() const;        FUNCTION function() const;        void operator()(void *emitter);    private:        FUNCTION _function;    };    template <class T> // T = class    class MemberFunctionSlot: public Slot    {        typedef T *OBJECT;        typedef void (T::*MEMBER_FUNCTION)(); // no parameters, but you could use your Argument class for this    public:        MemberFunctionSlot(OBJECT iobject, MEMBER_FUNCTION imember_function);        MemberFunctionSlot(const MemberFunctionSlot<T> &instance);        MemberFunctionSlot<T> *clone() const;        OBJECT object() const;        MEMBER_FUNCTION member_function() const;        void object(OBJECT iobject);        void operator()(void *emitter);    private:        OBJECT _object;        MEMBER_FUNCTION _member_function;    };