bool EventManager::AddListener(EventListener *listener, EVENT_TYPE type)
{
// TODO: validate type
EventListenerMap::iterator listenerItor = m_registry.find(type);
if (listenerItor == m_registry.end())
{
// need to register this listener for the given type
EventListenerMapIRes result = m_registry.insert(EventListenerMapEnt(type, EventListenerTable()));
ASSERT(result.second != false);
ASSERT(result.first != m_registry.end());
listenerItor = result.first;
}
// prevent duplicate listeners from being registered
EventListenerTable &table = (*listenerItor).second;
for (EventListenerTable::iterator itor = table.begin(); itor != table.end(); ++itor)
{
ASSERT(*itor != listener);
}
table.push_back(listener);
// also update the list of currently registered event types
m_typeList.insert(type);
return true;
}
// /////////////////////////////////////////////////////////////////
//
// /////////////////////////////////////////////////////////////////
bool EventManager::VAddListener(EventListenerPtr const &inListener, EventType const & inType)
{
if ( ! VValidateType( inType ) )
return false;
// check / update type list
EventTypeSet::iterator evIt = m_typeList.find( inType );
// find listener map entry, create one if no table already
// exists for this entry ...
EventListenerMap::iterator elmIt =
m_registry.find( inType.getHashValue() );
if ( elmIt == m_registry.end() )
{
EventListenerMapIRes elmIRes = m_registry.insert(
EventListenerMapEnt( inType.getHashValue(),
EventListenerTable() ) );
// whoops, could not insert into map!?!?
if ( elmIRes.second == false )
return false;
// should not be possible, how did we insert and create
// an empty table!?!?!
if ( elmIRes.first == m_registry.end() )
return false;
// store it so we can update the mapped list next ...
elmIt = elmIRes.first;
}
// update the mapped list of listeners, walk the existing
// list (if any entries) to prevent duplicate addition of
// listeners. This is a bit more costly at registration time
// but will prevent the hard-to-notice duplicate event
// propogation sequences that would happen if double-entries
// were allowed.
// note: use reference to make following code more simple
EventListenerTable & evlTable = (*elmIt).second;
for ( EventListenerTable::iterator it = evlTable.begin(),
itEnd = evlTable.end(); it != itEnd ; it++ )
{
bool bListenerMatch = ( *it == inListener );
if ( bListenerMatch )
return false;
}
// okay, event type validated, event listener validated,
// event listener not already in map, add it
evlTable.push_back( inListener );
return true;
}
bool Manager::VAddListener ( ListenerPtr const & inListener, TypeId const & inType )
{
if ( ! VValidateType( inType ) )
return false;
TypeIdSet::iterator evIt = m_typeList.find( inType );
EventListenerMap::iterator elmIt = m_registry.find( inType.Value() );
if ( elmIt == m_registry.end() )
{
EventListenerMapIRes elmIRes = m_registry.insert( EventListenerMapEnt( inType.Value(), EventListenerTable() ) );
if ( elmIRes.second == false )
return false;
if ( elmIRes.first == m_registry.end() )
return false;
elmIt = elmIRes.first;
}
EventListenerTable & evlTable = (*elmIt).second;
for ( EventListenerTable::iterator it = evlTable.begin(), itEnd = evlTable.end();
it != itEnd;
it++ )
{
bool bListenerMatch = ( *it == inListener );
if ( bListenerMatch )
return false;
}
evlTable.push_back( inListener );
return true;
}
