Migrate remaining Swiften/Base/foreach.h use to range-based for loop

Test-Information: Build on macOS 10.12.1 and all tests pass. Change-Id: Iedaa3fa7e7672c77909fd0568bf30e9393cb87e0
author: Tobias Markmann <tm@ayena.de> 2016-11-23 07:09:39 (GMT)
committer: Tobias Markmann <tm@ayena.de> 2016-11-23 11:30:02 (GMT)
commit: e405ff3561be3d3c0bd79d7d5173923a8828cf02 (patch)
tree: 9118ef838ebfaec1df90ec24761944b5d833774c /Slimber/Server.cpp
parent: 8a71b91be885652f37c5aab5e1ecf25af4599fbc (diff)
download: swift-e405ff3561be3d3c0bd79d7d5173923a8828cf02.zip
swift-e405ff3561be3d3c0bd79d7d5173923a8828cf02.tar.bz2
1 files changed, 9 insertions, 9 deletions
diff --git a/Slimber/Server.cpp b/Slimber/Server.cpp
index 7e24abe..3bc3112 100644
--- a/Slimber/Server.cpp
+++ b/Slimber/Server.cpp
@@ -1,45 +1,45 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Slimber/Server.h>
 
+#include <cassert>
 #include <string>
 
 #include <boost/bind.hpp>
 
 #include <Swiften/Base/Log.h>
 #include <Swiften/Base/String.h>
