4 files changed, 15 insertions, 19 deletions
diff --git a/Slimber/LinkLocalPresenceManager.cpp b/Slimber/LinkLocalPresenceManager.cpp
index f166b38..ec5f2cd 100644
--- a/Slimber/LinkLocalPresenceManager.cpp
+++ b/Slimber/LinkLocalPresenceManager.cpp
@@ -1,100 +1,99 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Slimber/LinkLocalPresenceManager.h>
 
 #include <boost/bind.hpp>
 
-#include <Swiften/Base/foreach.h>
 #include <Swiften/Elements/Presence.h>
 #include <Swiften/Elements/RosterPayload.h>
 #include <Swiften/LinkLocal/LinkLocalServiceBrowser.h>
 
 namespace Swift {
 
 LinkLocalPresenceManager::LinkLocalPresenceManager(LinkLocalServiceBrowser* browser) : browser(browser) {
     browser->onServiceAdded.connect(
             boost::bind(&LinkLocalPresenceManager::handleServiceAdded, this, _1));
     browser->onServiceChanged.connect(
             boost::bind(&LinkLocalPresenceManager::handleServiceChanged, this, _1));
     browser->onServiceRemoved.connect(
             boost::bind(&LinkLocalPresenceManager::handleServiceRemoved, this, _1));
 }
 
 boost::optional<LinkLocalService> LinkLocalPresenceManager::getServiceForJID(const JID& j) const {
-    foreach(const LinkLocalService& service, browser->getServices()) {
+    for (const auto& service : browser->getServices()) {
         if (service.getJID() == j) {
             return service;
         }
     }
     return boost::optional<LinkLocalService>();
 }
 
 void LinkLocalPresenceManager::handleServiceAdded(const LinkLocalService& service) {
     std::shared_ptr<RosterPayload> roster(new RosterPayload());
     roster->addItem(getRosterItem(service));
     onRosterChanged(roster);
     onPresenceChanged(getPresence(service));
 }
 
 void LinkLocalPresenceManager::handleServiceChanged(const LinkLocalService& service) {
     onPresenceChanged(getPresence(service));
 }
 
 void LinkLocalPresenceManager::handleServiceRemoved(const LinkLocalService& service) {
     std::shared_ptr<RosterPayload> roster(new RosterPayload());
     roster->addItem(RosterItemPayload(service.getJID(), "", RosterItemPayload::Remove));
     onRosterChanged(roster);
 }
 
 std::shared_ptr<RosterPayload> LinkLocalPresenceManager::getRoster() const {
     std::shared_ptr<RosterPayload> roster(new RosterPayload());
-    foreach(const LinkLocalService& service, browser->getServices()) {
+    for (const auto& service : browser->getServices()) {
         roster->addItem(getRosterItem(service));
     }
     return roster;
 }
 
 std::vector<std::shared_ptr<Presence> > LinkLocalPresenceManager::getAllPresence() const {
     std::vector<std::shared_ptr<Presence> > result;
-    foreach(const LinkLocalService& service, browser->getServices()) {
+    for (const auto& service : browser->getServices()) {
         result.push_back(getPresence(service));
     }
     return result;
 }
 
 RosterItemPayload LinkLocalPresenceManager::getRosterItem(const LinkLocalService& service) const {
- return RosterItemPayload(service.getJID(), getRosterName(service), RosterItemPayload::Both);
+    return RosterItemPayload(service.getJID(), getRosterName(service), RosterItemPayload::Both);
 }
 
 std::string LinkLocalPresenceManager::getRosterName(const LinkLocalService& service) const {
     LinkLocalServiceInfo info = service.getInfo();
     if (!info.getNick().empty()) {
         return info.getNick();
     }
     else if (!info.getFirstName().empty()) {
         std::string result = info.getFirstName();
         if (!info.getLastName().empty()) {
             result += " " + info.getLastName();
         }
         return result;
     }
     else if (!info.getLastName().empty()) {
         return info.getLastName();
     }
     return "";
 }
 
 std::shared_ptr<Presence> LinkLocalPresenceManager::getPresence(const LinkLocalService& service) const {
     std::shared_ptr<Presence> presence(new Presence());
     presence->setFrom(service.getJID());
     switch (service.getInfo().getStatus()) {
         case LinkLocalServiceInfo::Available:
             presence->setShow(StatusShow::Online);
             break;
         case LinkLocalServiceInfo::Away:
             presence->setShow(StatusShow::Away);
             break;
diff --git a/Slimber/MainController.cpp b/Slimber/MainController.cpp
index dcec6d5..cd36132 100644
--- a/Slimber/MainController.cpp
+++ b/Slimber/MainController.cpp
@@ -1,42 +1,41 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Slimber/MainController.h>
 
 #include <boost/bind.hpp>
 #include <boost/lexical_cast.hpp>
 
-#include <Swiften/Base/foreach.h>
 #include <Swiften/LinkLocal/DNSSD/PlatformDNSSDQuerierFactory.h>
 #include <Swiften/LinkLocal/LinkLocalService.h>
 #include <Swiften/LinkLocal/LinkLocalServiceBrowser.h>
 
 #include <Slimber/FileVCardCollection.h>
 #include <Slimber/Menulet.h>
 #include <Slimber/MenuletController.h>
 #include <Slimber/Server.h>
 
 #include <SwifTools/Application/PlatformApplicationPathProvider.h>
 
 using namespace Swift;
 
 MainController::MainController(Menulet* menulet, EventLoop* eventLoop) {
     dnsSDQuerier = PlatformDNSSDQuerierFactory(eventLoop).createQuerier();
     assert(dnsSDQuerier);
 
     linkLocalServiceBrowser = new LinkLocalServiceBrowser(dnsSDQuerier);
     linkLocalServiceBrowser->onServiceAdded.connect(
             boost::bind(&MainController::handleServicesChanged, this));
     linkLocalServiceBrowser->onServiceRemoved.connect(
             boost::bind(&MainController::handleServicesChanged, this));
     linkLocalServiceBrowser->onServiceChanged.connect(
             boost::bind(&MainController::handleServicesChanged, this));
 
     vCardCollection = new FileVCardCollection(
             PlatformApplicationPathProvider("Slimber").getDataDir());
 
     server = new Server(5222, 5562, linkLocalServiceBrowser, vCardCollection, eventLoop);
     server->onStopped.connect(
@@ -61,61 +60,61 @@ MainController::~MainController() {
     dnsSDQuerier->stop();
 }
 
 void MainController::start() {
     dnsSDQuerier->start();
     linkLocalServiceBrowser->start();
 
     handleSelfConnected(false);
     handleServicesChanged();
 
     server->start();
 }
 
 void MainController::stop() {
     server->stop();
     linkLocalServiceBrowser->stop();
     dnsSDQuerier->stop();
 }
 
 void MainController::handleSelfConnected(bool b) {
     if (b) {
         menuletController->setXMPPStatus("You are logged in", MenuletController::Online);
     }
     else {
         menuletController->setXMPPStatus("You are not logged in", MenuletController::Offline);
     }
 }
 
 void MainController::handleServicesChanged() {
     std::vector<std::string> names;
-    foreach(const LinkLocalService& service, linkLocalServiceBrowser->getServices()) {
+    for (const auto& service : linkLocalServiceBrowser->getServices()) {
         std::string description = service.getDescription();
         if (description != service.getName()) {
             description += " (" + service.getName() + ")";
         }
         names.push_back(description);
     }
     menuletController->setUserNames(names);
 }
 
 void MainController::handleServerStopped(boost::optional<ServerError> error) {
     if (error) {
         std::string message;
         switch (error->getType()) {
             case ServerError::C2SPortConflict:
                 message = std::string("Error: Port ") + boost::lexical_cast<std::string>(server->getClientToServerPort()) + std::string(" in use");
                 break;
             case ServerError::C2SError:
                 message = std::string("Local connection server error");
              break;
             case ServerError::LinkLocalPortConflict:
                 message = std::string("Error: Port ") + boost::lexical_cast<std::string>(server->getLinkLocalPort()) + std::string(" in use");
                 break;
             case ServerError::LinkLocalError:
                 message = std::string("External connection server error");
                 break;
         }
         menuletController->setXMPPStatus(message, MenuletController::Offline);
     }
     else {
         menuletController->setXMPPStatus("XMPP Server Not Running", MenuletController::Offline);
diff --git a/Slimber/MenuletController.cpp b/Slimber/MenuletController.cpp
index fdf2fc7..5ea5bc9 100644
--- a/Slimber/MenuletController.cpp
+++ b/Slimber/MenuletController.cpp
@@ -1,55 +1,53 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Slimber/MenuletController.h>
 
 #include <string>
 
-#include <Swiften/Base/foreach.h>
-
 #include <Slimber/Menulet.h>
 
 MenuletController::MenuletController(Menulet* menulet) :
         menulet(menulet), xmppStatus(Offline) {
     menulet->onRestartClicked.connect(boost::ref(onRestartRequested));
     update();
 }
 
 MenuletController::~MenuletController() {
 }
 
 void MenuletController::setXMPPStatus(const std::string& message, Status status) {
     xmppStatus = status;
     xmppStatusMessage = message;
     update();
 }
 
 void MenuletController::setUserNames(const std::vector<std::string>& users) {
     linkLocalUsers = users;
     update();
 }
 
 void MenuletController::update() {
     menulet->clear();
     if (linkLocalUsers.empty()) {
         menulet->setIcon("UsersOffline");
         menulet->addItem("No online users");
     }
     else {
         menulet->setIcon("UsersOnline");
         menulet->addItem("Online users:");
-        foreach(const std::string& user, linkLocalUsers) {
+        for (const auto& user : linkLocalUsers) {
             menulet->addItem(std::string("  ") + user);
         }
     }
     menulet->addSeparator();
     menulet->addItem(xmppStatusMessage, (xmppStatus == Online ? "Online" : "Offline"));
     menulet->addSeparator();
     menulet->addAboutItem();
     menulet->addSeparator();
     menulet->addRestartItem();
     menulet->addExitItem();
 }
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) {