Lots of tidying

src/EventManager/EventListener.cpp

@@ -7,14 +7,17 @@ namespace Bloom
     using namespace Bloom::Events;
 
     std::set<Events::EventType> EventListener::getRegisteredEventTypes() {
-        auto lock = this->registeredEventTypes.acquireLock();
+        const auto lock = this->registeredEventTypes.acquireLock();
         return this->registeredEventTypes.getValue();
     }
 
     void EventListener::registerEvent(SharedGenericEventPointer event) {
-        Logger::debug("Event \"" + event->getName() + "\" (" + std::to_string(event->id)
-            + ") registered for listener " + this->name);
-        auto queueLock = this->eventQueueByEventType.acquireLock();
+        Logger::debug(
+            "Event \"" + event->getName() + "\" (" + std::to_string(event->id) + ") registered for listener "
+                + this->name
+        );
+
+        const auto queueLock = this->eventQueueByEventType.acquireLock();
         auto& eventQueueByType = this->eventQueueByEventType.getValue();
 
         eventQueueByType[event->getType()].push(std::move(event));
@@ -26,33 +29,29 @@ namespace Bloom
     }
 
     void EventListener::waitAndDispatch(int msTimeout) {
-        auto queueLock = this->eventQueueByEventType.acquireLock();
-        auto& eventQueueByType = this->eventQueueByEventType.getValue();
-        auto registeredEventTypes = this->getRegisteredEventTypes();
-        std::optional<SharedGenericEventPointer> event;
+        {
+            auto queueLock = this->eventQueueByEventType.acquireLock();
+            const auto& eventQueueByType = this->eventQueueByEventType.getValue();
+            const auto registeredEventTypes = this->getRegisteredEventTypes();
+            std::optional<SharedGenericEventPointer> event;
 
-        auto eventsFound = [&registeredEventTypes, &event, &eventQueueByType]() -> bool {
-            for (auto& eventQueue: eventQueueByType) {
-                if (registeredEventTypes.contains(eventQueue.first) && !eventQueue.second.empty()) {
-                    return true;
+            const auto eventsFound = [&registeredEventTypes, &event, &eventQueueByType]() -> bool {
+                for (auto& eventQueue: eventQueueByType) {
+                    if (registeredEventTypes.contains(eventQueue.first) && !eventQueue.second.empty()) {
+                        return true;
+                    }
                 }
+                return false;
+            };
+
+            if (msTimeout > 0) {
+                this->eventQueueByEventTypeCV.wait_for(queueLock, std::chrono::milliseconds(msTimeout), eventsFound);
+
+            } else {
+                this->eventQueueByEventTypeCV.wait(queueLock, eventsFound);
             }
-            return false;
-        };
-
-        if (msTimeout > 0) {
-            this->eventQueueByEventTypeCV.wait_for(queueLock, std::chrono::milliseconds(msTimeout), eventsFound);
-
-        } else {
-            this->eventQueueByEventTypeCV.wait(queueLock, eventsFound);
         }
 
-        /*
-         * We don't want the dispatch to block other threads from registering more events. We don't need the
-         * lock anymore so it's fine to release it here.
-         */
-        queueLock.unlock();
-
         this->dispatchCurrentEvents();
     }
 
@@ -60,9 +59,8 @@ namespace Bloom
         Logger::debug("Dispatching event " + event->getName() + " (" + std::to_string(event->id) + ").");
 
         // Dispatch the event to all registered handlers
-        auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock();
-        auto& callbacks = this->eventTypeToCallbacksMapping.getValue().find(event->getType())->second;
-        mappingLock.unlock();
+        const auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock();
+        const auto& callbacks = this->eventTypeToCallbacksMapping.getValue().find(event->getType())->second;
 
         for (auto& callback : callbacks) {
             callback(*(event.get()));
@@ -78,7 +76,7 @@ namespace Bloom
     }
 
     std::vector<SharedGenericEventPointer> EventListener::getEvents() {
-        auto queueLock = this->eventQueueByEventType.acquireLock();
+        const auto queueLock = this->eventQueueByEventType.acquireLock();
         auto& eventQueueByType = this->eventQueueByEventType.getValue();
         std::vector<SharedGenericEventPointer> output;
 
@@ -101,7 +99,7 @@ namespace Bloom
     }
 
     void EventListener::clearAllCallbacks() {
-        auto lock = this->eventTypeToCallbacksMapping.acquireLock();
+        const auto lock = this->eventTypeToCallbacksMapping.acquireLock();
         this->eventTypeToCallbacksMapping.getValue().clear();
     }
 }

src/EventManager/EventListener.hpp

@@ -75,13 +75,13 @@ namespace Bloom
          */
         template<class EventType>
         void registerEventType() {
-            auto registeredEventTypesLock = this->registeredEventTypes.acquireLock();
+            const auto registeredEventTypesLock = this->registeredEventTypes.acquireLock();
             this->registeredEventTypes.getValue().insert(EventType::type);
         }
 
         template<class EventType>
         void deRegisterEventType() {
-            auto registeredEventTypesLock = this->registeredEventTypes.acquireLock();
+            const auto registeredEventTypesLock = this->registeredEventTypes.acquireLock();
             this->registeredEventTypes.getValue().erase(EventType::type);
         }
 
@@ -117,7 +117,7 @@ namespace Bloom
                 }
             ;
 
-            auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock();
+            const auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock();
             auto& mapping = this->eventTypeToCallbacksMapping.getValue();
 
             mapping[EventType::type].push_back(parentCallback);
@@ -137,7 +137,7 @@ namespace Bloom
             );
 
             {
-                auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock();
+                const auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock();
                 auto& mapping = this->eventTypeToCallbacksMapping.getValue();
 
                 if (mapping.contains(EventType::type)) {
@@ -150,7 +150,7 @@ namespace Bloom
                 this->registeredEventTypes.getValue().erase(EventType::type);
             }
 
-            auto queueLock = this->eventQueueByEventType.acquireLock();
+            const auto queueLock = this->eventQueueByEventType.acquireLock();
             auto& eventQueueByType = this->eventQueueByEventType.getValue();
 
             if (eventQueueByType.contains(EventType::type)) {