-#include <Swiften/Base/foreach.h>
 #include <Swiften/Elements/IQ.h>
 #include <Swiften/Elements/Presence.h>
 #include <Swiften/Elements/RosterPayload.h>
 #include <Swiften/Elements/ToplevelElement.h>
 #include <Swiften/Elements/VCard.h>
 #include <Swiften/LinkLocal/IncomingLinkLocalSession.h>
 #include <Swiften/LinkLocal/LinkLocalConnector.h>
 #include <Swiften/LinkLocal/LinkLocalServiceBrowser.h>
 #include <Swiften/LinkLocal/LinkLocalServiceInfo.h>
 #include <Swiften/LinkLocal/OutgoingLinkLocalSession.h>
 #include <Swiften/Network/BoostConnection.h>
 #include <Swiften/Network/BoostConnectionServer.h>
 #include <Swiften/Network/Connection.h>
 #include <Swiften/Network/ConnectionServer.h>
 #include <Swiften/Session/Session.h>
 #include <Swiften/Session/SessionTracer.h>
 
 #include <Limber/Server/ServerFromClientSession.h>
 #include <Limber/Server/UserRegistry.h>
 
 #include <Slimber/LinkLocalPresenceManager.h>
 #include <Slimber/VCardCollection.h>
 
 namespace Swift {
 
 Server::Server(
         int clientConnectionPort,
         int linkLocalConnectionPort,
         LinkLocalServiceBrowser* linkLocalServiceBrowser,
         VCardCollection* vCardCollection,
@@ -84,81 +84,81 @@ void Server::start() {
 
     assert(!presenceManager);
     presenceManager = new LinkLocalPresenceManager(linkLocalServiceBrowser);
     presenceManager->onRosterChanged.connect(
             boost::bind(&Server::handleRosterChanged, this, _1));
     presenceManager->onPresenceChanged.connect(
             boost::bind(&Server::handlePresenceChanged, this, _1));
 
     serverFromClientConnectionServer->start();
     serverFromNetworkConnectionServer->start();
 }
 
 void Server::stop() {
     stop(boost::optional<ServerError>());
 }
 
 void Server::stop(boost::optional<ServerError> e) {
     if (stopping) {
         return;
     }
 
     stopping = true;
 
     delete presenceManager;
     presenceManager = nullptr;
 
     if (serverFromClientSession) {
         serverFromClientSession->finishSession();
     }
     serverFromClientSession.reset();
-    foreach(std::shared_ptr<Session> session, linkLocalSessions) {
+    for (auto&& session : linkLocalSessions) {
         session->finishSession();
     }
     linkLocalSessions.clear();
-    foreach(std::shared_ptr<LinkLocalConnector> connector, connectors) {
+    for (auto&& connector : connectors) {
         connector->cancel();
     }
     connectors.clear();
     tracers.clear();
 
     if (serverFromNetworkConnectionServer) {
         serverFromNetworkConnectionServer->stop();
-        foreach(boost::signals2::connection& connection, serverFromNetworkConnectionServerSignalConnections) {
+        for (auto&& connection : serverFromNetworkConnectionServerSignalConnections) {
             connection.disconnect();
         }
         serverFromNetworkConnectionServerSignalConnections.clear();
         serverFromNetworkConnectionServer.reset();
     }
     if (serverFromClientConnectionServer) {
         serverFromClientConnectionServer->stop();
-        foreach(boost::signals2::connection& connection, serverFromClientConnectionServerSignalConnections) {
+        for (auto&& connection : serverFromClientConnectionServerSignalConnections) {
             connection.disconnect();
         }
         serverFromClientConnectionServerSignalConnections.clear();
         serverFromClientConnectionServer.reset();
     }
 
     stopping = false;
     onStopped(e);
 }
 
 void Server::handleNewClientConnection(std::shared_ptr<Connection> connection) {
     if (serverFromClientSession) {
         connection->disconnect();
     }
     serverFromClientSession = std::shared_ptr<ServerFromClientSession>(
             new ServerFromClientSession(idGenerator.generateID(), connection,
                     &payloadParserFactories, &payloadSerializers, &xmlParserFactory, &userRegistry));
     serverFromClientSession->setAllowSASLEXTERNAL();
     serverFromClientSession->onSessionStarted.connect(
             boost::bind(&Server::handleSessionStarted, this));
     serverFromClientSession->onElementReceived.connect(
             boost::bind(&Server::handleElementReceived, this, _1,
                 serverFromClientSession));
     serverFromClientSession->onSessionFinished.connect(
             boost::bind(&Server::handleSessionFinished, this,
             serverFromClientSession));
     //tracers.push_back(std::shared_ptr<SessionTracer>(
     //        new SessionTracer(serverFromClientSession)));
     serverFromClientSession->startSession();
 }
@@ -191,61 +191,61 @@ void Server::handleElementReceived(std::shared_ptr<ToplevelElement> element, std
 
     stanza->setFrom(session->getRemoteJID());
     if (!stanza->getTo().isValid()) {
         stanza->setTo(session->getLocalJID());
     }
 
     if (std::shared_ptr<Presence> presence = std::dynamic_pointer_cast<Presence>(stanza)) {
         if (presence->getType() == Presence::Available) {
             if (!linkLocalServiceRegistered) {
                 linkLocalServiceRegistered = true;
                 linkLocalServiceBrowser->registerService(
                         session->getRemoteJID().toBare().toString(),
                         linkLocalConnectionPort, getLinkLocalServiceInfo(presence));
             }
             else {
                 linkLocalServiceBrowser->updateService(
                         getLinkLocalServiceInfo(presence));
             }
             lastPresence = presence;
         }
         else {
             unregisterService();
         }
     }
     else if (!stanza->getTo().isValid() || stanza->getTo() == session->getLocalJID() || stanza->getTo() == session->getRemoteJID().toBare()) {
         if (std::shared_ptr<IQ> iq = std::dynamic_pointer_cast<IQ>(stanza)) {
             if (iq->getPayload<RosterPayload>()) {
                 if (iq->getType() == IQ::Get) {
                     session->sendElement(IQ::createResult(iq->getFrom(), iq->getID(), presenceManager->getRoster()));
                     rosterRequested = true;
-                    foreach(const std::shared_ptr<Presence> presence, presenceManager->getAllPresence()) {
+                    for (const auto& presence : presenceManager->getAllPresence()) {
                         session->sendElement(presence);
                     }
                 }
                 else {
                     session->sendElement(IQ::createError(iq->getFrom(), iq->getID(), ErrorPayload::Forbidden, ErrorPayload::Cancel));
                 }
             }
             if (std::shared_ptr<VCard> vcard = iq->getPayload<VCard>()) {
                 if (iq->getType() == IQ::Get) {
                     session->sendElement(IQ::createResult(iq->getFrom(), iq->getID(), vCardCollection->getOwnVCard()));
                 }
                 else {
                     vCardCollection->setOwnVCard(vcard);
                     session->sendElement(IQ::createResult(iq->getFrom(), iq->getID()));
                     if (lastPresence) {
                         linkLocalServiceBrowser->updateService(getLinkLocalServiceInfo(lastPresence));
                     }
                 }
             }
             else {
                 session->sendElement(IQ::createError(iq->getFrom(), iq->getID(), ErrorPayload::FeatureNotImplemented, ErrorPayload::Cancel));
             }
         }
     }
     else {
         JID toJID = stanza->getTo();
         std::shared_ptr<Session> outgoingSession =
                 getLinkLocalSessionForJID(toJID);
         if (outgoingSession) {
             outgoingSession->sendElement(stanza);
@@ -287,89 +287,89 @@ void Server::handleNewLinkLocalConnection(std::shared_ptr<Connection> connection
 }
 
 void Server::handleLinkLocalSessionFinished(std::shared_ptr<Session> session) {
     //std::cout << "Link local session from " << session->getRemoteJID() << " ended" << std::endl;
     linkLocalSessions.erase(
             std::remove(linkLocalSessions.begin(), linkLocalSessions.end(), session),
             linkLocalSessions.end());
 }
 
 void Server::handleLinkLocalElementReceived(std::shared_ptr<ToplevelElement> element, std::shared_ptr<Session> session) {
     if (std::shared_ptr<Stanza> stanza = std::dynamic_pointer_cast<Stanza>(element)) {
         JID fromJID = session->getRemoteJID();
         if (!presenceManager->getServiceForJID(fromJID.toBare())) {
             return; // TODO: Send error back
         }
         stanza->setFrom(fromJID);
         serverFromClientSession->sendElement(stanza);
     }
 }
 
 void Server::handleConnectFinished(std::shared_ptr<LinkLocalConnector> connector, bool error) {
     if (error) {
         SWIFT_LOG(warning) << "Error connecting" << std::endl;
         // TODO: Send back queued stanzas
     }
     else {
         std::shared_ptr<OutgoingLinkLocalSession> outgoingSession(
                 new OutgoingLinkLocalSession(
                     selfJID, connector->getService().getJID(), connector->getConnection(),
                     &payloadParserFactories, &payloadSerializers, &xmlParserFactory));
-        foreach(const std::shared_ptr<ToplevelElement> element, connector->getQueuedElements()) {
+        for (const auto& element : connector->getQueuedElements()) {
             outgoingSession->queueElement(element);
         }
         registerLinkLocalSession(outgoingSession);
     }
     connectors.erase(std::remove(connectors.begin(), connectors.end(), connector), connectors.end());
 }
 
 void Server::registerLinkLocalSession(std::shared_ptr<Session> session) {
     session->onSessionFinished.connect(
             boost::bind(&Server::handleLinkLocalSessionFinished, this, session));
     session->onElementReceived.connect(
             boost::bind(&Server::handleLinkLocalElementReceived, this, _1, session));
     linkLocalSessions.push_back(session);
     //tracers.push_back(std::make_shared<SessionTracer>(session));
     session->startSession();
 }
 
 std::shared_ptr<Session> Server::getLinkLocalSessionForJID(const JID& jid) {
-    foreach(const std::shared_ptr<Session> session, linkLocalSessions) {
+    for (const auto& session : linkLocalSessions) {
         if (session->getRemoteJID() == jid) {
             return session;
         }
     }
     return std::shared_ptr<Session>();
 }
 
 std::shared_ptr<LinkLocalConnector> Server::getLinkLocalConnectorForJID(const JID& jid) {
-    foreach(const std::shared_ptr<LinkLocalConnector> connector, connectors) {
+    for (const auto& connector : connectors) {
         if (connector->getService().getJID() == jid) {
             return connector;
         }
     }
     return std::shared_ptr<LinkLocalConnector>();
 }
 
 void Server::handleServiceRegistered(const DNSSDServiceID& service) {
     selfJID = JID(service.getName());
 }
 
 void Server::handleRosterChanged(std::shared_ptr<RosterPayload> roster) {
     if (rosterRequested) {
         assert(serverFromClientSession);
         std::shared_ptr<IQ> iq = IQ::createRequest(
                 IQ::Set, serverFromClientSession->getRemoteJID(),
                 idGenerator.generateID(), roster);
         iq->setFrom(serverFromClientSession->getRemoteJID().toBare());
         serverFromClientSession->sendElement(iq);
     }
 }
 
 void Server::handlePresenceChanged(std::shared_ptr<Presence> presence) {
     if (rosterRequested) {
         serverFromClientSession->sendElement(presence);
     }
 }
 
 void Server::handleClientConnectionServerStopped(boost::optional<BoostConnectionServer::Error> e) {
     if (e) {
author	Tobias Markmann <tm@ayena.de>	2016-11-23 07:09:39 (GMT)
committer	Tobias Markmann <tm@ayena.de>	2016-11-23 11:30:02 (GMT)
commit	e405ff3561be3d3c0bd79d7d5173923a8828cf02 (patch)
tree	9118ef838ebfaec1df90ec24761944b5d833774c /Slimber/Server.cpp
parent	8a71b91be885652f37c5aab5e1ecf25af4599fbc (diff)
download	swift-e405ff3561be3d3c0bd79d7d5173923a8828cf02.zip swift-e405ff3561be3d3c0bd79d7d5173923a8828cf02.tar.bz2