pcsx2/common/include/Utilities/EventSource.h

/*  PCSX2 - PS2 Emulator for PCs
 *  Copyright (C) 2002-2009  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
 *  ation, either version 3 of the License, or (at your option) any later version.
 *
 *  PCSX2 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 PCSX2.
 *  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#include <list>
#include "Threading.h"

// --------------------------------------------------------------------------------------
//  EventSource< template EvtType >
// --------------------------------------------------------------------------------------

template< typename ListenerType >
class EventSource
{
public:
	typedef typename ListenerType::EvtParams		EvtParams;
	typedef typename std::list< ListenerType* >		ListenerList;
	typedef typename ListenerList::iterator			ListenerIterator;

protected:
	typedef typename ListenerList::const_iterator	ConstIterator;

	ListenerList	m_listeners;

	// This is a cached copy of the listener list used to handle standard dispatching, which
	// allows for self-modification of the EventSource's listener list by the listeners.
	// Translation: The dispatcher uses this copy instead, to avoid iterator invalidation.
	ListenerList	m_cache_copy;
	bool			m_cache_valid;
	
	Threading::Mutex m_listeners_lock;

public:
	EventSource()
	{
		m_cache_valid = false;
	}

	virtual ~EventSource() throw() {}

	virtual ListenerIterator Add( ListenerType& listener );
	virtual void Remove( ListenerType& listener );
	virtual void Remove( const ListenerIterator& listenerHandle );
	
	void Add( ListenerType* listener )
	{
		if( listener == NULL ) return;
		Add( *listener );
	}
	
	void Remove( ListenerType* listener )
	{
		if( listener == NULL ) return;
		Remove( *listener );
	}

	void Dispatch( const EvtParams& params );

protected:
	virtual ListenerIterator _AddFast_without_lock( ListenerType& listener );
	virtual void _DispatchRaw( ListenerIterator iter, const ListenerIterator& iend, const EvtParams& params );
};

// --------------------------------------------------------------------------------------
//  EventListenerBinding< typename EvtType >
// --------------------------------------------------------------------------------------
// Encapsulated event listener binding, provides the "benefits" of object unwinding.
//
template< typename ListenerType >
class EventListenerBinding
{
public:
	typedef typename EventSource<ListenerType>::EventSourceType			EventSourceType;
	typedef typename EventSource<ListenerType>::ListenerIterator		ListenerIterator;

protected:
	EventSourceType&	m_source;
	const ListenerType	m_listener;
	ListenerIterator	m_iter;
	bool				m_attached;

public:
	EventListenerBinding( EventSourceType& source, ListenerType& listener, bool autoAttach=true )
		: m_source( source )
		, m_listener( listener )
	{
		m_attached = false;

		// If you want to assert on null pointers, you'll need to do the check yourself.  There's
		// too many cases where silently ignoring null pointers is the desired behavior.
		//if( !pxAssertDev( listener.OnEvent != NULL, "NULL listener callback function." ) ) return;
		if( autoAttach ) Attach();
	}

	virtual ~EventListenerBinding() throw()
	{
		Detach();
	}

	void Detach()
	{
		if( !m_attached ) return;
		m_source.Remove( m_iter );
		m_attached = false;
	}

	void Attach()
	{
		if( m_attached || (m_listener.OnEvent == NULL) ) return;
		m_iter = m_source.Add( m_listener );
		m_attached = true;
	}
};

// --------------------------------------------------------------------------------------
//  IEventDispatcher
// --------------------------------------------------------------------------------------
// This class is used as a base interface for EventListeners.  It allows the listeners to do
// customized dispatching of several event types into "user friendly" function overrides.
//
template< typename EvtParams >
class IEventDispatcher
{
protected:
	IEventDispatcher() {}

public:
	virtual ~IEventDispatcher() throw() {}
	virtual void DispatchEvent( const EvtParams& params )=0;
};