1 files changed, 31 insertions, 35 deletions
diff --git a/Swiften/EventLoop/SingleThreadedEventLoop.cpp b/Swiften/EventLoop/SingleThreadedEventLoop.cpp
index c2235b1..89b4460 100644
--- a/Swiften/EventLoop/SingleThreadedEventLoop.cpp
+++ b/Swiften/EventLoop/SingleThreadedEventLoop.cpp
@@ -4,62 +4,58 @@
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
-#include "Swiften/EventLoop/SingleThreadedEventLoop.h"
+/*
+ * Copyright (c) 2016-2019 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
 
-#include <boost/bind.hpp>
-#include <iostream>
+#include <Swiften/EventLoop/SingleThreadedEventLoop.h>
 
-#include "Swiften/Base/foreach.h"
+#include <iostream>
 
+#include <boost/bind.hpp>
 
 namespace Swift {
 
-SingleThreadedEventLoop::SingleThreadedEventLoop() 
-: shouldShutDown_(false)
+SingleThreadedEventLoop::SingleThreadedEventLoop()
+: shouldShutDown_(false), eventAvailable_(false)
 {
 }
 
 SingleThreadedEventLoop::~SingleThreadedEventLoop() {
-	if (!events_.empty()) {
-		std::cerr << "Warning: Pending events in SingleThreadedEventLoop at destruction time." << std::endl;
-	}
+
 }
 
 void SingleThreadedEventLoop::waitForEvents() {
-	boost::unique_lock<boost::mutex> lock(eventsMutex_);
-	while (events_.empty() && !shouldShutDown_) {
-		eventsAvailable_.wait(lock);
-	}
-
-	if (shouldShutDown_)
-		throw EventLoopCanceledException();
+    std::unique_lock<std::mutex> lock(eventAvailableMutex_);
+    while (!eventAvailable_ && !shouldShutDown_) {
+        eventAvailableCondition_.wait(lock);
+    }
+
+    if (shouldShutDown_) {
+        throw EventLoopCanceledException();
+    }
 }
 
 void SingleThreadedEventLoop::handleEvents() {
-	// Make a copy of the list of events so we don't block any threads that post 
-	// events while we process them.
-	std::vector<Event> events;
-	{
-		boost::unique_lock<boost::mutex> lock(eventsMutex_);
-		events.swap(events_);
-	}
-	
-	// Loop through all the events and handle them
-	foreach(const Event& event, events) {
-		handleEvent(event);
-	}
+    {
+        std::lock_guard<std::mutex> lock(eventAvailableMutex_);
+        eventAvailable_ = false;
+    }
+    handleNextEvent();
 }
 
 void SingleThreadedEventLoop::stop() {
-	boost::unique_lock<boost::mutex> lock(eventsMutex_);
-	shouldShutDown_ = true;
-	eventsAvailable_.notify_one();
+    std::unique_lock<std::mutex> lock(eventAvailableMutex_);
+    shouldShutDown_ = true;
+    eventAvailableCondition_.notify_one();
 }
 
-void SingleThreadedEventLoop::post(const Event& event) {
-	boost::lock_guard<boost::mutex> lock(eventsMutex_);
-	events_.push_back(event);
-	eventsAvailable_.notify_one();
+void SingleThreadedEventLoop::eventPosted() {
+    std::lock_guard<std::mutex> lock(eventAvailableMutex_);
+    eventAvailable_ = true;
+    eventAvailableCondition_.notify_one();
 }
 
 } // namespace Swift