lldb/source/Core/Broadcaster.cpp - llvm-project - Git at Google

 //===-- Broadcaster.cpp -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

 #include "lldb/Core/Broadcaster.h"

 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/lldb-private-log.h"

 using namespace lldb;
 using namespace lldb_private;

 Broadcaster::Broadcaster (BroadcasterManager *manager, const char *name) :
     m_broadcaster_name (name),
     m_listeners (),
     m_listeners_mutex (Mutex::eMutexTypeRecursive),
     m_hijacking_listeners(),
     m_hijacking_masks(),
     m_manager (manager)
 {
     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
     if (log)
         log->Printf ("%p Broadcaster::Broadcaster(\"%s\")", this, m_broadcaster_name.AsCString());

 }

 Broadcaster::~Broadcaster()
 {
     LogSP log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
     if (log)
         log->Printf ("%p Broadcaster::~Broadcaster(\"%s\")", this, m_broadcaster_name.AsCString());

     Clear();
 }

 void
 Broadcaster::CheckInWithManager ()
 {
     if (m_manager != NULL)
     {
         m_manager->SignUpListenersForBroadcaster(*this);
     }
 }

 void
 Broadcaster::Clear()
 {
     Mutex::Locker listeners_locker(m_listeners_mutex);

     // Make sure the listener forgets about this broadcaster. We do
     // this in the broadcaster in case the broadcaster object initiates
     // the removal.

     collection::iterator pos, end = m_listeners.end();
     for (pos = m_listeners.begin(); pos != end; ++pos)
         pos->first->BroadcasterWillDestruct (this);

     m_listeners.clear();
 }
 const ConstString &
 Broadcaster::GetBroadcasterName ()
 {
     return m_broadcaster_name;
 }

 bool
 Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const
 {
     uint32_t num_names_added = 0;
     if (event_mask && !m_event_names.empty())
     {
         event_names_map::const_iterator end = m_event_names.end();
         for (uint32_t bit=1u, mask=event_mask; mask != 0 && bit != 0; bit <<= 1, mask >>= 1)
         {
             if (mask & 1)
             {
                 event_names_map::const_iterator pos = m_event_names.find(bit);
                 if (pos != end)
                 {
                     if (num_names_added > 0)
                         s.PutCString(", ");

                     if (prefix_with_broadcaster_name)
                     {
                         s.PutCString (m_broadcaster_name.GetCString());
                         s.PutChar('.');
                     }
                     s.PutCString(pos->second.c_str());
                     ++num_names_added;
                 }
             }
         }
     }
     return num_names_added > 0;
 }

 void
 Broadcaster::AddInitialEventsToListener (Listener *listener, uint32_t requested_events)
 {

 }

 uint32_t
 Broadcaster::AddListener (Listener* listener, uint32_t event_mask)
 {
     if (listener == NULL)
         return 0;

     Mutex::Locker locker(m_listeners_mutex);
     collection::iterator pos, end = m_listeners.end();

     collection::iterator existing_pos = end;
     // See if we already have this listener, and if so, update its mask
     uint32_t taken_event_types = 0;
     for (pos = m_listeners.begin(); pos != end; ++pos)
     {
         if (pos->first == listener)
             existing_pos = pos;
     // For now don't descriminate on who gets what
     // FIXME: Implement "unique listener for this bit" mask
     //  taken_event_types |= pos->second;
     }

     // Each event bit in a Broadcaster object can only be used
     // by one listener
     uint32_t available_event_types = ~taken_event_types & event_mask;

     if (available_event_types)
     {
         // If we didn't find our listener, add it
         if (existing_pos == end)
         {
             // Grant a new listener the available event bits
             m_listeners.push_back(std::make_pair(listener, available_event_types));
         }
         else
         {
             // Grant the existing listener the available event bits
             existing_pos->second |= available_event_types;
         }

         // Individual broadcasters decide whether they have outstanding data when a
         // listener attaches, and insert it into the listener with this method.

         AddInitialEventsToListener (listener, available_event_types);
     }

     // Return the event bits that were granted to the listener
     return available_event_types;
 }

 bool
 Broadcaster::EventTypeHasListeners (uint32_t event_type)
 {
     Mutex::Locker locker (m_listeners_mutex);

     if (m_hijacking_listeners.size() > 0 && event_type & m_hijacking_masks.back())
         return true;

     if (m_listeners.empty())
         return false;

     collection::iterator pos, end = m_listeners.end();
     for (pos = m_listeners.begin(); pos != end; ++pos)
     {
         if (pos->second & event_type)
             return true;
     }
     return false;
 }

 bool
 Broadcaster::RemoveListener (Listener* listener, uint32_t event_mask)
 {
     Mutex::Locker locker(m_listeners_mutex);
     collection::iterator pos, end = m_listeners.end();
     // See if we already have this listener, and if so, update its mask
     for (pos = m_listeners.begin(); pos != end; ++pos)
     {
         if (pos->first == listener)
         {
             // Relinquish all event bits in "event_mask"
             pos->second &= ~event_mask;
             // If all bits have been relinquished then remove this listener
             if (pos->second == 0)
                 m_listeners.erase (pos);
             return true;
         }
     }
     return false;
 }

 void
 Broadcaster::BroadcastEvent (EventSP &event_sp)
 {
     return PrivateBroadcastEvent (event_sp, false);
 }

 void
 Broadcaster::BroadcastEventIfUnique (EventSP &event_sp)
 {
     return PrivateBroadcastEvent (event_sp, true);
 }

 void
 Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique)
 {
     // Can't add a NULL event...
     if (event_sp.get() == NULL)
         return;

     // Update the broadcaster on this event
     event_sp->SetBroadcaster (this);

     const uint32_t event_type = event_sp->GetType();

     Mutex::Locker event_types_locker(m_listeners_mutex);

     Listener *hijacking_listener = NULL;
     if (!m_hijacking_listeners.empty())
     {
         assert (!m_hijacking_masks.empty());
         hijacking_listener = m_hijacking_listeners.back();
         if ((event_type & m_hijacking_masks.back()) == 0)
             hijacking_listener = NULL;
     }

     LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
     if (log)
     {
         StreamString event_description;
         event_sp->Dump  (&event_description);
         log->Printf ("%p Broadcaster(\"%s\")::BroadcastEvent (event_sp = {%s}, unique =%i) hijack = %p",
                      this,
                      m_broadcaster_name.AsCString(""),
                      event_description.GetData(),
                      unique,
                      hijacking_listener);
     }

     if (hijacking_listener)
     {
         if (unique && hijacking_listener->PeekAtNextEventForBroadcasterWithType (this, event_type))
             return;
         hijacking_listener->AddEvent (event_sp);
     }
     else
     {
         collection::iterator pos, end = m_listeners.end();


         // Iterate through all listener/mask pairs
         for (pos = m_listeners.begin(); pos != end; ++pos)
         {
             // If the listener's mask matches any bits that we just set, then
             // put the new event on its event queue.
             if (event_type & pos->second)
             {
                 if (unique && pos->first->PeekAtNextEventForBroadcasterWithType (this, event_type))
                     continue;
                 pos->first->AddEvent (event_sp);
             }
         }
     }
 }

 void
 Broadcaster::BroadcastEvent (uint32_t event_type, EventData *event_data)
 {
     EventSP event_sp (new Event (event_type, event_data));
     PrivateBroadcastEvent (event_sp, false);
 }

 void
 Broadcaster::BroadcastEventIfUnique (uint32_t event_type, EventData *event_data)
 {
     EventSP event_sp (new Event (event_type, event_data));
     PrivateBroadcastEvent (event_sp, true);
 }

 bool
 Broadcaster::HijackBroadcaster (Listener *listener, uint32_t event_mask)
 {
     Mutex::Locker event_types_locker(m_listeners_mutex);

     LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
     if (log)
     {
         log->Printf ("%p Broadcaster(\"%s\")::HijackBroadcaster (listener(\"%s\")=%p)",
                      this,
                      m_broadcaster_name.AsCString(""),
                      listener->m_name.c_str(),
                      listener);
     }
     m_hijacking_listeners.push_back(listener);
     m_hijacking_masks.push_back(event_mask);
     return true;
 }

 void
 Broadcaster::RestoreBroadcaster ()
 {
     Mutex::Locker event_types_locker(m_listeners_mutex);

     LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
     if (log)
     {
         Listener *listener = m_hijacking_listeners.back();
         log->Printf ("%p Broadcaster(\"%s\")::RestoreBroadcaster (about to pop listener(\"%s\")=%p)",
                      this,
                      m_broadcaster_name.AsCString(""),
                      listener->m_name.c_str(),
                      listener);
     }
     m_hijacking_listeners.pop_back();
     m_hijacking_masks.pop_back();
 }

 ConstString &
 Broadcaster::GetBroadcasterClass() const
 {
     static ConstString class_name ("lldb.anonymous");
     return class_name;
 }

 BroadcastEventSpec::BroadcastEventSpec (const BroadcastEventSpec &rhs) :
     m_broadcaster_class (rhs.m_broadcaster_class),
     m_event_bits (rhs.m_event_bits)
 {
 }

 bool
 BroadcastEventSpec::operator< (const BroadcastEventSpec &rhs) const
 {
     if (GetBroadcasterClass() == rhs.GetBroadcasterClass())
     {
         return GetEventBits() < rhs.GetEventBits();
     }
     else
     {
         return GetBroadcasterClass() < rhs.GetBroadcasterClass();
     }
 }

 const BroadcastEventSpec &
 BroadcastEventSpec::operator= (const BroadcastEventSpec &rhs)
 {
     m_broadcaster_class = rhs.m_broadcaster_class;
     m_event_bits = rhs.m_event_bits;
     return *this;
 }

 BroadcasterManager::BroadcasterManager() :
     m_manager_mutex(Mutex::eMutexTypeRecursive)
 {

 }

 uint32_t
 BroadcasterManager::RegisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
 {
     Mutex::Locker locker(m_manager_mutex);

     collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
     uint32_t available_bits = event_spec.GetEventBits();

     while (iter != end_iter
            && (iter = find_if (iter, end_iter, BroadcasterClassMatches(event_spec.GetBroadcasterClass()))) != end_iter)
     {
         available_bits &= ~((*iter).first.GetEventBits());
         iter++;
     }

     if (available_bits != 0)
     {
         m_event_map.insert (event_listener_key (BroadcastEventSpec (event_spec.GetBroadcasterClass(), available_bits), &listener));
         m_listeners.insert(&listener);
     }

     return available_bits;
 }

 bool
 BroadcasterManager::UnregisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
 {
     Mutex::Locker locker(m_manager_mutex);
     bool removed_some = false;

     if (m_listeners.erase(&listener) == 0)
         return false;

     ListenerMatchesAndSharedBits predicate (event_spec, listener);
     std::vector<BroadcastEventSpec> to_be_readded;
     uint32_t event_bits_to_remove = event_spec.GetEventBits();

     // Go through the map and delete the exact matches, and build a list of matches that weren't exact to re-add:
     while (1)
     {
         collection::iterator iter, end_iter = m_event_map.end();
         iter = find_if (m_event_map.begin(), end_iter, predicate);
         if (iter == end_iter)
         {
             break;
         }
         else
         {
             uint32_t iter_event_bits = (*iter).first.GetEventBits();
             removed_some = true;

             if (event_bits_to_remove != iter_event_bits)
             {
                 uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
                 to_be_readded.push_back(BroadcastEventSpec (event_spec.GetBroadcasterClass(), new_event_bits));
             }
             m_event_map.erase (iter);
         }
     }

     // Okay now add back the bits that weren't completely removed:
     for (size_t i = 0; i < to_be_readded.size(); i++)
     {
         m_event_map.insert (event_listener_key (to_be_readded[i], &listener));
     }

     return removed_some;
 }

 Listener *
 BroadcasterManager::GetListenerForEventSpec (BroadcastEventSpec event_spec) const
 {
     Mutex::Locker locker(*(const_cast<Mutex *> (&m_manager_mutex)));

     collection::const_iterator iter, end_iter = m_event_map.end();
     iter = find_if (m_event_map.begin(), end_iter, BroadcastEventSpecMatches (event_spec));
     if (iter != end_iter)
         return (*iter).second;
     else
         return NULL;
 }

 void
 BroadcasterManager::RemoveListener (Listener &listener)
 {
     Mutex::Locker locker(m_manager_mutex);
     ListenerMatches predicate (listener);


     if (m_listeners.erase (&listener) == 0)
         return;

     while (1)
     {
         collection::iterator iter, end_iter = m_event_map.end();
         iter = find_if (m_event_map.begin(), end_iter, predicate);
         if (iter == end_iter)
             break;
         else
             m_event_map.erase(iter);
     }
 }

 void
 BroadcasterManager::SignUpListenersForBroadcaster (Broadcaster &broadcaster)
 {
     Mutex::Locker locker(m_manager_mutex);

     collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();

     while (iter != end_iter
            && (iter = find_if (iter, end_iter, BroadcasterClassMatches(broadcaster.GetBroadcasterClass()))) != end_iter)
     {
         (*iter).second->StartListeningForEvents (&broadcaster, (*iter).first.GetEventBits());
         iter++;
     }
 }

 void
 BroadcasterManager::Clear ()
 {
     Mutex::Locker locker(m_manager_mutex);
     listener_collection::iterator end_iter = m_listeners.end();

     for (listener_collection::iterator iter = m_listeners.begin(); iter != end_iter; iter++)
         (*iter)->BroadcasterManagerWillDestruct(this);
     m_listeners.clear();
     m_event_map.clear();

 }
	//===-- Broadcaster.cpp ------------------------------------------ C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "lldb/Core/Broadcaster.h"

	// C Includes
	// C++ Includes
	// Other libraries and framework includes
	// Project includes
	#include "lldb/Core/Log.h"
	#include "lldb/Core/Event.h"
	#include "lldb/Core/StreamString.h"
	#include "lldb/lldb-private-log.h"

	using namespace lldb;
	using namespace lldb_private;

	Broadcaster::Broadcaster (BroadcasterManager manager, const char name) :
	m_broadcaster_name (name),
	m_listeners (),
	m_listeners_mutex (Mutex::eMutexTypeRecursive),
	m_hijacking_listeners(),
	m_hijacking_masks(),
	m_manager (manager)
	{
	LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
	if (log)
	log->Printf ("%p Broadcaster::Broadcaster(\"%s\")", this, m_broadcaster_name.AsCString());

	}

	Broadcaster::~Broadcaster()
	{
	LogSP log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
	if (log)
	log->Printf ("%p Broadcaster::~Broadcaster(\"%s\")", this, m_broadcaster_name.AsCString());

	Clear();
	}

	void
	Broadcaster::CheckInWithManager ()
	{
	if (m_manager != NULL)
	{
	m_manager->SignUpListenersForBroadcaster(*this);
	}
	}

	void
	Broadcaster::Clear()
	{
	Mutex::Locker listeners_locker(m_listeners_mutex);

	// Make sure the listener forgets about this broadcaster. We do
	// this in the broadcaster in case the broadcaster object initiates
	// the removal.

	collection::iterator pos, end = m_listeners.end();
	for (pos = m_listeners.begin(); pos != end; ++pos)
	pos->first->BroadcasterWillDestruct (this);

	m_listeners.clear();
	}
	const ConstString &
	Broadcaster::GetBroadcasterName ()
	{
	return m_broadcaster_name;
	}

	bool
	Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const
	{
	uint32_t num_names_added = 0;
	if (event_mask && !m_event_names.empty())
	{
	event_names_map::const_iterator end = m_event_names.end();
	for (uint32_t bit=1u, mask=event_mask; mask != 0 && bit != 0; bit <<= 1, mask >>= 1)
	{
	if (mask & 1)
	{
	event_names_map::const_iterator pos = m_event_names.find(bit);
	if (pos != end)
	{
	if (num_names_added > 0)
	s.PutCString(", ");

	if (prefix_with_broadcaster_name)
	{
	s.PutCString (m_broadcaster_name.GetCString());
	s.PutChar('.');
	}
	s.PutCString(pos->second.c_str());
	++num_names_added;
	}
	}
	}
	}
	return num_names_added > 0;
	}

	void
	Broadcaster::AddInitialEventsToListener (Listener *listener, uint32_t requested_events)
	{

	}

	uint32_t
	Broadcaster::AddListener (Listener* listener, uint32_t event_mask)
	{
	if (listener == NULL)
	return 0;

	Mutex::Locker locker(m_listeners_mutex);
	collection::iterator pos, end = m_listeners.end();

	collection::iterator existing_pos = end;
	// See if we already have this listener, and if so, update its mask
	uint32_t taken_event_types = 0;
	for (pos = m_listeners.begin(); pos != end; ++pos)
	{
	if (pos->first == listener)
	existing_pos = pos;
	// For now don't descriminate on who gets what
	// FIXME: Implement "unique listener for this bit" mask
	// taken_event_types \|= pos->second;
	}

	// Each event bit in a Broadcaster object can only be used
	// by one listener
	uint32_t available_event_types = ~taken_event_types & event_mask;

	if (available_event_types)
	{
	// If we didn't find our listener, add it
	if (existing_pos == end)
	{
	// Grant a new listener the available event bits
	m_listeners.push_back(std::make_pair(listener, available_event_types));
	}
	else
	{
	// Grant the existing listener the available event bits
	existing_pos->second \|= available_event_types;
	}

	// Individual broadcasters decide whether they have outstanding data when a
	// listener attaches, and insert it into the listener with this method.

	AddInitialEventsToListener (listener, available_event_types);
	}

	// Return the event bits that were granted to the listener
	return available_event_types;
	}

	bool
	Broadcaster::EventTypeHasListeners (uint32_t event_type)
	{
	Mutex::Locker locker (m_listeners_mutex);

	if (m_hijacking_listeners.size() > 0 && event_type & m_hijacking_masks.back())
	return true;

	if (m_listeners.empty())
	return false;

	collection::iterator pos, end = m_listeners.end();
	for (pos = m_listeners.begin(); pos != end; ++pos)
	{
	if (pos->second & event_type)
	return true;
	}
	return false;
	}

	bool
	Broadcaster::RemoveListener (Listener* listener, uint32_t event_mask)
	{
	Mutex::Locker locker(m_listeners_mutex);
	collection::iterator pos, end = m_listeners.end();
	// See if we already have this listener, and if so, update its mask
	for (pos = m_listeners.begin(); pos != end; ++pos)
	{
	if (pos->first == listener)
	{
	// Relinquish all event bits in "event_mask"
	pos->second &= ~event_mask;
	// If all bits have been relinquished then remove this listener
	if (pos->second == 0)
	m_listeners.erase (pos);
	return true;
	}
	}
	return false;
	}

	void
	Broadcaster::BroadcastEvent (EventSP &event_sp)
	{
	return PrivateBroadcastEvent (event_sp, false);
	}

	void
	Broadcaster::BroadcastEventIfUnique (EventSP &event_sp)
	{
	return PrivateBroadcastEvent (event_sp, true);
	}

	void
	Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique)
	{
	// Can't add a NULL event...
	if (event_sp.get() == NULL)
	return;

	// Update the broadcaster on this event
	event_sp->SetBroadcaster (this);

	const uint32_t event_type = event_sp->GetType();

	Mutex::Locker event_types_locker(m_listeners_mutex);

	Listener *hijacking_listener = NULL;
	if (!m_hijacking_listeners.empty())
	{
	assert (!m_hijacking_masks.empty());
	hijacking_listener = m_hijacking_listeners.back();
	if ((event_type & m_hijacking_masks.back()) == 0)
	hijacking_listener = NULL;
	}

	LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
	if (log)
	{
	StreamString event_description;
	event_sp->Dump (&event_description);
	log->Printf ("%p Broadcaster(\"%s\")::BroadcastEvent (event_sp = {%s}, unique =%i) hijack = %p",
	this,
	m_broadcaster_name.AsCString(""),
	event_description.GetData(),
	unique,
	hijacking_listener);
	}

	if (hijacking_listener)
	{
	if (unique && hijacking_listener->PeekAtNextEventForBroadcasterWithType (this, event_type))
	return;
	hijacking_listener->AddEvent (event_sp);
	}
	else
	{
	collection::iterator pos, end = m_listeners.end();


	// Iterate through all listener/mask pairs
	for (pos = m_listeners.begin(); pos != end; ++pos)
	{
	// If the listener's mask matches any bits that we just set, then
	// put the new event on its event queue.
	if (event_type & pos->second)
	{
	if (unique && pos->first->PeekAtNextEventForBroadcasterWithType (this, event_type))
	continue;
	pos->first->AddEvent (event_sp);
	}
	}
	}
	}

	void
	Broadcaster::BroadcastEvent (uint32_t event_type, EventData *event_data)
	{
	EventSP event_sp (new Event (event_type, event_data));
	PrivateBroadcastEvent (event_sp, false);
	}

	void
	Broadcaster::BroadcastEventIfUnique (uint32_t event_type, EventData *event_data)
	{
	EventSP event_sp (new Event (event_type, event_data));
	PrivateBroadcastEvent (event_sp, true);
	}

	bool
	Broadcaster::HijackBroadcaster (Listener *listener, uint32_t event_mask)
	{
	Mutex::Locker event_types_locker(m_listeners_mutex);

	LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
	if (log)
	{
	log->Printf ("%p Broadcaster(\"%s\")::HijackBroadcaster (listener(\"%s\")=%p)",
	this,
	m_broadcaster_name.AsCString(""),
	listener->m_name.c_str(),
	listener);
	}
	m_hijacking_listeners.push_back(listener);
	m_hijacking_masks.push_back(event_mask);
	return true;
	}

	void
	Broadcaster::RestoreBroadcaster ()
	{
	Mutex::Locker event_types_locker(m_listeners_mutex);

	LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
	if (log)
	{
	Listener *listener = m_hijacking_listeners.back();
	log->Printf ("%p Broadcaster(\"%s\")::RestoreBroadcaster (about to pop listener(\"%s\")=%p)",
	this,
	m_broadcaster_name.AsCString(""),
	listener->m_name.c_str(),
	listener);
	}
	m_hijacking_listeners.pop_back();
	m_hijacking_masks.pop_back();
	}

	ConstString &
	Broadcaster::GetBroadcasterClass() const
	{
	static ConstString class_name ("lldb.anonymous");
	return class_name;
	}

	BroadcastEventSpec::BroadcastEventSpec (const BroadcastEventSpec &rhs) :
	m_broadcaster_class (rhs.m_broadcaster_class),
	m_event_bits (rhs.m_event_bits)
	{
	}

	bool
	BroadcastEventSpec::operator< (const BroadcastEventSpec &rhs) const
	{
	if (GetBroadcasterClass() == rhs.GetBroadcasterClass())
	{
	return GetEventBits() < rhs.GetEventBits();
	}
	else
	{
	return GetBroadcasterClass() < rhs.GetBroadcasterClass();
	}
	}

	const BroadcastEventSpec &
	BroadcastEventSpec::operator= (const BroadcastEventSpec &rhs)
	{
	m_broadcaster_class = rhs.m_broadcaster_class;
	m_event_bits = rhs.m_event_bits;
	return *this;
	}

	BroadcasterManager::BroadcasterManager() :
	m_manager_mutex(Mutex::eMutexTypeRecursive)
	{

	}

	uint32_t
	BroadcasterManager::RegisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
	{
	Mutex::Locker locker(m_manager_mutex);

	collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
	uint32_t available_bits = event_spec.GetEventBits();

	while (iter != end_iter
	&& (iter = find_if (iter, end_iter, BroadcasterClassMatches(event_spec.GetBroadcasterClass()))) != end_iter)
	{
	available_bits &= ~((*iter).first.GetEventBits());
	iter++;
	}

	if (available_bits != 0)
	{
	m_event_map.insert (event_listener_key (BroadcastEventSpec (event_spec.GetBroadcasterClass(), available_bits), &listener));
	m_listeners.insert(&listener);
	}

	return available_bits;
	}

	bool
	BroadcasterManager::UnregisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
	{
	Mutex::Locker locker(m_manager_mutex);
	bool removed_some = false;

	if (m_listeners.erase(&listener) == 0)
	return false;

	ListenerMatchesAndSharedBits predicate (event_spec, listener);
	std::vector<BroadcastEventSpec> to_be_readded;
	uint32_t event_bits_to_remove = event_spec.GetEventBits();

	// Go through the map and delete the exact matches, and build a list of matches that weren't exact to re-add:
	while (1)
	{
	collection::iterator iter, end_iter = m_event_map.end();
	iter = find_if (m_event_map.begin(), end_iter, predicate);
	if (iter == end_iter)
	{
	break;
	}
	else
	{
	uint32_t iter_event_bits = (*iter).first.GetEventBits();
	removed_some = true;

	if (event_bits_to_remove != iter_event_bits)
	{
	uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
	to_be_readded.push_back(BroadcastEventSpec (event_spec.GetBroadcasterClass(), new_event_bits));
	}
	m_event_map.erase (iter);
	}
	}

	// Okay now add back the bits that weren't completely removed:
	for (size_t i = 0; i < to_be_readded.size(); i++)
	{
	m_event_map.insert (event_listener_key (to_be_readded[i], &listener));
	}

	return removed_some;
	}

	Listener *
	BroadcasterManager::GetListenerForEventSpec (BroadcastEventSpec event_spec) const
	{
	Mutex::Locker locker((const_cast<Mutex > (&m_manager_mutex)));

	collection::const_iterator iter, end_iter = m_event_map.end();
	iter = find_if (m_event_map.begin(), end_iter, BroadcastEventSpecMatches (event_spec));
	if (iter != end_iter)
	return (*iter).second;
	else
	return NULL;
	}

	void
	BroadcasterManager::RemoveListener (Listener &listener)
	{
	Mutex::Locker locker(m_manager_mutex);
	ListenerMatches predicate (listener);


	if (m_listeners.erase (&listener) == 0)
	return;

	while (1)
	{
	collection::iterator iter, end_iter = m_event_map.end();
	iter = find_if (m_event_map.begin(), end_iter, predicate);
	if (iter == end_iter)
	break;
	else
	m_event_map.erase(iter);
	}
	}

	void
	BroadcasterManager::SignUpListenersForBroadcaster (Broadcaster &broadcaster)
	{
	Mutex::Locker locker(m_manager_mutex);

	collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();

	while (iter != end_iter
	&& (iter = find_if (iter, end_iter, BroadcasterClassMatches(broadcaster.GetBroadcasterClass()))) != end_iter)
	{
	(iter).second->StartListeningForEvents (&broadcaster, (iter).first.GetEventBits());
	iter++;
	}
	}

	void
	BroadcasterManager::Clear ()
	{
	Mutex::Locker locker(m_manager_mutex);
	listener_collection::iterator end_iter = m_listeners.end();

	for (listener_collection::iterator iter = m_listeners.begin(); iter != end_iter; iter++)
	(*iter)->BroadcasterManagerWillDestruct(this);
	m_listeners.clear();
	m_event_map.clear();

	}