3 files changed, 14 insertions, 17 deletions
diff --git a/Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuerier.cpp b/Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuerier.cpp
index 9cfe3cd..0906ffc 100644
--- a/Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuerier.cpp
+++ b/Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuerier.cpp
@@ -1,44 +1,43 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuerier.h>
 
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
 #include <Swiften/Base/Algorithm.h>
-#include <Swiften/Base/foreach.h>
 #include <Swiften/LinkLocal/DNSSD/Bonjour/BonjourBrowseQuery.h>
 #include <Swiften/LinkLocal/DNSSD/Bonjour/BonjourRegisterQuery.h>
 #include <Swiften/LinkLocal/DNSSD/Bonjour/BonjourResolveHostnameQuery.h>
 #include <Swiften/LinkLocal/DNSSD/Bonjour/BonjourResolveServiceQuery.h>
 
 namespace Swift {
 
 BonjourQuerier::BonjourQuerier(EventLoop* eventLoop) : eventLoop(eventLoop), stopRequested(false), thread(nullptr) {
     int fds[2];
     int result = pipe(fds);
     assert(result == 0);
     (void) result;
     interruptSelectReadSocket = fds[0];
     fcntl(interruptSelectReadSocket, F_SETFL, fcntl(interruptSelectReadSocket, F_GETFL)|O_NONBLOCK);
     interruptSelectWriteSocket = fds[1];
 }
 
 BonjourQuerier::~BonjourQuerier() {
     assert(!thread);
 }
 
 std::shared_ptr<DNSSDBrowseQuery> BonjourQuerier::createBrowseQuery() {
     return std::make_shared<BonjourBrowseQuery>(shared_from_this(), eventLoop);
 }
 
 std::shared_ptr<DNSSDRegisterQuery> BonjourQuerier::createRegisterQuery(const std::string& name, int port, const ByteArray& info) {
     return std::make_shared<BonjourRegisterQuery>(name, port, info, shared_from_this(), eventLoop);
 }
 
 std::shared_ptr<DNSSDResolveServiceQuery> BonjourQuerier::createResolveServiceQuery(const DNSSDServiceID& service) {
@@ -79,58 +78,58 @@ void BonjourQuerier::stop() {
     if (thread) {
         stopRequested = true;
         assert(runningQueries.empty());
         runningQueriesAvailableEvent.notify_one();
         interruptSelect();
         thread->join();
         delete thread;
         thread = nullptr;
         stopRequested = false;
     }
 }
 
 void BonjourQuerier::run() {
     while (!stopRequested) {
         fd_set fdSet;
         int maxSocket;
         {
             std::unique_lock<std::mutex> lock(runningQueriesMutex);
             if (runningQueries.empty()) {
                 runningQueriesAvailableEvent.wait(lock);
                 if (runningQueries.empty()) {
                     continue;
                 }
             }
 
             // Run all running queries
             FD_ZERO(&fdSet);
             maxSocket = interruptSelectReadSocket;
             FD_SET(interruptSelectReadSocket, &fdSet);
 
-            foreach(const std::shared_ptr<BonjourQuery>& query, runningQueries) {
+            for (const auto& query : runningQueries) {
                 int socketID = query->getSocketID();
                 maxSocket = std::max(maxSocket, socketID);
                 FD_SET(socketID, &fdSet);
             }
         }
 
         if (select(maxSocket+1, &fdSet, nullptr, nullptr, nullptr) <= 0) {
             continue;
         }
 
         if (FD_ISSET(interruptSelectReadSocket, &fdSet)) {
             char dummy;
             while (read(interruptSelectReadSocket, &dummy, 1) > 0) {}
         }
 
         {
             std::lock_guard<std::mutex> lock(runningQueriesMutex);
-            foreach(std::shared_ptr<BonjourQuery> query, runningQueries) {
+            for (auto&& query : runningQueries) {
                 if (FD_ISSET(query->getSocketID(), &fdSet)) {
                     query->processResult();
                 }
             }
         }
     }
 }
 
 }
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.cpp b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.cpp
index 63ad3b8..c17f8b2 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.cpp
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.cpp
@@ -1,140 +1,139 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h>
 
 #include <iostream>
 
 #include <boost/bind.hpp>
 
 #include <Swiften/Base/Algorithm.h>
-#include <Swiften/Base/foreach.h>
 #include <Swiften/EventLoop/EventLoop.h>
 #include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDBrowseQuery.h>
 #include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h>
 #include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveHostnameQuery.h>
 #include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h>
 
 namespace Swift {
 
 FakeDNSSDQuerier::FakeDNSSDQuerier(const std::string& domain, EventLoop* eventLoop) : domain(domain), eventLoop(eventLoop) {
 }
 
 FakeDNSSDQuerier::~FakeDNSSDQuerier() {
     if (!runningQueries.empty()) {
         std::cerr << "FakeDNSSDQuerier: Running queries not empty at destruction time" << std::endl;
     }
 }
 
 std::shared_ptr<DNSSDBrowseQuery> FakeDNSSDQuerier::createBrowseQuery() {
     return std::make_shared<FakeDNSSDBrowseQuery>(shared_from_this());
 }
 
 std::shared_ptr<DNSSDRegisterQuery> FakeDNSSDQuerier::createRegisterQuery(const std::string& name, int port, const ByteArray& info) {
     return std::make_shared<FakeDNSSDRegisterQuery>(name, port, info, shared_from_this());
 }
 
 std::shared_ptr<DNSSDResolveServiceQuery> FakeDNSSDQuerier::createResolveServiceQuery(const DNSSDServiceID& service) {
     return std::make_shared<FakeDNSSDResolveServiceQuery>(service, shared_from_this());
 }
 
 std::shared_ptr<DNSSDResolveHostnameQuery> FakeDNSSDQuerier::createResolveHostnameQuery(const std::string& hostname, int interfaceIndex) {
     return std::make_shared<FakeDNSSDResolveHostnameQuery>(hostname, interfaceIndex, shared_from_this());
 }
 
 void FakeDNSSDQuerier::addRunningQuery(std::shared_ptr<FakeDNSSDQuery> query) {
     runningQueries.push_back(query);
     allQueriesEverRun.push_back(query);
     if (std::shared_ptr<FakeDNSSDBrowseQuery> browseQuery = std::dynamic_pointer_cast<FakeDNSSDBrowseQuery>(query)) {
-        foreach(const DNSSDServiceID& service, services) {
+        for (const auto& service : services) {
             eventLoop->postEvent(boost::bind(boost::ref(browseQuery->onServiceAdded), service), shared_from_this());
         }
     }
     else if (std::shared_ptr<FakeDNSSDResolveServiceQuery> resolveQuery = std::dynamic_pointer_cast<FakeDNSSDResolveServiceQuery>(query)) {
-        for(ServiceInfoMap::const_iterator i = serviceInfo.begin(); i != serviceInfo.end(); ++i) {
-            if (i->first == resolveQuery->service) {
-                eventLoop->postEvent(boost::bind(boost::ref(resolveQuery->onServiceResolved), i->second), shared_from_this());
+        for (const auto& i : serviceInfo) {
+            if (i.first == resolveQuery->service) {
+                eventLoop->postEvent(boost::bind(boost::ref(resolveQuery->onServiceResolved), i.second), shared_from_this());
             }
         }
     }
     else if (std::shared_ptr<FakeDNSSDRegisterQuery> registerQuery = std::dynamic_pointer_cast<FakeDNSSDRegisterQuery>(query)) {
         DNSSDServiceID service(registerQuery->name, domain);
         eventLoop->postEvent(boost::bind(boost::ref(registerQuery->onRegisterFinished), service), shared_from_this());
     }
     else if (std::shared_ptr<FakeDNSSDResolveHostnameQuery> resolveHostnameQuery = std::dynamic_pointer_cast<FakeDNSSDResolveHostnameQuery>(query)) {
         std::map<std::string,boost::optional<HostAddress> >::const_iterator i = addresses.find(resolveHostnameQuery->hostname);
         if (i != addresses.end()) {
             eventLoop->postEvent(
                     boost::bind(
                         boost::ref(resolveHostnameQuery->onHostnameResolved), i->second),
                     shared_from_this());
         }
     }
 }
 
 void FakeDNSSDQuerier::removeRunningQuery(std::shared_ptr<FakeDNSSDQuery> query) {
     erase(runningQueries, query);
 }
 
 void FakeDNSSDQuerier::addService(const DNSSDServiceID& id) {
     services.insert(id);
-    foreach(const std::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {
+    for (const auto& query : getQueries<FakeDNSSDBrowseQuery>()) {
         eventLoop->postEvent(boost::bind(boost::ref(query->onServiceAdded), id), shared_from_this());
     }
 }
 
 void FakeDNSSDQuerier::removeService(const DNSSDServiceID& id) {
     services.erase(id);
     serviceInfo.erase(id);
-    foreach(const std::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {
+    for (const auto& query : getQueries<FakeDNSSDBrowseQuery>()) {
         eventLoop->postEvent(boost::bind(boost::ref(query->onServiceRemoved), id), shared_from_this());
     }
 }
 
 void FakeDNSSDQuerier::setServiceInfo(const DNSSDServiceID& id, const DNSSDResolveServiceQuery::Result& info) {
     std::pair<ServiceInfoMap::iterator, bool> r = serviceInfo.insert(std::make_pair(id, info));
     if (!r.second) {
         r.first->second = info;
     }
-    foreach(const std::shared_ptr<FakeDNSSDResolveServiceQuery>& query, getQueries<FakeDNSSDResolveServiceQuery>()) {
+    for (const auto& query : getQueries<FakeDNSSDResolveServiceQuery>()) {
         if (query->service == id) {
             eventLoop->postEvent(boost::bind(boost::ref(query->onServiceResolved), info), shared_from_this());
         }
     }
 }
 
 bool FakeDNSSDQuerier::isServiceRegistered(const std::string& name, int port, const ByteArray& info) {
-    foreach(const std::shared_ptr<FakeDNSSDRegisterQuery>& query, getQueries<FakeDNSSDRegisterQuery>()) {
+    for (const auto& query : getQueries<FakeDNSSDRegisterQuery>()) {
         if (query->name == name && query->port == port && query->info == info) {
             return true;
         }
     }
     return false;
 }
 
 void FakeDNSSDQuerier::setBrowseError() {
-    foreach(const std::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {
+    for (const auto& query : getQueries<FakeDNSSDBrowseQuery>()) {
         eventLoop->postEvent(boost::ref(query->onError), shared_from_this());
     }
 }
 
 void FakeDNSSDQuerier::setRegisterError() {
-    foreach(const std::shared_ptr<FakeDNSSDRegisterQuery>& query, getQueries<FakeDNSSDRegisterQuery>()) {
+    for (const auto& query : getQueries<FakeDNSSDRegisterQuery>()) {
         eventLoop->postEvent(boost::bind(boost::ref(query->onRegisterFinished), boost::optional<DNSSDServiceID>()), shared_from_this());
     }
 }
 
 void FakeDNSSDQuerier::setAddress(const std::string& hostname, boost::optional<HostAddress> address) {
     addresses[hostname] = address;
-    foreach(const std::shared_ptr<FakeDNSSDResolveHostnameQuery>& query, getQueries<FakeDNSSDResolveHostnameQuery>()) {
+    for (const auto& query : getQueries<FakeDNSSDResolveHostnameQuery>()) {
         if (query->hostname == hostname) {
             eventLoop->postEvent(boost::bind(
                     boost::ref(query->onHostnameResolved), address), shared_from_this());
         }
     }
 }
 
 }
diff --git a/Swiften/LinkLocal/OutgoingLinkLocalSession.cpp b/Swiften/LinkLocal/OutgoingLinkLocalSession.cpp
index f97d9a1..a639ec5 100644
--- a/Swiften/LinkLocal/OutgoingLinkLocalSession.cpp
+++ b/Swiften/LinkLocal/OutgoingLinkLocalSession.cpp
@@ -1,53 +1,52 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/LinkLocal/OutgoingLinkLocalSession.h>
 
 #include <boost/bind.hpp>
 
-#include <Swiften/Base/foreach.h>
 #include <Swiften/Elements/IQ.h>
 #include <Swiften/Elements/ProtocolHeader.h>
 #include <Swiften/Elements/StreamFeatures.h>
 #include <Swiften/StreamStack/XMPPLayer.h>
 
 namespace Swift {
 
 OutgoingLinkLocalSession::OutgoingLinkLocalSession(
         const JID& localJID,
         const JID& remoteJID,
         std::shared_ptr<Connection> connection,
         PayloadParserFactoryCollection* payloadParserFactories,
         PayloadSerializerCollection* payloadSerializers,
         XMLParserFactory* xmlParserFactory) :
             Session(connection, payloadParserFactories, payloadSerializers, xmlParserFactory) {
     setLocalJID(localJID);
     setRemoteJID(remoteJID);
 }
 
 void OutgoingLinkLocalSession::handleSessionStarted() {
     ProtocolHeader header;
     header.setFrom(getLocalJID());
     getXMPPLayer()->writeHeader(header);
 }
 
 void OutgoingLinkLocalSession::handleStreamStart(const ProtocolHeader&) {
-    foreach(const std::shared_ptr<ToplevelElement>& stanza, queuedElements_) {
+    for (const auto& stanza : queuedElements_) {
         sendElement(stanza);
     }
     queuedElements_.clear();
 }
 
 void OutgoingLinkLocalSession::handleElement(std::shared_ptr<ToplevelElement> element) {
     onElementReceived(element);
 }
 
 void OutgoingLinkLocalSession::queueElement(std::shared_ptr<ToplevelElement> element) {
     queuedElements_.push_back(element);
 }
 
 
 }