X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FEvents%2FEvents_Loop.cpp;h=ca8fb331cfb59a58606d39ce50321bdadf2fd050;hb=77ce6d35ac8d2f0fdaecb4f23e0870bf74e36103;hp=1fb0ed1780636c244923a3b50469ce0e68ab22f4;hpb=3da12847434e80669f608d589074a181df87da4e;p=modules%2Fshaper.git diff --git a/src/Events/Events_Loop.cpp b/src/Events/Events_Loop.cpp index 1fb0ed178..ca8fb331c 100644 --- a/src/Events/Events_Loop.cpp +++ b/src/Events/Events_Loop.cpp @@ -1,6 +1,21 @@ -// File: Events_Loop.hxx -// Created: Thu Mar 13 2014 -// Author: Mikhail PONIKAROV +// Copyright (C) 2014-2024 CEA, EDF +// +// This library 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 Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library 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 +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #include #include @@ -8,8 +23,6 @@ #include #include -using namespace std; - Events_Loop* Events_Loop::loop() { // initialized on initialization of the application @@ -20,10 +33,10 @@ Events_Loop* Events_Loop::loop() Events_ID Events_Loop::eventByName(const char* theName) { ///! All events created in this session, uniquely identified by the text and char pointer - static map CREATED_EVENTS; + static std::map CREATED_EVENTS; char* aResult; - string aName(theName); - map::iterator aFound = CREATED_EVENTS.find(aName); + std::string aName(theName); + std::map::iterator aFound = CREATED_EVENTS.find(aName); if (aFound == CREATED_EVENTS.end()) { //not created yet #ifdef WIN32 aResult = _strdup(theName); // copy to make unique internal pointer @@ -37,84 +50,227 @@ Events_ID Events_Loop::eventByName(const char* theName) return Events_ID(aResult); } -void Events_Loop::send(Events_Message& theMessage, bool isGroup) +void Events_Loop::sendProcessEvent(const std::shared_ptr& theMessage, + std::list& theListeners, const bool theFlushedNow) { + std::list::iterator aL = theListeners.begin(); + for (; aL != theListeners.end(); aL++) { + if (theFlushedNow && (*aL)->groupMessages()) { + (*aL)->groupWhileFlush(theMessage); + } else { + (*aL)->processEvent(theMessage); + } + } +} + +void Events_Loop::send(const std::shared_ptr& theMessage, bool isGroup) +{ + if (myImmediateListeners.find(theMessage->eventID().eventText()) != myImmediateListeners.end()) { + myImmediateListeners[theMessage->eventID().eventText()]->processEvent(theMessage); + } // if it is grouped message, just accumulate it - if (isGroup) { - Events_MessageGroup* aGroup = dynamic_cast(&theMessage); + bool isFlushedNow = myFlushed.find(theMessage->eventID().myID) != myFlushed.end(); + if (isGroup && !isFlushedNow) { + std::shared_ptr aGroup = + std::dynamic_pointer_cast(theMessage); if (aGroup) { - std::map::iterator aMyGroup = myGroups.find( + std::map >::iterator aMyGroup = myGroups.find( aGroup->eventID().eventText()); if (aMyGroup == myGroups.end()) { // create a new group of messages for accumulation myGroups[aGroup->eventID().eventText()] = aGroup->newEmpty(); aMyGroup = myGroups.find(aGroup->eventID().eventText()); } - aMyGroup->second->Join(*aGroup); + std::shared_ptr aStored = + std::dynamic_pointer_cast(aMyGroup->second); + aStored->Join(aGroup); return; } } - - // TO DO: make it in thread and with usage of semaphores - - map > >::iterator aFindID = myListeners.find( - theMessage.eventID().eventText()); + // send + std::map > >::iterator aFindID = + myListeners.find(theMessage->eventID().eventText()); if (aFindID != myListeners.end()) { - map >::iterator aFindSender = aFindID->second.find( - theMessage.sender()); + std::map >::iterator aFindSender = aFindID->second.find( + theMessage->sender()); if (aFindSender != aFindID->second.end()) { - list& aListeners = aFindSender->second; - for (list::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++) - (*aL)->processEvent(&theMessage); + sendProcessEvent(theMessage, aFindSender->second, isFlushedNow && isGroup); } - if (theMessage.sender()) { // also call for NULL senders registered + if (theMessage->sender()) { // also call for NULL senders registered aFindSender = aFindID->second.find(NULL); if (aFindSender != aFindID->second.end()) { - list& aListeners = aFindSender->second; - for (list::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++) - (*aL)->processEvent(&theMessage); + sendProcessEvent(theMessage, aFindSender->second, isFlushedNow && isGroup); } } } } void Events_Loop::registerListener(Events_Listener* theListener, const Events_ID theID, - void* theSender) + void* theSender, bool theImmediate) { - map > >::iterator aFindID = myListeners.find( - theID.eventText()); + if (theImmediate) { // just register as an immediate + myImmediateListeners[theID.eventText()] = theListener; + return; + } + std::map > >::iterator aFindID = + myListeners.find(theID.eventText()); if (aFindID == myListeners.end()) { // create container associated with ID - myListeners[theID.eventText()] = map >(); + myListeners[theID.eventText()] = std::map >(); aFindID = myListeners.find(theID.eventText()); } - map >::iterator aFindSender = aFindID->second.find(theSender); + std::map >::iterator aFindSender = + aFindID->second.find(theSender); if (aFindSender == aFindID->second.end()) { // create container associated with sender - aFindID->second[theSender] = list(); + aFindID->second[theSender] = std::list(); aFindSender = aFindID->second.find(theSender); } - // check that listener was not registered wit hsuch parameters before - list& aListeners = aFindSender->second; - for (list::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++) + // check that listener was not registered with such parameters before + std::list& aListeners = aFindSender->second; + for (std::list::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++) if (*aL == theListener) return; // avoid duplicates aListeners.push_back(theListener); } +void Events_Loop::removeListener(Events_Listener* theListener) +{ + // remove the listener in myListeners map + std::map > >::const_reverse_iterator + anIt = myListeners.rbegin(); + while(anIt != myListeners.rend()) { + std::map > aLMap = anIt->second; + std::map >::const_reverse_iterator aLIt = aLMap.rbegin(); + while (aLIt != aLMap.rend()) { + std::list aListeners = aLIt->second; + std::list::const_reverse_iterator aLsIt = aListeners.rbegin(); + for (; aLsIt != aListeners.rend(); aLsIt++) { + if (*aLsIt == theListener) { + aListeners.remove(theListener); + aLMap[aLIt->first] = aListeners; + myListeners[anIt->first] = aLMap; + break; + } + } + if (aListeners.empty()) { + aLMap.erase(aLIt->first); + myListeners[anIt->first] = aLMap; + if (aLMap.empty()) + break; // avoid incrementation of the iterator if the container is empty + } + aLIt++; + } + if (anIt->second.empty()) { + myListeners.erase(anIt->first); + if (myListeners.empty()) + break; // avoid incrementation of the iterator if the container is empty + } + anIt++; + } + + // remove the listener in myImmediateListeners map + std::map::const_reverse_iterator anImIt = myImmediateListeners.rbegin(); + while(anImIt != myImmediateListeners.rend()) { + if (anImIt->second == theListener) { + myImmediateListeners.erase(anImIt->first); + if (myImmediateListeners.empty()) + break; // avoid incrementation of the iterator if the container is empty + } + anImIt++; + } +} + void Events_Loop::flush(const Events_ID& theID) { if (!myFlushActive) return; - std::map::iterator aMyGroup = myGroups.find(theID.eventText()); - if (aMyGroup != myGroups.end()) { // really sends - Events_MessageGroup* aGroup = aMyGroup->second; + bool hasEventsToFlush = !myGroups.empty(); + std::map >::iterator aMyGroup; + for(aMyGroup = myGroups.find(theID.eventText()); + aMyGroup != myGroups.end(); aMyGroup = myGroups.find(theID.eventText())) + { // really sends + bool aWasFlushed = myFlushed.find(theID.myID) != myFlushed.end(); + if (!aWasFlushed) + myFlushed.insert(theID.myID); + std::shared_ptr aGroup = aMyGroup->second; myGroups.erase(aMyGroup); - send(*aGroup, false); - delete aGroup; + send(aGroup, false); + + if (!aWasFlushed) { + // TODO: Stabilization fix. Check later. + if(myFlushed.find(theID.myID) != myFlushed.end()) { + myFlushed.erase(myFlushed.find(theID.myID)); + } +#ifdef _DEBUG + else { + bool aProblem = true; + } +#endif + } + // send accumulated messages to "groupListeners" + std::map > >::iterator aFindID = + myListeners.find(theID.eventText()); + if (aFindID != myListeners.end()) { + std::map >::iterator aFindSender = + aFindID->second.begin(); + for(; aFindSender != aFindID->second.end(); aFindSender++) { + std::list::iterator aListener = aFindSender->second.begin(); + for(; aListener != aFindSender->second.end(); aListener++) { + if ((*aListener)->groupMessages()) { + (*aListener)->flushGrouped(theID); + } + } + } + } + } + if (hasEventsToFlush && myGroups.empty() && myFlushed.empty()) { + // no more messages left in the queue, so, finalize the sketch processing + static Events_ID anID = Events_Loop::eventByName("SketchPrepared"); + std::shared_ptr aMsg(new Events_Message(anID, this)); + Events_Loop::loop()->send(aMsg, false); } } -void Events_Loop::activateFlushes(const bool theActivate) +void Events_Loop::eraseMessages(const Events_ID& theID) { + std::map >::iterator aMyGroup = + myGroups.find(theID.eventText()); + if (aMyGroup != myGroups.end()) { + myGroups.erase(aMyGroup); + } +} + + +bool Events_Loop::activateFlushes(const bool theActivate) +{ + bool isActive = myFlushActive; myFlushActive = theActivate; + return isActive; } + +void Events_Loop::clear(const Events_ID& theID) +{ + std::map>::iterator aMyGroup = + myGroups.find(theID.eventText()); + if (aMyGroup != myGroups.end()) { // really sends + myGroups.erase(aMyGroup); + } +} + +bool Events_Loop::isFlushed(const Events_ID& theID) +{ + return myFlushed.find(theID.myID) != myFlushed.end(); +} + +void Events_Loop::setFlushed(const Events_ID& theID, const bool theValue) +{ + if (theValue) + myFlushed.insert(theID.myID); + else + myFlushed.erase(myFlushed.find(theID.myID)); +} + +bool Events_Loop::hasGrouppedEvent(const Events_ID& theID) +{ + return myGroups.find(theID.myID) != myGroups.end(); +} \ No newline at end of file