src/Events/Events_Loop.cpp

   1 // File:        Events_Loop.hxx
   2 // Created:     Thu Mar 13 2014
   3 // Author:      Mikhail PONIKAROV
   4
   5 #include <Events_Loop.h>
   6 #include <Events_MessageGroup.h>
   7
   8 #include <string>
   9 #include <cstring>
  10
  11 using namespace std;
  12
  13 Events_Loop* Events_Loop::loop()
  14 {
  15   // initialized on initialization of the application
  16   static Events_Loop MAIN_LOOP;
  17   return &MAIN_LOOP;
  18 }
  19
  20 Events_ID Events_Loop::eventByName(const char* theName)
  21 {
  22   ///! All events created in this session, uniquely identified by the text and char pointer
  23   static map<string, char*> CREATED_EVENTS;
  24   char* aResult;
  25   string aName(theName);
  26   map<string, char*>::iterator aFound = CREATED_EVENTS.find(aName);
  27   if (aFound == CREATED_EVENTS.end()) {  //not created yet
  28 #ifdef WIN32
  29     aResult = _strdup(theName);  // copy to make unique internal pointer
  30 #else
  31     aResult = strdup(theName);  // copy to make unique internal pointer
  32 #endif
  33     CREATED_EVENTS[aName] = aResult;
  34   } else
  35     aResult = aFound->second;
  36
  37   return Events_ID(aResult);
  38 }
  39
  40 void Events_Loop::send(const boost::shared_ptr<Events_Message>& theMessage, bool isGroup)
  41 {
  42   if (myImmediateListeners.find(theMessage->eventID().eventText()) != myImmediateListeners.end()) {
  43     myImmediateListeners[theMessage->eventID().eventText()]->processEvent(theMessage);
  44   }
  45   // if it is grouped message, just accumulate it
  46   if (isGroup && myFlushed.find(theMessage->eventID().myID) == myFlushed.end()) {
  47     boost::shared_ptr<Events_MessageGroup> aGroup =
  48       boost::dynamic_pointer_cast<Events_MessageGroup>(theMessage);
  49     if (aGroup) {
  50       std::map<char*, boost::shared_ptr<Events_Message> >::iterator aMyGroup = myGroups.find(
  51           aGroup->eventID().eventText());
  52       if (aMyGroup == myGroups.end()) {  // create a new group of messages for accumulation
  53         myGroups[aGroup->eventID().eventText()] = aGroup->newEmpty();
  54         aMyGroup = myGroups.find(aGroup->eventID().eventText());
  55       }
  56       boost::shared_ptr<Events_MessageGroup> aStored =
  57         boost::dynamic_pointer_cast<Events_MessageGroup>(aMyGroup->second);
  58       aStored->Join(aGroup);
  59       return;
  60     }
  61   }
  62
  63   // TODO: make it in thread and with usage of semaphores
  64
  65   map<char*, map<void*, list<Events_Listener*> > >::iterator aFindID = myListeners.find(
  66       theMessage->eventID().eventText());
  67   if (aFindID != myListeners.end()) {
  68     map<void*, list<Events_Listener*> >::iterator aFindSender = aFindID->second.find(
  69         theMessage->sender());
  70     if (aFindSender != aFindID->second.end()) {
  71       list<Events_Listener*>& aListeners = aFindSender->second;
  72       for (list<Events_Listener*>::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++)
  73         (*aL)->processEvent(theMessage);
  74     }
  75     if (theMessage->sender()) {  // also call for NULL senders registered
  76       aFindSender = aFindID->second.find(NULL);
  77       if (aFindSender != aFindID->second.end()) {
  78         list<Events_Listener*>& aListeners = aFindSender->second;
  79         for (list<Events_Listener*>::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++)
  80           (*aL)->processEvent(theMessage);
  81       }
  82     }
  83   }
  84 }
  85
  86 void Events_Loop::registerListener(Events_Listener* theListener, const Events_ID theID,
  87                                    void* theSender, bool theImmediate)
  88 {
  89   if (theImmediate) { // just register as an immediate
  90     myImmediateListeners[theID.eventText()] = theListener;
  91     return;
  92   }
  93   map<char*, map<void*, list<Events_Listener*> > >::iterator aFindID = myListeners.find(
  94       theID.eventText());
  95   if (aFindID == myListeners.end()) {  // create container associated with ID
  96     myListeners[theID.eventText()] = map<void*, list<Events_Listener*> >();
  97     aFindID = myListeners.find(theID.eventText());
  98   }
  99
 100   map<void*, list<Events_Listener*> >::iterator aFindSender = aFindID->second.find(theSender);
 101   if (aFindSender == aFindID->second.end()) {  // create container associated with sender
 102     aFindID->second[theSender] = list<Events_Listener*>();
 103     aFindSender = aFindID->second.find(theSender);
 104   }
 105   // check that listener was not registered wit hsuch parameters before
 106   list<Events_Listener*>& aListeners = aFindSender->second;
 107   for (list<Events_Listener*>::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++)
 108     if (*aL == theListener)
 109       return;  // avoid duplicates
 110
 111   aListeners.push_back(theListener);
 112 }
 113
 114 void Events_Loop::flush(const Events_ID& theID)
 115 {
 116   if (!myFlushActive)
 117     return;
 118   std::map<char*, boost::shared_ptr<Events_Message>>::iterator aMyGroup =
 119     myGroups.find(theID.eventText());
 120   if (aMyGroup != myGroups.end()) {  // really sends
 121     myFlushed.insert(theID.myID);
 122     boost::shared_ptr<Events_Message> aGroup = aMyGroup->second;
 123     myGroups.erase(aMyGroup);
 124     send(aGroup, false);
 125     myFlushed.erase(myFlushed.find(theID.myID));
 126   }
 127 }
 128
 129 void Events_Loop::activateFlushes(const bool theActivate)
 130 {
 131   myFlushActive = theActivate;
 132 }
 133
 134 void Events_Loop::clear(const Events_ID& theID)
 135 {
 136   std::map<char*, boost::shared_ptr<Events_Message>>::iterator aMyGroup =
 137     myGroups.find(theID.eventText());
 138   if (aMyGroup != myGroups.end()) {  // really sends
 139     myGroups.erase(aMyGroup);
 140   }
 141 }
 142
 143 void Events_Loop::autoFlush(const Events_ID& theID, const bool theAuto)
 144 {
 145   if (theAuto)
 146     myFlushed.insert(theID.myID);
 147   else
 148     myFlushed.erase(myFlushed.find(theID.myID));
 149 }