// /////////////////////////////////////////////////////////////////
//
// /////////////////////////////////////////////////////////////////
EventListenerList EventManager::GetListenerList(EventType const &eventType) const
{
// invalid event type, so sad
if ( ! VValidateType( eventType ) )
return EventListenerList();
EventListenerMap::const_iterator itListeners =
m_registry.find( eventType.getHashValue() );
// no listerners currently for this event type, so sad
if ( itListeners == m_registry.end() )
return EventListenerList();
EventListenerTable const & table = itListeners->second;
// there was, but is not now, any listerners currently for
// this event type, so sad
if ( table.size() == 0 )
return EventListenerList();
EventListenerList result;
result.reserve( table.size() );
for ( EventListenerTable::const_iterator it = table.begin(),
end = table.end(); it != end ; it++ )
{
result.push_back( *it );
}
return result;
}
///
/// リスナーのリストを取得
EventListenerList EventManager::getListenerList(
const EventType &event_type
) {
if (!isValidateEventType(event_type)) {
// 無効なイベントの場合
// 空のリスナーリストを返す
return EventListenerList();
}
// イベントのリスナーリストを取得
auto map_it = registry_.find(event_type.key());
if (map_it == registry_.end()) {
// このイベント型にはリスナーがいない
// 空のリストを返す
return EventListenerList();
}
const EventListenerTable& table = map_it->second;
if (table.empty()) {
// このイベント型には以前はリスナーがあったが現在は無い
// 空のリストを返す
return EventListenerList();
}
// ※ここまで来るということは、このイベントの
// リスナーのリストは確かに存在する
// リスナーのリストを別インスタンスとして作成して返す
EventListenerList result;
result.reserve(table.size());
auto table_it = table.begin();
auto table_end = table.end();
for (; table_it != table_end; ++table_it) {
// もどす用のリストにリスナーのリスト内容をコピー
result.push_back((*table_it)->target());
}
// もどす
return result;
}
EventListenerList EventManager::GetListenerList(EVENT_TYPE type) const
{
EventListenerMap::const_iterator listenerItor = m_registry.find(type);
if (listenerItor == m_registry.end())
return EventListenerList(); // no registered listeners for this type
const EventListenerTable &table = listenerItor->second;
if (table.size() == 0)
return EventListenerList(); // no registered listeners for this type
EventListenerList result;
result.reserve(table.size());
for (EventListenerTable::const_iterator i = table.begin(); i != table.end(); ++i)
result.push_back(*i);
return result;
}
//Add a listener to listener list related to event type. Create event type if not created before
bool GameEventManager::AddListener(IEventListener* const listenerptr, const GameEventType& eventtype)
{
//Be sure this listener-eventtype mapping doesnt exist
EventListenersMap::iterator mapitr = mEvTypeListenerMap.find(eventtype);
//IF - Type not registered to any event
if(mapitr == mEvTypeListenerMap.end())
{
EvListInsertResult insertresult = mEvTypeListenerMap.insert(
EvListEntry(eventtype,EventListenerList())
);
//Double check insertion was correct
if(insertresult.second == false)
{
SingletonLogMgr::Instance()->AddNewLine("GameEventManager::AddListener","Insertion of new event and related list failure!!!!!!",LOGEXCEPTION);
return false;
}
//Store iterator for this position of event-listenerlist
mapitr = insertresult.first;
}
//Be sure listener wasnt registered
EventListenerList::iterator listeneritr;
EventListenerList& listenerlist = (*mapitr).second; //Temp variable (REFERENCE!)
//LOOP - Search for this listener register
for(listeneritr = listenerlist.begin(); listeneritr != listenerlist.end(); listeneritr++)
{
if(*listeneritr == listenerptr)
{
SingletonLogMgr::Instance()->AddNewLine("GameEventManager::AddListener","Attempt to add the same listener to same event type twice!",LOGEXCEPTION);
return false;
}
}//LOOP END
//Event type added (or registered previously) and it doesnt have this listener related to it:
//Add listener to list
(*mapitr).second.push_back(listenerptr);
return true;
}
// Adds an event listener to the list for that event type. Returns false if listener is not added, true if added
bool EventManager::addListener(EventListenerPtr const & listener, EventType const & type)
{
if (!validateType(type))
return false;
EventTypeSet::iterator it = m_eventTypes.find(type);
// Looks to see if the event is a type seen before and adds the event type if not.
if (it == m_eventTypes.end())
{
EventTypeSetRet itEvent = m_eventTypes.insert(type);
if (itEvent.second == false)
return false;
if (itEvent.first == m_eventTypes.end())
return false;
it = itEvent.first;
}
EventListenerMap::iterator itMap = m_listenerMap.find(type.getId());
// Finds the list of listeners for the event type and creates one if it doesn't exist.
if (itMap == m_listenerMap.end())
{
EventListenerMapRet itListMap = m_listenerMap.insert(EventListenerMapEntry(type.getId(), EventListenerList()));
if (itListMap.second == false)
return false;
if (itListMap.first == m_listenerMap.end())
return false;
itMap = itListMap.first;
}
EventListenerList & theList= (*itMap).second;
// Checks to see if the listener is already in the map.
for (EventListenerList::iterator i = theList.begin(); i != theList.end(); i++)
{
if ((*i) == listener)
return false;
}
theList.push_back(listener);
return true;
}
