3 files changed, 3 insertions, 7 deletions
diff --git a/Swiften/EventLoop/EventLoop.cpp b/Swiften/EventLoop/EventLoop.cpp
index eefbf65..186616f 100644
--- a/Swiften/EventLoop/EventLoop.cpp
+++ b/Swiften/EventLoop/EventLoop.cpp
@@ -1,94 +1,93 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/EventLoop/EventLoop.h>
 
 #include <algorithm>
 #include <cassert>
 #include <vector>
 
 #include <boost/bind.hpp>
 #include <boost/lambda/bind.hpp>
 #include <boost/lambda/lambda.hpp>
 #include <boost/optional.hpp>
 
 #include <Swiften/Base/Log.h>
-#include <Swiften/Base/foreach.h>
 
 namespace lambda = boost::lambda;
 
 namespace Swift {
 
 inline void invokeCallback(const Event& event) {
     try {
         assert(!event.callback.empty());
         event.callback();
     }
     catch (const std::exception& e) {
         SWIFT_LOG(error) << "Uncaught exception in event loop: " << e.what() << std::endl;
     }
     catch (...) {
         SWIFT_LOG(error) << "Uncaught non-exception in event loop" << std::endl;
     }
 }
 
 EventLoop::EventLoop() : nextEventID_(0), handlingEvents_(false) {
 }
 
 EventLoop::~EventLoop() {
 }
 
 void EventLoop::handleNextEvents() {
     const int eventsBatched = 100;
     // If handleNextEvents is already in progress, e.g. in case of a recursive call due to
     // the event loop implementation, then do no handle further events. Instead call
     // eventPosted() to continue event handling later.
     bool callEventPosted = handlingEvents_;
     if (!handlingEvents_) {
         handlingEvents_ = true;
         std::unique_lock<std::recursive_mutex> lock(removeEventsMutex_);
         {
             std::vector<Event> nextEvents;
             {
                 std::unique_lock<std::recursive_mutex> lock(eventsMutex_);
                 for (int n = 0; ((n < eventsBatched) && !events_.empty()); n++) {
                     nextEvents.push_back(events_.front());
                     events_.pop_front();
                 }
                 callEventPosted = !events_.empty();
             }
             if (!nextEvents.empty()) {
-                foreach (const Event& event, nextEvents) {
+                for (const auto& event : nextEvents) {
                     invokeCallback(event);
                 }
             }
         }
         handlingEvents_ = false;
     }
 
     if (callEventPosted) {
         eventPosted();
     }
 }
 
 void EventLoop::postEvent(boost::function<void ()> callback, std::shared_ptr<EventOwner> owner) {
     Event event(owner, callback);
     bool callEventPosted = false;
     {
         std::unique_lock<std::recursive_mutex> lock(eventsMutex_);
 
         callEventPosted = events_.empty();
 
         event.id = nextEventID_;
         nextEventID_++;
         events_.push_back(event);
     }
     if (callEventPosted) {
         eventPosted();
     }
 }
 
 void EventLoop::removeEventsFromOwner(std::shared_ptr<EventOwner> owner) {
diff --git a/Swiften/EventLoop/SimpleEventLoop.cpp b/Swiften/EventLoop/SimpleEventLoop.cpp
index 2397016..cac04e4 100644
--- a/Swiften/EventLoop/SimpleEventLoop.cpp
+++ b/Swiften/EventLoop/SimpleEventLoop.cpp
@@ -1,42 +1,40 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/EventLoop/SimpleEventLoop.h>
 
 #include <boost/bind.hpp>
 
-#include <Swiften/Base/foreach.h>
-
 namespace Swift {
 
 SimpleEventLoop::SimpleEventLoop() : isRunning_(true), eventAvailable_(false) {
 }
 
 SimpleEventLoop::~SimpleEventLoop() {
 }
 
 void SimpleEventLoop::doRun(bool breakAfterEvents) {
     while (isRunning_) {
         {
             std::unique_lock<std::mutex> lock(eventAvailableMutex_);
             while (!eventAvailable_) {
                 eventAvailableCondition_.wait(lock);
             }
 
             eventAvailable_ = false;
         }
         runOnce();
         if (breakAfterEvents) {
             return;
         }
     }
 }
 
 void SimpleEventLoop::runOnce() {
     handleNextEvents();
 }
 
 void SimpleEventLoop::stop() {
diff --git a/Swiften/EventLoop/SingleThreadedEventLoop.cpp b/Swiften/EventLoop/SingleThreadedEventLoop.cpp
index acb6e4d..0542f37 100644
--- a/Swiften/EventLoop/SingleThreadedEventLoop.cpp
+++ b/Swiften/EventLoop/SingleThreadedEventLoop.cpp
@@ -1,62 +1,61 @@
 /*
  * Copyright (c) 2010 Soren Dreijer
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
  * Copyright (c) 2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/EventLoop/SingleThreadedEventLoop.h>
 
 #include <iostream>
 
 #include <boost/bind.hpp>
 
-#include <Swiften/Base/foreach.h>
-
 namespace Swift {
 
 SingleThreadedEventLoop::SingleThreadedEventLoop()
 : shouldShutDown_(false), eventAvailable_(false)
 {
 }
 
 SingleThreadedEventLoop::~SingleThreadedEventLoop() {
 
 }
 
 void SingleThreadedEventLoop::waitForEvents() {
     std::unique_lock<std::mutex> lock(eventAvailableMutex_);
     while (!eventAvailable_ && !shouldShutDown_) {
         eventAvailableCondition_.wait(lock);
     }
 
-    if (shouldShutDown_)
+    if (shouldShutDown_) {
         throw EventLoopCanceledException();
+    }
 }
 
 void SingleThreadedEventLoop::handleEvents() {
     {
         std::lock_guard<std::mutex> lock(eventAvailableMutex_);
         eventAvailable_ = false;
     }
     handleNextEvents();
 }
 
 void SingleThreadedEventLoop::stop() {
     std::unique_lock<std::mutex> lock(eventAvailableMutex_);
     shouldShutDown_ = true;
     eventAvailableCondition_.notify_one();
 }
 
 void SingleThreadedEventLoop::eventPosted() {
     std::lock_guard<std::mutex> lock(eventAvailableMutex_);
     eventAvailable_ = true;
     eventAvailableCondition_.notify_one();
 }
 
 } // namespace Swift