8 files changed, 45 insertions, 48 deletions
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDBrowseQuery.h b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDBrowseQuery.h
index 860de41..15d8128 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDBrowseQuery.h
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDBrowseQuery.h
@@ -14,7 +14,7 @@ namespace Swift {
 
     class FakeDNSSDBrowseQuery : public DNSSDBrowseQuery, public FakeDNSSDQuery {
         public:
-            FakeDNSSDBrowseQuery(boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier) {
+            FakeDNSSDBrowseQuery(std::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier) {
             }
 
             void startBrowsing() {
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.cpp b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.cpp
index 89698a6..63ad3b8 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.cpp
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.cpp
@@ -29,42 +29,42 @@ FakeDNSSDQuerier::~FakeDNSSDQuerier() {
     }
 }
 
-boost::shared_ptr<DNSSDBrowseQuery> FakeDNSSDQuerier::createBrowseQuery() {
-    return boost::shared_ptr<DNSSDBrowseQuery>(new FakeDNSSDBrowseQuery(shared_from_this()));
+std::shared_ptr<DNSSDBrowseQuery> FakeDNSSDQuerier::createBrowseQuery() {
+    return std::make_shared<FakeDNSSDBrowseQuery>(shared_from_this());
 }
 
-boost::shared_ptr<DNSSDRegisterQuery> FakeDNSSDQuerier::createRegisterQuery(const std::string& name, int port, const ByteArray& info) {
-    return boost::shared_ptr<DNSSDRegisterQuery>(new FakeDNSSDRegisterQuery(name, port, info, 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());
 }
 
-boost::shared_ptr<DNSSDResolveServiceQuery> FakeDNSSDQuerier::createResolveServiceQuery(const DNSSDServiceID& service) {
-    return boost::shared_ptr<DNSSDResolveServiceQuery>(new FakeDNSSDResolveServiceQuery(service, shared_from_this()));
+std::shared_ptr<DNSSDResolveServiceQuery> FakeDNSSDQuerier::createResolveServiceQuery(const DNSSDServiceID& service) {
+    return std::make_shared<FakeDNSSDResolveServiceQuery>(service, shared_from_this());
 }
 
-boost::shared_ptr<DNSSDResolveHostnameQuery> FakeDNSSDQuerier::createResolveHostnameQuery(const std::string& hostname, int interfaceIndex) {
-    return boost::shared_ptr<DNSSDResolveHostnameQuery>(new FakeDNSSDResolveHostnameQuery(hostname, interfaceIndex, 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(boost::shared_ptr<FakeDNSSDQuery> query) {
+void FakeDNSSDQuerier::addRunningQuery(std::shared_ptr<FakeDNSSDQuery> query) {
     runningQueries.push_back(query);
     allQueriesEverRun.push_back(query);
-    if (boost::shared_ptr<FakeDNSSDBrowseQuery> browseQuery = boost::dynamic_pointer_cast<FakeDNSSDBrowseQuery>(query)) {
+    if (std::shared_ptr<FakeDNSSDBrowseQuery> browseQuery = std::dynamic_pointer_cast<FakeDNSSDBrowseQuery>(query)) {
         foreach(const DNSSDServiceID& service, services) {
             eventLoop->postEvent(boost::bind(boost::ref(browseQuery->onServiceAdded), service), shared_from_this());
         }
     }
-    else if (boost::shared_ptr<FakeDNSSDResolveServiceQuery> resolveQuery = boost::dynamic_pointer_cast<FakeDNSSDResolveServiceQuery>(query)) {
+    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());
             }
         }
     }
-    else if (boost::shared_ptr<FakeDNSSDRegisterQuery> registerQuery = boost::dynamic_pointer_cast<FakeDNSSDRegisterQuery>(query)) {
+    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 (boost::shared_ptr<FakeDNSSDResolveHostnameQuery> resolveHostnameQuery = boost::dynamic_pointer_cast<FakeDNSSDResolveHostnameQuery>(query)) {
+    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(
@@ -75,13 +75,13 @@ void FakeDNSSDQuerier::addRunningQuery(boost::shared_ptr<FakeDNSSDQuery> query)
     }
 }
 
-void FakeDNSSDQuerier::removeRunningQuery(boost::shared_ptr<FakeDNSSDQuery> query) {
+void FakeDNSSDQuerier::removeRunningQuery(std::shared_ptr<FakeDNSSDQuery> query) {
     erase(runningQueries, query);
 }
 
 void FakeDNSSDQuerier::addService(const DNSSDServiceID& id) {
     services.insert(id);
-    foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {
+    foreach(const std::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {
         eventLoop->postEvent(boost::bind(boost::ref(query->onServiceAdded), id), shared_from_this());
     }
 }
@@ -89,7 +89,7 @@ void FakeDNSSDQuerier::addService(const DNSSDServiceID& id) {
 void FakeDNSSDQuerier::removeService(const DNSSDServiceID& id) {
     services.erase(id);
     serviceInfo.erase(id);
-    foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {
+    foreach(const std::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {
         eventLoop->postEvent(boost::bind(boost::ref(query->onServiceRemoved), id), shared_from_this());
     }
 }
@@ -99,7 +99,7 @@ void FakeDNSSDQuerier::setServiceInfo(const DNSSDServiceID& id, const DNSSDResol
     if (!r.second) {
         r.first->second = info;
     }
-    foreach(const boost::shared_ptr<FakeDNSSDResolveServiceQuery>& query, getQueries<FakeDNSSDResolveServiceQuery>()) {
+    foreach(const std::shared_ptr<FakeDNSSDResolveServiceQuery>& query, getQueries<FakeDNSSDResolveServiceQuery>()) {
         if (query->service == id) {
             eventLoop->postEvent(boost::bind(boost::ref(query->onServiceResolved), info), shared_from_this());
         }
@@ -107,7 +107,7 @@ void FakeDNSSDQuerier::setServiceInfo(const DNSSDServiceID& id, const DNSSDResol
 }
 
 bool FakeDNSSDQuerier::isServiceRegistered(const std::string& name, int port, const ByteArray& info) {
-    foreach(const boost::shared_ptr<FakeDNSSDRegisterQuery>& query, getQueries<FakeDNSSDRegisterQuery>()) {
+    foreach(const std::shared_ptr<FakeDNSSDRegisterQuery>& query, getQueries<FakeDNSSDRegisterQuery>()) {
         if (query->name == name && query->port == port && query->info == info) {
             return true;
         }
@@ -116,20 +116,20 @@ bool FakeDNSSDQuerier::isServiceRegistered(const std::string& name, int port, co
 }
 
 void FakeDNSSDQuerier::setBrowseError() {
-    foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {
+    foreach(const std::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {
         eventLoop->postEvent(boost::ref(query->onError), shared_from_this());
     }
 }
 
 void FakeDNSSDQuerier::setRegisterError() {
-    foreach(const boost::shared_ptr<FakeDNSSDRegisterQuery>& query, getQueries<FakeDNSSDRegisterQuery>()) {
+    foreach(const std::shared_ptr<FakeDNSSDRegisterQuery>& 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 boost::shared_ptr<FakeDNSSDResolveHostnameQuery>& query, getQueries<FakeDNSSDResolveHostnameQuery>()) {
+    foreach(const std::shared_ptr<FakeDNSSDResolveHostnameQuery>& query, getQueries<FakeDNSSDResolveHostnameQuery>()) {
         if (query->hostname == hostname) {
             eventLoop->postEvent(boost::bind(
                     boost::ref(query->onHostnameResolved), address), shared_from_this());
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h
index 536bf90..85fdc3a 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h
@@ -7,12 +7,10 @@
 #pragma once
 
 #include <list>
+#include <memory>
 #include <set>
 #include <string>
 
-#include <boost/enable_shared_from_this.hpp>
-#include <boost/shared_ptr.hpp>
-
 #include <Swiften/Base/API.h>
 #include <Swiften/Base/ByteArray.h>
 #include <Swiften/EventLoop/EventOwner.h>
@@ -28,7 +26,7 @@ namespace Swift {
     class SWIFTEN_API FakeDNSSDQuerier :
             public DNSSDQuerier,
             public EventOwner,
-            public boost::enable_shared_from_this<FakeDNSSDQuerier> {
+            public std::enable_shared_from_this<FakeDNSSDQuerier> {
         public:
             FakeDNSSDQuerier(const std::string& domain, EventLoop* eventLoop);
             ~FakeDNSSDQuerier();
@@ -40,16 +38,16 @@ namespace Swift {
                 allQueriesEverRun.clear();
             }
 
-            boost::shared_ptr<DNSSDBrowseQuery> createBrowseQuery();
-            boost::shared_ptr<DNSSDRegisterQuery> createRegisterQuery(
+            std::shared_ptr<DNSSDBrowseQuery> createBrowseQuery();
+            std::shared_ptr<DNSSDRegisterQuery> createRegisterQuery(
                     const std::string& name, int port, const ByteArray& info);
-            boost::shared_ptr<DNSSDResolveServiceQuery> createResolveServiceQuery(
+            std::shared_ptr<DNSSDResolveServiceQuery> createResolveServiceQuery(
                     const DNSSDServiceID&);
-            boost::shared_ptr<DNSSDResolveHostnameQuery> createResolveHostnameQuery(
+            std::shared_ptr<DNSSDResolveHostnameQuery> createResolveHostnameQuery(
                     const std::string& hostname, int interfaceIndex);
 
-            void addRunningQuery(boost::shared_ptr<FakeDNSSDQuery>);
-            void removeRunningQuery(boost::shared_ptr<FakeDNSSDQuery>);
+            void addRunningQuery(std::shared_ptr<FakeDNSSDQuery>);
+            void removeRunningQuery(std::shared_ptr<FakeDNSSDQuery>);
 
             void addService(const DNSSDServiceID& id);
             void removeService(const DNSSDServiceID& id);
@@ -62,10 +60,10 @@ namespace Swift {
 
         public:
             template<typename T>
-            std::vector< boost::shared_ptr<T> > getAllQueriesEverRun() const {
-                std::vector< boost::shared_ptr<T> > result;
+            std::vector< std::shared_ptr<T> > getAllQueriesEverRun() const {
+                std::vector< std::shared_ptr<T> > result;
                 for (QueryList::const_iterator i = allQueriesEverRun.begin(); i != allQueriesEverRun.end(); ++i) {
-                    if (boost::shared_ptr<T> resultQuery = boost::dynamic_pointer_cast<T>(*i)) {
+                    if (std::shared_ptr<T> resultQuery = std::dynamic_pointer_cast<T>(*i)) {
                         result.push_back(resultQuery);
                     }
                 }
@@ -74,10 +72,10 @@ namespace Swift {
 
         private:
             template<typename T>
-            std::vector< boost::shared_ptr<T> > getQueries() const {
-                std::vector< boost::shared_ptr<T> > result;
+            std::vector< std::shared_ptr<T> > getQueries() const {
+                std::vector< std::shared_ptr<T> > result;
                 for (QueryList::const_iterator i = runningQueries.begin(); i != runningQueries.end(); ++i) {
-                    if (boost::shared_ptr<T> resultQuery = boost::dynamic_pointer_cast<T>(*i)) {
+                    if (std::shared_ptr<T> resultQuery = std::dynamic_pointer_cast<T>(*i)) {
                         result.push_back(resultQuery);
                     }
                 }
@@ -87,7 +85,7 @@ namespace Swift {
         private:
             std::string domain;
             EventLoop* eventLoop;
-            typedef std::list< boost::shared_ptr<FakeDNSSDQuery> > QueryList;
+            typedef std::list< std::shared_ptr<FakeDNSSDQuery> > QueryList;
             QueryList runningQueries;
             QueryList allQueriesEverRun;
             std::set<DNSSDServiceID> services;
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.cpp b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.cpp
index 980b757..0e05968 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.cpp
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.cpp
@@ -10,7 +10,7 @@
 
 namespace Swift {
 
-FakeDNSSDQuery::FakeDNSSDQuery(boost::shared_ptr<FakeDNSSDQuerier> querier) : querier(querier) {
+FakeDNSSDQuery::FakeDNSSDQuery(std::shared_ptr<FakeDNSSDQuerier> querier) : querier(querier) {
 }
 
 FakeDNSSDQuery::~FakeDNSSDQuery() {
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h
index 0d7dedc..5d869d4 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h
@@ -6,8 +6,7 @@
 
 #pragma once
 
-#include <boost/enable_shared_from_this.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 #include <Swiften/EventLoop/EventOwner.h>
 
@@ -16,9 +15,9 @@ namespace Swift {
 
     class FakeDNSSDQuery :
             public EventOwner,
-            public boost::enable_shared_from_this<FakeDNSSDQuery> {
+            public std::enable_shared_from_this<FakeDNSSDQuery> {
         public:
-            FakeDNSSDQuery(boost::shared_ptr<FakeDNSSDQuerier>);
+            FakeDNSSDQuery(std::shared_ptr<FakeDNSSDQuerier>);
             virtual ~FakeDNSSDQuery();
 
         protected:
@@ -26,6 +25,6 @@ namespace Swift {
             void finish();
 
         protected:
-            boost::shared_ptr<FakeDNSSDQuerier> querier;
+            std::shared_ptr<FakeDNSSDQuerier> querier;
     };
 }
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h
index 484b2c2..7478841 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h
@@ -17,7 +17,7 @@ namespace Swift {
 
     class FakeDNSSDRegisterQuery : public DNSSDRegisterQuery, public FakeDNSSDQuery {
         public:
-            FakeDNSSDRegisterQuery(const std::string& name, int port, const ByteArray& info, boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), name(name), port(port), info(info) {
+            FakeDNSSDRegisterQuery(const std::string& name, int port, const ByteArray& info, std::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), name(name), port(port), info(info) {
             }
 
             void registerService() {
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveHostnameQuery.h b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveHostnameQuery.h
index 0b6a95d..60dc144 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveHostnameQuery.h
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveHostnameQuery.h
@@ -17,7 +17,7 @@ namespace Swift {
 
     class FakeDNSSDResolveHostnameQuery : public DNSSDResolveHostnameQuery, public FakeDNSSDQuery {
         public:
-            FakeDNSSDResolveHostnameQuery(const std::string& hostname, int interfaceIndex, boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), hostname(hostname), interfaceIndex(interfaceIndex) {
+            FakeDNSSDResolveHostnameQuery(const std::string& hostname, int interfaceIndex, std::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), hostname(hostname), interfaceIndex(interfaceIndex) {
             }
 
             void run() {
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h
index 180fbb2..8a02e7b 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h
@@ -15,7 +15,7 @@ namespace Swift {
 
     class FakeDNSSDResolveServiceQuery : public DNSSDResolveServiceQuery, public FakeDNSSDQuery {
         public:
-            FakeDNSSDResolveServiceQuery(const DNSSDServiceID& service, boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), service(service) {
+            FakeDNSSDResolveServiceQuery(const DNSSDServiceID& service, std::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), service(service) {
             }
 
             void start() {