libtransport.git Changeset - 6d2f8c192761

@@ @@ -2,19 +2,19 @@ language: cpp @@
 python:
   - "2.7_with_system_site_packages"
 virtualenv:
   system_site_packages: true
 sudo: required
 dist: trusty
 before_script:
           - curl -k https://swift.im/keys/packages.key | sudo apt-key add -
           - echo "deb http://swift.im/packages/ubuntu/trusty development main" | sudo tee -a /etc/apt/sources.list
           - echo "deb http://packages.spectrum.im/spectrum2/ trusty main" | sudo tee -a /etc/apt/sources.list
           - echo " deb http://packages.prosody.im/debian trusty main" | sudo tee -a /etc/apt/sources.list
           - sudo apt-get update -qq
           - sudo apt-get install -y --force-yes prosody ngircd python-sleekxmpp libswiften-dev libprotobuf-dev protobuf-compiler pidgin-dev liblog4cxx10-dev libpopt-dev libboost-dev libboost-signals-dev libboost-system-dev libboost-thread-dev libboost-locale-dev libboost-filesystem-dev libboost-program-options-dev libboost-regex-dev libboost-date-time-dev libcppunit-dev libcommuni-dev
+          - sudo apt-get install -y --force-yes prosody ngircd python-sleekxmpp libswiften-dev libprotobuf-dev protobuf-compiler pidgin-dev liblog4cxx10-dev libpopt-dev libboost-dev libboost-signals-dev libboost-system-dev libboost-thread-dev libboost-locale-dev libboost-filesystem-dev libboost-program-options-dev libboost-regex-dev libboost-date-time-dev libcppunit-dev libcommuni-dev libminiupnpc-dev libnatpmp-dev
           - sudo killall lua5.1
 install: "pip install --user sleekxmpp"
 script:
           - cmake -DCMAKE_BUILD_TYPE=Debug -DENABLE_TESTS=ON . && make && make extended_test
 notifications:
   slack: spectrum2:CIlYHtxGMAaxs3qVHfwBzCuy

CMakeLists.txt

➞

Show inline comments

@@ @@ -66,25 +66,26 @@ if(NOT SWIFTEN_FOUND) @@
 	endif()
 	if (LIBIDN_LIBRARY)
 		set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} ${LIBIDN_LIBRARY})
 	endif()
 	if (LIBXML_LIBRARY)
 		set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} ${LIBXML_LIBRARY})
 	endif()
 	set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} "Dnsapi")
 	set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} "Crypt32")
 	set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} "Secur32")
 	set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} "Iphlpapi")
 	set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} "Winscard")
 	message(STATUS "Using swiften: ${SWIFTEN_INCLUDE_DIR} ${SWIFTEN_LIBRARY}")
 	message(STATUS "XXXUsing swiften: ${SWIFTEN_INCLUDE_DIR} ${SWIFTEN_LIBRARY}
 	Version: ${SWIFTEN_VERSION}")
 endif()
 # FIND BOOST
 if (WIN32)
 	set(Boost_USE_STATIC_LIBS      ON)
 	set(Boost_USE_MULTITHREADED      ON)
 	set(Boost_USE_STATIC_RUNTIME    OFF)
 	find_package(Boost COMPONENTS program_options date_time system filesystem regex thread signals locale REQUIRED)
 else(WIN32)
 	LIST_CONTAINS(contains -lboost_program_options ${SWIFTEN_LIBRARY})
 	if(contains)
 		message(STATUS "Using non-multithreaded boost")
@@ @@ -475,13 +476,12 @@ else(DOXYGEN_FOUND) @@
 	endif()
 endif(DOXYGEN_FOUND)
 message("----------------------")
 if(NOT SQLITE3_FOUND AND NOT MYSQL_FOUND AND NOT PQXX_FOUND)
 	if(ENABLE_SQLITE3 OR ENABLE_MYSQL OR ENABLE_PQXX)
 		message("Could not find any database - Please install at least one of sqlite3-devel, mysql-devel or pqxx-devel if you want to use transport mode.")
 	else(ENABLE_SQLITE3 OR ENABLE_MYSQL OR ENABLE_PQXX)
 		message("Please enable at least one of SQLITE3, MYSQL, PQXX databases to use transport mode.")
 	endif()
 endif()

backends/frotz/main.cpp

➞

Show inline comments

@@ @@ -2,24 +2,25 @@ @@
  * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com
+ *
  * This example is free, and not covered by LGPL license. There is no
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #include "transport/Config.h"
 #include "transport/NetworkPlugin.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/SwiftenCompat.h"
 #include <boost/filesystem.hpp>
 #include "unistd.h"
 #include "signal.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 Swift::SimpleEventLoop *loop_;
 using namespace boost::program_options;
 using namespace Transport;
 class FrotzNetworkPlugin;
 FrotzNetworkPlugin * np = NULL;
+	}
 	else {
 		close(CHILD_READ);
 		close(CHILD_WRITE);
+	}
+}
 class FrotzNetworkPlugin : public NetworkPlugin {
 	public:
 		Swift::BoostNetworkFactories *m_factories;
 		Swift::BoostIOServiceThread m_boostIOServiceThread;
-		boost::shared_ptr<Swift::Connection> m_conn;
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> m_conn;
 		FrotzNetworkPlugin(Config *config, Swift::SimpleEventLoop *loop, const std::string &host, int port) : NetworkPlugin() {
 			this->config = config;
 			m_factories = new Swift::BoostNetworkFactories(loop);
 			m_conn = m_factories->getConnectionFactory()->createConnection();
 			m_conn->onDataRead.connect(boost::bind(&FrotzNetworkPlugin::_handleDataRead, this, _1));
 			m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(host), port));
 // 			m_conn->onConnectFinished.connect(boost::bind(&FrotzNetworkPlugin::_handleConnected, this, _1));
 // 			m_conn->onDisconnected.connect(boost::bind(&FrotzNetworkPlugin::handleDisconnected, this));
+		}
 		void sendData(const std::string &string) {
 			m_conn->write(Swift::createSafeByteArray(string));
+		}
-		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) {
+		void _handleDataRead(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::SafeByteArray> data) {
 			std::string d(data->begin(), data->end());
 			handleDataRead(d);
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			np->handleConnected(user);
 			std::vector<std::string> groups;
 			groups.push_back("ZCode");
 			np->handleBuddyChanged(user, "zcode", "ZCode", groups, pbnetwork::STATUS_ONLINE);
 // 			sleep(1);
 // 			np->handleMessage(np->m_user, "zork", first_msg);
+		}

backends/libpurple/main.cpp

➞

Show inline comments

@@ @@ -7,24 +7,25 @@ @@
 #define _LIBC_INTERFACE_H_ 1
 #include "purple.h"
 #include <algorithm>
 #include <iostream>
 #include <fstream>
 #include "transport/NetworkPlugin.h"
 #include "transport/Logging.h"
 #include "transport/Config.h"
 #include "transport/StorageBackend.h"
 #include "geventloop.h"
 #include "Swiften/SwiftenCompat.h"
 // #include "valgrind/memcheck.h"
 #if !defined(__FreeBSD__) && !defined(__APPLE__)
 #include "malloc.h"
 #endif
 #include "errno.h"
 #include <boost/make_shared.hpp>
 #include <boost/locale.hpp>
 #include <boost/locale/conversion.hpp>
 #include <boost/thread/mutex.hpp>
 #ifdef WITH_LIBEVENT
+}
 static std::vector<std::string> split(const std::string &s, char delim) {
     std::vector<std::string> elems;
     return split(s, delim, elems);
+}
 static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond);
 class SpectrumNetworkPlugin;
-boost::shared_ptr<Config> config;
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Config> config;
 SpectrumNetworkPlugin *np;
 StorageBackend *storagebackend;
 static std::string host;
 static int port = 10000;
 struct FTData {
 	unsigned long id;
 	unsigned long timer;
 	bool paused;
 };
@@ @@ -2251,25 +2252,25 @@ int main(int argc, char **argv) { @@
 			std::cout << "SIGCHLD handler can't be set\n";
 			return -1;
+		}
 #endif
 	std::string error;
 	Config *cfg = Config::createFromArgs(argc, argv, error, host, port);
 	if (cfg == NULL) {
 		std::cerr << error;
 		return 1;
+	}
-	config = boost::shared_ptr<Config>(cfg);
+	config = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Config>(cfg);
 	Logging::initBackendLogging(config.get());
 	if (CONFIG_STRING(config, "service.protocol") == "prpl-hangouts") {
 		storagebackend = StorageBackend::createBackend(config.get(), error);
 		if (storagebackend == NULL) {
 			LOG4CXX_ERROR(logger, "Error creating StorageBackend! " << error);
 			LOG4CXX_ERROR(logger, "Hangouts backend needs storage backend configured to work! " << error);
 			return NetworkPlugin::StorageBackendNeeded;
+		}
 		else if (!storagebackend->connect()) {
 			LOG4CXX_ERROR(logger, "Can't connect to database!")
 				return -1;

backends/smstools3/main.cpp

➞

Show inline comments

@@ @@ -7,24 +7,25 @@ @@
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #include "transport/Config.h"
 #include "transport/Logging.h"
 #include "transport/NetworkPlugin.h"
 #include "transport/SQLite3Backend.h"
 #include "transport/MySQLBackend.h"
 #include "transport/PQXXBackend.h"
 #include "transport/StorageBackend.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/SwiftenCompat.h"
 #include <boost/filesystem.hpp>
 #include "unistd.h"
 #include "signal.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 #include <fstream>
 #include <streambuf>
 Swift::SimpleEventLoop *loop_;
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
@@ @@ -36,25 +37,25 @@ using namespace Transport; @@
 DEFINE_LOGGER(logger, "SMSNetworkPlugin");
 #define INTERNAL_USER "/sms@backend@internal@user"
 class SMSNetworkPlugin;
 SMSNetworkPlugin * np = NULL;
 class SMSNetworkPlugin : public NetworkPlugin {
 	public:
 		Swift::BoostNetworkFactories *m_factories;
 		Swift::BoostIOServiceThread m_boostIOServiceThread;
-		boost::shared_ptr<Swift::Connection> m_conn;
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> m_conn;
 		Swift::Timer::ref m_timer;
 		int m_internalUser;
 		StorageBackend *storageBackend;
 		SMSNetworkPlugin(Config *config, Swift::SimpleEventLoop *loop, StorageBackend *storagebackend, const std::string &host, int port) : NetworkPlugin() {
 			this->config = config;
 			this->storageBackend = storagebackend;
 			m_factories = new Swift::BoostNetworkFactories(loop);
 			m_conn = m_factories->getConnectionFactory()->createConnection();
 			m_conn->onDataRead.connect(boost::bind(&SMSNetworkPlugin::_handleDataRead, this, _1));
 			m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(host), port));
 // 			m_conn->onConnectFinished.connect(boost::bind(&FrotzNetworkPlugin::_handleConnected, this, _1));
@@ @@ -160,25 +161,25 @@ class SMSNetworkPlugin : public NetworkPlugin { @@
 				uuid += bucket[rand() % bucket.size()];
+			}
 			std::ofstream myfile;
 			myfile.open (std::string("/var/spool/sms/outgoing/spectrum." + uuid).c_str());
 			myfile << data;
 			myfile.close();
+		}
 		void sendData(const std::string &string) {
 			m_conn->write(Swift::createSafeByteArray(string));
+		}
-		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) {
+		void _handleDataRead(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::SafeByteArray> data) {
 			std::string d(data->begin(), data->end());
 			handleDataRead(d);
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			UserInfo info;
 			if (!storageBackend->getUser(user, info)) {
 				handleDisconnected(user, 0, "Not registered user.");
 				return;
+			}
 			std::list<BuddyInfo> roster;
 			storageBackend->getBuddies(info.id, roster);

backends/swiften/main.cpp

➞

Show inline comments

 // Transport includes
 #include "transport/Config.h"
 #include "transport/NetworkPlugin.h"
 #include "transport/Logging.h"
 #include "boost/date_time/posix_time/posix_time.hpp"
 // Swiften
 #include "Swiften/Swiften.h"
 #include "Swiften/SwiftenCompat.h"
 #include <Swiften/Version.h>
 #define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)
 #ifndef WIN32
 // for signal handler
 #include "unistd.h"
 #include "signal.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 #endif
 #ifndef __FreeBSD__
@@ @@ -42,49 +43,49 @@ class SwiftenPlugin; @@
 NetworkPlugin *np = NULL;
 Swift::XMPPSerializer *serializer;
 class ForwardIQHandler : public Swift::IQHandler {
 	public:
 		std::map <std::string, std::string> m_id2resource;
 		ForwardIQHandler(NetworkPlugin *np, const std::string &user) {
 			m_np = np;
 			m_user = user;
+		}
-		bool handleIQ(boost::shared_ptr<Swift::IQ> iq) {
+		bool handleIQ(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq) {
 			if (iq->getPayload<Swift::RosterPayload>() != NULL) {
 				return false;
+			}
 			if (iq->getType() == Swift::IQ::Get) {
 				m_id2resource[iq->getID()] = iq->getFrom().getResource();
+			}
 			iq->setTo(m_user);
 			std::string xml = safeByteArrayToString(serializer->serializeElement(iq));
 			m_np->sendRawXML(xml);
 			return true;
+		}
 	private:
 		NetworkPlugin *m_np;
 		std::string m_user;
 };
 class SwiftenPlugin : public NetworkPlugin, Swift::XMPPParserClient {
 	public:
 		Swift::BoostNetworkFactories *m_factories;
 		Swift::BoostIOServiceThread m_boostIOServiceThread;
-		boost::shared_ptr<Swift::Connection> m_conn;
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> m_conn;
 		bool m_firstPing;
 		Swift::FullPayloadSerializerCollection collection;
 		Swift::XMPPParser *m_xmppParser;
 		Swift::FullPayloadParserFactoryCollection m_collection2;
 		SwiftenPlugin(Config *config, Swift::SimpleEventLoop *loop, const std::string &host, int port) : NetworkPlugin() {
 			this->config = config;
 			m_firstPing = true;
 			m_factories = new Swift::BoostNetworkFactories(loop);
 			m_conn = m_factories->getConnectionFactory()->createConnection();
 			m_conn->onDataRead.connect(boost::bind(&SwiftenPlugin::_handleDataRead, this, _1));
 			m_xmppParser = new Swift::XMPPParser(this, &m_collection2, m_factories->getXMLParserFactory());
 			m_xmppParser->parse("<stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' to='localhost' version='1.0'>");
 			LOG4CXX_INFO(logger, "Starting the plugin.");
+		}
 		// NetworkPlugin uses this method to send the data to networkplugin server
 		void sendData(const std::string &string) {
 			m_conn->write(Swift::createSafeByteArray(string));
+		}
 		// This method has to call handleDataRead with all received data from network plugin server
-		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) {
+		void _handleDataRead(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::SafeByteArray> data) {
 			if (m_firstPing) {
 				m_firstPing = false;
 				NetworkPlugin::PluginConfig cfg;
 				cfg.setRawXML(true);
 				cfg.setNeedRegistration(false);
 				sendConfig(cfg);
+			}
 			std::string d(data->begin(), data->end());
 			handleDataRead(d);
+		}
 		void handleStreamStart(const Swift::ProtocolHeader&) {}
 #if HAVE_SWIFTEN_3
-		void handleElement(boost::shared_ptr<Swift::ToplevelElement> element) {
+		void handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ToplevelElement> element) {
 #else
-		void handleElement(boost::shared_ptr<Swift::Element> element) {
+		void handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element> element) {
 #endif
-			boost::shared_ptr<Swift::Stanza> stanza = boost::dynamic_pointer_cast<Swift::Stanza>(element);
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Stanza> stanza = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::Stanza>(element);
 			if (!stanza) {
 				return;
+			}
 			std::string user = stanza->getFrom().toBare();
-			boost::shared_ptr<Swift::Client> client = m_users[user];
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Client> client = m_users[user];
 			if (!client)
 				return;
 			stanza->setFrom(client->getJID());
-			boost::shared_ptr<Swift::Message> message = boost::dynamic_pointer_cast<Swift::Message>(stanza);
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::Message>(stanza);
 			if (message) {
 				client->sendMessage(message);
 				return;
+			}
-			boost::shared_ptr<Swift::Presence> presence = boost::dynamic_pointer_cast<Swift::Presence>(stanza);
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Presence> presence = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::Presence>(stanza);
 			if (presence) {
 				client->sendPresence(presence);
 				return;
+			}
-			boost::shared_ptr<Swift::IQ> iq = boost::dynamic_pointer_cast<Swift::IQ>(stanza);
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::IQ>(stanza);
 			if (iq) {
 				if (m_handlers[user]->m_id2resource.find(stanza->getID()) != m_handlers[user]->m_id2resource.end()) {
 					std::string resource = m_handlers[user]->m_id2resource[stanza->getID()];
 					if (resource.empty()) {
 						iq->setTo(Swift::JID(iq->getTo().getNode(), iq->getTo().getDomain()));
 					} else {
 						iq->setTo(Swift::JID(iq->getTo().getNode(), iq->getTo().getDomain(), resource));
+					}
 					m_handlers[user]->m_id2resource.erase(stanza->getID());
+				}
 				client->getIQRouter()->sendIQ(iq);
 					case Swift::ClientError::CertificateRejectedError: message = ("Certificate has been rejected"); break;
 					case Swift::ClientError::CertificateUntrustedError: message = ("Certificate is not trusted"); break;
 					case Swift::ClientError::InvalidCertificatePurposeError: message = ("Certificate cannot be used for encrypting your connection"); break;
 					case Swift::ClientError::CertificatePathLengthExceededError: message = ("Certificate path length constraint exceeded"); break;
 					case Swift::ClientError::InvalidCertificateSignatureError: message = ("Invalid certificate signature"); break;
 					case Swift::ClientError::InvalidCAError: message = ("Invalid Certificate Authority"); break;
 					case Swift::ClientError::InvalidServerIdentityError: message = ("Certificate does not match the host identity"); break;
+				}
+			}
 			LOG4CXX_INFO(logger, user << ": Disconnected " << message);
 			handleDisconnected(user, reconnect ? 0 : 3, message);
-			boost::shared_ptr<Swift::Client> client = m_users[user];
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				client->onConnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));
 				client->onDisconnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));
 				client->onMessageReceived.disconnect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));
 				m_users.erase(user);
 				m_handlers.erase(user);
+			}
 #ifndef WIN32
 #ifndef __FreeBSD__
 #ifndef __MACH__
 			// force returning of memory chunks allocated by libxml2 to kernel
 		void handleSwiftRosterReceived(const std::string &user) {
 			Swift::PresenceOracle *oracle = m_users[user]->getPresenceOracle();
 			BOOST_FOREACH(const Swift::XMPPRosterItem &item, m_users[user]->getRoster()->getItems()) {
 				Swift::Presence::ref lastPresence = oracle->getLastPresence(item.getJID());
 				pbnetwork::StatusType status = lastPresence ? ((pbnetwork::StatusType) lastPresence->getShow()) : pbnetwork::STATUS_NONE;
 				handleBuddyChanged(user, item.getJID().toBare().toString(),
 								   item.getName(), item.getGroups(), status);
+			}
+		}
 		void handleSwiftPresenceChanged(const std::string &user, Swift::Presence::ref presence) {
-// 			boost::shared_ptr<Swift::Client> client = m_users[user];
+// 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Client> client = m_users[user];
 // 			if (client->getMUCRegistry()->isMUC(presence->getFrom().toBare())) {
 // 				return;
 // 			}
 //
 // 			if (presence->getPayload<Swift::MUCUserPayload>() != NULL || presence->getPayload<Swift::MUCPayload>() != NULL) {
 // 				return;
 // 			}
 //
 // 			LOG4CXX_INFO(logger, user << ": " << presence->getFrom().toBare().toString() << " presence changed");
 //
 // 			std::string message = presence->getStatus();
 // 			std::string photo = "";
 //
-// 			boost::shared_ptr<Swift::VCardUpdate> update = presence->getPayload<Swift::VCardUpdate>();
+// 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCardUpdate> update = presence->getPayload<Swift::VCardUpdate>();
 // 			if (update) {
 // 				photo = update->getPhotoHash();
 // 			}
 //
 // 			boost::optional<Swift::XMPPRosterItem> item = m_users[user]->getRoster()->getItem(presence->getFrom());
 // 			if (item) {
 // 				handleBuddyChanged(user, presence->getFrom().toBare().toString(), item->getName(), item->getGroups(), (pbnetwork::StatusType) presence->getShow(), message, photo);
 // 			}
 // 			else {
 // 				std::vector<std::string> groups;
 // 				handleBuddyChanged(user, presence->getFrom().toBare().toString(), presence->getFrom().toBare(), groups, (pbnetwork::StatusType) presence->getShow(), message, photo);
 // 			}
+		}
 		void handleSwiftenDataWritten(const Swift::SafeByteArray &data) {
 			LOG4CXX_INFO(logger_xml, "XML OUT " << safeByteArrayToString(data));
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			LOG4CXX_INFO(logger, user << ": connecting as " << legacyName);
 			Swift::JID jid(legacyName);
 			if (legacyName.find("/") == std::string::npos) {
 				jid = Swift::JID(legacyName + "/Spectrum");
+			}
-			boost::shared_ptr<Swift::Client> client = boost::make_shared<Swift::Client>(jid, password, m_factories);
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Client> client = SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::Client>(jid, password, m_factories);
 			m_users[user] = client;
 			client->setAlwaysTrustCertificates();
 			client->onConnected.connect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));
 			client->onDisconnected.connect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));
 			client->onMessageReceived.connect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));
 			client->getRoster()->onInitialRosterPopulated.connect(boost::bind(&SwiftenPlugin::handleSwiftRosterReceived, this, user));
 			client->getPresenceOracle()->onPresenceChange.connect(boost::bind(&SwiftenPlugin::handleSwiftPresenceChanged, this, user, _1));
 			client->onDataRead.connect(boost::bind(&SwiftenPlugin::handleSwiftenDataRead, this, _1));
 			client->onDataWritten.connect(boost::bind(&SwiftenPlugin::handleSwiftenDataWritten, this, _1));
 			client->getSubscriptionManager()->onPresenceSubscriptionRequest.connect(boost::bind(&SwiftenPlugin::handleSubscriptionRequest, this, user, _1, _2, _3));
 			client->getSubscriptionManager()->onPresenceSubscriptionRevoked.connect(boost::bind(&SwiftenPlugin::handleSubscriptionRevoked, this, user, _1, _2));
 			Swift::ClientOptions opt;
 			opt.allowPLAINWithoutTLS = true;
 			client->connect(opt);
-			boost::shared_ptr<ForwardIQHandler> handler = boost::make_shared<ForwardIQHandler>(this, user);
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ForwardIQHandler> handler = SWIFTEN_SHRPTR_NAMESPACE::make_shared<ForwardIQHandler>(this, user);
 			client->getIQRouter()->addHandler(handler);
 			m_handlers[user] = handler;
+		}
 		void handleSubscriptionRequest(const std::string &user, const Swift::JID& jid, const std::string& message, Swift::Presence::ref presence) {
 			handleSwiftPresenceChanged(user, presence);
+		}
 		void handleSubscriptionRevoked(const std::string &user, const Swift::JID& jid, const std::string& message) {
 			Swift::Presence::ref presence = Swift::Presence::create();
 			presence->setTo(user);
 			presence->setFrom(jid);
 			presence->setType(Swift::Presence::Unsubscribe);
 			handleSwiftPresenceChanged(user, presence);
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
-			boost::shared_ptr<Swift::Client> client = m_users[user];
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				client->onConnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));
 // 				client->onDisconnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));
 				client->onMessageReceived.disconnect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));
 				client->getRoster()->onInitialRosterPopulated.disconnect(boost::bind(&SwiftenPlugin::handleSwiftRosterReceived, this, user));
 				client->getPresenceOracle()->onPresenceChange.disconnect(boost::bind(&SwiftenPlugin::handleSwiftPresenceChanged, this, user, _1));
 				client->disconnect();
+			}
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &xhtml = "", const std::string &id = "") {
+		}
 		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) {
-			boost::shared_ptr<Swift::Client> client = m_users[user];
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				LOG4CXX_INFO(logger, user << ": Added/Updated buddy " << buddyName << ".");
 				if (!client->getRoster()->containsJID(buddyName) || client->getRoster()->getSubscriptionStateForJID(buddyName) != Swift::RosterItemPayload::Both) {
 					Swift::RosterItemPayload item;
 					item.setName(alias);
 					item.setJID(buddyName);
 					item.setGroups(groups);
-					boost::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());
+					SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());
 					roster->addItem(item);
 					Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(roster, client->getIQRouter());
 // 					request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));
 					request->send();
 					client->getSubscriptionManager()->requestSubscription(buddyName);
+				}
 				else {
 					Swift::JID contact(buddyName);
 					Swift::RosterItemPayload item(contact, alias, client->getRoster()->getSubscriptionStateForJID(contact));
 					item.setGroups(groups);
-					boost::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());
+					SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());
 					roster->addItem(item);
 					Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(roster, client->getIQRouter());
 // 					request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));
 					request->send();
+				}
+			}
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
-			boost::shared_ptr<Swift::Client> client = m_users[user];
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				Swift::RosterItemPayload item(buddyName, "", Swift::RosterItemPayload::Remove);
-				boost::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());
+				SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());
 				roster->addItem(item);
 				Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(roster, client->getIQRouter());
 // 				request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));
 				request->send();
+			}
+		}
 		void handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password) {
+		}
 		void handleLeaveRoomRequest(const std::string &user, const std::string &room) {
+		}
 	private:
 		Config *config;
 		std::map<std::string, boost::shared_ptr<Swift::Client> > m_users;
 		std::map<std::string, boost::shared_ptr<ForwardIQHandler> > m_handlers;
 		std::map<std::string, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Client> > m_users;
 		std::map<std::string, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ForwardIQHandler> > m_handlers;
 };
 #ifndef WIN32
 static void spectrum_sigchld_handler(int sig)
+{
 	int status;
 	pid_t pid;
 	do {
 		pid = waitpid(-1, &status, WNOHANG);
 	} while (pid != 0 && pid != (pid_t)-1);

backends/template/plugin.cpp

➞

Show inline comments

 	m_conn->onDataRead.connect(boost::bind(&Plugin::_handleDataRead, this, _1));
 	m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(host), port));
 	LOG4CXX_INFO(logger, "Starting the plugin.");
+}
 // NetworkPlugin uses this method to send the data to networkplugin server
 void Plugin::sendData(const std::string &string) {
 	m_conn->write(Swift::createSafeByteArray(string));
+}
 // This method has to call handleDataRead with all received data from network plugin server
-void Plugin::_handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) {
+void Plugin::_handleDataRead(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::SafeByteArray> data) {
 	std::string d(data->begin(), data->end());
 	handleDataRead(d);
+}
 void Plugin::handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 	handleConnected(user);
 	LOG4CXX_INFO(logger, user << ": Added buddy - Echo.");
 	handleBuddyChanged(user, "echo", "Echo", std::vector<std::string>(), pbnetwork::STATUS_ONLINE);
+}
 void Plugin::handleLogoutRequest(const std::string &user, const std::string &legacyName) {
+}

backends/template/plugin.h

➞

Show inline comments

 #pragma once
 #include "Swiften/Swiften.h"
 #include "Swiften/SwiftenCompat.h"
 #include "transport/Config.h"
 #include "transport/NetworkPlugin.h"
 class Plugin : public Transport::NetworkPlugin {
 	public:
 		Plugin(Transport::Config *config, Swift::SimpleEventLoop *loop, const std::string &host, int port);
 		// NetworkPlugin uses this method to send the data to networkplugin server
 		void sendData(const std::string &string);
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password);
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName);
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml = "", const std::string &id = "");
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups);
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups);
 	private:
 		// This method has to call handleDataRead with all received data from network plugin server
-		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data);
+		void _handleDataRead(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::SafeByteArray> data);
 	private:
 		Swift::BoostNetworkFactories *m_factories;
 		Swift::BoostIOServiceThread m_boostIOServiceThread;
-		boost::shared_ptr<Swift::Connection> m_conn;
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> m_conn;
 		Transport::Config *config;
 };

backends/twitter/TwitterPlugin.cpp

➞

Show inline comments

 	LOG4CXX_INFO(logger, "Fetch timeout is set to " << CONFIG_INT_DEFAULTED(config, "twitter.fetch_timeout", 90000));
 	tweet_timer = m_factories->getTimerFactory()->createTimer(CONFIG_INT_DEFAULTED(config, "twitter.fetch_timeout", 90000));
 	message_timer = m_factories->getTimerFactory()->createTimer(CONFIG_INT_DEFAULTED(config, "twitter.fetch_timeout", 90000));
 	tweet_timer->onTick.connect(boost::bind(&TwitterPlugin::pollForTweets, this));
 	message_timer->onTick.connect(boost::bind(&TwitterPlugin::pollForDirectMessages, this));
 	tweet_timer->start();
 	message_timer->start();
 #if HAVE_SWIFTEN_3
-		cryptoProvider = boost::shared_ptr<Swift::CryptoProvider>(Swift::PlatformCryptoProvider::create());
+		cryptoProvider = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::CryptoProvider>(Swift::PlatformCryptoProvider::create());
 #endif
 	LOG4CXX_INFO(logger, "Starting the plugin.");
+}
 TwitterPlugin::~TwitterPlugin()
+{
 	delete storagebackend;
 	std::set<std::string>::iterator it;
 	for(it = onlineUsers.begin() ; it != onlineUsers.end() ; it++) delete userdb[*it].sessions;
 	delete tp;
+}
 // Send data to NetworkPlugin server
 void TwitterPlugin::sendData(const std::string &string)
+{
 	m_conn->write(Swift::createSafeByteArray(string));
+}
 // Receive date from the NetworkPlugin server and invoke the appropirate payload handler (implement in the NetworkPlugin class)
-void TwitterPlugin::_handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data)
+void TwitterPlugin::_handleDataRead(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::SafeByteArray> data)
+{
 	if (m_firstPing) {
 		m_firstPing = false;
 		// Users can join the network without registering if we allow
 		// one user to connect multiple IRC networks.
 		NetworkPlugin::PluginConfig cfg;
 		cfg.setNeedPassword(false);
 		sendConfig(cfg);
+	}
 	std::string d(data->begin(), data->end());
 	handleDataRead(d);

backends/twitter/TwitterPlugin.h

➞

Show inline comments

@@ @@ -2,24 +2,25 @@ @@
 #define TWITTER_PLUGIN
 #include "transport/Config.h"
 #include "transport/NetworkPlugin.h"
 #include "transport/Logging.h"
 #include "transport/SQLite3Backend.h"
 #include "transport/MySQLBackend.h"
 #include "transport/PQXXBackend.h"
 #include "transport/StorageBackend.h"
 #include "transport/ThreadPool.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/SwiftenCompat.h"
 #ifndef _WIN32
 #include "unistd.h"
 #include "signal.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 #endif
 #include <boost/algorithm/string.hpp>
 #include <boost/signal.hpp>
 #include <boost/thread.hpp>
 #include <boost/thread/mutex.hpp>
 #include "twitcurl.h"
@@ @@ -46,40 +47,40 @@ using namespace Transport; @@
 #define STR(x) (std::string("(") + x.from + ", " + x.to + ", " + x.message + ")")
 class TwitterPlugin;
 extern TwitterPlugin *np;
 extern Swift::SimpleEventLoop *loop_; // Event Loop
 class TwitterPlugin : public NetworkPlugin {
 	public:
 		Swift::BoostNetworkFactories *m_factories;
 		Swift::BoostIOServiceThread m_boostIOServiceThread;
-		boost::shared_ptr<Swift::Connection> m_conn;
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> m_conn;
 #if HAVE_SWIFTEN_3
-		boost::shared_ptr<Swift::CryptoProvider> cryptoProvider;
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::CryptoProvider> cryptoProvider;
 #endif
 		Swift::Timer::ref tweet_timer;
 		Swift::Timer::ref message_timer;
 		StorageBackend *storagebackend;
 		TwitterPlugin(Config *config, Swift::SimpleEventLoop *loop, StorageBackend *storagebackend, const std::string &host, int port);
 		~TwitterPlugin();
 		// Send data to NetworkPlugin server
 		void sendData(const std::string &string);
 		// Receive date from the NetworkPlugin server and invoke the appropirate payload handler (implement in the NetworkPlugin class)
-		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data);
+		void _handleDataRead(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::SafeByteArray> data);
 		// User trying to login into his twitter account
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password);
 		// User logging out
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName);
 		void handleJoinRoomRequest(const std::string &/*user*/, const std::string &/*room*/, const std::string &/*nickname*/, const std::string &/*pasword*/);
 		void handleLeaveRoomRequest(const std::string &/*user*/, const std::string &/*room*/);
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml = "", const std::string &id = "");

cmake_modules/SwiftenConfig.cmake

➞

Show inline comments

 FIND_LIBRARY(SWIFTEN_LIBRARY NAMES Swiften Swiften3 HINTS ../lib)
 FIND_PATH(SWIFTEN_INCLUDE_DIR NAMES "Swiften/Swiften.h" PATH_SUFFIXES libSwiften Swiften HINTS ../include)
 if( SWIFTEN_LIBRARY AND SWIFTEN_INCLUDE_DIR )
 	find_program(SWIFTEN_CONFIG_EXECUTABLE NAMES swiften-config DOC "swiften-config executable" HINTS ../bin)
 	set( SWIFTEN_CFLAGS "" )
 	if (SWIFTEN_CONFIG_EXECUTABLE)
 		# Libs
 		execute_process(
 			COMMAND ${SWIFTEN_CONFIG_EXECUTABLE} --libs
 			OUTPUT_VARIABLE SWIFTEN_LIB)
 		string(REGEX REPLACE "[\r\n]"                  " " SWIFTEN_LIB "${SWIFTEN_LIB}")
 		string(REGEX REPLACE " +$"                     ""  SWIFTEN_LIB "${SWIFTEN_LIB}")
 		set(SWIFTEN_LIBRARY "")
 		if (APPLE)
 			string(REGEX MATCHALL "-framework [A-Za-z]+" APPLE_FRAMEWORKS "${SWIFTEN_LIB}")
 			foreach(framework ${APPLE_FRAMEWORKS})
 				list(APPEND SWIFTEN_LIBRARY ${framework} )
 			endforeach(framework)
 			string(REGEX REPLACE "-framework [A-Za-z]+" "" SWIFTEN_LIB "${SWIFTEN_LIB}")
@@ @@ -21,24 +22,38 @@ if( SWIFTEN_LIBRARY AND SWIFTEN_INCLUDE_DIR ) @@
 		string(REGEX REPLACE " " ";" SWIFTEN_LIB "${SWIFTEN_LIB}")
 		foreach(f ${SWIFTEN_LIB})
 			STRING(SUBSTRING ${f} 0 2 f_out)
 			STRING(COMPARE EQUAL ${f_out} "/L" IS_PATH)
 			if(${IS_PATH})
 				string(REGEX REPLACE "/LIBPATH:" ""  f_replaced "${f}")
 				message("Added link directory: ${f_replaced}")
 				link_directories(${f_replaced})
 			else()
 				list(APPEND SWIFTEN_LIBRARY ${f})
 			endif()
 		endforeach(f)
 		# Version
 		execute_process(
 			COMMAND ${SWIFTEN_CONFIG_EXECUTABLE} --version
 			OUTPUT_VARIABLE SWIFTEN_VERSION)
 		string(REGEX REPLACE "[\r\n]"                  " " SWIFTEN_VERSION "${SWIFTEN_VERSION}")
 		string(REGEX REPLACE " +$"                     ""  SWIFTEN_VERSION "${SWIFTEN_VERSION}")
 		string(REGEX REPLACE "swiften-config "          ""  SWIFTEN_VERSION "${SWIFTEN_VERSION}")
 		if("${SWIFTEN_VERSION}" STRGREATER "4")
 			message( STATUS "Found Swiften > 4 requesting C++11")
 			add_definitions(-std=c++11)
 		endif()
 		set( SWIFTEN_FOUND 1 )
 	else()
 		message( STATUS "Could NOT find swiften-config" )
 	endif()
 	if (SWIFTEN_FOUND)
 		set( SWIFTEN_INCLUDE_DIR ${SWIFTEN_INCLUDE_DIR} )
 		message( STATUS "Found libSwiften: ${SWIFTEN_LIBRARY}, ${SWIFTEN_INCLUDE_DIR}")
 	endif()
 else( SWIFTEN_LIBRARY AND SWIFTEN_INCLUDE_DIR )
     message( STATUS "Could NOT find libSwiften" )

include/Swiften/Elements/AttentionPayload.h

➞

Show inline comments

@@ @@ -3,21 +3,23 @@ @@
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <vector>
 #include <string>
 #include <boost/shared_ptr.hpp>
 #include <Swiften/Elements/Payload.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class AttentionPayload : public Payload {
 		public:
-			typedef boost::shared_ptr<AttentionPayload> ref;
+			typedef SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<AttentionPayload> ref;
 		public:
 			AttentionPayload();
 	};
+}

include/Swiften/Elements/InvisiblePayload.h

➞

Show inline comments

@@ @@ -3,23 +3,25 @@ @@
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <vector>
 #include <string>
 #include <boost/shared_ptr.hpp>
 #include <Swiften/Elements/Payload.h>
 #include "Swiften/SwiftenCompat.h"
 // This payload is NOT part of ANY XEP and it is only
 // libtransport related extension.
 namespace Swift {
 	class InvisiblePayload : public Payload {
 		public:
-			typedef boost::shared_ptr<InvisiblePayload> ref;
+			typedef SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<InvisiblePayload> ref;
 		public:
 			InvisiblePayload();
 	};
+}

include/Swiften/FileTransfer/CombinedOutgoingFileTransferManager.cpp

➞

Show inline comments

@@ @@ -22,48 +22,48 @@ @@
 namespace Swift {
 CombinedOutgoingFileTransferManager::CombinedOutgoingFileTransferManager(JingleSessionManager* jingleSessionManager, IQRouter* router, EntityCapsProvider* capsProvider, RemoteJingleTransportCandidateSelectorFactory* remoteFactory, LocalJingleTransportCandidateGeneratorFactory* localFactory, SOCKS5BytestreamRegistry* bytestreamRegistry, SOCKS5BytestreamProxy* bytestreamProxy, Transport::PresenceOracle *presOracle, SOCKS5BytestreamServer *bytestreamServer) : jsManager(jingleSessionManager), iqRouter(router), capsProvider(capsProvider), remoteFactory(remoteFactory), localFactory(localFactory), bytestreamRegistry(bytestreamRegistry), bytestreamProxy(bytestreamProxy), presenceOracle(presOracle), bytestreamServer(bytestreamServer) {
 	idGenerator = new IDGenerator();
+}
 CombinedOutgoingFileTransferManager::~CombinedOutgoingFileTransferManager() {
 	delete idGenerator;
+}
-boost::shared_ptr<OutgoingFileTransfer> CombinedOutgoingFileTransferManager::createOutgoingFileTransfer(const JID& from, const JID& receipient, boost::shared_ptr<ReadBytestream> readBytestream, const StreamInitiationFileInfo& fileInfo) {
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<OutgoingFileTransfer> CombinedOutgoingFileTransferManager::createOutgoingFileTransfer(const JID& from, const JID& receipient, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ReadBytestream> readBytestream, const StreamInitiationFileInfo& fileInfo) {
 	// check if receipient support Jingle FT
 	boost::optional<JID> fullJID = highestPriorityJIDSupportingJingle(receipient);
 	if (!fullJID.is_initialized()) {
 		fullJID = highestPriorityJIDSupportingSI(receipient);
+	}
 	else {
-		JingleSessionImpl::ref jingleSession = boost::make_shared<JingleSessionImpl>(from, receipient, idGenerator->generateID(), iqRouter);
+		JingleSessionImpl::ref jingleSession = SWIFTEN_SHRPTR_NAMESPACE::make_shared<JingleSessionImpl>(from, receipient, idGenerator->generateID(), iqRouter);
 		//jsManager->getSession(receipient, idGenerator->generateID());
 		assert(jingleSession);
 		jsManager->registerOutgoingSession(from, jingleSession);
 #if !HAVE_SWIFTEN_3
-		boost::shared_ptr<OutgoingJingleFileTransfer> jingleFT =  boost::shared_ptr<OutgoingJingleFileTransfer>(new OutgoingJingleFileTransfer(jingleSession, remoteFactory, localFactory, iqRouter, idGenerator, from, receipient, readBytestream, fileInfo, bytestreamRegistry, bytestreamProxy));
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<OutgoingJingleFileTransfer> jingleFT =  SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<OutgoingJingleFileTransfer>(new OutgoingJingleFileTransfer(jingleSession, remoteFactory, localFactory, iqRouter, idGenerator, from, receipient, readBytestream, fileInfo, bytestreamRegistry, bytestreamProxy));
 		return jingleFT;
 #endif
+	}
 	if (!fullJID.is_initialized()) {
-		return boost::shared_ptr<OutgoingFileTransfer>();
+		return SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<OutgoingFileTransfer>();
+	}
 	// otherwise try SI
-	boost::shared_ptr<MyOutgoingSIFileTransfer> jingleFT =  boost::shared_ptr<MyOutgoingSIFileTransfer>(new MyOutgoingSIFileTransfer(idGenerator->generateID(), from, fullJID.get(), fileInfo.getName(), fileInfo.getSize(), fileInfo.getDescription(), readBytestream, iqRouter, bytestreamServer, bytestreamRegistry));
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<MyOutgoingSIFileTransfer> jingleFT =  SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<MyOutgoingSIFileTransfer>(new MyOutgoingSIFileTransfer(idGenerator->generateID(), from, fullJID.get(), fileInfo.getName(), fileInfo.getSize(), fileInfo.getDescription(), readBytestream, iqRouter, bytestreamServer, bytestreamRegistry));
 	// else fail
 	return jingleFT;
+}
 boost::optional<JID> CombinedOutgoingFileTransferManager::highestPriorityJIDSupportingJingle(const JID& bareJID) {
 	JID fullReceipientJID;
 	int priority = INT_MIN;
 	//getAllPresence(bareJID) gives you all presences for the bare JID (i.e. all resources) Remko Tronçon @ 11:11
 	std::vector<Presence::ref> presences = presenceOracle->getAllPresence(bareJID);

include/Swiften/FileTransfer/CombinedOutgoingFileTransferManager.h

➞

Show inline comments

@@ @@ -3,24 +3,27 @@ @@
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <boost/shared_ptr.hpp>
 #include <boost/optional.hpp>
 #include <Swiften/JID/JID.h>
 #include "transport/PresenceOracle.h"
 #include "Swiften/SwiftenCompat.h"
 #include <Swiften/FileTransfer/OutgoingFileTransfer.h>
 #include <Swiften/Version.h>
 #define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)
 namespace Swift {
 class JingleSessionManager;
 class IQRouter;
 class EntityCapsProvider;
 class RemoteJingleTransportCandidateSelectorFactory;
 class LocalJingleTransportCandidateGeneratorFactory;
 class OutgoingFileTransfer;
@@ @@ -29,25 +32,25 @@ class IDGenerator; @@
 class ReadBytestream;
 class StreamInitiationFileInfo;
 class SOCKS5BytestreamRegistry;
 class SOCKS5BytestreamProxy;
 class SOCKS5BytestreamServer;
 class PresenceOracle;
 class CombinedOutgoingFileTransferManager {
 public:
 	CombinedOutgoingFileTransferManager(JingleSessionManager* jingleSessionManager, IQRouter* router, EntityCapsProvider* capsProvider, RemoteJingleTransportCandidateSelectorFactory* remoteFactory, LocalJingleTransportCandidateGeneratorFactory* localFactory, SOCKS5BytestreamRegistry* bytestreamRegistry, SOCKS5BytestreamProxy* bytestreamProxy, Transport::PresenceOracle* presOracle, SOCKS5BytestreamServer *server);
 	~CombinedOutgoingFileTransferManager();
-	boost::shared_ptr<OutgoingFileTransfer> createOutgoingFileTransfer(const JID& from, const JID& to, boost::shared_ptr<ReadBytestream>, const StreamInitiationFileInfo&);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<OutgoingFileTransfer> createOutgoingFileTransfer(const JID& from, const JID& to, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ReadBytestream>, const StreamInitiationFileInfo&);
 private:
 	boost::optional<JID> highestPriorityJIDSupportingJingle(const JID& bareJID);
 	boost::optional<JID> highestPriorityJIDSupportingSI(const JID& bareJID);
 	JingleSessionManager* jsManager;
 	IQRouter* iqRouter;
 	EntityCapsProvider* capsProvider;
 	RemoteJingleTransportCandidateSelectorFactory* remoteFactory;
 	LocalJingleTransportCandidateGeneratorFactory* localFactory;
 	IDGenerator *idGenerator;
 	SOCKS5BytestreamRegistry* bytestreamRegistry;
 	SOCKS5BytestreamProxy* bytestreamProxy;

include/Swiften/FileTransfer/MyOutgoingSIFileTransfer.cpp

➞

Show inline comments

@@ @@ -5,27 +5,29 @@ @@
  */
 #include <Swiften/FileTransfer/MyOutgoingSIFileTransfer.h>
 #include <boost/bind.hpp>
 #include <Swiften/FileTransfer/StreamInitiationRequest.h>
 #include <Swiften/FileTransfer/BytestreamsRequest.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamServer.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>
 #include <Swiften/FileTransfer/IBBSendSession.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
-MyOutgoingSIFileTransfer::MyOutgoingSIFileTransfer(const std::string& id, const JID& from, const JID& to, const std::string& name, int size, const std::string& description, boost::shared_ptr<ReadBytestream> bytestream, IQRouter* iqRouter, SOCKS5BytestreamServer* socksServer, SOCKS5BytestreamRegistry* registry) : id(id), from(from), to(to), name(name), size(size), description(description), bytestream(bytestream), iqRouter(iqRouter), socksServer(socksServer), registry(registry) {
+MyOutgoingSIFileTransfer::MyOutgoingSIFileTransfer(const std::string& id, const JID& from, const JID& to, const std::string& name, int size, const std::string& description, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ReadBytestream> bytestream, IQRouter* iqRouter, SOCKS5BytestreamServer* socksServer, SOCKS5BytestreamRegistry* registry) : id(id), from(from), to(to), name(name), size(size), description(description), bytestream(bytestream), iqRouter(iqRouter), socksServer(socksServer), registry(registry) {
+}
 void MyOutgoingSIFileTransfer::start() {
 	StreamInitiation::ref streamInitiation(new StreamInitiation());
 	streamInitiation->setID(id);
 	streamInitiation->setFileInfo(StreamInitiationFileInfo(name, description, size));
 	streamInitiation->addProvidedMethod("http://jabber.org/protocol/bytestreams");
 	streamInitiation->addProvidedMethod("http://jabber.org/protocol/ibb");
 	StreamInitiationRequest::ref request = StreamInitiationRequest::create(from, to, streamInitiation, iqRouter);
 	request->onResponse.connect(boost::bind(&MyOutgoingSIFileTransfer::handleStreamInitiationRequestResponse, this, _1, _2));
 	request->send();
+}
 			registry->addReadBytestream(SOCKS5BytestreamRegistry::getHostname(id, from, to), bytestream);
 			socksServer->addReadBytestream(id, from, to, bytestream);
 #endif
 			Bytestreams::ref bytestreams(new Bytestreams());
 			bytestreams->setStreamID(id);
 			HostAddressPort addressPort = socksServer->getAddressPort();
 			bytestreams->addStreamHost(Bytestreams::StreamHost(addressPort.getAddress().toString(), from, addressPort.getPort()));
 			BytestreamsRequest::ref request = BytestreamsRequest::create(from, to, bytestreams, iqRouter);
 			request->onResponse.connect(boost::bind(&MyOutgoingSIFileTransfer::handleBytestreamsRequestResponse, this, _1, _2));
 			request->send();
+		}
 		else if (response->getRequestedMethod() == "http://jabber.org/protocol/ibb") {
-			ibbSession = boost::shared_ptr<IBBSendSession>(new IBBSendSession(id, from, to, bytestream, iqRouter));
+			ibbSession = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<IBBSendSession>(new IBBSendSession(id, from, to, bytestream, iqRouter));
 			ibbSession->onFinished.connect(boost::bind(&MyOutgoingSIFileTransfer::handleIBBSessionFinished, this, _1));
 			ibbSession->start();
 #if !HAVE_SWIFTEN_3
 			onStateChange(FileTransfer::State(FileTransfer::State::Transferring));
 #endif
+		}
+	}
+}
 void MyOutgoingSIFileTransfer::handleBytestreamsRequestResponse(Bytestreams::ref, ErrorPayload::ref error) {
 	if (error) {
 		finish(FileTransferError());

include/Swiften/FileTransfer/MyOutgoingSIFileTransfer.h

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #pragma once
 #include <boost/shared_ptr.hpp>
 #include <boost/signals.hpp>
 #include "Swiften/SwiftenCompat.h"
 #include <Swiften/FileTransfer/OutgoingFileTransfer.h>
 #include <Swiften/FileTransfer/ReadBytestream.h>
 #include <Swiften/Base/boost_bsignals.h>
 #include <Swiften/FileTransfer/FileTransferError.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamServer.h>
 #include <Swiften/JID/JID.h>
 #include <Swiften/Elements/StreamInitiation.h>
 #include <Swiften/Elements/Bytestreams.h>
 #include <Swiften/Elements/ErrorPayload.h>
 #include <Swiften/FileTransfer/IBBSendSession.h>
 #include <Swiften/Version.h>
 #define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)
 namespace Swift {
 	class IQRouter;
 	class SOCKS5BytestreamServer;
 	class SOCKS5BytestreamRegistry;
 	class MyOutgoingSIFileTransfer : public OutgoingFileTransfer {
 		public:
-			MyOutgoingSIFileTransfer(const std::string& id, const JID& from, const JID& to, const std::string& name, int size, const std::string& description, boost::shared_ptr<ReadBytestream> bytestream, IQRouter* iqRouter, SOCKS5BytestreamServer* socksServer, SOCKS5BytestreamRegistry* registry);
+			MyOutgoingSIFileTransfer(const std::string& id, const JID& from, const JID& to, const std::string& name, int size, const std::string& description, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ReadBytestream> bytestream, IQRouter* iqRouter, SOCKS5BytestreamServer* socksServer, SOCKS5BytestreamRegistry* registry);
 			virtual void start();
 			virtual void stop();
 			virtual void cancel();
 			boost::signal<void (const boost::optional<FileTransferError>&)> onFinished;
 		private:
 			void handleStreamInitiationRequestResponse(StreamInitiation::ref, ErrorPayload::ref);
 			void handleBytestreamsRequestResponse(Bytestreams::ref, ErrorPayload::ref);
 			void finish(boost::optional<FileTransferError> error);
 			void handleIBBSessionFinished(boost::optional<FileTransferError> error);
 		private:
 			std::string id;
 			JID from;
 			JID to;
 			std::string name;
 			int size;
 			std::string description;
-			boost::shared_ptr<ReadBytestream> bytestream;
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ReadBytestream> bytestream;
 			IQRouter* iqRouter;
 			SOCKS5BytestreamServer* socksServer;
-			boost::shared_ptr<IBBSendSession> ibbSession;
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<IBBSendSession> ibbSession;
 			SOCKS5BytestreamRegistry *registry;
 	};
+}

include/Swiften/Network/DummyConnectionServer.cpp

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #include <Swiften/Network/DummyConnectionServer.h>
 #include <boost/signal.hpp>
 #include <boost/bind.hpp>
 #include <boost/system/system_error.hpp>
 #include <boost/asio/placeholders.hpp>
 #include <Swiften/EventLoop/EventLoop.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 DummyConnectionServer::DummyConnectionServer(EventLoop* eventLoop) : eventLoop(eventLoop) {
+}
 void DummyConnectionServer::start() {
+}
 void DummyConnectionServer::stop() {
+}
-void DummyConnectionServer::acceptConnection(boost::shared_ptr<Swift::Connection> connection) {
+void DummyConnectionServer::acceptConnection(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> connection) {
 		eventLoop->postEvent(
 				boost::bind(boost::ref(onNewConnection), connection),
-				shared_from_this());
+				SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DummyConnectionServer>(this));
 // 		connection->listen();
+}
 HostAddressPort DummyConnectionServer::getAddressPort() const {
 	return HostAddressPort();
+}
+}

include/Swiften/Network/DummyConnectionServer.h

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #pragma once
 #include <boost/shared_ptr.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/enable_shared_from_this.hpp>
 #include <Swiften/Base/boost_bsignals.h>
 #include <Swiften/Network/DummyConnection.h>
 #include <Swiften/Network/ConnectionServer.h>
 #include <Swiften/EventLoop/EventOwner.h>
 #include <Swiften/Version.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class DummyConnectionServer : public ConnectionServer, public EventOwner, public boost::enable_shared_from_this<DummyConnectionServer> {
 		public:
-			typedef boost::shared_ptr<DummyConnectionServer> ref;
+			typedef SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DummyConnectionServer> ref;
 			enum Error {
 				Conflict,
 				UnknownError
 			};
 			static ref create(EventLoop* eventLoop) {
 				return ref(new DummyConnectionServer(eventLoop));
 			static SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DummyConnectionServer> create(EventLoop* eventLoop) {
 				return SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DummyConnectionServer>(new DummyConnectionServer(eventLoop));
+			}
-			void acceptConnection(boost::shared_ptr<Swift::Connection> connection);
+			void acceptConnection(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> connection);
 #if (SWIFTEN_VERSION >= 0x030000)
 			virtual boost::optional<ConnectionServer::Error> tryStart() {
 				return boost::optional<ConnectionServer::Error>();
+			}
 #endif
 			virtual void start();
 			virtual void stop();
 			virtual HostAddressPort getAddressPort() const;

include/Swiften/Network/DummyConnectionServerFactory.cpp

➞

Show inline comments

@@ @@ -3,21 +3,21 @@ @@
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <Swiften/Network/DummyConnectionServerFactory.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 namespace Swift {
 DummyConnectionServerFactory::DummyConnectionServerFactory(EventLoop* eventLoop) : eventLoop(eventLoop) {
+}
-boost::shared_ptr<ConnectionServer> DummyConnectionServerFactory::createConnectionServer(int port) {
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ConnectionServer> DummyConnectionServerFactory::createConnectionServer(int port) {
 	return DummyConnectionServer::create(eventLoop);
+}
-boost::shared_ptr<ConnectionServer> DummyConnectionServerFactory::createConnectionServer(const Swift::HostAddress &hostAddress, int port) {
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ConnectionServer> DummyConnectionServerFactory::createConnectionServer(const Swift::HostAddress &hostAddress, int port) {
 	return DummyConnectionServer::create(eventLoop);
+}
+}

include/Swiften/Network/DummyConnectionServerFactory.h

➞

Show inline comments

@@ @@ -2,27 +2,29 @@ @@
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <boost/asio/io_service.hpp>
 #include <Swiften/Network/ConnectionServerFactory.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class ConnectionServer;
 	class DummyConnectionServerFactory : public ConnectionServerFactory {
 		public:
 			DummyConnectionServerFactory(EventLoop* eventLoop);
-			virtual boost::shared_ptr<ConnectionServer> createConnectionServer(int port);
+			virtual SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ConnectionServer> createConnectionServer(int port);
-			virtual boost::shared_ptr<ConnectionServer> createConnectionServer(const Swift::HostAddress &hostAddress, int port);
+			virtual SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ConnectionServer> createConnectionServer(const Swift::HostAddress &hostAddress, int port);
 		private:
 			EventLoop* eventLoop;
 	};
+}

include/Swiften/Network/DummyNetworkFactories.cpp

➞

Show inline comments

@@ @@ -13,25 +13,25 @@ @@
 #include <Swiften/Crypto/CryptoProvider.h>
 #include <Swiften/Crypto/PlatformCryptoProvider.h>
 #include <Swiften/Network/NetworkEnvironment.h>
 #include <Swiften/Network/PlatformNetworkEnvironment.h>
 #endif
 namespace Swift {
 DummyNetworkFactories::DummyNetworkFactories(EventLoop* eventLoop) {
 	timerFactory = new DummyTimerFactory();
 	connectionFactory = new DummyConnectionFactory(eventLoop);
 #if HAVE_SWIFTEN_3
-	idnConverter = boost::shared_ptr<IDNConverter>(PlatformIDNConverter::create());
+	idnConverter = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<IDNConverter>(PlatformIDNConverter::create());
 	domainNameResolver = new PlatformDomainNameResolver(idnConverter.get(), eventLoop);
 	cryptoProvider = PlatformCryptoProvider::create();
 	networkEnvironment = new PlatformNetworkEnvironment();
 #else
 	domainNameResolver = new PlatformDomainNameResolver(eventLoop);
 #endif
 	connectionServerFactory = new DummyConnectionServerFactory(eventLoop);
 	m_platformXMLParserFactory =  new PlatformXMLParserFactory();
 	this->eventLoop = eventLoop;
+}
 DummyNetworkFactories::~DummyNetworkFactories() {

include/Swiften/Network/DummyNetworkFactories.h

➞

Show inline comments

@@ @@ -7,24 +7,26 @@ @@
 #pragma once
 #include <Swiften/Version.h>
 #define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)
 #include <Swiften/Network/NetworkFactories.h>
 #include <Swiften/Parser/PlatformXMLParserFactory.h>
 #if HAVE_SWIFTEN_3
 #include <Swiften/IDN/IDNConverter.h>
 #include <Swiften/IDN/PlatformIDNConverter.h>
 #endif
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class EventLoop;
 	class DummyNetworkFactories : public NetworkFactories {
 		public:
 			DummyNetworkFactories(EventLoop *eventLoop);
 			~DummyNetworkFactories();
 			virtual TimerFactory* getTimerFactory() const {
 				return timerFactory;
+			}
@@ @@ -68,21 +70,21 @@ namespace Swift { @@
             Swift::TLSContextFactory* getTLSContextFactory() const {
                 return 0;
+            }
             Swift::ProxyProvider* getProxyProvider() const {
                 return 0;
+            }
 		private:
 			PlatformXMLParserFactory *m_platformXMLParserFactory;
 			TimerFactory* timerFactory;
 			ConnectionFactory* connectionFactory;
 #if HAVE_SWIFTEN_3
-			boost::shared_ptr<IDNConverter> idnConverter;
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<IDNConverter> idnConverter;
 			CryptoProvider* cryptoProvider;
 			NetworkEnvironment* networkEnvironment;
 #endif
 			DomainNameResolver* domainNameResolver;
 			ConnectionServerFactory* connectionServerFactory;
 			EventLoop *eventLoop;
 	};
+}

include/Swiften/Parser/PayloadParsers/XHTMLIMParser.cpp

➞

Show inline comments

 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <cassert>
 #include <Swiften/Parser/PayloadParsers/XHTMLIMParser.h>
 #include <Swiften/Parser/SerializingParser.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 XHTMLIMParser::XHTMLIMParser() : level_(TopLevel), bodyParser_(0) {
+}
 void XHTMLIMParser::handleStartElement(const std::string& element, const std::string& ns, const AttributeMap& attributes) {
 	++level_;
 	if (level_ == BodyLevel) {
 		if (element == "body") {
 			assert(!bodyParser_);
 			bodyParser_ = new SerializingParser();
 	--level_;
+}
 void XHTMLIMParser::handleCharacterData(const std::string& data) {
 	if (bodyParser_) {
 		bodyParser_->handleCharacterData(data);
+	}
 	else {
 		currentText_ += data;
+	}
+}
-boost::shared_ptr<XHTMLIMPayload> XHTMLIMParser::getLabelPayload() const {
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<XHTMLIMPayload> XHTMLIMParser::getLabelPayload() const {
 	return getPayloadInternal();
+}
+}

include/Swiften/Parser/PayloadParsers/XHTMLIMParser.h

➞

Show inline comments

 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <Swiften/Elements/XHTMLIMPayload.h>
 #include <Swiften/Parser/GenericPayloadParser.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class SerializingParser;
 	class XHTMLIMParser : public GenericPayloadParser<XHTMLIMPayload> {
 		public:
 			XHTMLIMParser();
 			virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes);
 			virtual void handleEndElement(const std::string& element, const std::string&);
 			virtual void handleCharacterData(const std::string& data);
-			boost::shared_ptr<XHTMLIMPayload> getLabelPayload() const;
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<XHTMLIMPayload> getLabelPayload() const;
 		private:
 			enum Level {
 				TopLevel = 0,
 				PayloadLevel = 1,
 				BodyLevel = 2,
 				InsideBodyLevel = 3
 			};
 			int level_;
 			SerializingParser* bodyParser_;
 			std::string currentText_;
 	};
+}

include/Swiften/Parser/StringTreeParser.h

➞

Show inline comments

@@ @@ -5,35 +5,37 @@ @@
  */
 #pragma once
 #include <deque>
 #include <boost/shared_ptr.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <Swiften/Parser/Tree/ParserElement.h>
 #include <Swiften/Parser/XMLParserClient.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	/**
 	 * Generics parser offering something a bit like a DOM to work with.
 	 */
 	class StringTreeParser : public XMLParserClient {
 		public:
 			StringTreeParser() : XMLParserClient() {}
 			virtual void handleStartElement(const std::string& element, const std::string& xmlns, const AttributeMap& attributes) {
 				if (!root_) {
-					root_ = boost::make_shared<ParserElement>(element, xmlns, attributes);
+					root_ = SWIFTEN_SHRPTR_NAMESPACE::make_shared<ParserElement>(element, xmlns, attributes);
 					elementStack_.push_back(root_);
+				}
 				else {
 					ParserElement::ref current = *elementStack_.rbegin();
 					elementStack_.push_back(current->addChild(element, xmlns, attributes));
+				}
+			}
 			virtual void handleEndElement(const std::string& /*element*/, const std::string&) {
 				elementStack_.pop_back();
 				if (elementStack_.empty()) {
 					handleTree(root_);

include/Swiften/Serializer/PayloadSerializers/AttentionSerializer.cpp

➞

Show inline comments

@@ @@ -8,19 +8,19 @@ @@
 #include <boost/shared_ptr.hpp>
 #include <Swiften/Serializer/XML/XMLTextNode.h>
 #include <Swiften/Serializer/XML/XMLRawTextNode.h>
 #include <Swiften/Serializer/XML/XMLElement.h>
 namespace Swift {
 AttentionSerializer::AttentionSerializer() : GenericPayloadSerializer<AttentionPayload>() {
+}
-std::string AttentionSerializer::serializePayload(boost::shared_ptr<AttentionPayload> attention)  const {
+std::string AttentionSerializer::serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<AttentionPayload> attention)  const {
 	XMLElement attentionElement("attention", "urn:xmpp:attention:0");
 	return attentionElement.serialize();
+}
+}

include/Swiften/Serializer/PayloadSerializers/AttentionSerializer.h

➞

Show inline comments

 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <Swiften/Serializer/GenericPayloadSerializer.h>
 #include <Swiften/Elements/AttentionPayload.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class AttentionSerializer : public GenericPayloadSerializer<AttentionPayload> {
 		public:
 			AttentionSerializer();
-			virtual std::string serializePayload(boost::shared_ptr<AttentionPayload>)  const;
+			virtual std::string serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<AttentionPayload>)  const;
 	};
+}

include/Swiften/Serializer/PayloadSerializers/GatewayPayloadSerializer.cpp

➞

Show inline comments

@@ @@ -2,40 +2,42 @@ @@
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <Swiften/Serializer/PayloadSerializers/GatewayPayloadSerializer.h>
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Serializer/XML/XMLRawTextNode.h>
 #include <Swiften/Serializer/XML/XMLTextNode.h>
 #include <Swiften/Serializer/XML/XMLElement.h>
 #include <Swiften/Serializer/PayloadSerializerCollection.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 GatewayPayloadSerializer::GatewayPayloadSerializer()
 	: GenericPayloadSerializer<GatewayPayload>() {
+}
-std::string GatewayPayloadSerializer::serializePayload(boost::shared_ptr<GatewayPayload> payload)  const {
+std::string GatewayPayloadSerializer::serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<GatewayPayload> payload)  const {
 	XMLElement query("query", "jabber:iq:gateway");
 	if (payload->getJID().isValid()) {
-		boost::shared_ptr<XMLElement> jid(new XMLElement("jid", "", payload->getJID().toBare().toString()));
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<XMLElement> jid(new XMLElement("jid", "", payload->getJID().toBare().toString()));
 		query.addNode(jid);
+	}
 	if (!payload->getDesc().empty()) {
-		boost::shared_ptr<XMLElement> desc(new XMLElement("desc", "", payload->getDesc()));
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<XMLElement> desc(new XMLElement("desc", "", payload->getDesc()));
 		query.addNode(desc);
+	}
 	if (!payload->getPrompt().empty()) {
-		boost::shared_ptr<XMLElement> prompt(new XMLElement("prompt", "", payload->getPrompt()));
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<XMLElement> prompt(new XMLElement("prompt", "", payload->getPrompt()));
 		query.addNode(prompt);
+	}
 	return query.serialize();
+}
+}

include/Swiften/Serializer/PayloadSerializers/GatewayPayloadSerializer.h

➞

Show inline comments

 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <Swiften/Serializer/GenericPayloadSerializer.h>
 #include <Swiften/Elements/GatewayPayload.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class GatewayPayloadSerializer : public GenericPayloadSerializer<GatewayPayload> {
 		public:
 			GatewayPayloadSerializer();
-			virtual std::string serializePayload(boost::shared_ptr<GatewayPayload> item)  const;
+			virtual std::string serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<GatewayPayload> item)  const;
 	};
+}

include/Swiften/Serializer/PayloadSerializers/InvisibleSerializer.cpp

➞

Show inline comments

@@ @@ -10,19 +10,19 @@ @@
 #include <Swiften/Serializer/XML/XMLTextNode.h>
 #include <Swiften/Serializer/XML/XMLRawTextNode.h>
 #include <Swiften/Serializer/XML/XMLElement.h>
 namespace Swift {
 // This payload is NOT part of ANY XEP and it is only
 // libtransport related extension.
 InvisibleSerializer::InvisibleSerializer() : GenericPayloadSerializer<InvisiblePayload>() {
+}
-std::string InvisibleSerializer::serializePayload(boost::shared_ptr<InvisiblePayload> attention)  const {
+std::string InvisibleSerializer::serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<InvisiblePayload> attention)  const {
 	XMLElement attentionElement("invisible", "urn:xmpp:invisible:0");
 	return attentionElement.serialize();
+}
+}

include/Swiften/Serializer/PayloadSerializers/InvisibleSerializer.h

➞

Show inline comments

 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <Swiften/Serializer/GenericPayloadSerializer.h>
 #include <Swiften/Elements/InvisiblePayload.h>
 #include "Swiften/SwiftenCompat.h"
 // This payload is NOT part of ANY XEP and it is only
 // libtransport related extension.
 namespace Swift {
 	class InvisibleSerializer : public GenericPayloadSerializer<InvisiblePayload> {
 		public:
 			InvisibleSerializer();
-			virtual std::string serializePayload(boost::shared_ptr<InvisiblePayload>)  const;
+			virtual std::string serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<InvisiblePayload>)  const;
 	};
+}

include/Swiften/Serializer/PayloadSerializers/SpectrumErrorSerializer.cpp

➞

Show inline comments

@@ @@ -10,25 +10,25 @@ @@
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Serializer/XML/XMLTextNode.h>
 #include <Swiften/Serializer/XML/XMLRawTextNode.h>
 #include <Swiften/Serializer/XML/XMLElement.h>
 #include <boost/lexical_cast.hpp>
 namespace Swift {
 SpectrumErrorSerializer::SpectrumErrorSerializer() : GenericPayloadSerializer<SpectrumErrorPayload>() {
+}
-std::string SpectrumErrorSerializer::serializePayload(boost::shared_ptr<SpectrumErrorPayload> error)  const {
+std::string SpectrumErrorSerializer::serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<SpectrumErrorPayload> error)  const {
 	std::string data;
 	switch (error->getError()) {
 		case SpectrumErrorPayload::CONNECTION_ERROR_NETWORK_ERROR: data = "CONNECTION_ERROR_NETWORK_ERROR"; break;
 		case SpectrumErrorPayload::CONNECTION_ERROR_INVALID_USERNAME: data = "CONNECTION_ERROR_INVALID_USERNAME"; break;
 		case SpectrumErrorPayload::CONNECTION_ERROR_AUTHENTICATION_FAILED: data = "CONNECTION_ERROR_AUTHENTICATION_FAILED"; break;
 		case SpectrumErrorPayload::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE: data = "CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE"; break;
 		case SpectrumErrorPayload::CONNECTION_ERROR_NO_SSL_SUPPORT: data = "CONNECTION_ERROR_NO_SSL_SUPPORT"; break;
 		case SpectrumErrorPayload::CONNECTION_ERROR_ENCRYPTION_ERROR: data = "CONNECTION_ERROR_ENCRYPTION_ERROR"; break;
 		case SpectrumErrorPayload::CONNECTION_ERROR_NAME_IN_USE: data = "CONNECTION_ERROR_NAME_IN_USE"; break;
 		case SpectrumErrorPayload::CONNECTION_ERROR_INVALID_SETTINGS: data = "CONNECTION_ERROR_INVALID_SETTINGS"; break;
 		case SpectrumErrorPayload::CONNECTION_ERROR_CERT_NOT_PROVIDED: data = "CONNECTION_ERROR_CERT_NOT_PROVIDED"; break;
 		case SpectrumErrorPayload::CONNECTION_ERROR_CERT_UNTRUSTED: data = "CONNECTION_ERROR_CERT_UNTRUSTED"; break;

include/Swiften/Serializer/PayloadSerializers/SpectrumErrorSerializer.h

➞

Show inline comments

 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <Swiften/Serializer/GenericPayloadSerializer.h>
 #include <Swiften/Elements/SpectrumErrorPayload.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class SpectrumErrorSerializer : public GenericPayloadSerializer<SpectrumErrorPayload> {
 		public:
 			SpectrumErrorSerializer();
-			virtual std::string serializePayload(boost::shared_ptr<SpectrumErrorPayload>)  const;
+			virtual std::string serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<SpectrumErrorPayload>)  const;
 	};
+}

include/Swiften/Serializer/PayloadSerializers/StatsSerializer.cpp

➞

Show inline comments

@@ @@ -4,33 +4,35 @@ @@
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <Swiften/Serializer/PayloadSerializers/StatsSerializer.h>
 #include <boost/shared_ptr.hpp>
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Serializer/XML/XMLTextNode.h>
 #include <Swiften/Serializer/XML/XMLRawTextNode.h>
 #include <Swiften/Serializer/XML/XMLElement.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 StatsSerializer::StatsSerializer() : GenericPayloadSerializer<StatsPayload>() {
+}
-std::string StatsSerializer::serializePayload(boost::shared_ptr<StatsPayload> stats)  const {
+std::string StatsSerializer::serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<StatsPayload> stats)  const {
 	XMLElement queryElement("query", "http://jabber.org/protocol/stats");
 	foreach(const StatsPayload::Item& item, stats->getItems()) {
-		boost::shared_ptr<XMLElement> statElement(new XMLElement("stat"));
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<XMLElement> statElement(new XMLElement("stat"));
 		statElement->setAttribute("name", item.getName());
 		if (!item.getUnits().empty()) {
 			statElement->setAttribute("units", item.getUnits());
+		}
 		if (!item.getValue().empty()) {
 			statElement->setAttribute("value", item.getValue());
+		}
 		queryElement.addNode(statElement);
+	}
 	return queryElement.serialize();

include/Swiften/Serializer/PayloadSerializers/StatsSerializer.h

➞

Show inline comments

 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <Swiften/Serializer/GenericPayloadSerializer.h>
 #include <Swiften/Elements/StatsPayload.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class StatsSerializer : public GenericPayloadSerializer<StatsPayload> {
 		public:
 			StatsSerializer();
-			virtual std::string serializePayload(boost::shared_ptr<StatsPayload>)  const;
+			virtual std::string serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<StatsPayload>)  const;
 	};
+}

include/Swiften/Serializer/PayloadSerializers/XHTMLIMSerializer.cpp

➞

Show inline comments

 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <Swiften/Serializer/PayloadSerializers/XHTMLIMSerializer.h>
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Serializer/XML/XMLRawTextNode.h>
 #include <Swiften/Serializer/XML/XMLTextNode.h>
 #include <Swiften/Serializer/XML/XMLElement.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 XHTMLIMSerializer::XHTMLIMSerializer() : GenericPayloadSerializer<XHTMLIMPayload>() {
+}
-std::string XHTMLIMSerializer::serializePayload(boost::shared_ptr<XHTMLIMPayload> payload)  const {
+std::string XHTMLIMSerializer::serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<XHTMLIMPayload> payload)  const {
 	XMLElement html("html", "http://jabber.org/protocol/xhtml-im");
 	boost::shared_ptr<XMLElement> body(new XMLElement("body", "http://www.w3.org/1999/xhtml"));
 	body->addNode(boost::shared_ptr<XMLRawTextNode>(new XMLRawTextNode(payload->getBody())));
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<XMLElement> body(new XMLElement("body", "http://www.w3.org/1999/xhtml"));
 	body->addNode(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<XMLRawTextNode>(new XMLRawTextNode(payload->getBody())));
 	html.addNode(body);
 	return html.serialize();
+}
+}

include/Swiften/Serializer/PayloadSerializers/XHTMLIMSerializer.h

➞

Show inline comments

 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <Swiften/Serializer/GenericPayloadSerializer.h>
 #include <Swiften/Elements/XHTMLIMPayload.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class XHTMLIMSerializer : public GenericPayloadSerializer<XHTMLIMPayload> {
 		public:
 			XHTMLIMSerializer();
-			virtual std::string serializePayload(boost::shared_ptr<XHTMLIMPayload> xhtml)  const;
+			virtual std::string serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<XHTMLIMPayload> xhtml)  const;
 	};
+}

include/Swiften/Server/Server.cpp

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #include "Swiften/Server/Server.h"
 #include <string>
 #include <boost/bind.hpp>
 #include <boost/signal.hpp>
 #include "Swiften/Base/String.h"
 #include "Swiften/Base/foreach.h"
 #include "Swiften/Network/Connection.h"
 #include "Swiften/Network/ConnectionServer.h"
 #include "Swiften/Network/ConnectionServerFactory.h"
 #include "Swiften/Elements/Element.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Network/NetworkFactories.h"
 #include "Swiften/Session/SessionTracer.h"
 #include "Swiften/Elements/IQ.h"
@@ @@ -79,45 +80,45 @@ void Server::start() { @@
 // 				boost::bind(&Server::handleClientConnectionServerStopped, this, _1)));
 	serverFromClientConnectionServer->start();
+}
 void Server::stop() {
 	if (stopping) {
 		return;
+	}
 	stopping = true;
-// 	foreach(boost::shared_ptr<ServerFromClientSession> session, serverFromClientSessions) {
+// 	foreach(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> session, serverFromClientSessions) {
 // 		session->finishSession();
 // 	}
 	serverFromClientSessions.clear();
 	if (serverFromClientConnectionServer) {
 		serverFromClientConnectionServer->stop();
-		foreach(boost::bsignals::connection& connection, serverFromClientConnectionServerSignalConnections) {
+		foreach(SWIFTEN_SIGNAL_NAMESPACE::connection& connection, serverFromClientConnectionServerSignalConnections) {
 			connection.disconnect();
+		}
 		serverFromClientConnectionServerSignalConnections.clear();
 		serverFromClientConnectionServer.reset();
+	}
 	stopping = false;
 // 	onStopped(e);
+}
-void Server::handleNewClientConnection(boost::shared_ptr<Connection> connection) {
+void Server::handleNewClientConnection(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Connection> connection) {
-	boost::shared_ptr<ServerFromClientSession> serverFromClientSession = boost::shared_ptr<ServerFromClientSession>(
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> serverFromClientSession = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession>(
 			new ServerFromClientSession(idGenerator.generateID(), connection,
 					getPayloadParserFactories(), getPayloadSerializers(), userRegistry_, parserFactory_));
 	//serverFromClientSession->setAllowSASLEXTERNAL();
 	serverFromClientSession->onSessionStarted.connect(
 			boost::bind(&Server::handleSessionStarted, this, serverFromClientSession));
 	serverFromClientSession->onSessionFinished.connect(
 			boost::bind(&Server::handleSessionFinished, this,
 			serverFromClientSession));
 	serverFromClientSession->onDataRead.connect(boost::bind(&Server::handleDataRead, this, _1));
 	serverFromClientSession->onDataWritten.connect(boost::bind(&Server::handleDataWritten, this, _1));
 	serverFromClientSessions.push_back(serverFromClientSession);
+}
 void Server::handleDataRead(const SafeByteArray& data) {
 	onDataRead(data);
+}
 void Server::handleDataWritten(const SafeByteArray& data) {
 	onDataWritten(data);
+}
-void Server::handleSessionStarted(boost::shared_ptr<ServerFromClientSession> session) {
+void Server::handleSessionStarted(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> session) {
 	dynamic_cast<ServerStanzaChannel *>(stanzaChannel_)->addSession(session);
+}
-void Server::handleSessionFinished(boost::shared_ptr<ServerFromClientSession> session) {
+void Server::handleSessionFinished(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> session) {
 // 	if (!session->getRemoteJID().isValid()) {
 // 		Swift::Presence::ref presence = Swift::Presence::create();
 // 		presence->setFrom(session->getBareJID());
 // 		presence->setType(Swift::Presence::Unavailable);
 // 		dynamic_cast<ServerStanzaChannel *>(stanzaChannel_)->onPresenceReceived(presence);
 // 	}
 	serverFromClientSessions.erase(std::remove(serverFromClientSessions.begin(), serverFromClientSessions.end(), session), serverFromClientSessions.end());
 	session->onSessionStarted.disconnect(
 			boost::bind(&Server::handleSessionStarted, this, session));
 	session->onSessionFinished.disconnect(
 			boost::bind(&Server::handleSessionFinished, this, session));
+}

include/Swiften/Server/Server.h

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #pragma once
 #include <boost/shared_ptr.hpp>
 #include <boost/optional.hpp>
 #include <boost/signals2.hpp>
 #include <vector>
 #include "Swiften/Network/BoostIOServiceThread.h"
 #include "Swiften/Network/ConnectionServer.h"
 #include "Swiften/Server/UserRegistry.h"
 #include "Swiften/Server/ServerSession.h"
 #include "Swiften/Base/IDGenerator.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/JID/JID.h"
 #include "Swiften/Base/ByteArray.h"
 #include "Swiften/Entity/Entity.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h"
 #include "Swiften/SwiftenCompat.h"
 #include <Swiften/TLS/CertificateWithKey.h>
 #include <Swiften/Parser/PlatformXMLParserFactory.h>
 namespace Swift {
 	class ConnectionServer;
 	class SessionTracer;
 	class EventLoop;
 	class NetworkFactories;
 	class StanzaChannel;
 	class IQRouter;
 	class TLSServerContextFactory;
@@ @@ -44,48 +46,48 @@ namespace Swift { @@
 			int getPort() const {
 				return port_;
+			}
 			StanzaChannel* getStanzaChannel() const {
 				return stanzaChannel_;
+			}
 			IQRouter* getIQRouter() const {
 				return iqRouter_;
+			}
-			boost::shared_ptr<ConnectionServer> getConnectionServer() const {
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ConnectionServer> getConnectionServer() const {
 				return serverFromClientConnectionServer;
+			}
 			boost::signal<void (const SafeByteArray&)> onDataRead;
 			boost::signal<void (const SafeByteArray&)> onDataWritten;
 			void addTLSEncryption(TLSServerContextFactory* tlsContextFactory, CertificateWithKey::ref cert);
 		private:
 			void handleNewClientConnection(boost::shared_ptr<Connection> c);
 			void handleSessionStarted(boost::shared_ptr<ServerFromClientSession>);
 			void handleSessionFinished(boost::shared_ptr<ServerFromClientSession>);
 			void handleElementReceived(boost::shared_ptr<Element> element, boost::shared_ptr<ServerFromClientSession> session);
 			void handleNewClientConnection(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Connection> c);
 			void handleSessionStarted(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession>);
 			void handleSessionFinished(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession>);
 			void handleElementReceived(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Element> element, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> session);
 			void handleDataRead(const SafeByteArray&);
 			void handleDataWritten(const SafeByteArray&);
 		private:
 			IDGenerator idGenerator;
 			UserRegistry *userRegistry_;
 			int port_;
 			EventLoop* eventLoop;
 			NetworkFactories* networkFactories_;
 			bool stopping;
 			boost::shared_ptr<ConnectionServer> serverFromClientConnectionServer;
 			std::vector<boost::bsignals::connection> serverFromClientConnectionServerSignalConnections;
 			std::list<boost::shared_ptr<ServerFromClientSession> > serverFromClientSessions;
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ConnectionServer> serverFromClientConnectionServer;
 			std::vector<SWIFTEN_SIGNAL_NAMESPACE::connection> serverFromClientConnectionServerSignalConnections;
 			std::list<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> > serverFromClientSessions;
 			JID selfJID;
 			StanzaChannel *stanzaChannel_;
 			IQRouter *iqRouter_;
 			TLSServerContextFactory *tlsFactory;
 			CertificateWithKey::ref cert;
 			PlatformXMLParserFactory *parserFactory_;
 			std::string address_;
 	};
+}

include/Swiften/Server/ServerFromClientSession.cpp

➞

Show inline comments

@@ @@ -20,137 +20,139 @@ @@
 #include <Swiften/Elements/IQ.h>
 #include <Swiften/Elements/AuthSuccess.h>
 #include <Swiften/Elements/AuthFailure.h>
 #include <Swiften/Elements/AuthRequest.h>
 #include <Swiften/SASL/PLAINMessage.h>
 #include <Swiften/StreamStack/StreamStack.h>
 #include <Swiften/StreamStack/TLSServerLayer.h>
 #include <Swiften/Elements/StartTLSRequest.h>
 #include <Swiften/Elements/TLSProceed.h>
 #include <iostream>
 #include <Swiften/TLS/CertificateWithKey.h>
 #include "Swiften/SwiftenCompat.h"
 #include <Swiften/Version.h>
 #if (SWIFTEN_VERSION >= 0x030000)
 #include <Swiften/Elements/ToplevelElement.h>
 #endif
 namespace Swift {
 ServerFromClientSession::ServerFromClientSession(
 		const std::string& id,
-		boost::shared_ptr<Connection> connection,
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Connection> connection,
 		PayloadParserFactoryCollection* payloadParserFactories,
 		PayloadSerializerCollection* payloadSerializers,
 		UserRegistry* userRegistry,
 		XMLParserFactory* factory,
 		Swift::JID remoteJID) :
 			Session(connection, payloadParserFactories, payloadSerializers, factory),
 			id_(id),
 			userRegistry_(userRegistry),
 			authenticated_(false),
 			initialized(false),
 			allowSASLEXTERNAL(false),
 			tlsLayer(0),
 			tlsConnected(false) {
 				setRemoteJID(remoteJID);
+}
 ServerFromClientSession::~ServerFromClientSession() {
 	if (tlsLayer) {
 		delete tlsLayer;
+	}
+}
 void ServerFromClientSession::handlePasswordValid() {
 	if (!isInitialized()) {
-		getXMPPLayer()->writeElement(boost::shared_ptr<AuthSuccess>(new AuthSuccess()));
+		getXMPPLayer()->writeElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<AuthSuccess>(new AuthSuccess()));
 		authenticated_ = true;
 		getXMPPLayer()->resetParser();
+	}
+}
 void ServerFromClientSession::handlePasswordInvalid(const std::string &error) {
 	if (!isInitialized()) {
-		getXMPPLayer()->writeElement(boost::shared_ptr<AuthFailure>(new AuthFailure));
+		getXMPPLayer()->writeElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<AuthFailure>(new AuthFailure));
 		if (!error.empty()) {
-			boost::shared_ptr<StreamError> msg(new StreamError(StreamError::UndefinedCondition, error));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<StreamError> msg(new StreamError(StreamError::UndefinedCondition, error));
 			getXMPPLayer()->writeElement(msg);
+		}
 		finishSession(AuthenticationFailedError);
+	}
+}
 #if (SWIFTEN_VERSION >= 0x030000)
-void ServerFromClientSession::handleElement(boost::shared_ptr<ToplevelElement> element) {
+void ServerFromClientSession::handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ToplevelElement> element) {
 #else
-void ServerFromClientSession::handleElement(boost::shared_ptr<Element> element) {
+void ServerFromClientSession::handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Element> element) {
 #endif
 	if (isInitialized()) {
 		onElementReceived(element);
+	}
 	else {
 		if (AuthRequest* authRequest = dynamic_cast<AuthRequest*>(element.get())) {
 			if (authRequest->getMechanism() == "PLAIN" || (allowSASLEXTERNAL && authRequest->getMechanism() == "EXTERNAL")) {
 				if (authRequest->getMechanism() == "EXTERNAL") {
-						getXMPPLayer()->writeElement(boost::shared_ptr<AuthSuccess>(new AuthSuccess()));
+						getXMPPLayer()->writeElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<AuthSuccess>(new AuthSuccess()));
 						authenticated_ = true;
 						getXMPPLayer()->resetParser();
+				}
 				else {
 					PLAINMessage plainMessage(authRequest->getMessage() ? *authRequest->getMessage() : createSafeByteArray(""));
 					user_ = plainMessage.getAuthenticationID();
 					userRegistry_->isValidUserPassword(JID(plainMessage.getAuthenticationID(), getLocalJID().getDomain()), this, plainMessage.getPassword());
+				}
+			}
 			else {
-				getXMPPLayer()->writeElement(boost::shared_ptr<AuthFailure>(new AuthFailure));
+				getXMPPLayer()->writeElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<AuthFailure>(new AuthFailure));
 				finishSession(NoSupportedAuthMechanismsError);
+			}
+		}
 		else if (dynamic_cast<StartTLSRequest*>(element.get()) != NULL) {
-			getXMPPLayer()->writeElement(boost::shared_ptr<TLSProceed>(new TLSProceed));
+			getXMPPLayer()->writeElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<TLSProceed>(new TLSProceed));
 			getStreamStack()->addLayer(tlsLayer);
 			tlsLayer->connect();
 			getXMPPLayer()->resetParser();
+		}
 		else if (IQ* iq = dynamic_cast<IQ*>(element.get())) {
-			if (boost::shared_ptr<ResourceBind> resourceBind = iq->getPayload<ResourceBind>()) {
+			if (SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ResourceBind> resourceBind = iq->getPayload<ResourceBind>()) {
 				std::string bucket = "abcdefghijklmnopqrstuvwxyz";
 				std::string uuid;
 				for (int i = 0; i < 10; i++) {
 					uuid += bucket[rand() % bucket.size()];
+				}
 				setRemoteJID(JID(user_, getLocalJID().getDomain(), uuid));
-				boost::shared_ptr<ResourceBind> resultResourceBind(new ResourceBind());
+				SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ResourceBind> resultResourceBind(new ResourceBind());
 				resultResourceBind->setJID(getRemoteJID());
 				getXMPPLayer()->writeElement(IQ::createResult(JID(), iq->getID(), resultResourceBind));
+			}
 			else if (iq->getPayload<StartSession>()) {
 				getXMPPLayer()->writeElement(IQ::createResult(getRemoteJID(), iq->getID()));
 				setInitialized();
+			}
+		}
+	}
+}
 void ServerFromClientSession::handleStreamStart(const ProtocolHeader& incomingHeader) {
 	setLocalJID(JID(incomingHeader.getTo()));
 	ProtocolHeader header;
 	header.setFrom(incomingHeader.getTo());
 	header.setID(id_);
 	getXMPPLayer()->writeHeader(header);
-	boost::shared_ptr<StreamFeatures> features(new StreamFeatures());
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<StreamFeatures> features(new StreamFeatures());
 	if (!authenticated_) {
 		if (tlsLayer && !tlsConnected) {
 			features->setHasStartTLS();
+		}
 		features->addAuthenticationMechanism("PLAIN");
 		if (allowSASLEXTERNAL) {
 			features->addAuthenticationMechanism("EXTERNAL");
+		}
+	}
 	else {
 		features->setHasResourceBind();
@@ @@ -168,25 +170,25 @@ void ServerFromClientSession::setAllowSASLEXTERNAL() { @@
 	allowSASLEXTERNAL = true;
+}
 void ServerFromClientSession::handleSessionFinished(const boost::optional<SessionError>&) {
 	userRegistry_->stopLogin(JID(user_, getLocalJID().getDomain()), this);
+}
 void ServerFromClientSession::addTLSEncryption(TLSServerContextFactory* tlsContextFactory, CertificateWithKey::ref cert) {
 	tlsLayer = new TLSServerLayer(tlsContextFactory);
 	if (!tlsLayer->setServerCertificate(cert)) {
 // 		std::cout << "error\n";
 		// TODO:
-// 		onClosed(boost::shared_ptr<Error>(new Error(Error::InvalidTLSCertificateError)));
+// 		onClosed(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Error>(new Error(Error::InvalidTLSCertificateError)));
+	}
 	else {
 		tlsLayer->onError.connect(boost::bind(&ServerFromClientSession::handleTLSError, this));
 		tlsLayer->onConnected.connect(boost::bind(&ServerFromClientSession::handleTLSConnected, this));
 // 		getStreamStack()->addLayer(tlsLayer);
 // 		tlsLayer->onError.connect(boost::bind(&BasicSessionStream::handleTLSError, this));
 // 		tlsLayer->onConnected.connect(boost::bind(&BasicSessionStream::handleTLSConnected, this));
 // 		tlsLayer->connect();
+	}
+}
+}

include/Swiften/Server/ServerFromClientSession.h

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #pragma once
 #include <boost/shared_ptr.hpp>
 #include <Swiften/Base/boost_bsignals.h>
 #include <boost/enable_shared_from_this.hpp>
 #include <boost/signals.hpp>
 #include <string>
 #include <Swiften/Session/Session.h>
 #include <Swiften/JID/JID.h>
 #include <Swiften/Network/Connection.h>
 #include <Swiften/Base/ByteArray.h>
 #include <Swiften/TLS/CertificateWithKey.h>
 #include <Swiften/Version.h>
 #define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class ProtocolHeader;
 	class Element;
 	class Stanza;
 	class PayloadParserFactoryCollection;
 	class PayloadSerializerCollection;
 	class StreamStack;
 	class UserRegistry;
 	class XMPPLayer;
 	class ConnectionLayer;
 	class Connection;
 	class TLSServerLayer;
 	class TLSServerContextFactory;
 	class PKCS12Certificate;
 	class ServerFromClientSession : public Session {
 		public:
 			ServerFromClientSession(
 					const std::string& id,
-					boost::shared_ptr<Connection> connection,
+					SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Connection> connection,
 					PayloadParserFactoryCollection* payloadParserFactories,
 					PayloadSerializerCollection* payloadSerializers,
 					UserRegistry* userRegistry,
 					XMLParserFactory* factory,
 					Swift::JID remoteJID = Swift::JID());
 			~ServerFromClientSession();
 			boost::signal<void ()> onSessionStarted;
 			void setAllowSASLEXTERNAL();
 			const std::string &getUser() {
 				return user_;
+			}
 			void addTLSEncryption(TLSServerContextFactory* tlsContextFactory, CertificateWithKey::ref cert);
 			Swift::JID getBareJID() {
 				return Swift::JID(user_, getLocalJID().getDomain());
+			}
 			void handlePasswordValid();
 			void handlePasswordInvalid(const std::string &error = "");
 		private:
 #if HAVE_SWIFTEN_3
-			void handleElement(boost::shared_ptr<ToplevelElement>);
+			void handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ToplevelElement>);
 #else
-			void handleElement(boost::shared_ptr<Element>);
+			void handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Element>);
 #endif
 			void handleStreamStart(const ProtocolHeader& header);
 			void handleSessionFinished(const boost::optional<SessionError>&);
 			void setInitialized();
 			bool isInitialized() const {
 				return initialized;
+			}
 			void handleTLSError() { }
 			void handleTLSConnected() { tlsConnected = true; }

include/Swiften/Server/ServerSession.h

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #pragma once
 #include <boost/shared_ptr.hpp>
 #include <Swiften/Elements/Stanza.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class ServerSession {
 		public:
 			virtual ~ServerSession();
 			virtual const JID& getJID() const = 0;
 			virtual int getPriority() const = 0;
-			virtual void sendStanza(boost::shared_ptr<Stanza>) = 0;
+			virtual void sendStanza(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Stanza>) = 0;
 	};
+}

include/Swiften/Server/ServerStanzaChannel.cpp

➞

Show inline comments

@@ @@ -12,172 +12,172 @@ @@
 namespace Swift {
 namespace {
 // 	struct PriorityLessThan {
 // 		bool operator()(const ServerSession* s1, const ServerSession* s2) const {
 // 			return s1->getPriority() < s2->getPriority();
 // 		}
 // 	};
 	struct HasJID {
 		HasJID(const JID& jid) : jid(jid) {}
-		bool operator()(const boost::shared_ptr<ServerFromClientSession> session) const {
+		bool operator()(const SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> session) const {
 			return session->getRemoteJID().equals(jid, JID::WithResource);
+		}
 		JID jid;
 	};
+}
-void ServerStanzaChannel::addSession(boost::shared_ptr<ServerFromClientSession> session) {
+void ServerStanzaChannel::addSession(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> session) {
 	sessions[session->getRemoteJID().toBare().toString()].push_back(session);
 	session->onSessionFinished.connect(boost::bind(&ServerStanzaChannel::handleSessionFinished, this, _1, session));
 	session->onElementReceived.connect(boost::bind(&ServerStanzaChannel::handleElement, this, _1, session));
 	session->onDataRead.connect(boost::bind(&ServerStanzaChannel::handleDataRead, this, _1, session));
+}
-void ServerStanzaChannel::removeSession(boost::shared_ptr<ServerFromClientSession> session) {
+void ServerStanzaChannel::removeSession(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> session) {
 	session->onSessionFinished.disconnect(boost::bind(&ServerStanzaChannel::handleSessionFinished, this, _1, session));
 	session->onElementReceived.disconnect(boost::bind(&ServerStanzaChannel::handleElement, this, _1, session));
 	session->onDataRead.disconnect(boost::bind(&ServerStanzaChannel::handleDataRead, this, _1, session));
-	std::list<boost::shared_ptr<ServerFromClientSession> > &lst = sessions[session->getRemoteJID().toBare().toString()];
+	std::list<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> > &lst = sessions[session->getRemoteJID().toBare().toString()];
 	lst.erase(std::remove(lst.begin(), lst.end(), session), lst.end());
+}
-void ServerStanzaChannel::sendIQ(boost::shared_ptr<IQ> iq) {
+void ServerStanzaChannel::sendIQ(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<IQ> iq) {
 	send(iq);
+}
-void ServerStanzaChannel::sendMessage(boost::shared_ptr<Message> message) {
+void ServerStanzaChannel::sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Message> message) {
 	send(message);
+}
-void ServerStanzaChannel::sendPresence(boost::shared_ptr<Presence> presence) {
+void ServerStanzaChannel::sendPresence(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Presence> presence) {
 	send(presence);
+}
-void ServerStanzaChannel::handleDataRead(const SafeByteArray &data, const boost::shared_ptr<ServerFromClientSession> &session) {
+void ServerStanzaChannel::handleDataRead(const SafeByteArray &data, const SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> &session) {
 	if (safeByteArrayToString(data).find("</stream:stream>") != std::string::npos) {
 		Swift::Presence::ref presence = Swift::Presence::create();
 		presence->setFrom(session->getRemoteJID());
 		presence->setType(Swift::Presence::Unavailable);
 		onPresenceReceived(presence);
+	}
+}
 #if HAVE_SWIFTEN_3
-void ServerStanzaChannel::finishSession(const JID& to, boost::shared_ptr<ToplevelElement> element, bool last) {
+void ServerStanzaChannel::finishSession(const JID& to, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ToplevelElement> element, bool last) {
 #else
-void ServerStanzaChannel::finishSession(const JID& to, boost::shared_ptr<Element> element, bool last) {
+void ServerStanzaChannel::finishSession(const JID& to, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Element> element, bool last) {
 #endif
 	std::vector<boost::shared_ptr<ServerFromClientSession> > candidateSessions;
 	for (std::list<boost::shared_ptr<ServerFromClientSession> >::const_iterator i = sessions[to.toBare().toString()].begin(); i != sessions[to.toBare().toString()].end(); ++i) {
 	std::vector<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> > candidateSessions;
 	for (std::list<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> >::const_iterator i = sessions[to.toBare().toString()].begin(); i != sessions[to.toBare().toString()].end(); ++i) {
 		candidateSessions.push_back(*i);
+	}
-	for (std::vector<boost::shared_ptr<ServerFromClientSession> >::const_iterator i = candidateSessions.begin(); i != candidateSessions.end(); ++i) {
+	for (std::vector<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> >::const_iterator i = candidateSessions.begin(); i != candidateSessions.end(); ++i) {
 		removeSession(*i);
 		if (element) {
 			(*i)->sendElement(element);
+		}
 		if (last && (*i)->getRemoteJID().isValid()) {
 			Swift::Presence::ref presence = Swift::Presence::create();
 			presence->setFrom((*i)->getRemoteJID());
 			presence->setType(Swift::Presence::Unavailable);
 			onPresenceReceived(presence);
+		}
 		(*i)->finishSession();
 // 		std::cout << "FINISH SESSION " << sessions[to.toBare().toString()].size() << "\n";
 		if (last) {
 			break;
+		}
+	}
+}
 std::string ServerStanzaChannel::getNewIQID() {
 	return idGenerator.generateID();
+}
-void ServerStanzaChannel::send(boost::shared_ptr<Stanza> stanza) {
+void ServerStanzaChannel::send(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Stanza> stanza) {
 	JID to = stanza->getTo();
 	assert(to.isValid());
 	if (!stanza->getFrom().isValid()) {
 		stanza->setFrom(m_jid);
+	}
 	// For a full JID, first try to route to a session with the full JID
 	if (!to.isBare()) {
-		std::list<boost::shared_ptr<ServerFromClientSession> >::const_iterator i = std::find_if(sessions[stanza->getTo().toBare().toString()].begin(), sessions[stanza->getTo().toBare().toString()].end(), HasJID(to));
+		std::list<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> >::const_iterator i = std::find_if(sessions[stanza->getTo().toBare().toString()].begin(), sessions[stanza->getTo().toBare().toString()].end(), HasJID(to));
 		if (i != sessions[stanza->getTo().toBare().toString()].end()) {
 			(*i)->sendElement(stanza);
 			return;
+		}
+	}
 	// Look for candidate sessions
 	to = to.toBare();
 	std::vector<boost::shared_ptr<ServerFromClientSession> > candidateSessions;
 	for (std::list<boost::shared_ptr<ServerFromClientSession> >::const_iterator i = sessions[stanza->getTo().toBare().toString()].begin(); i != sessions[stanza->getTo().toBare().toString()].end(); ++i) {
 	std::vector<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> > candidateSessions;
 	for (std::list<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> >::const_iterator i = sessions[stanza->getTo().toBare().toString()].begin(); i != sessions[stanza->getTo().toBare().toString()].end(); ++i) {
 		if ((*i)->getRemoteJID().equals(to, JID::WithoutResource)) {
 			candidateSessions.push_back(*i);
 			(*i)->sendElement(stanza);
+		}
+	}
 	if (candidateSessions.empty()) {
 		return;
+	}
 	// Find the session with the highest priority
 // 	std::vector<ServerSession*>::const_iterator i = std::max_element(sessions.begin(), sessions.end(), PriorityLessThan());
 // 	(*i)->sendStanza(stanza);
 	return;
+}
-void ServerStanzaChannel::handleSessionFinished(const boost::optional<Session::SessionError>&, const boost::shared_ptr<ServerFromClientSession>& session) {
+void ServerStanzaChannel::handleSessionFinished(const boost::optional<Session::SessionError>&, const SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession>& session) {
 	removeSession(session);
 // 	if (!session->initiatedFinish()) {
 		Swift::Presence::ref presence = Swift::Presence::create();
 		presence->setFrom(session->getRemoteJID());
 		presence->setType(Swift::Presence::Unavailable);
 		onPresenceReceived(presence);
 // 	}
+}
 void ServerStanzaChannel::handleElement(boost::shared_ptr<Element> element, const boost::shared_ptr<ServerFromClientSession>& session) {
 	boost::shared_ptr<Stanza> stanza = boost::dynamic_pointer_cast<Stanza>(element);
 void ServerStanzaChannel::handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Element> element, const SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession>& session) {
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Stanza> stanza = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Stanza>(element);
 	if (!stanza) {
 		return;
+	}
 	stanza->setFrom(session->getRemoteJID());
 	if (!stanza->getFrom().isValid())
 		return;
-	boost::shared_ptr<Message> message = boost::dynamic_pointer_cast<Message>(stanza);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Message> message = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Message>(stanza);
 	if (message) {
 		onMessageReceived(message);
 		return;
+	}
-	boost::shared_ptr<Presence> presence = boost::dynamic_pointer_cast<Presence>(stanza);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Presence> presence = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Presence>(stanza);
 	if (presence) {
 		onPresenceReceived(presence);
 		return;
+	}
-	boost::shared_ptr<IQ> iq = boost::dynamic_pointer_cast<IQ>(stanza);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<IQ> iq = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<IQ>(stanza);
 	if (iq) {
 		onIQReceived(iq);
 		return;
+	}
+}
 void ServerStanzaChannel::handleSessionInitialized() {
 	onAvailableChanged(true);
+}
+}

include/Swiften/Server/ServerStanzaChannel.h

➞

Show inline comments

@@ @@ -16,51 +16,51 @@ @@
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/TLS/Certificate.h"
 #include <Swiften/Version.h>
 #define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)
 namespace Swift {
 	class Error;
 	class ServerStanzaChannel : public StanzaChannel {
 		public:
 			ServerStanzaChannel(const JID &selfJID) : StanzaChannel() {
 				m_jid = selfJID;
+			}
 			void addSession(boost::shared_ptr<ServerFromClientSession> session);
 			void removeSession(boost::shared_ptr<ServerFromClientSession> session);
 			void addSession(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> session);
 			void removeSession(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> session);
 			void sendIQ(boost::shared_ptr<IQ> iq);
 			void sendMessage(boost::shared_ptr<Message> message);
 			void sendPresence(boost::shared_ptr<Presence> presence);
 			void sendIQ(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<IQ> iq);
 			void sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Message> message);
 			void sendPresence(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Presence> presence);
 #if HAVE_SWIFTEN_3
-			void finishSession(const JID& to, boost::shared_ptr<ToplevelElement> element, bool last = false);
+			void finishSession(const JID& to, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ToplevelElement> element, bool last = false);
 #else
-			void finishSession(const JID& to, boost::shared_ptr<Element> element, bool last = false);
+			void finishSession(const JID& to, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Element> element, bool last = false);
 #endif
 			bool getStreamManagementEnabled() const {
 				return false;
+			}
 			bool isAvailable() const {
 				return true;
+			}
 			std::vector<Certificate::ref> getPeerCertificateChain() const {
 				return std::vector<Certificate::ref>();
+			}
 		private:
 			std::string getNewIQID();
 			void send(boost::shared_ptr<Stanza> stanza);
 			void handleSessionFinished(const boost::optional<Session::SessionError>&, const boost::shared_ptr<ServerFromClientSession> &session);
 			void handleElement(boost::shared_ptr<Element> element, const boost::shared_ptr<ServerFromClientSession> &session);
 			void handleDataRead(const SafeByteArray &data, const boost::shared_ptr<ServerFromClientSession> &session);
 			void send(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Stanza> stanza);
 			void handleSessionFinished(const boost::optional<Session::SessionError>&, const SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> &session);
 			void handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Element> element, const SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> &session);
 			void handleDataRead(const SafeByteArray &data, const SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> &session);
 			void handleSessionInitialized();
 		private:
 			JID m_jid;
 			IDGenerator idGenerator;
 			// [JID][resources][ServerFromClientSession]
-			std::map<std::string, std::list<boost::shared_ptr<ServerFromClientSession> > > sessions;
+			std::map<std::string, std::list<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> > > sessions;
 	};
+}

include/Swiften/Server/ServerStanzaRouter.cpp

➞

Show inline comments

@@ @@ -23,25 +23,25 @@ namespace { @@
 	struct HasJID {
 		HasJID(const JID& jid) : jid(jid) {}
 		bool operator()(const ServerSession* session) const {
 			return session->getJID().equals(jid, JID::WithResource);
+		}
 		JID jid;
 	};
+}
 ServerStanzaRouter::ServerStanzaRouter() {
+}
-bool ServerStanzaRouter::routeStanza(boost::shared_ptr<Stanza> stanza) {
+bool ServerStanzaRouter::routeStanza(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Stanza> stanza) {
 	JID to = stanza->getTo();
 	assert(to.isValid());
 	// For a full JID, first try to route to a session with the full JID
 	if (!to.isBare()) {
 		std::vector<ServerSession*>::const_iterator i = std::find_if(clientSessions_.begin(), clientSessions_.end(), HasJID(to));
 		if (i != clientSessions_.end()) {
 			(*i)->sendStanza(stanza);
 			return true;
+		}
+	}

include/Swiften/Server/ServerStanzaRouter.h

➞

Show inline comments

@@ @@ -3,28 +3,30 @@ @@
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #pragma once
 #include <boost/shared_ptr.hpp>
 #include <map>
 #include <Swiften/JID/JID.h>
 #include <Swiften/Elements/Stanza.h>
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class ServerSession;
 	class ServerStanzaRouter {
 		public:
 			ServerStanzaRouter();
-			bool routeStanza(boost::shared_ptr<Stanza>);
+			bool routeStanza(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Stanza>);
 			void addClientSession(ServerSession*);
 			void removeClientSession(ServerSession*);
 		private:
 			std::vector<ServerSession*> clientSessions_;
 	};
+}

include/Swiften/StreamStack/TLSServerLayer.cpp

➞

Show inline comments

@@ @@ -36,17 +36,17 @@ void TLSServerLayer::writeData(const SafeByteArray& data) { @@
 void TLSServerLayer::handleDataRead(const SafeByteArray& data) {
 	context->handleDataFromNetwork(data);
+}
 bool TLSServerLayer::setServerCertificate(CertificateWithKey::ref certificate) {
 	return context->setServerCertificate(certificate);
+}
 Certificate::ref TLSServerLayer::getPeerCertificate() const {
 	return context->getPeerCertificate();
+}
-boost::shared_ptr<CertificateVerificationError> TLSServerLayer::getPeerCertificateVerificationError() const {
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CertificateVerificationError> TLSServerLayer::getPeerCertificateVerificationError() const {
 	return context->getPeerCertificateVerificationError();
+}
+}

include/Swiften/StreamStack/TLSServerLayer.h

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
-#include "Swiften/Base/boost_bsignals.h"
+#include <boost/signals.hpp>
 #include "Swiften/Base/SafeByteArray.h"
 #include "Swiften/StreamStack/StreamLayer.h"
 #include "Swiften/TLS/Certificate.h"
 #include <Swiften/TLS/CertificateWithKey.h>
 #include "Swiften/TLS/CertificateVerificationError.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Swift {
 	class TLSServerContext;
 	class TLSServerContextFactory;
 	class PKCS12Certificate;
 	class TLSServerLayer : public StreamLayer {
 		public:
 			TLSServerLayer(TLSServerContextFactory*);
 			~TLSServerLayer();
 			void connect();
 			bool setServerCertificate(CertificateWithKey::ref cert);
 			Certificate::ref getPeerCertificate() const;
-			boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;
 			void writeData(const SafeByteArray& data);
 			void handleDataRead(const SafeByteArray& data);
 			TLSServerContext* getContext() const {
 				return context;
+			}
 		public:
 			boost::signal<void ()> onError;
 			boost::signal<void ()> onConnected;

include/Swiften/SwiftenCompat.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Swift compatibility
+ *
  * Copyright (c) 2016, Vladimir Matena <vlada.matena@gmail.com>
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 #include <Swiften/Version.h>
 /*
  * Define macros for Swiften compatible shared pointer and signal namespaces.
+ *
  * Using these it is possible to declare shared pointers and signals like this:
+ *
  * SWIFTEN_SIGNAL_NAMESPACE::signal signal;
  * SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Type> ptr;
+ *
  * These are guaranteed to be the same implementation as Swift uses internally,
  * thus can be used when passign/retrieveing data from/to swiften.
+ *
  * This is due to Swift 4 moved from boost::shared_ptr to SWIFTEN_SHRPTR_NAMESPACE::shared_ptr
  * and from boost::signals to boost::signals2 .
  */
 #if (SWIFTEN_VERSION >= 0x040000)
 #define SWIFTEN_SHRPTR_NAMESPACE std
 #define SWIFTEN_SIGNAL_NAMESPACE boost::signals2
 #else
 #define SWIFTEN_SHRPTR_NAMESPACE boost
 #define SWIFTEN_SIGNAL_NAMESPACE boost::signals
 #endif

include/Swiften/TLS/OpenSSL/OpenSSLServerContext.cpp

➞

Show inline comments

 		onDataForApplication(data);
 		data.resize(SSL_READ_BUFFERSIZE);
 		ret = SSL_read(handle_, vecptr(data), data.size());
 	}
 	if (ret < 0 && SSL_get_error(handle_, ret) != SSL_ERROR_WANT_READ) {
 		state_ = Error;
 // 		std::cout << "AAAAAAAA 3\n";
 		onError();
 	}
 }
 bool OpenSSLServerContext::setServerCertificate(CertificateWithKey::ref certref) {
-	boost::shared_ptr<PKCS12Certificate> certificate = boost::dynamic_pointer_cast<PKCS12Certificate>(certref);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<PKCS12Certificate> certificate = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<PKCS12Certificate>(certref);
 	if (certificate->isNull()) {
 		LOG4CXX_ERROR(logger, "TLS WILL NOT WORK: Certificate can't be loaded.");
 		return false;
 	}
 	// Create a PKCS12 structure
 	BIO* bio = BIO_new(BIO_s_mem());
 	BIO_write(bio, vecptr(certificate->getData()), certificate->getData().size());
-	boost::shared_ptr<PKCS12> pkcs12(d2i_PKCS12_bio(bio, NULL), PKCS12_free);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<PKCS12> pkcs12(d2i_PKCS12_bio(bio, NULL), PKCS12_free);
 	BIO_free(bio);
 	if (!pkcs12) {
 		LOG4CXX_ERROR(logger, "TLS WILL NOT WORK: Certificate is not in PKCS#12 format.");
 		return false;
 	}
 	// Parse PKCS12
 	X509 *certPtr = 0;
 	EVP_PKEY* privateKeyPtr = 0;
 	STACK_OF(X509)* caCertsPtr = 0;
 	int result = PKCS12_parse(pkcs12.get(), reinterpret_cast<const char*>(vecptr(certificate->getPassword())), &privateKeyPtr, &certPtr, &caCertsPtr);
 	if (result != 1) {
 		LOG4CXX_ERROR(logger, "TLS WILL NOT WORK: Certificate is not in PKCS#12 format.");
 		return false;
 	}
 	boost::shared_ptr<X509> cert(certPtr, X509_free);
 	boost::shared_ptr<EVP_PKEY> privateKey(privateKeyPtr, EVP_PKEY_free);
 	boost::shared_ptr<STACK_OF(X509)> caCerts(caCertsPtr, freeX509Stack);
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<X509> cert(certPtr, X509_free);
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<EVP_PKEY> privateKey(privateKeyPtr, EVP_PKEY_free);
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<STACK_OF(X509)> caCerts(caCertsPtr, freeX509Stack);
 	// Use the key & certificates
 	if (SSL_CTX_use_certificate(context_, cert.get()) != 1) {
 		LOG4CXX_ERROR(logger, "TLS WILL NOT WORK: Can't use this certificate");
 		return false;
 	}
 	if (SSL_CTX_use_PrivateKey(context_, privateKey.get()) != 1) {
 		LOG4CXX_ERROR(logger, "TLS WILL NOT WORK: Can't use this private key");
 		return false;
 	}
 	return true;
 }
 Certificate::ref OpenSSLServerContext::getPeerCertificate() const {
-	boost::shared_ptr<X509> x509Cert(SSL_get_peer_certificate(handle_), X509_free);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<X509> x509Cert(SSL_get_peer_certificate(handle_), X509_free);
 	if (x509Cert) {
 		return Certificate::ref(new OpenSSLCertificate(x509Cert));
 	}
 	else {
 		return Certificate::ref();
 	}
 }
-boost::shared_ptr<CertificateVerificationError> OpenSSLServerContext::getPeerCertificateVerificationError() const {
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CertificateVerificationError> OpenSSLServerContext::getPeerCertificateVerificationError() const {
 	int verifyResult = SSL_get_verify_result(handle_);
 	if (verifyResult != X509_V_OK) {
-		return boost::shared_ptr<CertificateVerificationError>(new CertificateVerificationError(getVerificationErrorTypeForResult(verifyResult)));
+		return SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CertificateVerificationError>(new CertificateVerificationError(getVerificationErrorTypeForResult(verifyResult)));
 	}
 	else {
-		return boost::shared_ptr<CertificateVerificationError>();
+		return SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CertificateVerificationError>();
 	}
 }
 ByteArray OpenSSLServerContext::getFinishMessage() const {
 	ByteArray data;
 	data.resize(MAX_FINISHED_SIZE);
 	size_t size = SSL_get_finished(handle_, vecptr(data), data.size());
 	data.resize(size);
 	return data;
 }
 CertificateVerificationError::Type OpenSSLServerContext::getVerificationErrorTypeForResult(int result) {

include/Swiften/TLS/OpenSSL/OpenSSLServerContext.h

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #pragma once
 #include <openssl/ssl.h>
 #include "Swiften/Base/boost_bsignals.h"
 #include <boost/noncopyable.hpp>
 #include "Swiften/TLS/TLSServerContext.h"
 #include "Swiften/Base/ByteArray.h"
 #include "Swiften/SwiftenCompat.h"
 #include <Swiften/TLS/CertificateWithKey.h>
 namespace Swift {
 	class PKCS12Certificate;
 	class OpenSSLServerContext : public TLSServerContext, boost::noncopyable {
 		public:
 			OpenSSLServerContext();
 			~OpenSSLServerContext();
 			void connect();
 			bool setServerCertificate(CertificateWithKey::ref cert);
 			void handleDataFromNetwork(const SafeByteArray&);
 			void handleDataFromApplication(const SafeByteArray&);
 			Certificate::ref getPeerCertificate() const;
-			boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;
 			virtual ByteArray getFinishMessage() const;
 		private:
 			static void ensureLibraryInitialized();
 			static CertificateVerificationError::Type getVerificationErrorTypeForResult(int);
 			void doConnect();
 			void sendPendingDataToNetwork();
 			void sendPendingDataToApplication();

include/Swiften/TLS/Schannel/SchannelServerContext.cpp

➞

Show inline comments

 		}
 		sendDataOnNetwork(&sendBuffer[0], outBuffers[0].cbBuffer + outBuffers[1].cbBuffer + outBuffers[2].cbBuffer);
 		bytesSent += bytesToSend;
 	} while (bytesSent < data.size());
 }
 //------------------------------------------------------------------------
 bool SchannelServerContext::setServerCertificate(CertificateWithKey::ref certificate)
 {
-	boost::shared_ptr<CAPICertificate> capiCertificate = boost::dynamic_pointer_cast<CAPICertificate>(certificate);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CAPICertificate> capiCertificate = std::dynamic_pointer_cast<CAPICertificate>(certificate);
 	if (!capiCertificate || capiCertificate->isNull()) {
 		return false;
 	}
 	// We assume that the Certificate Store Name/Certificate Name
 	// are valid at this point
 	m_cert_store_name = capiCertificate->getCertStoreName();
 	m_cert_name = capiCertificate->getCertName();
 	return true;
 }
 //------------------------------------------------------------------------
 	SECURITY_STATUS status = QueryContextAttributes(m_ctxtHandle, SECPKG_ATTR_REMOTE_CERT_CONTEXT, pServerCert.Reset());
 	if (status != SEC_E_OK)
 		return pCertificate;
 	pCertificate.reset( new SchannelCertificate(pServerCert) );
 	return pCertificate;
 }
 //------------------------------------------------------------------------
 CertificateVerificationError::ref SchannelServerContext::getPeerCertificateVerificationError() const
 {
-	boost::shared_ptr<CertificateVerificationError> pCertError;
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CertificateVerificationError> pCertError;
 	if (m_state == Error)
 		pCertError.reset( new CertificateVerificationError(m_verificationError) );
 	return pCertError;
 }
 //------------------------------------------------------------------------
 ByteArray SchannelServerContext::getFinishMessage() const
 {
 	// TODO: Implement

include/Swiften/TLS/Schannel/SchannelServerContext.h

➞

Show inline comments

 /*
  * Copyright (c) 2011 Soren Dreijer
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include "Swiften/Base/boost_bsignals.h"
 #include "Swiften/TLS/TLSServerContext.h"
 #include "Swiften/TLS/Schannel/SchannelUtil.h"
 #include <Swiften/TLS/CertificateWithKey.h>
 #include "Swiften/Base/ByteArray.h"
 #define SECURITY_WIN32
 #include <Windows.h>
 #include <Schannel.h>
 #include <security.h>
 #include <schnlsp.h>
 #include <boost/noncopyable.hpp>
 namespace Swift
 {
 	class SchannelServerContext : public TLSServerContext, boost::noncopyable
 	{
 	public:
-		typedef boost::shared_ptr<SchannelServerContext> sp_t;
+		typedef SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<SchannelServerContext> sp_t;
 	public:
 		SchannelServerContext();
 		~SchannelServerContext();
 		//
 		// TLSContext
 		//
 		virtual void	connect();
 		virtual bool	setServerCertificate(CertificateWithKey::ref cert);

include/Swiften/TLS/SecureTransport/SecureTransportServerContext.h

➞

Show inline comments

 		virtual ByteArray getFinishMessage() const;
 	private:
 		static OSStatus SSLSocketReadCallback(SSLConnectionRef connection, void *data, size_t *dataLength);
 		static OSStatus SSLSocketWriteCallback(SSLConnectionRef connection, const void *data, size_t *dataLength);
 	private:
 		enum State { None, Handshake, HandshakeDone, Error};
 		static std::string stateToString(State state);
 		void setState(State newState);
 		static boost::shared_ptr<TLSError> nativeToTLSError(OSStatus error);
 		boost::shared_ptr<CertificateVerificationError> CSSMErrorToVerificationError(OSStatus resultCode);
 		static SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<TLSError> nativeToTLSError(OSStatus error);
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CertificateVerificationError> CSSMErrorToVerificationError(OSStatus resultCode);
 		void processHandshake();
 		void verifyServerCertificate();
-		void fatalError(boost::shared_ptr<TLSError> error, boost::shared_ptr<CertificateVerificationError> certificateError);
+		void fatalError(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<TLSError> error, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CertificateVerificationError> certificateError);
 	private:
-		boost::shared_ptr<SSLContext> sslContext_;
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<SSLContext> sslContext_;
 		SafeByteArray readingBuffer_;
 		State state_;
 		CertificateVerificationError::ref verificationError_;
 		CertificateWithKey::ref clientCertificate_;
 		bool checkCertificateRevocation_;
 };
 }

include/Swiften/TLS/SecureTransport/SecureTransportServerContext.mm

➞

Show inline comments

@@ @@ -30,25 +30,25 @@ T bridge_cast(S source) { @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wold-style-cast"
 	return (__bridge T)(source);
 #pragma clang diagnostic pop
 }
 namespace Swift {
 namespace {
 CFArrayRef CreateClientCertificateChainAsCFArrayRef(CertificateWithKey::ref key) {
-	boost::shared_ptr<PKCS12Certificate> pkcs12 = boost::dynamic_pointer_cast<PKCS12Certificate>(key);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<PKCS12Certificate> pkcs12 = std::dynamic_pointer_cast<PKCS12Certificate>(key);
 	if (!key) {
 		return NULL;
 	}
 	SafeByteArray safePassword = pkcs12->getPassword();
 	CFIndex passwordSize = 0;
 	try {
 		passwordSize = boost::numeric_cast<CFIndex>(safePassword.size());
 	} catch (...) {
 		return NULL;
 	}
 		CFArrayAppendValue(certChain, nsItems[0][@"identity"]);
 		for (CFIndex index = 0; index < CFArrayGetCount(bridge_cast<CFArrayRef>(nsItems[0][@"chain"])); index++) {
 			CFArrayAppendValue(certChain, CFArrayGetValueAtIndex(bridge_cast<CFArrayRef>(nsItems[0][@"chain"]), index));
 		}
 	}
 	return certChain;
 }
 }
 SecureTransportContext::SecureTransportServerContext(bool checkCertificateRevocation) : state_(None), checkCertificateRevocation_(checkCertificateRevocation) {
-	sslContext_ = boost::shared_ptr<SSLContext>(SSLCreateContext(NULL, kSSLClientSide, kSSLStreamType), CFRelease);
+	sslContext_ = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<SSLContext>(SSLCreateContext(NULL, kSSLClientSide, kSSLStreamType), CFRelease);
 	OSStatus error = noErr;
 	// set IO callbacks
 	error = SSLSetIOFuncs(sslContext_.get(), &SecureTransportContext::SSLSocketReadCallback, &SecureTransportContext::SSLSocketWriteCallback);
 	if (error != noErr) {
 		SWIFT_LOG(error) << "Unable to set IO functions to SSL context." << std::endl;
 		sslContext_.reset();
 	}
 	error = SSLSetConnection(sslContext_.get(), this);
 	if (error != noErr) {
 		SWIFT_LOG(error) << "Unable to set connection to SSL context." << std::endl;
 }
 void SecureTransportServerContext::setState(State newState) {
 	SWIFT_LOG(debug) << "Switch state from " << stateToString(state_) << " to " << stateToString(newState) << "." << std::endl;
 	state_ = newState;
 }
 void SecureTransportServerContext::connect() {
 	SWIFT_LOG_ASSERT(state_ == None, error) << "current state '" << stateToString(state_) << " invalid." << std::endl;
 	if (clientCertificate_) {
 		CFArrayRef certs = CreateClientCertificateChainAsCFArrayRef(clientCertificate_);
 		if (certs) {
-			boost::shared_ptr<CFArray> certRefs(certs, CFRelease);
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CFArray> certRefs(certs, CFRelease);
 			OSStatus result = SSLSetCertificate(sslContext_.get(), certRefs.get());
 			if (result != noErr) {
 				SWIFT_LOG(error) << "SSLSetCertificate failed with error " << result << "." << std::endl;
 			}
 		}
 	}
 	processHandshake();
 }
 void SecureTransportServerContext::processHandshake() {
 	SWIFT_LOG_ASSERT(state_ == None || state_ == Handshake, error) << "current state '" << stateToString(state_) << " invalid." << std::endl;
 	OSStatus error = SSLHandshake(sslContext_.get());
@@ @@ -182,108 +182,108 @@ void SecureTransportServerContext::processHandshake() { @@
 	else if (error == noErr) {
 		SWIFT_LOG(debug) << "TLS handshake successful." << std::endl;
 		setState(HandshakeDone);
 		onConnected();
 	}
 	else if (error == errSSLPeerAuthCompleted) {
 		SWIFT_LOG(debug) << "Received server certificate. Start verification." << std::endl;
 		setState(Handshake);
 		verifyServerCertificate();
 	}
 	else {
 		SWIFT_LOG(debug) << "Error returned from SSLHandshake call is " << error << "." << std::endl;
-		fatalError(nativeToTLSError(error), boost::make_shared<CertificateVerificationError>());
+		fatalError(nativeToTLSError(error), SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>());
 	}
 }
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 void SecureTransportServerContext::verifyServerCertificate() {
 	SecTrustRef trust = NULL;
 	OSStatus error = SSLCopyPeerTrust(sslContext_.get(), &trust);
 	if (error != noErr) {
-		fatalError(boost::make_shared<TLSError>(), boost::make_shared<CertificateVerificationError>());
+		fatalError(SWIFTEN_SHRPTR_NAMESPACE::make_shared<TLSError>(), SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>());
 		return;
 	}
-	boost::shared_ptr<SecTrust> trustRef = boost::shared_ptr<SecTrust>(trust, CFRelease);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<SecTrust> trustRef = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<SecTrust>(trust, CFRelease);
 	if (checkCertificateRevocation_) {
 		error = SecTrustSetOptions(trust, kSecTrustOptionRequireRevPerCert | kSecTrustOptionFetchIssuerFromNet);
 		if (error != noErr) {
-			fatalError(boost::make_shared<TLSError>(), boost::make_shared<CertificateVerificationError>());
+			fatalError(SWIFTEN_SHRPTR_NAMESPACE::make_shared<TLSError>(), SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>());
 			return;
 		}
 	}
 	SecTrustResultType trustResult;
 	error = SecTrustEvaluate(trust, &trustResult);
 	if (error != errSecSuccess) {
-		fatalError(boost::make_shared<TLSError>(), boost::make_shared<CertificateVerificationError>());
+		fatalError(SWIFTEN_SHRPTR_NAMESPACE::make_shared<TLSError>(), SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>());
 		return;
 	}
 	OSStatus cssmResult = 0;
 	switch(trustResult) {
 		case kSecTrustResultUnspecified:
 			SWIFT_LOG(warning) << "Successful implicit validation. Result unspecified." << std::endl;
 			break;
 		case kSecTrustResultProceed:
 			SWIFT_LOG(warning) << "Validation resulted in explicitly trusted." << std::endl;
 			break;
 		case kSecTrustResultRecoverableTrustFailure:
 			SWIFT_LOG(warning) << "recoverable trust failure" << std::endl;
 			error = SecTrustGetCssmResultCode(trust, &cssmResult);
 			if (error == errSecSuccess) {
 				verificationError_ = CSSMErrorToVerificationError(cssmResult);
 				if (cssmResult == CSSMERR_TP_VERIFY_ACTION_FAILED || cssmResult == CSSMERR_APPLETP_INCOMPLETE_REVOCATION_CHECK ) {
 					// Find out the reason why the verification failed.
 					CFArrayRef certChain;
 					CSSM_TP_APPLE_EVIDENCE_INFO* statusChain;
 					error = SecTrustGetResult(trustRef.get(), &trustResult, &certChain, &statusChain);
 					if (error == errSecSuccess) {
-						boost::shared_ptr<CFArray> certChainRef = boost::shared_ptr<CFArray>(certChain, CFRelease);
+						SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CFArray> certChainRef = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CFArray>(certChain, CFRelease);
 						for (CFIndex index = 0; index < CFArrayGetCount(certChainRef.get()); index++) {
 							for (CFIndex n = 0; n < statusChain[index].NumStatusCodes; n++) {
 								// Even though Secure Transport reported CSSMERR_APPLETP_INCOMPLETE_REVOCATION_CHECK on the whole certificate
 								// chain, the actual cause can be that a revocation check for a specific cert returned CSSMERR_TP_CERT_REVOKED.
 								if (!verificationError_ || verificationError_->getType() == CertificateVerificationError::RevocationCheckFailed) {
 									verificationError_ = CSSMErrorToVerificationError(statusChain[index].StatusCodes[n]);
 								}
 							}
 						}
 					}
 					else {
 					}
 				}
 			}
 			else {
-				verificationError_ = boost::make_shared<CertificateVerificationError>(CertificateVerificationError::UnknownError);
+				verificationError_ = SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>(CertificateVerificationError::UnknownError);
 			}
 			break;
 		case kSecTrustResultOtherError:
-			verificationError_ = boost::make_shared<CertificateVerificationError>(CertificateVerificationError::UnknownError);
+			verificationError_ = SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>(CertificateVerificationError::UnknownError);
 			break;
 		default:
 			SWIFT_LOG(warning) << "Unhandled trust result " << trustResult << "." << std::endl;
 			break;
 	}
 	if (verificationError_) {
 		setState(Error);
 		SSLClose(sslContext_.get());
 		sslContext_.reset();
-		onError(boost::make_shared<TLSError>());
+		onError(SWIFTEN_SHRPTR_NAMESPACE::make_shared<TLSError>());
 	}
 	else {
 		// proceed with handshake
 		processHandshake();
 	}
 }
 #pragma clang diagnostic pop
 bool SecureTransportServerContext::setClientCertificate(CertificateWithKey::ref cert) {
 	CFArrayRef nativeClientChain = CreateClientCertificateChainAsCFArrayRef(cert);
 	if (nativeClientChain) {
 			while (error == noErr) {
 				applicationData.resize(readingBuffer_.size());
 				error = SSLRead(sslContext_.get(), applicationData.data(), applicationData.size(), &bytesRead);
 				if (error == noErr) {
 					// Read successful.
 				}
 				else if (error == errSSLWouldBlock) {
 					// Secure Transport does not want more data.
 					break;
 				}
 				else {
 					SWIFT_LOG(error) << "SSLRead failed with error " << error << ", read bytes: " << bytesRead << "." << std::endl;
-					fatalError(boost::make_shared<TLSError>(), boost::make_shared<CertificateVerificationError>());
+					fatalError(SWIFTEN_SHRPTR_NAMESPACE::make_shared<TLSError>(), SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>());
 					return;
 				}
 				if (bytesRead > 0) {
 					applicationData.resize(bytesRead);
 					onDataForApplication(applicationData);
 				}
 				else {
 					break;
 				}
 			}
 			break;
 void SecureTransportServerContext::handleDataFromApplication(const SafeByteArray& data) {
 	size_t processedBytes = 0;
 	OSStatus error = SSLWrite(sslContext_.get(), data.data(), data.size(), &processedBytes);
 	switch(error) {
 		case errSSLWouldBlock:
 			SWIFT_LOG(warning) << "Unexpected because the write callback does not block." << std::endl;
 			return;
 		case errSSLClosedGraceful:
 		case noErr:
 			return;
 		default:
 			SWIFT_LOG(warning) << "SSLWrite returned error code: " << error << ", processed bytes: " << processedBytes << std::endl;
-			fatalError(boost::make_shared<TLSError>(), boost::shared_ptr<CertificateVerificationError>());
+			fatalError(SWIFTEN_SHRPTR_NAMESPACE::make_shared<TLSError>(), SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CertificateVerificationError>());
 	}
 }
 std::vector<Certificate::ref> SecureTransportServerContext::getPeerCertificateChain() const {
 	std::vector<Certificate::ref> peerCertificateChain;
 	if (sslContext_) {
 			typedef boost::remove_pointer<SecTrustRef>::type SecTrust;
-			boost::shared_ptr<SecTrust> securityTrust;
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<SecTrust> securityTrust;
 			SecTrustRef secTrust = NULL;;
 			OSStatus error = SSLCopyPeerTrust(sslContext_.get(), &secTrust);
 			if (error == noErr) {
-				securityTrust = boost::shared_ptr<SecTrust>(secTrust, CFRelease);
+				securityTrust = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<SecTrust>(secTrust, CFRelease);
 				CFIndex chainSize = SecTrustGetCertificateCount(securityTrust.get());
 				for (CFIndex n = 0; n < chainSize; n++) {
 					SecCertificateRef certificate = SecTrustGetCertificateAtIndex(securityTrust.get(), n);
 					if (certificate) {
-						peerCertificateChain.push_back(boost::make_shared<SecureTransportCertificate>(certificate));
+						peerCertificateChain.push_back(SWIFTEN_SHRPTR_NAMESPACE::make_shared<SecureTransportCertificate>(certificate));
 					}
 				}
 			}
 			else {
 				SWIFT_LOG(warning) << "Failed to obtain peer trust structure; error = " << error << "." << std::endl;
 			}
 	}
 	return peerCertificateChain;
 }
 CertificateVerificationError::ref SecureTransportServerContext::getPeerCertificateVerificationError() const {
 OSStatus SecureTransportServerContext::SSLSocketWriteCallback(SSLConnectionRef connection, const void *data, size_t *dataLength) {
 	SecureTransportContext* context = const_cast<SecureTransportContext*>(static_cast<const SecureTransportContext*>(connection));
 	OSStatus retValue = noErr;
 	SafeByteArray safeData;
 	safeData.resize(*dataLength);
 	memcpy(safeData.data(), data, safeData.size());
 	context->onDataForNetwork(safeData);
 	return retValue;
 }
 boost::shared_ptr<TLSError> SecureTransportServerContext::nativeToTLSError(OSStatus /* error */) {
 	boost::shared_ptr<TLSError> swiftenError;
 	swiftenError = boost::make_shared<TLSError>();
 SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<TLSError> SecureTransportServerContext::nativeToTLSError(OSStatus /* error */) {
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<TLSError> swiftenError;
 	swiftenError = SWIFTEN_SHRPTR_NAMESPACE::make_shared<TLSError>();
 	return swiftenError;
 }
 boost::shared_ptr<CertificateVerificationError> SecureTransportServerContext::CSSMErrorToVerificationError(OSStatus resultCode) {
 	boost::shared_ptr<CertificateVerificationError> error;
 SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CertificateVerificationError> SecureTransportServerContext::CSSMErrorToVerificationError(OSStatus resultCode) {
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CertificateVerificationError> error;
 	switch(resultCode) {
 		case CSSMERR_TP_NOT_TRUSTED:
 			SWIFT_LOG(debug) << "CSSM result code: CSSMERR_TP_NOT_TRUSTED" << std::endl;
-			error = boost::make_shared<CertificateVerificationError>(CertificateVerificationError::Untrusted);
+			error = SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>(CertificateVerificationError::Untrusted);
 			break;
 		case CSSMERR_TP_CERT_NOT_VALID_YET:
 			SWIFT_LOG(debug) << "CSSM result code: CSSMERR_TP_CERT_NOT_VALID_YET" << std::endl;
-			error = boost::make_shared<CertificateVerificationError>(CertificateVerificationError::NotYetValid);
+			error = SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>(CertificateVerificationError::NotYetValid);
 			break;
 		case CSSMERR_TP_CERT_EXPIRED:
 			SWIFT_LOG(debug) << "CSSM result code: CSSMERR_TP_CERT_EXPIRED" << std::endl;
-			error = boost::make_shared<CertificateVerificationError>(CertificateVerificationError::Expired);
+			error = SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>(CertificateVerificationError::Expired);
 			break;
 		case CSSMERR_TP_CERT_REVOKED:
 			SWIFT_LOG(debug) << "CSSM result code: CSSMERR_TP_CERT_REVOKED" << std::endl;
-			error = boost::make_shared<CertificateVerificationError>(CertificateVerificationError::Revoked);
+			error = SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>(CertificateVerificationError::Revoked);
 			break;
 		case CSSMERR_TP_VERIFY_ACTION_FAILED:
 			SWIFT_LOG(debug) << "CSSM result code: CSSMERR_TP_VERIFY_ACTION_FAILED" << std::endl;
 			break;
 		case CSSMERR_APPLETP_INCOMPLETE_REVOCATION_CHECK:
 			SWIFT_LOG(debug) << "CSSM result code: CSSMERR_APPLETP_INCOMPLETE_REVOCATION_CHECK" << std::endl;
 			if (checkCertificateRevocation_) {
-				error = boost::make_shared<CertificateVerificationError>(CertificateVerificationError::RevocationCheckFailed);
+				error = SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>(CertificateVerificationError::RevocationCheckFailed);
 			}
 			break;
 		case CSSMERR_APPLETP_OCSP_UNAVAILABLE:
 			SWIFT_LOG(debug) << "CSSM result code: CSSMERR_APPLETP_OCSP_UNAVAILABLE" << std::endl;
 			if (checkCertificateRevocation_) {
-				error = boost::make_shared<CertificateVerificationError>(CertificateVerificationError::RevocationCheckFailed);
+				error = SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>(CertificateVerificationError::RevocationCheckFailed);
 			}
 			break;
 		case CSSMERR_APPLETP_SSL_BAD_EXT_KEY_USE:
 			SWIFT_LOG(debug) << "CSSM result code: CSSMERR_APPLETP_SSL_BAD_EXT_KEY_USE" << std::endl;
-			error = boost::make_shared<CertificateVerificationError>(CertificateVerificationError::InvalidPurpose);
+			error = SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>(CertificateVerificationError::InvalidPurpose);
 			break;
 		default:
 			SWIFT_LOG(warning) << "unhandled CSSM error: " << resultCode << ", CSSM_TP_BASE_TP_ERROR: " << CSSM_TP_BASE_TP_ERROR << std::endl;
-			error = boost::make_shared<CertificateVerificationError>(CertificateVerificationError::UnknownError);
+			error = SWIFTEN_SHRPTR_NAMESPACE::make_shared<CertificateVerificationError>(CertificateVerificationError::UnknownError);
 			break;
 	}
 	return error;
 }
-void SecureTransportServerContext::fatalError(boost::shared_ptr<TLSError> error, boost::shared_ptr<CertificateVerificationError> certificateError) {
+void SecureTransportServerContext::fatalError(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<TLSError> error, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CertificateVerificationError> certificateError) {
 	setState(Error);
 	if (sslContext_) {
 		SSLClose(sslContext_.get());
 	}
 	verificationError_ = certificateError;
 	onError(error);
 }
 }

include/Swiften/TLS/TLSServerContext.h

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #pragma once
 #include "Swiften/Base/boost_bsignals.h"
 #include <boost/shared_ptr.hpp>
 #include <boost/signals.hpp>
 #include "Swiften/Base/SafeByteArray.h"
 #include "Swiften/TLS/Certificate.h"
 #include <Swiften/TLS/CertificateWithKey.h>
 #include "Swiften/TLS/CertificateVerificationError.h"
 namespace Swift {
 	class PKCS12Certificate;
 	class TLSServerContext {
 		public:
 			virtual ~TLSServerContext();

include/boost/dll/import.hpp

➞

Show inline comments

@@ @@ -21,207 +21,207 @@ @@
 #endif
 /// \file boost/dll/import.hpp
 /// \brief Contains all the boost::dll::import* reference counting
 /// functions that hold a shared pointer to the instance of
 /// boost::dll::shared_library.
 namespace boost { namespace dll {
 namespace detail {
     template <class T>
     class refc_function {
-        boost::shared_ptr<shared_library>   lib_;
+        SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<shared_library>   lib_;
         T*                                  func_ptr_;
     public:
-        refc_function(const boost::shared_ptr<shared_library>& lib, T* func_ptr) BOOST_NOEXCEPT
+        refc_function(const SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<shared_library>& lib, T* func_ptr) BOOST_NOEXCEPT
             : lib_(lib)
             , func_ptr_(func_ptr)
         {}
         operator T*() const BOOST_NOEXCEPT {
             return func_ptr_;
+        }
     };
     template <class T, class = void>
     struct import_type;
     template <class T>
     struct import_type<T, typename boost::disable_if<boost::is_object<T> >::type> {
         typedef boost::dll::detail::refc_function<T> base_type;
         typedef boost::function<
             typename boost::dll::detail::strip_calling_convention<T>::type
         > type;
     };
     template <class T>
     struct import_type<T, typename boost::enable_if<boost::is_object<T> >::type> {
         typedef boost::shared_ptr<T> base_type;
         typedef boost::shared_ptr<T> type;
         typedef SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<T> base_type;
         typedef SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<T> type;
     };
 } // namespace detail
 #ifndef BOOST_DLL_DOXYGEN
 #   define BOOST_DLL_IMPORT_RESULT_TYPE inline typename boost::dll::detail::import_type<T>::type
 #endif
 /*!
-* Returns boost::function<T> or boost::shared_ptr<T> that holds an imported function or variable
+* Returns boost::function<T> or SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<T> that holds an imported function or variable
 * from the loaded library and refcounts usage
 * of the loaded shared library, so that it won't get unload until all copies of return value
 * are not destroyed.
+*
 * This call will succeed if call to \forcedlink{shared_library}`::has(const char* )`
 * function with the same symbol name returned `true`.
+*
 * For importing symbols by \b alias names use \forcedlink{import_alias} method.
+*
 * \b Examples:
 * \code
 * boost::function<int(int)> f = import<int(int)>(
-*           boost::make_shared<shared_library>("test_lib.so"),
+*           SWIFTEN_SHRPTR_NAMESPACE::make_shared<shared_library>("test_lib.so"),
 *           "integer_func_name"
 *       );
 * \endcode
+*
 * \code
 * boost::function<int(int)> f = import<int(int)>("test_lib.so", "integer_func_name");
 * \endcode
+*
 * \code
-* boost::shared_ptr<int> i = import<int>("test_lib.so", "integer_name");
+* SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<int> i = import<int>("test_lib.so", "integer_name");
 * \endcode
+*
 * \b Template \b parameter \b T:    Type of the symbol that we are going to import. Must be explicitly specified.
+*
 * \param lib Path or shared pointer to library to load function from.
 * \param name Null-terminated C or C++ mangled name of the function to import. Can handle std::string, char*, const char*.
 * \param mode An mode that will be used on library load.
+*
-* \return boost::function<T> if T is a function type, or boost::shared_ptr<T> if T is an object type.
+* \return boost::function<T> if T is a function type, or SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<T> if T is an object type.
+*
 * \throw boost::system::system_error if symbol does not exist or if the DLL/DSO was not loaded.
 *       Overload that accepts path also throws std::bad_alloc in case of insufficient memory.
 */
 template <class T>
 BOOST_DLL_IMPORT_RESULT_TYPE import(const boost::filesystem::path& lib, const char* name,
     load_mode::type mode = load_mode::default_mode);
 //! \overload boost::dll::import(const boost::filesystem::path& lib, const char* name, load_mode::type mode)
 template <class T>
 BOOST_DLL_IMPORT_RESULT_TYPE import(const boost::filesystem::path& lib, const std::string& name,
     load_mode::type mode = load_mode::default_mode)
+{
     return boost::dll::import<T>(
-        boost::make_shared<boost::dll::shared_library>(lib, mode),
+        SWIFTEN_SHRPTR_NAMESPACE::make_shared<boost::dll::shared_library>(lib, mode),
         name.c_str()
     );
+}
 //! \overload boost::dll::import(const boost::filesystem::path& lib, const char* name, load_mode::type mode)
 template <class T>
-BOOST_DLL_IMPORT_RESULT_TYPE import(const boost::shared_ptr<shared_library>& lib, const char* name) {
+BOOST_DLL_IMPORT_RESULT_TYPE import(const SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<shared_library>& lib, const char* name) {
     typedef typename boost::dll::detail::import_type<T>::base_type type;
     return type(lib, &lib->get<T>(name));
+}
 //! \overload boost::dll::import(const boost::filesystem::path& lib, const char* name, load_mode::type mode)
 template <class T>
-BOOST_DLL_IMPORT_RESULT_TYPE import(const boost::shared_ptr<shared_library>& lib, const std::string& name) {
+BOOST_DLL_IMPORT_RESULT_TYPE import(const SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<shared_library>& lib, const std::string& name) {
     return boost::dll::import<T>(lib, name.c_str());
+}
 template <class T>
 BOOST_DLL_IMPORT_RESULT_TYPE import(const boost::filesystem::path& lib, const char* name, load_mode::type mode) {
     return boost::dll::import<T>(
-        boost::make_shared<boost::dll::shared_library>(lib, mode),
+        SWIFTEN_SHRPTR_NAMESPACE::make_shared<boost::dll::shared_library>(lib, mode),
         name
     );
+}
 /*!
-* Returns boost::function<T> or boost::shared_ptr<T> that holds an imported function or variable
+* Returns boost::function<T> or SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<T> that holds an imported function or variable
 * from the loaded library and refcounts usage
 * of the loaded shared library, so that it won't get unload until all copies of return value
 * are not destroyed.
+*
 * This call will succeed if call to \forcedlink{shared_library}`::has(const char* )`
 * function with the same symbol name returned `true`.
+*
 * For importing symbols by \b non \b alias names use \forcedlink{import} method.
+*
 * \b Examples:
 * \code
 * boost::function<int(int)> f = import_alias<int(int)>(
-*           boost::make_shared<shared_library>("test_lib.so"),
+*           SWIFTEN_SHRPTR_NAMESPACE::make_shared<shared_library>("test_lib.so"),
 *           "integer_func_alias_name"
 *       );
 * \endcode
+*
 * \code
 * boost::function<int(int)> f = import_alias<int(int)>("test_lib.so", "integer_func_alias_name");
 * \endcode
+*
 * \code
-* boost::shared_ptr<int> i = import_alias<int>("test_lib.so", "integer_alias_name");
+* SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<int> i = import_alias<int>("test_lib.so", "integer_alias_name");
 * \endcode
+*
 * \b Template \b parameter \b T:    Type of the symbol alias that we are going to import. Must be explicitly specified.
+*
 * \param lib Path or shared pointer to library to load function from.
 * \param name Null-terminated C or C++ mangled name of the function or variable to import. Can handle std::string, char*, const char*.
 * \param mode An mode that will be used on library load.
+*
-* \return boost::function<T> if T is a function type, or boost::shared_ptr<T> if T is an object type.
+* \return boost::function<T> if T is a function type, or SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<T> if T is an object type.
+*
 * \throw boost::system::system_error if symbol does not exist or if the DLL/DSO was not loaded.
 *       Overload that accepts path also throws std::bad_alloc in case of insufficient memory.
 */
 template <class T>
 BOOST_DLL_IMPORT_RESULT_TYPE import_alias(const boost::filesystem::path& lib, const char* name,
     load_mode::type mode = load_mode::default_mode);
 //! \overload boost::dll::import_alias(const boost::filesystem::path& lib, const char* name, load_mode::type mode)
 template <class T>
 BOOST_DLL_IMPORT_RESULT_TYPE import_alias(const boost::filesystem::path& lib, const std::string& name,
     load_mode::type mode = load_mode::default_mode)
+{
     return boost::dll::import_alias<T>(
-        boost::make_shared<boost::dll::shared_library>(lib, mode),
+        SWIFTEN_SHRPTR_NAMESPACE::make_shared<boost::dll::shared_library>(lib, mode),
         name.c_str()
     );
+}
 //! \overload boost::dll::import_alias(const boost::filesystem::path& lib, const char* name, load_mode::type mode)
 template <class T>
-BOOST_DLL_IMPORT_RESULT_TYPE import_alias(const boost::shared_ptr<shared_library>& lib, const std::string& name) {
+BOOST_DLL_IMPORT_RESULT_TYPE import_alias(const SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<shared_library>& lib, const std::string& name) {
     return boost::dll::import_alias<T>(lib, name.c_str());
+}
 //! \overload boost::dll::import_alias(const boost::filesystem::path& lib, const char* name, load_mode::type mode)
 template <class T>
-BOOST_DLL_IMPORT_RESULT_TYPE import_alias(const boost::shared_ptr<shared_library>& lib, const char* name) {
+BOOST_DLL_IMPORT_RESULT_TYPE import_alias(const SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<shared_library>& lib, const char* name) {
     typedef typename boost::dll::detail::import_type<T>::base_type type;
     return type(lib, lib->get<T*>(name));
+}
 template <class T>
 BOOST_DLL_IMPORT_RESULT_TYPE import_alias(const boost::filesystem::path& lib, const char* name, load_mode::type mode) {
     return boost::dll::import_alias<T>(
-        boost::make_shared<boost::dll::shared_library>(lib, mode),
+        SWIFTEN_SHRPTR_NAMESPACE::make_shared<boost::dll::shared_library>(lib, mode),
         name
     );
+}
 #undef BOOST_DLL_IMPORT_RESULT_TYPE
 }} // boost::dll
 #endif // BOOST_DLL_IMPORT_HPP

include/boost/dll/shared_library.hpp

➞

Show inline comments

@@ @@ -3,24 +3,27 @@ @@
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 #ifndef BOOST_DLL_SHARED_LIBRARY_HPP
 #define BOOST_DLL_SHARED_LIBRARY_HPP
 /// \file boost/dll/shared_library.hpp
 /// \brief Contains the boost::dll::shared_library class, core class for all the
 /// DLL/DSO operations.
 // Walkaround for compatibility with boost 1.54
 #include <boost/move/move.hpp>
 #include <boost/config.hpp>
 #include <boost/predef/os.h>
 #include <boost/utility/explicit_operator_bool.hpp>
 #include <boost/dll/detail/system_error.hpp>
 #include <boost/dll/detail/aggressive_ptr_cast.hpp>
 #if BOOST_OS_WINDOWS
 #   include <boost/dll/detail/windows/shared_library_impl.hpp>
 #else
 #   include <boost/dll/detail/posix/shared_library_impl.hpp>
 #endif

include/boost/signalslib.hpp

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Walkaroung for Boost, Qt namespace clash
+ *
  * Taken from boost documantation:
  * http://www.boost.org/doc/libs/1_55_0/doc/html/signals/s04.html
  */
 #ifndef SIGNALSLIB_HPP_INCLUDED
 #define SIGNALSLIB_HPP_INCLUDED
 #if defined(signals) && defined(QOBJECTDEFS_H) && \
   !defined(QT_MOC_CPP)
 #  undef signals
 #  define signals signals
 #endif
 #include <boost/signal.hpp>
 namespace boost
+{
   namespace signalslib = signals;
+}
 #if defined(signals) && defined(QOBJECTDEFS_H) && \
   !defined(QT_MOC_CPP)
 #  undef signals
 // Restore the macro definition of "signals", as it was
 // defined by Qt's <qobjectdefs.h>.
 #  define signals protected
 #endif
 #endif

include/transport/Config.h

➞

Show inline comments

@@ @@ -17,25 +17,25 @@ @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <boost/program_options.hpp>
 #include <boost/foreach.hpp>
 #include <boost/format.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/assign.hpp>
 #include <boost/bind.hpp>
-#include <boost/signal.hpp>
+#include <boost/signalslib.hpp>
 namespace Transport {
 template <class myType>
 const myType &safeAs(const boost::program_options::variable_value &var, const myType &def) {
 	try  {
 		return var.as<myType>();
+	}
 	catch(...) {
 		return def;
+	}
+}

include/transport/Conversation.h

➞

Show inline comments

@@ @@ -16,24 +16,25 @@ @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include <list>
 #include "Swiften/Elements/Message.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Transport {
 class ConversationManager;
 /// Represents one XMPP-Legacy network conversation.
 class Conversation {
 	public:
 		typedef enum {
 			PARTICIPANT_FLAG_NONE = 0,
 			PARTICIPANT_FLAG_MODERATOR = 1,
 			PARTICIPANT_FLAG_CONFLICT = 2,
@@ @@ -54,27 +55,27 @@ class Conversation { @@
 		/// Destructor.
 		virtual ~Conversation();
 		/// Returns legacy network name of this conversation.
 		/// \return legacy network name of this conversation.
 		const std::string &getLegacyName() { return m_legacyName; }
 		/// Handles new message from Legacy network and forwards it to XMPP.
 		/// \param message Message received from legacy network.
 		/// \param nickname For MUC conversation this is nickname of room participant who sent this message.
-		void handleMessage(boost::shared_ptr<Swift::Message> &message, const std::string &nickname = "");
+		void handleMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &message, const std::string &nickname = "");
-		void handleRawMessage(boost::shared_ptr<Swift::Message> &message);
+		void handleRawMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &message);
 		void handleRawPresence(Swift::Presence::ref presence);
 		/// Handles participant change in MUC.
 		/// \param nickname Nickname of participant which changed.
 		/// \param flag ParticipantFlag.
 		/// \param status Current status of this participant.
 		/// \param statusMessage Current status message of this participant.
 		/// \param newname If participant was renamed, this variable contains his new name.
 		void handleParticipantChanged(const std::string &nickname, ParticipantFlag flag, int status = Swift::StatusShow::None, const std::string &statusMessage = "", const std::string &newname = "", const std::string &iconhash = "", const std::string &alias = "");
 		/// Sets XMPP user nickname in MUC rooms.
@@ @@ -98,25 +99,25 @@ class Conversation { @@
 			m_jids.clear();
+		}
 		void removeJID(const Swift::JID &jid);
 		const std::list<Swift::JID> &getJIDs() {
 			return m_jids;
+		}
 		/// Sends message to Legacy network.
 		/// \param message Message.
-		virtual void sendMessage(boost::shared_ptr<Swift::Message> &message) = 0;
+		virtual void sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &message) = 0;
 		/// Returns ConversationManager associated with this Conversation.
 		/// \return  ConversationManager associated with this Conversation.
 		ConversationManager *getConversationManager() {
 			return m_conversationManager;
+		}
 		/// Returns True if this conversation is MUC room.
 		/// \return  True if this conversation is MUC room.
 		bool isMUC() {
@@ @@ -138,43 +139,43 @@ class Conversation { @@
 		void destroyRoom();
 		std::string getParticipants();
 		void sendParticipants(const Swift::JID &to, const std::string &nickname);
 		void sendCachedMessages(const Swift::JID &to = Swift::JID());
 		void setMUCEscaping(bool mucEscaping);
 	private:
 		Swift::Presence::ref generatePresence(const std::string &nick, int flag, int status, const std::string &statusMessage, const std::string &newname = "", const std::string &iconhash = "");
-		void cacheMessage(boost::shared_ptr<Swift::Message> &message);
+		void cacheMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &message);
 	private:
 		ConversationManager *m_conversationManager;
 		std::string m_legacyName;
 		std::string m_nickname;
 		std::string m_room;
 		bool m_muc;
 		Swift::JID m_jid;
 		std::list<Swift::JID> m_jids;
 		bool m_sentInitialPresence;
 		bool m_nicknameChanged;
 		bool m_mucEscaping;
 		bool m_sentInitialSubject;
 		// TODO: Move this to some extra class to cache the most used
 		// rooms across different accounts. Just now if we have 10 users
 		// connected to single room, we store all those things 10 times.
 		// It would be also great to store last 100 messages per room
 		// every time, so we can get history messages for IRC for example.
 		boost::shared_ptr<Swift::Message> m_subject;
 		std::list<boost::shared_ptr<Swift::Message> > m_cachedMessages;
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> m_subject;
 		std::list<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> > m_cachedMessages;
 		typedef struct {
 			Swift::Presence::ref presence;
 			std::string alias;
 		} Participant;
 		std::map<std::string, Participant> m_participants;
 };
+}

include/transport/FileTransferManager.h

➞

Show inline comments

@@ @@ -40,34 +40,34 @@ @@
 #endif
 namespace Transport {
 class UserManager;
 class User;
 class Component;
 class Buddy;
 class FileTransferManager {
 	public:
 		typedef struct Transfer {
-			boost::shared_ptr<Swift::OutgoingFileTransfer> ft;
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::OutgoingFileTransfer> ft;
 			Swift::JID from;
 			Swift::JID to;
-			boost::shared_ptr<Swift::ReadBytestream> readByteStream;
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ReadBytestream> readByteStream;
 		} Transfer;
 		FileTransferManager(Component *component, UserManager *userManager);
 		virtual ~FileTransferManager();
-		FileTransferManager::Transfer sendFile(User *user, Buddy *buddy, boost::shared_ptr<Swift::ReadBytestream> byteStream, const Swift::StreamInitiationFileInfo &info);
+		FileTransferManager::Transfer sendFile(User *user, Buddy *buddy, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ReadBytestream> byteStream, const Swift::StreamInitiationFileInfo &info);
 	private:
 		Component *m_component;
 		UserManager *m_userManager;
 		Swift::CombinedOutgoingFileTransferManager* m_outgoingFTManager;
 		Swift::RemoteJingleTransportCandidateSelectorFactory* m_remoteCandidateSelectorFactory;
 		Swift::LocalJingleTransportCandidateGeneratorFactory* m_localCandidateGeneratorFactory;
 		Swift::JingleSessionManager *m_jingleSessionManager;
 		Swift::SOCKS5BytestreamRegistry* m_bytestreamRegistry;
 #if HAVE_SWIFTEN_3
 		Swift::SOCKS5BytestreamServerManager* m_proxyServerManager;
 		Swift::SOCKS5BytestreamProxiesManager *m_proxyManager;

include/transport/Frontend.h

➞

Show inline comments

@@ @@ -21,24 +21,25 @@ @@
 #pragma once
 #include <string>
 #include <algorithm>
 #include <Swiften/EventLoop/EventLoop.h>
 #include <Swiften/Network/NetworkFactories.h>
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Elements/VCard.h"
 #include "Swiften/Elements/Message.h"
 #include "Swiften/Elements/IQ.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/SwiftenCompat.h"
 #include <boost/signal.hpp>
 namespace Transport {
 class Config;
 class UserRegistry;
 class Component;
 class User;
 class Buddy;
 class RosterManager;
 class UserManager;
@@ @@ -65,47 +66,47 @@ class Frontend { @@
 		virtual void init(Component *component, Swift::EventLoop *loop, Swift::NetworkFactories *factories, Config *config, UserRegistry *userRegistry) = 0;
 		virtual void connectToServer() = 0;
 		virtual void disconnectFromServer() = 0;
 		virtual void sendPresence(Swift::Presence::ref presence) = 0;
 		virtual void sendVCard(Swift::VCard::ref vcard, Swift::JID to) = 0;
 		virtual void sendRosterRequest(Swift::RosterPayload::ref, Swift::JID to) = 0;
-		virtual void sendMessage(boost::shared_ptr<Swift::Message> message) = 0;
+		virtual void sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message) = 0;
-		virtual void sendIQ(boost::shared_ptr<Swift::IQ>) = 0;
+		virtual void sendIQ(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ>) = 0;
-		virtual boost::shared_ptr<Swift::DiscoInfo> sendCapabilitiesRequest(Swift::JID to) = 0;
+		virtual SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> sendCapabilitiesRequest(Swift::JID to) = 0;
 		virtual void reconnectUser(const std::string &user) = 0;
 		virtual RosterManager *createRosterManager(User *user, Component *component) = 0;
 		virtual User *createUser(const Swift::JID &jid, UserInfo &userInfo, Component *component, UserManager *userManager) = 0;
 		virtual UserManager *createUserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend = NULL) = 0;
 		virtual void clearRoomList() = 0;
 		virtual void addRoomToRoomList(const std::string &handle, const std::string &name) = 0;
 		virtual std::string setOAuth2Code(const std::string &code, const std::string &state) { return "OAuth2 code is not needed for this frontend."; }
 		virtual std::string getOAuth2URL(const std::vector<std::string> &args) { return ""; }
 		virtual std::string getRegistrationFields() { return "Jabber ID\n3rd-party network username\n3rd-party network password"; }
 		virtual bool isRawXMLEnabled() { return false; }
 		boost::signal<void (User *, const std::string &name, unsigned int id)> onVCardRequired;
-		boost::signal<void (User *, boost::shared_ptr<Swift::VCard> vcard)> onVCardUpdated;
+		boost::signal<void (User *, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> vcard)> onVCardUpdated;
 		boost::signal<void (Buddy *, const Swift::RosterItemPayload &item)> onBuddyUpdated;
 		boost::signal<void (Buddy *)> onBuddyRemoved;
 		boost::signal<void (Buddy *, const Swift::RosterItemPayload &item)> onBuddyAdded;
 		boost::signal<void (Swift::Message::ref message)> onMessageReceived;
 		boost::signal<void (bool /* isAvailable */)> onAvailableChanged;
 		boost::signal<void (boost::shared_ptr<Swift::Presence>) > onPresenceReceived;
 		boost::signal<void (const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info)> onCapabilitiesReceived;
 		boost::signal<void (SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Presence>) > onPresenceReceived;
 		boost::signal<void (const Swift::JID& jid, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> info)> onCapabilitiesReceived;
 };
+}

include/transport/MemoryReadBytestream.h

➞

Show inline comments

@@ @@ -13,37 +13,39 @@ @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <string>
 #include <map>
 #include <boost/signal.hpp>
 #include "Swiften/FileTransfer/ReadBytestream.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Transport {
 class MemoryReadBytestream : public Swift::ReadBytestream {
 	public:
 		MemoryReadBytestream(unsigned long size);
 		virtual ~MemoryReadBytestream();
 		unsigned long appendData(const std::string &data);
-		virtual boost::shared_ptr<std::vector<unsigned char> > read(size_t size);
+		virtual SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<std::vector<unsigned char> > read(size_t size);
 		void setFinished() { m_finished = true; }
 		bool isFinished() const;
 		boost::signal<void ()> onDataNeeded;
 	private:
 		bool m_finished;
 		std::string m_data;
 		bool neededData;
 		unsigned long m_sent;
 		unsigned long m_size;

include/transport/NetworkPluginServer.h

➞

Show inline comments

@@ @@ -30,24 +30,25 @@ @@
 #include "Swiften/Elements/ChatState.h"
 #include "Swiften/Elements/RosterItemPayload.h"
 #include "Swiften/Elements/VCard.h"
 #include "Swiften/Elements/Message.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/Elements/IQ.h"
 #include "Swiften/Network/Timer.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h"
 #include "Swiften/Parser/XMPPParser.h"
 #include "Swiften/Parser/XMPPParserClient.h"
 #include "Swiften/Serializer/XMPPSerializer.h"
 #include "Swiften/SwiftenCompat.h"
 #include <Swiften/Version.h>
 #include <Swiften/FileTransfer/FileTransfer.h>
 #define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)
 #define NETWORK_PLUGIN_API_VERSION (1)
 namespace Transport {
 class UserManager;
 class User;
 class Component;
 class Buddy;
@@ @@ -59,25 +60,25 @@ class RosterResponder; @@
 class BlockResponder;
 class DummyReadBytestream;
 class AdminInterface;
 class FileTransferManager;
 class FileTransfer;
 class NetworkPluginServer : Swift::XMPPParserClient {
 	public:
 		struct Backend {
 			int pongReceived;
 			std::list<User *> users;
 			Swift::SafeByteArray data;
-			boost::shared_ptr<Swift::Connection> connection;
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> connection;
 			unsigned long res;
 			unsigned long init_res;
 			unsigned long shared;
 			bool acceptUsers;
 			bool longRun;
 			bool willDie;
 			std::string id;
 		};
 		NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager);
 		virtual ~NetworkPluginServer();
@@ @@ -95,31 +96,31 @@ class NetworkPluginServer : Swift::XMPPParserClient { @@
 		const std::list<Backend *> &getBackends() {
 			return m_clients;
+		}
 		const std::vector<std::string> &getCrashedBackends() {
 			return m_crashedBackends;
+		}
 		void collectBackend();
 		bool moveToLongRunBackend(User *user);
-		void handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &message);
+		void handleMessageReceived(NetworkConversation *conv, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &message);
 	public:
-		void handleNewClientConnection(boost::shared_ptr<Swift::Connection> c);
+		void handleNewClientConnection(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> c);
 		void handleSessionFinished(Backend *c);
 		void handlePongReceived(Backend *c);
-		void handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data);
+		void handleDataRead(Backend *c, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::SafeByteArray> data);
 		void handleConnectedPayload(const std::string &payload);
 		void handleDisconnectedPayload(const std::string &payload);
 		void handleBuddyChangedPayload(const std::string &payload);
 		void handleBuddyRemovedPayload(const std::string &payload);
 		void handleConvMessagePayload(const std::string &payload, bool subject = false);
 		void handleConvMessageAckPayload(const std::string &payload);
 		void handleParticipantChangedPayload(const std::string &payload);
 		void handleRoomChangedPayload(const std::string &payload);
 		void handleVCardPayload(const std::string &payload);
 		void handleChatStatePayload(const std::string &payload, Swift::ChatState::ChatStateType type);
 		void handleAuthorizationPayload(const std::string &payload);
@@ @@ -139,59 +140,59 @@ class NetworkPluginServer : Swift::XMPPParserClient { @@
 		void handleUserReadyToConnect(User *user);
 		void handleUserPresenceChanged(User *user, Swift::Presence::ref presence);
 		void handleUserDestroyed(User *user);
 		void handleBuddyUpdated(Buddy *buddy, const Swift::RosterItemPayload &item);
 		void handleBuddyRemoved(Buddy *buddy);
 		void handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item);
 		void handleUserBuddyAdded(User *user, Buddy *buddy);
 		void handleUserBuddyRemoved(User *user, Buddy *buddy);
 		void handleBlockToggled(Buddy *buddy);
-		void handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> vcard);
+		void handleVCardUpdated(User *user, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> vcard);
 		void handleVCardRequired(User *user, const std::string &name, unsigned int id);
 		void handleFTStateChanged(Swift::FileTransfer::State state, const std::string &userName, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long id);
 		void handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID);
 		void handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size);
 		void handleFTDataNeeded(Backend *b, unsigned long ftid);
 		void handlePIDTerminated(unsigned long pid);
 	private:
-		void send(boost::shared_ptr<Swift::Connection> &, const std::string &data);
+		void send(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> &, const std::string &data);
 		void pingTimeout();
 		void sendPing(Backend *c);
 		void sendAPIVersion(Backend *c);
 		Backend *getFreeClient(bool acceptUsers = true, bool longRun = false, bool check = false);
 		void connectWaitingUsers();
 		void loginDelayFinished();
 		void handleRawIQReceived(boost::shared_ptr<Swift::IQ> iq);
 		void handleRawPresenceReceived(boost::shared_ptr<Swift::Presence> presence);
 		void handleRawIQReceived(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq);
 		void handleRawPresenceReceived(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Presence> presence);
 		void handleStreamStart(const Swift::ProtocolHeader&) {}
 #if HAVE_SWIFTEN_3
-		void handleElement(boost::shared_ptr<Swift::ToplevelElement> element);
+		void handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ToplevelElement> element);
 #else
-		void handleElement(boost::shared_ptr<Swift::Element> element);
+		void handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element> element);
 #endif
 		void handleStreamEnd() {}
 		UserManager *m_userManager;
 		VCardResponder *m_vcardResponder;
 		RosterResponder *m_rosterResponder;
 		BlockResponder *m_blockResponder;
 		Config *m_config;
-		boost::shared_ptr<Swift::ConnectionServer> m_server;
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ConnectionServer> m_server;
 		std::list<Backend *>  m_clients;
 		std::vector<unsigned long> m_pids;
 		Swift::Timer::ref m_pingTimer;
 		Swift::Timer::ref m_collectTimer;
 		Swift::Timer::ref m_loginTimer;
 		Component *m_component;
 		std::list<User *> m_waitingUsers;
 		bool m_isNextLongRun;
 		std::map<unsigned long, FileTransferManager::Transfer> m_filetransfers;
 		FileTransferManager *m_ftManager;
 		std::vector<std::string> m_crashedBackends;
 		AdminInterface *m_adminInterface;

include/transport/PresenceOracle.h

➞

Show inline comments

@@ @@ -13,30 +13,30 @@ @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <map>
 #include <boost/signals.hpp>
 #include <string>
 #include <Swiften/Elements/Presence.h>
 #include <Swiften/Client/StanzaChannel.h>
 #include <Swiften/Base/boost_bsignals.h>
 namespace Transport {
 class Frontend;
 class PresenceOracle {
 	public:
 		PresenceOracle(Frontend* frontend);
 		~PresenceOracle();
 		Swift::Presence::ref getLastPresence(const Swift::JID&) const;
 		Swift::Presence::ref getHighestPriorityPresence(const Swift::JID& bareJID) const;
 		std::vector<Swift::Presence::ref> getAllPresence(const Swift::JID& bareJID) const;

include/transport/RosterManager.h

➞

Show inline comments

@@ @@ -14,24 +14,25 @@ @@
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include <map>
 #include <boost/signal.hpp>
 #include <boost/pool/pool_alloc.hpp>
 #include <boost/pool/object_pool.hpp>
 // #include "rosterstorage.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Queries/GenericRequest.h"
 #include "Swiften/Roster/SetRosterRequest.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/Network/Timer.h"
 namespace Transport {
 class Buddy;

include/transport/Transport.h

➞

Show inline comments

@@ @@ -12,31 +12,33 @@ @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <vector>
 #include <boost/signal.hpp>
 #include <boost/bind.hpp>
 #include "Swiften/Network/BoostTimerFactory.h"
 #include "Swiften/Network/BoostIOServiceThread.h"
 #include "Swiften/Network/NetworkFactories.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/Elements/IQ.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Transport {
 	class StorageBackend;
 	class Factory;
 	class UserRegistry;
 	class Frontend;
 	class PresenceOracle;
 	class Factory;
 	class Config;
 	class UserManager;
 	class AdminInterface;
@@ @@ -99,25 +101,25 @@ namespace Transport { @@
 			boost::signal<void ()> onConnected;
 			/// This signal is emitted when XML stanza is sent to server.
 			Config *getConfig() { return m_config; }
 			/// It's emitted only for presences addressed to transport itself
 			/// (for example to="j2j.domain.tld") and for presences comming to
 			/// MUC (for example to="#chat%irc.freenode.org@irc.domain.tld")
 			/// \param presence Presence.
 			boost::signal<void (Swift::Presence::ref presence)> onUserPresenceReceived;
-			boost::signal<void (boost::shared_ptr<Swift::IQ>)> onRawIQReceived;
+			boost::signal<void (SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ>)> onRawIQReceived;
 			boost::signal<void ()> onAdminInterfaceSet;
 			void handlePresence(Swift::Presence::ref presence);
 			void handleConnected();
 			void handleConnectionError(const std::string &error);
 			void handleDataRead(const std::string &data);
 			void handleDataWritten(const std::string &data);
 			Frontend *getFrontend() {
 				return m_frontend;
+			}
@@ @@ -125,25 +127,25 @@ namespace Transport { @@
 			PresenceOracle *getPresenceOracle();
 			void setAdminInterface(AdminInterface *adminInterface) {
 				m_adminInterface = adminInterface;
 				onAdminInterfaceSet();
+			}
 			AdminInterface *getAdminInterface() {
 				return m_adminInterface;
+			}
 		private:
-			void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);
+			void handleDiscoInfoResponse(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);
 			void handleCapsChanged(const Swift::JID& jid);
 			void handleBackendConfigChanged();
 			Swift::NetworkFactories *m_factories;
 			Swift::Timer::ref m_reconnectTimer;
 			PresenceOracle *m_presenceOracle;
 			Transport::UserRegistry *m_userRegistry;
 			StorageBackend *m_storageBackend;
 			int m_reconnectCount;
 			Config* m_config;

include/transport/User.h

➞

Show inline comments

@@ @@ -11,34 +11,36 @@ @@
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <boost/signal.hpp>
 #include <time.h>
 #include "transport/StorageBackend.h"
 #include <Swiften/FileTransfer/OutgoingFileTransfer.h>
 #include "Swiften/Elements/SpectrumErrorPayload.h"
 #include "Swiften/JID/JID.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/Elements/Message.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "Swiften/Network/Timer.h"
 #include "Swiften/Network/Connection.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Transport {
 class Component;
 class RosterManager;
 class ConversationManager;
 class UserManager;
 class PresenceOracle;
 /// Represents online XMPP user.
 class User {
 	public:
@@ @@ -80,25 +82,25 @@ class User { @@
 		virtual void addRoomToRoomList(const std::string &handle, const std::string &name) {}
 		virtual void requestVCard() {}
 		void setData(void *data) { m_data = data; }
 		void *getData() { return m_data; }
 		/// Handles presence from XMPP JID associated with this user.
 		/// \param presence Swift::Presence.
 		void handlePresence(Swift::Presence::ref presence, bool forceJoin = false);
 		void handleSubscription(Swift::Presence::ref presence);
-		void handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info);
+		void handleDiscoInfo(const Swift::JID& jid, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> info);
 		time_t &getLastActivity() {
 			return m_lastActivity;
+		}
 		void updateLastActivity() {
 			m_lastActivity = time(NULL);
+		}
 		/// Returns language.
 		/// \return language
 		const char *getLang() { return "en"; }
@@ @@ -160,26 +162,26 @@ class User { @@
 		Swift::JID m_jid;
 		Component *m_component;
 		RosterManager *m_rosterManager;
 		UserManager *m_userManager;
 		ConversationManager *m_conversationManager;
 		PresenceOracle *m_presenceOracle;
 		UserInfo m_userInfo;
 		void *m_data;
 		bool m_connected;
 		bool m_readyForConnect;
 		bool m_ignoreDisconnect;
 		Swift::Timer::ref m_reconnectTimer;
-		boost::shared_ptr<Swift::Connection> connection;
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> connection;
 		time_t m_lastActivity;
 		std::map<Swift::JID, Swift::DiscoInfo::ref> m_legacyCaps;
-		std::vector<boost::shared_ptr<Swift::OutgoingFileTransfer> > m_filetransfers;
+		std::vector<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::OutgoingFileTransfer> > m_filetransfers;
 		int m_resources;
 		int m_reconnectCounter;
 		std::list<Swift::Presence::ref> m_joinedRooms;
 		std::map<std::string, std::string> m_settings;
 		bool m_cacheMessages;
 		int m_reconnectLimit;
 		StorageBackend *m_storageBackend;
 };
+}

include/transport/UserManager.h

➞

Show inline comments

@@ @@ -11,33 +11,35 @@ @@
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <boost/signal.hpp>
 #include <string>
 #include <map>
 #include "Swiften/Elements/Message.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/JID/JID.h"
 #include "Swiften/Disco/EntityCapsProvider.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "Swiften/Elements/VCard.h"
 #include "Swiften/Network/Timer.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Transport {
 class User;
 class Component;
 class StorageBackend;
 class StorageResponder;
 class RosterResponder;
 class UserRegistration;
 class UserRegistry;
 /// Manages online XMPP Users.
 		unsigned long getMessagesToBackend() { return m_sentToBackend; }
 	private:
 		void handlePresence(Swift::Presence::ref presence);
 		void handleMessageReceived(Swift::Message::ref message);
 		void handleGeneralPresenceReceived(Swift::Presence::ref presence);
 		void handleProbePresence(Swift::Presence::ref presence);
 		void handleErrorPresence(Swift::Presence::ref presence);
 		void handleSubscription(Swift::Presence::ref presence);
 		void handleMUCPresence(Swift::Presence::ref presence);
 		void handleRemoveTimeout(const std::string jid, User *user, bool reconnect);
-		void handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info);
+		void handleDiscoInfo(const Swift::JID& jid, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> info);
 		void addUser(User *user);
 		long m_onlineBuddies;
 		User *m_cachedUser;
 		std::map<std::string, User *> m_users;
 		Component *m_component;
 		StorageBackend *m_storageBackend;
 		StorageResponder *m_storageResponder;
 		UserRegistry *m_userRegistry;
 		Swift::Timer::ref m_removeTimer;
 		unsigned long m_sentToXMPP;
 		unsigned long m_sentToBackend;

include/transport/WebSocketClient.h

➞

Show inline comments

@@ @@ -22,24 +22,25 @@ @@
 #include <Swiften/Network/TLSConnectionFactory.h>
 #include <Swiften/Network/HostAddressPort.h>
 #include <Swiften/TLS/PlatformTLSFactories.h>
 #include <Swiften/Network/DomainNameResolveError.h>
 #include <Swiften/Network/DomainNameAddressQuery.h>
 #include <Swiften/Network/DomainNameResolver.h>
 #include <Swiften/Network/HostAddress.h>
 #include <Swiften/Network/Connection.h>
 #include <Swiften/Base/SafeByteArray.h>
 #include "Swiften/Version.h"
 #include "Swiften/Network/Timer.h"
 #include "Swiften/SwiftenCompat.h"
 #define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)
 #if HAVE_SWIFTEN_3
 #include <Swiften/TLS/TLSOptions.h>
 #endif
 #include <string>
 #include <algorithm>
 #include <map>
 #include <boost/signal.hpp>
@@ @@ -57,33 +58,33 @@ class WebSocketClient { @@
 		void connectServer(const std::string &u);
 		void disconnectServer();
 		void write(const std::string &data);
 		boost::signal<void (const std::string &payload)> onPayloadReceived;
 		boost::signal<void ()> onWebSocketConnected;
 		boost::signal<void (const boost::optional<Swift::Connection::Error> &error)> onWebSocketDisconnected;
 	private:
 		void handleDNSResult(const std::vector<Swift::HostAddress>&, boost::optional<Swift::DomainNameResolveError>);
-		void handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data);
+		void handleDataRead(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::SafeByteArray> data);
 		void handleConnected(bool error);
 		void handleDisconnected(const boost::optional<Swift::Connection::Error> &error);
 		void connectServer();
 	private:
 		Component *m_component;
 		boost::shared_ptr<Swift::DomainNameAddressQuery> m_dnsQuery;
 		boost::shared_ptr<Swift::Connection> m_conn;
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DomainNameAddressQuery> m_dnsQuery;
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> m_conn;
 		Swift::TLSConnectionFactory *m_tlsConnectionFactory;
 		Swift::PlatformTLSFactories *m_tlsFactory;
 		std::string m_host;
 		std::string m_path;
 		std::string m_buffer;
 		bool m_upgraded;
 		Swift::Timer::ref m_reconnectTimer;
 		std::string m_user;
 };
+}

libtransport/Buddy.cpp

➞

Show inline comments

 		presence->setStatus(statusMessage);
 	if (s.getType() == Swift::StatusShow::None)
 		presence->setType(Swift::Presence::Unavailable);
 	presence->setShow(s.getType());
 	if (presence->getType() != Swift::Presence::Unavailable) {
 		// caps
 // 		if (features & 0/*TRANSPORT_FEATURE_AVATARS*/) {
-			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::VCardUpdate (getIconHash())));
+			presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::VCardUpdate (getIconHash())));
 // 		}
 // 		if (isBlocked()) {
-// 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Transport::BlockPayload ()));
+// 			presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Transport::BlockPayload ()));
 // 		}
+	}
 	BOOST_FOREACH(Swift::Presence::ref &p, m_presences) {
 		if (p->getFrom() == presence->getFrom()) {
 			p = presence;
 			return m_presences;
+		}
+	}
 	m_presences.push_back(presence);

libtransport/CMakeLists.txt

➞

Show inline comments

@@ @@ -50,16 +50,17 @@ if (WIN32) @@
 	TARGET_LINK_LIBRARIES(transport transport-plugin sqlite3 ${PQXX_LIBRARY} ${CURL_LIBRARIES} ${PQ_LIBRARY} ${MYSQL_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES} ${PROTOBUF_LIBRARY} psapi.lib)
 else()
 	TARGET_LINK_LIBRARIES(transport transport-plugin ${PQXX_LIBRARY} ${CURL_LIBRARIES} ${PQ_LIBRARY} ${SQLITE3_LIBRARIES} ${MYSQL_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES} ${POPT_LIBRARY} ${PROTOBUF_LIBRARY})
 endif()
 SET_TARGET_PROPERTIES(transport PROPERTIES
       VERSION ${TRANSPORT_VERSION} SOVERSION ${TRANSPORT_VERSION}
+)
 if (APPLE)
 	TARGET_LINK_LIBRARIES(transport ${APPLE_FRAMEWORKS})
 endif()
 INSTALL(TARGETS transport LIBRARY DESTINATION ${LIB_INSTALL_DIR} ARCHIVE DESTINATION ${LIB_INSTALL_DIR} COMPONENT libraries)
 #CONFIGURE_FILE(transport.pc.in "${CMAKE_CURRENT_BINARY_DIR}/transport.pc")
 #INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/transport.pc" DESTINATION lib/pkgconfig)

libtransport/Conversation.cpp

➞

Show inline comments

@@ @@ -79,49 +79,49 @@ void Conversation::destroyRoom() { @@
 		item.actor = "Transport";
 		item.reason = "Spectrum 2 transport is being shut down.";
 		Swift::MUCUserPayload *p = new Swift::MUCUserPayload ();
 		p->addItem(item);
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 332;
 		p->addStatusCode(c);
 		Swift::MUCUserPayload::StatusCode c2;
 		c2.code = 307;
 		p->addStatusCode(c2);
-		presence->addPayload(boost::shared_ptr<Swift::Payload>(p));
+		presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(p));
 		BOOST_FOREACH(const Swift::JID &jid, m_jids) {
 			presence->setTo(jid);
 			m_conversationManager->getComponent()->getFrontend()->sendPresence(presence);
+		}
+	}
+}
 void Conversation::setRoom(const std::string &room) {
 	m_room = room;
 	m_legacyName = m_room + "/" + m_legacyName;
+}
-void Conversation::cacheMessage(boost::shared_ptr<Swift::Message> &message) {
+void Conversation::cacheMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &message) {
 	boost::posix_time::ptime timestamp = boost::posix_time::second_clock::universal_time();
-	boost::shared_ptr<Swift::Delay> delay(boost::make_shared<Swift::Delay>());
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Delay> delay(SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::Delay>());
 	delay->setStamp(timestamp);
 	message->addPayload(delay);
 	m_cachedMessages.push_back(message);
 	if (m_cachedMessages.size() > 100) {
 		m_cachedMessages.pop_front();
+	}
+}
-void Conversation::handleRawMessage(boost::shared_ptr<Swift::Message> &message) {
+void Conversation::handleRawMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &message) {
 	if (message->getType() != Swift::Message::Groupchat) {
 		if (m_conversationManager->getComponent()->inServerMode() && m_conversationManager->getUser()->shouldCacheMessages()) {
 			cacheMessage(message);
+		}
 		else {
 			m_conversationManager->getComponent()->getFrontend()->sendMessage(message);
+		}
+	}
 	else {
 		if (m_jids.empty()) {
 			cacheMessage(message);
+		}
 						return;
+					}
 					else {
 						LOG4CXX_INFO(logger, m_jid.toString() << ": Forwarding subject message.");
+					}
+				}
 				m_conversationManager->getComponent()->getFrontend()->sendMessage(message);
+			}
+		}
+	}
+}
-void Conversation::handleMessage(boost::shared_ptr<Swift::Message> &message, const std::string &nickname) {
+void Conversation::handleMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &message, const std::string &nickname) {
 	if (m_muc) {
 		message->setType(Swift::Message::Groupchat);
+	}
 	else {
 		if (message->getType() == Swift::Message::Headline) {
 			if (m_conversationManager->getUser()->getUserSetting("send_headlines") != "1") {
 				message->setType(Swift::Message::Chat);
+			}
+		}
 		else {
 			message->setType(Swift::Message::Chat);
+		}
 	// Self presence has to be sent as first.
 	Swift::Presence::ref presence = generatePresence(m_nickname, 0, (int) Swift::StatusShow::Online, "", "", "");
 	presence->setTo(to);
 	m_conversationManager->getComponent()->getFrontend()->sendPresence(presence);
 	for (std::map<std::string, Participant>::iterator it = m_participants.begin(); it != m_participants.end(); it++) {
 		(*it).second.presence->setTo(to);
 		m_conversationManager->getComponent()->getFrontend()->sendPresence((*it).second.presence);
+	}
+}
 void Conversation::sendCachedMessages(const Swift::JID &to) {
-	for (std::list<boost::shared_ptr<Swift::Message> >::const_iterator it = m_cachedMessages.begin(); it != m_cachedMessages.end(); it++) {
+	for (std::list<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> >::const_iterator it = m_cachedMessages.begin(); it != m_cachedMessages.end(); it++) {
 		if (to.isValid()) {
 			(*it)->setTo(to);
+		}
 		else {
 			(*it)->setTo(m_jid.toBare());
+		}
 		m_conversationManager->getComponent()->getFrontend()->sendMessage(*it);
+	}
 	if (m_subject) {
 		if (to.isValid()) {
 			m_subject->setTo(to);
 	if (s.getType() == Swift::StatusShow::None) {
 		presence->setType(Swift::Presence::Unavailable);
+	}
 	presence->setShow(s.getType());
 	Swift::MUCUserPayload *p = new Swift::MUCUserPayload ();
 	if (m_nickname == nickname) {
 		if (flag & PARTICIPANT_FLAG_CONFLICT) {
 			delete p;
 			presence->setType(Swift::Presence::Error);
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::Conflict)));
 			presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 			presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::Conflict)));
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Generating error presence: PARTICIPANT_FLAG_CONFLICT");
 			return presence;
+		}
 		else if (flag & PARTICIPANT_FLAG_NOT_AUTHORIZED) {
 			delete p;
 			presence->setType(Swift::Presence::Error);
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::NotAuthorized, Swift::ErrorPayload::Auth, statusMessage)));
 			presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 			presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::NotAuthorized, Swift::ErrorPayload::Auth, statusMessage)));
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Generating error presence: PARTICIPANT_FLAG_NOT_AUTHORIZED");
 			return presence;
+		}
 		else if (flag & PARTICIPANT_FLAG_ROOM_NOT_FOUD) {
 			delete p;
 			presence->setType(Swift::Presence::Error);
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::ItemNotFound, Swift::ErrorPayload::Cancel, statusMessage)));
 			presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 			presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::ItemNotFound, Swift::ErrorPayload::Cancel, statusMessage)));
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Generating error presence: PARTICIPANT_FLAG_ROOM_NOT_FOUND");
 			return presence;
+		}
 		else {
 			Swift::MUCUserPayload::StatusCode c;
 			c.code = 110;
 			p->addStatusCode(c);
 			if (m_nicknameChanged) {
 				Swift::MUCUserPayload::StatusCode c;
 				c.code = 210;
 				p->addStatusCode(c);
 				m_nicknameChanged = false;
 		item.role = Swift::MUCOccupant::Moderator;
+	}
 	if (!newname.empty()) {
 		item.nick = newname;
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 303;
 		p->addStatusCode(c);
 		presence->setType(Swift::Presence::Unavailable);
+	}
 	if (!iconhash.empty()) {
-		presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::VCardUpdate (iconhash)));
+		presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::VCardUpdate (iconhash)));
+	}
 	p->addItem(item);
-	presence->addPayload(boost::shared_ptr<Swift::Payload>(p));
+	presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(p));
 	return presence;
+}
 void Conversation::setNickname(const std::string &nickname) {
 	if (!nickname.empty() && m_nickname != nickname) {
 		m_nicknameChanged = true;
+	}
 	m_nickname = nickname;
+}
 void Conversation::handleRawPresence(Swift::Presence::ref presence) {

libtransport/FileTransferManager.cpp

➞

Show inline comments

 // 	m_jingleSessionManager = new Swift::JingleSessionManager(m_component->getIQRouter());
 // #if !HAVE_SWIFTEN_3
 // 	m_connectivityManager = new Swift::ConnectivityManager(m_component->getNetworkFactories()->getNATTraverser());
 // #endif
 // 	m_bytestreamRegistry = new Swift::SOCKS5BytestreamRegistry();
 // #if !HAVE_SWIFTEN_3
 // 	m_bytestreamProxy = new Swift::SOCKS5BytestreamProxy(m_component->getNetworkFactories()->getConnectionFactory(), m_component->getNetworkFactories()->getTimerFactory());
 // 	m_localCandidateGeneratorFactory = new Swift::DefaultLocalJingleTransportCandidateGeneratorFactory(m_connectivityManager, m_bytestreamRegistry, m_bytestreamProxy, "thishouldnotbeused");
 // 	m_remoteCandidateSelectorFactory = new Swift::DefaultRemoteJingleTransportCandidateSelectorFactory(m_component->getNetworkFactories()->getConnectionFactory(), m_component->getNetworkFactories()->getTimerFactory());
 // #else
 // 	m_proxyManager = new Swift::SOCKS5BytestreamProxiesManager(m_component->getNetworkFactories()->getConnectionFactory(), m_component->getNetworkFactories()->getTimerFactory(), m_component->getNetworkFactories()->getDomainNameResolver(), m_component->getIQRouter(), "bar.com");
 // #endif
-// 	boost::shared_ptr<Swift::ConnectionServer> server = m_component->getNetworkFactories()->getConnectionServerFactory()->createConnectionServer(19645);
+// 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ConnectionServer> server = m_component->getNetworkFactories()->getConnectionServerFactory()->createConnectionServer(19645);
 // 	server->start();
 // #if HAVE_SWIFTEN_3
 // 	m_proxyServerManager = new Swift::SOCKS5BytestreamServerManager(m_bytestreamRegistry, m_component->getNetworkFactories()->getConnectionServerFactory(), m_component->getNetworkFactories()->getNetworkEnvironment(), m_component->getNetworkFactories()->getNATTraverser());
 // #else
 // 	m_bytestreamServer = new Swift::SOCKS5BytestreamServer(server, m_bytestreamRegistry);
 // 	m_bytestreamServer->start();
 // 	m_outgoingFTManager = new Swift::CombinedOutgoingFileTransferManager(m_jingleSessionManager, m_component->getIQRouter(),
 // 		m_userManager, m_remoteCandidateSelectorFactory,
 // 		m_localCandidateGeneratorFactory, m_bytestreamRegistry,
 // 		m_bytestreamProxy, m_component->getPresenceOracle(),
 // 		m_bytestreamServer);
 // #endif
@@ @@ -73,25 +73,25 @@ FileTransferManager::~FileTransferManager() { @@
 // 	delete m_localCandidateGeneratorFactory;
 // #endif
 // 	delete m_outgoingFTManager;
 // 	delete m_jingleSessionManager;
 // 	delete m_bytestreamRegistry;
 // #if !HAVE_SWIFTEN_3
 // 	delete m_bytestreamServer;
 // 	delete m_bytestreamProxy;
 // 	delete m_connectivityManager;
 // #endif
+}
-FileTransferManager::Transfer FileTransferManager::sendFile(User *user, Buddy *buddy, boost::shared_ptr<Swift::ReadBytestream> byteStream, const Swift::StreamInitiationFileInfo &info) {
+FileTransferManager::Transfer FileTransferManager::sendFile(User *user, Buddy *buddy, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ReadBytestream> byteStream, const Swift::StreamInitiationFileInfo &info) {
  	FileTransferManager::Transfer transfer;
 // 	transfer.from = buddy->getJID();
 // 	transfer.to = user->getJID();
 // 	transfer.readByteStream = byteStream;
 //
 // 	LOG4CXX_INFO(logger, "Starting FT from '" << transfer.from << "' to '" << transfer.to << "'")
 //
 // 	transfer.ft = m_outgoingFTManager->createOutgoingFileTransfer(transfer.from, transfer.to, transfer.readByteStream, info);
 // // 	if (transfer.ft) {
 // // 		m_filetransfers.push_back(ft);
 // // 		ft->onStateChange.connect(boost::bind(&User::handleFTStateChanged, this, _1, Buddy::JIDToLegacyName(from), info.getName(), info.getSize(), id));
 // // 		transfer.ft->start();

libtransport/MemoryReadByteStream.cpp

➞

Show inline comments

 MemoryReadBytestream::~MemoryReadBytestream() {
+}
 unsigned long MemoryReadBytestream::appendData(const std::string &data) {
 	m_data += data;
 	onDataAvailable();
 	neededData = false;
 	return m_data.size();
+}
-boost::shared_ptr<std::vector<unsigned char> > MemoryReadBytestream::read(size_t size) {
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<std::vector<unsigned char> > MemoryReadBytestream::read(size_t size) {
 	if (m_data.empty()) {
 		onDataNeeded();
-		return boost::shared_ptr<std::vector<unsigned char> >(new std::vector<unsigned char>());
+		return SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<std::vector<unsigned char> >(new std::vector<unsigned char>());
+	}
 	if (m_data.size() < size) {
-		boost::shared_ptr<std::vector<unsigned char> > ptr(new std::vector<unsigned char>(m_data.begin(), m_data.end()));
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<std::vector<unsigned char> > ptr(new std::vector<unsigned char>(m_data.begin(), m_data.end()));
 		m_sent += m_data.size();
 		m_data.clear();
 		if (m_sent == m_size)
 			m_finished = true;
 		onDataNeeded();
 		return ptr;
+	}
-	boost::shared_ptr<std::vector<unsigned char> > ptr(new std::vector<unsigned char>(m_data.begin(), m_data.begin() + size));
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<std::vector<unsigned char> > ptr(new std::vector<unsigned char>(m_data.begin(), m_data.begin() + size));
 	m_data.erase(m_data.begin(), m_data.begin() + size);
 	m_sent += size;
 	if (m_sent == m_size)
 		m_finished = true;
 	if (m_data.size() < 500000 && !neededData) {
 		neededData = true;
 		onDataNeeded();
+	}
 	return ptr;
+}
 bool MemoryReadBytestream::isFinished() const {

libtransport/MySQLBackend.cpp

➞

Show inline comments

@@ @@ -77,26 +77,24 @@ @@
 	if (ret == 0) \
 		exec_ok = true; \
 	else if (ret == 2013) { \
 		LOG4CXX_INFO(logger, "MySQL connection lost. Reconnecting...");\
 		disconnect(); \
 		connect(); \
 		return METHOD; \
 	} \
 	else \
 		exec_ok = false; \
+	}
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "MySQLBackend");
 static bool exec_ok;
 MySQLBackend::Statement::Statement(MYSQL *conn, const std::string &format, const std::string &statement) {
 	m_resultOffset = -1;
 	m_conn = conn;
 	m_offset = 0;
 	m_string = statement;
 	m_stmt = mysql_stmt_init(conn);
 	if (mysql_stmt_prepare(m_stmt, statement.c_str(), statement.size())) {

libtransport/NetworkPluginServer.cpp

➞

Show inline comments

@@ @@ -74,29 +74,29 @@ static unsigned long backend_id; @@
 static unsigned long bytestream_id;
 DEFINE_LOGGER(logger, "NetworkPluginServer");
 static NetworkPluginServer *_server;
 class NetworkConversation : public Conversation {
 	public:
 		NetworkConversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false) : Conversation(conversationManager, legacyName, muc) {
+		}
 		// Called when there's new message to legacy network from XMPP network
-		void sendMessage(boost::shared_ptr<Swift::Message> &message) {
+		void sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &message) {
 			onMessageToSend(this, message);
+		}
-		boost::signal<void (NetworkConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;
+		boost::signal<void (NetworkConversation *, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &)> onMessageToSend;
 };
 class NetworkFactory : public Factory {
 	public:
 		NetworkFactory(NetworkPluginServer *nps) {
 			m_nps = nps;
+		}
 		virtual ~NetworkFactory() {}
 		// Creates new conversation (NetworkConversation in this case)
 		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMuc) {
@@ @@ -380,25 +380,25 @@ void NetworkPluginServer::start() { @@
 		signal(SIGCHLD, SigCatcher);
 #endif
 		// quit the while loop
 		break;
+	}
+}
 void NetworkPluginServer::loginDelayFinished() {
 	m_loginTimer->stop();
 	connectWaitingUsers();
+}
-void NetworkPluginServer::handleNewClientConnection(boost::shared_ptr<Swift::Connection> c) {
+void NetworkPluginServer::handleNewClientConnection(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> c) {
 	// Create new Backend instance
 	Backend *client = new Backend;
 	client->pongReceived = -1;
 	client->connection = c;
 	client->res = 0;
 	client->init_res = 0;
 	client->shared = 0;
 	// Until we receive first PONG from backend, backend is in willDie state.
 	client->willDie = true;
 	// Backend does not accept new clients automatically if it's long-running
 	client->acceptUsers = !m_isNextLongRun;
 	client->longRun = m_isNextLongRun;
 	user->handleDisconnected(payload.message(), (Swift::SpectrumErrorPayload::Error) payload.error());
+}
 void NetworkPluginServer::handleVCardPayload(const std::string &data) {
 	pbnetwork::VCard payload;
 	if (payload.ParseFromString(data) == false) {
 		std::cout << "PARSING ERROR\n";
 		// TODO: ERROR
 		return;
+	}
 	std::string field;
-	boost::shared_ptr<Swift::VCard> vcard(new Swift::VCard());
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> vcard(new Swift::VCard());
 	utf8::replace_invalid(payload.fullname().begin(), payload.fullname().end(), std::back_inserter(field), '_');
 	vcard->setFullName(field);
 	field.clear();
 	utf8::replace_invalid(payload.nickname().begin(), payload.nickname().end(), std::back_inserter(field), '_');
 	vcard->setNickname(field);
 	vcard->setPhoto(Swift::createByteArray(payload.photo()));
 	m_userManager->sendVCard(payload.id(), vcard);
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	// We're not creating new Conversation just because of chatstates.
 	// Some networks/clients spams with chatstates a lot and it leads to bigger memory usage.
 	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());
 	if (!conv) {
 		return;
+	}
 	// Forward chatstate
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->addPayload(boost::make_shared<Swift::ChatState>(type));
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->addPayload(SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::ChatState>(type));
 	conv->handleMessage(msg);
+}
 void NetworkPluginServer::handleBuddyChangedPayload(const std::string &data) {
 	pbnetwork::Buddy payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user) {
 		LOG4CXX_ERROR(logger, "handleConvMessagePayload: unknown username " << payload.username());
 		return;
+	}
 	// Message from legacy network triggers network acticity
 	user->updateLastActivity();
 	// Set proper body.
-	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 	if (subject) {
 		msg->setSubject(payload.message());
+	}
 	else {
 		msg->setBody(payload.message());
+	}
 	if (payload.headline()) {
 		msg->setType(Swift::Message::Headline);
+	}
 	// Add xhtml-im payload.
 	if (CONFIG_BOOL(m_config, "service.enable_xhtml") && !payload.xhtml().empty()) {
-		msg->addPayload(boost::make_shared<Swift::XHTMLIMPayload>(payload.xhtml()));
+		msg->addPayload(SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::XHTMLIMPayload>(payload.xhtml()));
+	}
 	if (!payload.timestamp().empty()) {
 		boost::posix_time::ptime timestamp = boost::posix_time::from_iso_string(payload.timestamp());
-		boost::shared_ptr<Swift::Delay> delay(boost::make_shared<Swift::Delay>());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Delay> delay(SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::Delay>());
 		delay->setStamp(timestamp);
 		msg->addPayload(delay);
+	}
 	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());
 	// We can't create Conversation for payload with nickname, because this means the message is from room,
 	// but this user is not in any room, so it's OK to just reject this message
 	if (!conv && !payload.nickname().empty()) {
 		LOG4CXX_WARN(logger, "handleConvMessagePayload: No conversation with name " << payload.buddyname());
 		return;
+	}
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	if (payload.id().empty()) {
 		LOG4CXX_WARN(logger, "Received message ack with empty ID, not forwarding to XMPP.");
 		return;
+	}
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->addPayload(boost::make_shared<Swift::DeliveryReceipt>(payload.id()));
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->addPayload(SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::DeliveryReceipt>(payload.id()));
 	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());
 	// Receipts don't create conversation
 	if (!conv) {
 		return;
+	}
 	// Forward it
 	conv->handleMessage(msg);
+}
 void NetworkPluginServer::handleAttentionPayload(const std::string &data) {
 	pbnetwork::ConversationMessage payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
-	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->setBody(payload.message());
-	msg->addPayload(boost::make_shared<Swift::AttentionPayload>());
+	msg->addPayload(SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::AttentionPayload>());
 	// Attentions trigger new Conversation creation
 	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());
 	if (!conv) {
 		conv = new NetworkConversation(user->getConversationManager(), payload.buddyname());
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, this, _1, _2));
+	}
 	conv->handleMessage(msg);
+}
 	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(payload.buddyname());
 	if (!buddy) {
 		// TODO: escape? reject?
 		return;
+	}
 	Swift::StreamInitiationFileInfo fileInfo;
 	fileInfo.setSize(payload.size());
 	fileInfo.setName(payload.filename());
 	Backend *c = (Backend *) user->getData();
-	boost::shared_ptr<MemoryReadBytestream> bytestream(new MemoryReadBytestream(payload.size()));
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<MemoryReadBytestream> bytestream(new MemoryReadBytestream(payload.size()));
 	bytestream->onDataNeeded.connect(boost::bind(&NetworkPluginServer::handleFTDataNeeded, this, c, bytestream_id + 1));
 	LOG4CXX_INFO(logger, "jid=" << buddy->getJID());
 	FileTransferManager::Transfer transfer = m_ftManager->sendFile(user, buddy, bytestream, fileInfo);
 	if (!transfer.ft) {
 		handleFTRejected(user, payload.buddyname(), payload.filename(), payload.size());
 		return;
+	}
 	m_filetransfers[++bytestream_id] = transfer;
 #if !HAVE_SWIFTEN_3
 void NetworkPluginServer::handleQueryPayload(Backend *b, const std::string &data) {
 	pbnetwork::BackendConfig payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	if (!m_adminInterface) {
 		return;
+	}
-	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->setBody(payload.config());
 	m_adminInterface->handleQuery(msg);
 	pbnetwork::BackendConfig response;
 #if HAVE_SWIFTEN_3
 	response.set_config(msg->getBody().get_value_or(""));
 #else
 	response.set_config(msg->getBody());
 #endif
 	std::string message;
 	response.SerializeToString(&message);
 		for (int i = 0; i < payload.room_size() && i < payload.name_size(); i++) {
 			user->addRoomToRoomList(Swift::JID::getEscapedNode(payload.room(i)) + "@" + m_component->getJID().toString(), payload.name(i));
+		}
+	}
 	else {
 		m_component->getFrontend()->clearRoomList();
 		for (int i = 0; i < payload.room_size() && i < payload.name_size(); i++) {
 			m_component->getFrontend()->addRoomToRoomList(Swift::JID::getEscapedNode(payload.room(i)) + "@" + m_component->getJID().toString(), payload.name(i));
+		}
+	}
+}
 #if HAVE_SWIFTEN_3
-void NetworkPluginServer::handleElement(boost::shared_ptr<Swift::ToplevelElement> element) {
+void NetworkPluginServer::handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ToplevelElement> element) {
 #else
-void NetworkPluginServer::handleElement(boost::shared_ptr<Swift::Element> element) {
+void NetworkPluginServer::handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element> element) {
 #endif
-	boost::shared_ptr<Swift::Stanza> stanza = boost::dynamic_pointer_cast<Swift::Stanza>(element);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Stanza> stanza = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::Stanza>(element);
 	if (!stanza) {
 		return;
+	}
 	User *user = m_userManager->getUser(stanza->getTo().toBare());
 	if (!user)
 		return;
 	Swift::JID originalJID = stanza->getFrom();
 	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(originalJID.toBare());
 	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(stanza->getFrom().toBare());
 					name.replace(name.find_last_of("@"), 1, "%");
+				}
+			}
+		}
 		if (stanza->getFrom().getResource().empty()) {
 			stanza->setFrom(Swift::JID(name, m_component->getJID().toString()));
+		}
 		else {
 			stanza->setFrom(Swift::JID(name, m_component->getJID().toString(), stanza->getFrom().getResource()));
+		}
+	}
-	boost::shared_ptr<Swift::Message> message = boost::dynamic_pointer_cast<Swift::Message>(stanza);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::Message>(stanza);
 	if (message) {
 		if (conv) {
 			conv->handleRawMessage(message);
 			return;
+		}
 		m_component->getFrontend()->sendMessage(message);
 		return;
+	}
-	boost::shared_ptr<Swift::Presence> presence = boost::dynamic_pointer_cast<Swift::Presence>(stanza);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Presence> presence = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::Presence>(stanza);
 	if (presence) {
 		if (buddy) {
 			if (!buddy->isAvailable() && presence->getType() != Swift::Presence::Unavailable) {
 				buddy->m_status.setType(Swift::StatusShow::Online);
+			}
 			buddy->handleRawPresence(presence);
+		}
 		else if (conv) {
 			conv->handleRawPresence(presence);
+		}
 		else {
 			m_component->getFrontend()->sendPresence(presence);
+		}
 		return;
+	}
 	// TODO: Move m_id2resource in User and clean it up
-	boost::shared_ptr<Swift::IQ> iq = boost::dynamic_pointer_cast<Swift::IQ>(stanza);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::IQ>(stanza);
 	if (iq) {
 		if (m_id2resource.find(stanza->getTo().toBare().toString() + stanza->getID()) != m_id2resource.end()) {
 			iq->setTo(Swift::JID(iq->getTo().getNode(), iq->getTo().getDomain(), m_id2resource[stanza->getTo().toBare().toString() + stanza->getID()]));
 			m_id2resource.erase(stanza->getTo().toBare().toString() + stanza->getID());
+		}
 		else {
 			Swift::Presence::ref highest = m_component->getPresenceOracle()->getHighestPriorityPresence(user->getJID());
 			if (highest) {
 			    iq->setTo(highest->getFrom());
 			} else {
 			    iq->setTo(user->getJID());
+			}
+		}
 		m_component->getFrontend()->sendIQ(iq);
 		return;
+	}
+}
 void NetworkPluginServer::handleRawXML(const std::string &xml) {
 	m_xmppParser->parse(xml);
+}
-void NetworkPluginServer::handleRawPresenceReceived(boost::shared_ptr<Swift::Presence> presence) {
+void NetworkPluginServer::handleRawPresenceReceived(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Presence> presence) {
 	if (!CONFIG_BOOL_DEFAULTED(m_config, "features.rawxml", false)) {
 		return;
+	}
 	User *user = m_userManager->getUser(presence->getFrom().toBare());
 	if (!user)
 		return;
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	if (!presence->getTo().getResource().empty()) {
 		presence->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain(), presence->getTo().getResource()));
+	}
 	else {
 		presence->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain()));
+	}
 	std::string xml = safeByteArrayToString(m_serializer->serializeElement(presence));
 	WRAP(xml, pbnetwork::WrapperMessage_Type_TYPE_RAW_XML);
 	send(c->connection, xml);
+}
-void NetworkPluginServer::handleRawIQReceived(boost::shared_ptr<Swift::IQ> iq) {
+void NetworkPluginServer::handleRawIQReceived(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq) {
 	User *user = m_userManager->getUser(iq->getFrom().toBare());
 	if (!user)
 		return;
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	if (iq->getType() == Swift::IQ::Get) {
 		m_id2resource[iq->getFrom().toBare().toString() + iq->getID()] = iq->getFrom().getResource();
+	}
 	if (!iq->getTo().getResource().empty()) {
 		iq->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain(), iq->getTo().getResource()));
+	}
 	else {
 		iq->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain()));
+	}
 	std::string xml = safeByteArrayToString(m_serializer->serializeElement(iq));
 	WRAP(xml, pbnetwork::WrapperMessage_Type_TYPE_RAW_XML);
 	send(c->connection, xml);
+}
-void NetworkPluginServer::handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data) {
+void NetworkPluginServer::handleDataRead(Backend *c, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::SafeByteArray> data) {
 	// Append data to buffer
 	c->data.insert(c->data.end(), data->begin(), data->end());
 	// Parse data while there are some
 	while (c->data.size() != 0) {
 		// expected_size of wrapper message
 		unsigned int expected_size;
 		// if data is >= 4, we have whole header and we can
 		// read expected_size.
 		if (c->data.size() >= 4) {
 			expected_size = *((unsigned int*) &c->data[0]);
 			case pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE_ACK:
 				handleConvMessageAckPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_RAW_XML:
 				handleRawXML(wrapper.payload());
 				break;
 			default:
 				return;
+		}
+	}
+}
-void NetworkPluginServer::send(boost::shared_ptr<Swift::Connection> &c, const std::string &data) {
+void NetworkPluginServer::send(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> &c, const std::string &data) {
 	// generate header - size of wrapper message
 	uint32_t size = htonl(data.size());
 	char *header = (char *) &size;
 	// send header together with wrapper message
 	c->write(Swift::createSafeByteArray(std::string(header, 4) + data));
+}
 void NetworkPluginServer::pingTimeout() {
 	LOG4CXX_INFO(logger, "Sending PING to backends");
 	// TODO: move to separate timer, those 2 loops could be expensive
 	// Some users are connected for weeks and they are blocking backend to be destroyed and its memory
+	}
 	send(c->connection, message);
 	c->users.remove(user);
 	// If backend should handle only one user, it must not accept another one before
 	// we kill it, so set up willDie to true
 	if (c->users.size() == 0 && CONFIG_INT(m_config, "service.users_per_backend") == 1) {
 		LOG4CXX_INFO(logger, "Backend " << c->id << " will die, because the last user disconnected");
 		c->willDie = true;
+	}
+}
-void NetworkPluginServer::handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &msg) {
+void NetworkPluginServer::handleMessageReceived(NetworkConversation *conv, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &msg) {
 	conv->getConversationManager()->getUser()->updateLastActivity();
 	if (CONFIG_BOOL_DEFAULTED(m_config, "features.rawxml", false)) {
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		if (!c) {
 			return;
+		}
 		Swift::JID legacyname = Swift::JID(Buddy::JIDToLegacyName(msg->getTo()));
 		if (!msg->getTo().getResource().empty()) {
 			msg->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain(), msg->getTo().getResource()));
+		}
 		else {
 			msg->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain()));
+		}
 		std::string xml = safeByteArrayToString(m_serializer->serializeElement(msg));
 		WRAP(xml, pbnetwork::WrapperMessage_Type_TYPE_RAW_XML);
 		send(c->connection, xml);
 		return;
+	}
-	boost::shared_ptr<Swift::ChatState> statePayload = msg->getPayload<Swift::ChatState>();
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ChatState> statePayload = msg->getPayload<Swift::ChatState>();
 	if (statePayload) {
 		pbnetwork::WrapperMessage_Type type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED;
 		switch (statePayload->getChatState()) {
 			case Swift::ChatState::Active:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING;
 				break;
 			case Swift::ChatState::Composing:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING;
 				break;
 			case Swift::ChatState::Paused:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED;
 				break;
 			buddy.SerializeToString(&message);
 			WRAP(message, type);
 			Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 			if (!c) {
 				return;
+			}
 			send(c->connection, message);
+		}
+	}
-	boost::shared_ptr<Swift::AttentionPayload> attentionPayload = msg->getPayload<Swift::AttentionPayload>();
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::AttentionPayload> attentionPayload = msg->getPayload<Swift::AttentionPayload>();
 	if (attentionPayload) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 #if HAVE_SWIFTEN_3
 		m.set_message(msg->getBody().get_value_or(""));
 #else
 		m.set_message(msg->getBody());
 #endif
 		std::string message;
 		m.SerializeToString(&message);
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ROOM_SUBJECT_CHANGED);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		send(c->connection, message);
 		return;
+	}
 	std::string xhtml;
-	boost::shared_ptr<Swift::XHTMLIMPayload> xhtmlPayload = msg->getPayload<Swift::XHTMLIMPayload>();
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::XHTMLIMPayload> xhtmlPayload = msg->getPayload<Swift::XHTMLIMPayload>();
 	if (xhtmlPayload) {
 		xhtml = xhtmlPayload->getBody();
+	}
 	// Send normal message
 #if HAVE_SWIFTEN_3
 	std::string body = msg->getBody().get_value_or("");
 #else
 	std::string body = msg->getBody();
 #endif
 	if (!body.empty() || !xhtml.empty()) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 		m.set_message(body);
 		m.set_xhtml(xhtml);
-		boost::shared_ptr<Swift::DeliveryReceiptRequest> receiptPayload = msg->getPayload<Swift::DeliveryReceiptRequest>();
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DeliveryReceiptRequest> receiptPayload = msg->getPayload<Swift::DeliveryReceiptRequest>();
 		if (receiptPayload && !msg->getID().empty()) {
 			m.set_id(msg->getID());
+		}
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		if (!c) {
 			return;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
-void NetworkPluginServer::handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> v) {
+void NetworkPluginServer::handleVCardUpdated(User *user, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> v) {
 	if (!v) {
 		LOG4CXX_INFO(logger, user->getJID().toString() << ": Received empty VCard");
 		return;
+	}
 	pbnetwork::VCard vcard;
 	vcard.set_username(user->getJID().toBare());
 	vcard.set_buddyname("");
 	vcard.set_id(0);
 	vcard.set_photo(&v->getPhoto()[0], v->getPhoto().size());
 	vcard.set_nickname(v->getNickname());

libtransport/PQXXBackend.cpp

➞

Show inline comments

@@ @@ -17,25 +17,24 @@ @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #ifdef WITH_PQXX
 #include "transport/PQXXBackend.h"
 #include "transport/Util.h"
 #include <boost/bind.hpp>
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 using namespace boost;
 namespace Transport {
 static LoggerPtr logger = Logger::getLogger("PQXXBackend");
 PQXXBackend::PQXXBackend(Config *config) {
 	m_config = config;
 	m_prefix = CONFIG_STRING(m_config, "database.prefix");
+}
 PQXXBackend::~PQXXBackend(){
 	disconnect();

libtransport/PresenceOracle.cpp

➞

Show inline comments

@@ @@ -37,48 +37,48 @@ PresenceOracle::PresenceOracle(Frontend* frontend) { @@
 PresenceOracle::~PresenceOracle() {
 	frontend_->onPresenceReceived.disconnect(boost::bind(&PresenceOracle::handleIncomingPresence, this, _1));
 	frontend_->onAvailableChanged.disconnect(boost::bind(&PresenceOracle::handleStanzaChannelAvailableChanged, this, _1));
+}
 void PresenceOracle::handleStanzaChannelAvailableChanged(bool available) {
 	if (available) {
 		entries_.clear();
+	}
+}
 void PresenceOracle::clearPresences(const Swift::JID& bareJID) {
-	std::map<JID, boost::shared_ptr<Presence> > jidMap = entries_[bareJID];
+	std::map<JID, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Presence> > jidMap = entries_[bareJID];
 	jidMap.clear();
 	entries_[bareJID] = jidMap;
+}
 void PresenceOracle::handleIncomingPresence(Presence::ref presence) {
 	// ignore presences for some contact, we're checking only presences for the transport itself here.
 	// filter out login/logout presence spam
 	if (!presence->getTo().getNode().empty())
 		return;
 	JID bareJID(presence->getFrom().toBare());
 	if (presence->getType() == Presence::Subscribe || presence->getType() == Presence::Subscribed) {
+	}
 	else {
 		Presence::ref passedPresence = presence;
 		if (presence->getType() == Presence::Unsubscribe || presence->getType() == Presence::Unsubscribed) {
 			/* 3921bis says that we don't follow up with an unavailable, so simulate this ourselves */
 			passedPresence = Presence::ref(new Presence());
 			passedPresence->setType(Presence::Unavailable);
 			passedPresence->setFrom(bareJID);
 			passedPresence->setStatus(presence->getStatus());
+		}
-		std::map<JID, boost::shared_ptr<Presence> > jidMap = entries_[bareJID];
+		std::map<JID, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Presence> > jidMap = entries_[bareJID];
 		if (passedPresence->getFrom().isBare() && presence->getType() == Presence::Unavailable) {
 			/* Have a bare-JID only presence of offline */
 			jidMap.clear();
 		} else if (passedPresence->getType() == Presence::Available) {
 			/* Don't have a bare-JID only offline presence once there are available presences */
 			jidMap.erase(bareJID);
+		}
 		if (passedPresence->getType() == Presence::Unavailable && jidMap.size() > 1) {
 			jidMap.erase(passedPresence->getFrom());
 		} else {
 			jidMap[passedPresence->getFrom()] = passedPresence;
+		}

libtransport/RosterManager.cpp

➞

Show inline comments

 	response->setTo(m_user->getJID());
 	response->setFrom(buddy->getJID());
 	response->setType(Swift::Presence::Unsubscribed);
 	m_component->getFrontend()->sendPresence(response);
+}
 void RosterManager::sendBuddySubscribePresence(Buddy *buddy) {
 	Swift::Presence::ref response = Swift::Presence::create();
 	response->setTo(m_user->getJID());
 	response->setFrom(buddy->getJID().toBare());
 	response->setType(Swift::Presence::Subscribe);
 	if (!buddy->getAlias().empty()) {
-		response->addPayload(boost::make_shared<Swift::Nickname>(buddy->getAlias()));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::Nickname>(buddy->getAlias()));
+	}
 	m_component->getFrontend()->sendPresence(response);
+}
 void RosterManager::handleBuddyChanged(Buddy *buddy) {
+}
 void RosterManager::setBuddy(Buddy *buddy) {
 	std::string name = buddy->getName();
 	name = boost::locale::to_lower(name);
 	LOG4CXX_INFO(logger, "Associating buddy " << name << " with " << m_user->getJID().toString());
 	m_buddies[name] = buddy;

libtransport/SQLite3Backend.cpp

➞

Show inline comments

@@ @@ -52,26 +52,24 @@ @@
 							(void)STATEMENT##_id_get;
 #define BIND_INT(STATEMENT, VARIABLE) sqlite3_bind_int(STATEMENT, STATEMENT##_id++, VARIABLE)
 #define BIND_STR(STATEMENT, VARIABLE) sqlite3_bind_text(STATEMENT, STATEMENT##_id++, VARIABLE.c_str(), -1, SQLITE_STATIC)
 #define RESET_GET_COUNTER(STATEMENT)	STATEMENT##_id_get = 0;
 #define GET_INT(STATEMENT)	sqlite3_column_int(STATEMENT, STATEMENT##_id_get++)
 #define GET_STR(STATEMENT)	(const char *) sqlite3_column_text(STATEMENT, STATEMENT##_id_get++)
 #define GET_BLOB(STATEMENT)	(const void *) sqlite3_column_blob(STATEMENT, STATEMENT##_id_get++)
 #define EXECUTE_STATEMENT(STATEMENT, NAME) 	if(sqlite3_step(STATEMENT) != SQLITE_DONE) {\
 		LOG4CXX_ERROR(logger, NAME<< (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));\
+			}
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "SQLite3Backend");
 SQLite3Backend::SQLite3Backend(Config *config) {
 	m_config = config;
 	m_db = NULL;
 	m_prefix = CONFIG_STRING(m_config, "database.prefix");
+}
 SQLite3Backend::~SQLite3Backend(){
 	if (m_db) {

libtransport/ThreadPool.cpp

➞

Show inline comments

 #include "transport/ThreadPool.h"
 #include "transport/Logging.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Transport {
 DEFINE_LOGGER(logger, "ThreadPool")
 boost::signals2::signal< void (Thread*, int) > onWorkCompleted;
 static void Worker(Thread *t, int wid, Swift::EventLoop *loop)
+{
 	LOG4CXX_INFO(logger, "Starting thread " << wid)
 	t->run();
-	loop->postEvent(boost::bind(boost::ref(onWorkCompleted), t, wid), boost::shared_ptr<Swift::EventOwner>());
+	loop->postEvent(boost::bind(boost::ref(onWorkCompleted), t, wid), SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::EventOwner>());
+}
 ThreadPool::ThreadPool(Swift::EventLoop *loop, int maxthreads) : MAX_THREADS(maxthreads)
+{
 	this->loop = loop;
 	activeThreads = 0;
 	worker = (boost::thread **) malloc(sizeof(boost::thread *) * MAX_THREADS);
 	for(int i=0 ; i<MAX_THREADS ; i++) {
 		worker[i] = NULL;
 		freeThreads.push(i);
+	}

libtransport/User.cpp

➞

Show inline comments

@@ @@ -30,26 +30,24 @@ @@
 #include "transport/Logging.h"
 #include "transport/StorageBackend.h"
 #include "transport/Buddy.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/MUCPayload.h"
 #include "Swiften/Elements/SpectrumErrorPayload.h"
 #include "Swiften/Elements/CapsInfo.h"
 #include "Swiften/Elements/VCardUpdate.h"
 #include <boost/foreach.hpp>
 #include <stdio.h>
 #include <stdlib.h>
 using namespace boost;
 #define foreach         BOOST_FOREACH
 namespace Transport {
 DEFINE_LOGGER(logger, "User");
 User::User(const Swift::JID &jid, UserInfo &userInfo, Component *component, UserManager *userManager) {
 	m_jid = jid.toBare();
 	m_data = NULL;
 	m_cacheMessages = false;
 	m_component = component;
 	m_rosterManager = component->getFrontend()->createRosterManager(this, m_component);
 	m_conversationManager = new ConversationManager(this, m_component);
 	LOG4CXX_INFO(logger, m_jid.toString() << ": Created");
 	updateLastActivity();
+}
 User::~User(){
 	LOG4CXX_INFO(logger, m_jid.toString() << ": Destroying");
 // 	if (m_component->inServerMode()) {
 // #if HAVE_SWIFTEN_3
-// 		dynamic_cast<Swift::ServerStanzaChannel *>(m_component->getFrontend())->finishSession(m_jid, boost::shared_ptr<Swift::ToplevelElement>());
+// 		dynamic_cast<Swift::ServerStanzaChannel *>(m_component->getFrontend())->finishSession(m_jid, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ToplevelElement>());
 // #else
-// 		dynamic_cast<Swift::ServerStanzaChannel *>(m_component->getFrontend())->finishSession(m_jid, boost::shared_ptr<Swift::Element>());
+// 		dynamic_cast<Swift::ServerStanzaChannel *>(m_component->getFrontend())->finishSession(m_jid, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element>());
 // #endif
 // 	}
 	m_reconnectTimer->stop();
 	delete m_rosterManager;
 	delete m_conversationManager;
+}
 const Swift::JID &User::getJID() {
 	return m_jid;
+}
@@ @@ -165,44 +163,44 @@ void User::leaveRoom(const std::string &room) { @@
+	}
 	Conversation *conv = m_conversationManager->getConversation(room);
 	if (conv) {
 		m_conversationManager->removeConversation(conv);
 		delete conv;
+	}
+}
 void User::handlePresence(Swift::Presence::ref presence, bool forceJoin) {
 	LOG4CXX_INFO(logger, "PRESENCE " << presence->getFrom().toString() << " " << presence->getTo().toString());
-	boost::shared_ptr<Swift::VCardUpdate> vcardUpdate = presence->getPayload<Swift::VCardUpdate>();
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCardUpdate> vcardUpdate = presence->getPayload<Swift::VCardUpdate>();
 	if (vcardUpdate) {
 		std::string value = "";
 		int type = (int) TYPE_STRING;
 		if (m_storageBackend) {
 			m_storageBackend->getUserSetting(m_userInfo.id, "photohash", type, value);
+		}
 		if (value != vcardUpdate->getPhotoHash()) {
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Requesting VCard")
 			if (m_storageBackend) {
 				m_storageBackend->updateUserSetting(m_userInfo.id, "photohash", vcardUpdate->getPhotoHash());
+			}
 			requestVCard();
+		}
+	}
 	if (!m_connected) {
 		// we are not connected to legacy network, so we should do it when disco#info arrive :)
 		if (m_readyForConnect == false) {
-			boost::shared_ptr<Swift::CapsInfo> capsInfo = presence->getPayload<Swift::CapsInfo>();
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::CapsInfo> capsInfo = presence->getPayload<Swift::CapsInfo>();
 			if (capsInfo && capsInfo->getHash() == "sha-1") {
 				if (m_component->getFrontend()->sendCapabilitiesRequest(presence->getFrom()) != Swift::DiscoInfo::ref()) {
 					LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 					m_readyForConnect = true;
 					onReadyToConnect();
+				}
 				else {
 					m_reconnectTimer->start();
+				}
+			}
 			else if (m_component->inServerMode()) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 			response->setTo(m_jid.toBare());
 			response->setFrom(m_component->getJID());
 			response->setType(Swift::Presence::Unavailable);
 			onPresenceChanged(response);
+		}
+	}
+}
 void User::handleSubscription(Swift::Presence::ref presence) {
 	m_rosterManager->handleSubscription(presence);
+}
-void User::handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info) {
+void User::handleDiscoInfo(const Swift::JID& jid, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> info) {
 	LOG4CXX_INFO(logger, jid.toString() << ": got disco#info");
 #ifdef SUPPORT_LEGACY_CAPS
 	m_legacyCaps[jid] = info;
 #endif
 	onConnectingTimeout();
+}
 void User::onConnectingTimeout() {
 	if (m_connected || m_readyForConnect)
 		return;
 	m_reconnectTimer->stop();
 			return;
+		}
+	}
 	if (error.empty()) {
 		LOG4CXX_INFO(logger, m_jid.toString() << ": Disconnected from legacy network");
+	}
 	else {
 		LOG4CXX_INFO(logger, m_jid.toString() << ": Disconnected from legacy network with error " << error);
+	}
 	onDisconnected();
-	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->setBody(error);
 	msg->setTo(m_jid.toBare());
 	msg->setFrom(m_component->getJID());
-	msg->addPayload(boost::make_shared<Swift::SpectrumErrorPayload>(e));
+	msg->addPayload(SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::SpectrumErrorPayload>(e));
 	m_component->getFrontend()->sendMessage(msg);
 	disconnectUser(error, e);
 	std::string jid = m_jid.toBare().toString();
 	if (m_userManager->getUser(jid) != NULL) {
 		m_userManager->removeUser(this);
+	}
+}
 std::vector<Swift::JID> User::getJIDWithFeature(const std::string &feature) {
        std::vector<Swift::JID> jid;

libtransport/UserManager.cpp

➞

Show inline comments

+}
 void UserManager::removeAllUsers(bool onUserBehalf) {
 	while(m_users.begin() != m_users.end()) {
 		removeUser((*m_users.begin()).second, onUserBehalf);
+	}
+}
 int UserManager::getUserCount() {
 	return m_users.size();
+}
-void UserManager::handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info) {
+void UserManager::handleDiscoInfo(const Swift::JID& jid, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> info) {
 	User *user = getUser(jid.toBare().toString());
 	if (!user) {
 		return;
+	}
 	user->handleDiscoInfo(jid, info);
+}
 void UserManager::handlePresence(Swift::Presence::ref presence) {
 	std::string barejid = presence->getTo().toBare().toString();
 	std::string userkey = presence->getFrom().toBare().toString();
+				}
+			}
+		}
 		// Unregistered users are not able to login
 		if (!registered) {
 			LOG4CXX_WARN(logger, "Unregistered user " << userkey << " tried to login");
 			return;
+		}
 		if (CONFIG_BOOL(m_component->getConfig(), "service.vip_only") && res.vip == false) {
 			if (!CONFIG_STRING(m_component->getConfig(), "service.vip_message").empty()) {
-				boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+				SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 				msg->setBody(CONFIG_STRING(m_component->getConfig(), "service.vip_message"));
 				msg->setTo(presence->getFrom());
 				msg->setFrom(m_component->getJID());
 				m_component->getFrontend()->sendMessage(msg);
+			}
 			LOG4CXX_WARN(logger, "Non VIP user " << userkey << " tried to login");
 			if (m_component->inServerMode()) {
 				m_userRegistry->onPasswordInvalid(presence->getFrom());
+			}
 			return;
+		}
 	// Connect the user again when we're reconnecting.
 	if (reconnect) {
 		connectUser(jid);
+	}
+}
 void UserManager::handleMessageReceived(Swift::Message::ref message) {
 	if (message->getType() == Swift::Message::Error) {
 		return;
+	}
 	// Do not count chatstate notification...
-	boost::shared_ptr<Swift::ChatState> statePayload = message->getPayload<Swift::ChatState>();
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ChatState> statePayload = message->getPayload<Swift::ChatState>();
 	if (!statePayload) {
 		messageToBackendSent();
+	}
 #if HAVE_SWIFTEN_3
 	std::string body = message->getBody().get_value_or("");
 #else
 	std::string body = message->getBody();
 #endif
 	if (body.empty() && !statePayload && message->getSubject().empty()) {
 		return;
+	}
@@ @@ -546,38 +546,38 @@ void UserManager::connectUser(const Swift::JID &user) { @@
 			// User is already logged in, so his password is OK, but this new user has different password => bad password.
 			// We can't call m_userRegistry->onPasswordInvalid() here, because this fuction is called from Swift::Parser
 			// and onPasswordInvalid destroys whole session together with parser itself, which leads to crash.
 			if (m_userRegistry->getUserPassword(user.toBare().toString()) != u->getUserInfo().password) {
 				m_userRegistry->removeLater(user);
 				return;
+			}
 			if (CONFIG_BOOL(m_component->getConfig(), "service.more_resources")) {
 				m_userRegistry->onPasswordValid(user);
+			}
 			else {
 				// Send message to currently logged in session
-				boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+				SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 				msg->setBody("You have signed on from another location.");
 				msg->setTo(user);
 				msg->setFrom(m_component->getJID());
 				m_component->getFrontend()->sendMessage(msg);
 				// Switch the session = accept new one, disconnect old one.
 				// Unavailable presence from old session has to be ignored, otherwise it would disconnect the user from legacy network.
 				m_userRegistry->onPasswordValid(user);
 				m_component->onUserPresenceReceived.disconnect(bind(&UserManager::handlePresence, this, _1));
 // #if HAVE_SWIFTEN_3
-// 				dynamic_cast<Swift::ServerStanzaChannel *>(m_component->getFrontend())->finishSession(user, boost::shared_ptr<Swift::ToplevelElement>(new Swift::StreamError()), true);
+// 				dynamic_cast<Swift::ServerStanzaChannel *>(m_component->getFrontend())->finishSession(user, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ToplevelElement>(new Swift::StreamError()), true);
 // #else
-// 				dynamic_cast<Swift::ServerStanzaChannel *>(m_component->getFrontend())->finishSession(user, boost::shared_ptr<Swift::Element>(new Swift::StreamError()), true);
+// 				dynamic_cast<Swift::ServerStanzaChannel *>(m_component->getFrontend())->finishSession(user, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element>(new Swift::StreamError()), true);
 // #endif
 				m_component->onUserPresenceReceived.connect(bind(&UserManager::handlePresence, this, _1));
+			}
+		}
 		else {
 			// User is created, but not connected => he's loggin in or he just logged out, but hasn't been deleted yet.
 			// Stop deletion process if there's any
 			m_removeTimer->onTick.disconnect(boost::bind(&UserManager::handleRemoveTimeout, this, user.toBare().toString(), m_users[user.toBare().toString()], false));
 			// Delete old User instance but create new one immediatelly
 			m_removeTimer->onTick.connect(boost::bind(&UserManager::handleRemoveTimeout, this, user.toBare().toString(), m_users[user.toBare().toString()], true));
 			m_removeTimer->start();

libtransport/UsersReconnecter.cpp

➞

Show inline comments

@@ @@ -21,43 +21,42 @@ @@
 #include "transport/UsersReconnecter.h"
 #include "transport/StorageBackend.h"
 #include "transport/Transport.h"
 #include "transport/Logging.h"
 #include "transport/Frontend.h"
 #include "transport/Config.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Network/NetworkFactories.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "UserReconnecter");
 UsersReconnecter::UsersReconnecter(Component *component, StorageBackend *storageBackend) {
 	m_component = component;
 	m_storageBackend = storageBackend;
 	m_started = false;
 	m_nextUserTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(1000);
 	m_nextUserTimer->onTick.connect(boost::bind(&UsersReconnecter::reconnectNextUser, this));
 	m_component->onConnected.connect(bind(&UsersReconnecter::handleConnected, this));
+	m_component->onConnected.connect(boost::bind(&UsersReconnecter::handleConnected, this));
+}
 UsersReconnecter::~UsersReconnecter() {
 	m_component->onConnected.disconnect(bind(&UsersReconnecter::handleConnected, this));
+	m_component->onConnected.disconnect(boost::bind(&UsersReconnecter::handleConnected, this));
 	m_nextUserTimer->stop();
 	m_nextUserTimer->onTick.disconnect(boost::bind(&UsersReconnecter::reconnectNextUser, this));
+}
 void UsersReconnecter::reconnectNextUser() {
 	if (m_users.empty()) {
 		LOG4CXX_INFO(logger, "All users reconnected, stopping UserReconnecter.");
 		return;
+	}
 	std::string user = m_users.back();
 	m_users.pop_back();

libtransport/Util.cpp

➞

Show inline comments

@@ @@ -34,26 +34,24 @@ @@
 #include <pwd.h>
 #include <grp.h>
 #include <sys/resource.h>
 #include "libgen.h"
 #else
 #include <windows.h>
 #include <process.h>
 #define getpid _getpid
 #endif
 using namespace boost::filesystem;
 using namespace boost;
 namespace Transport {
 namespace Util {
 void createDirectories(Transport::Config *config, const boost::filesystem::path& ph) {
 	if (ph.empty() || exists(ph)) {
 		return;
+	}
 	// First create branch, by calling ourself recursively
 	createDirectories(config, ph.branch_path());

libtransport/WebSocketClient.cpp

➞

Show inline comments

@@ @@ -120,25 +120,25 @@ void WebSocketClient::write(const std::string &data) { @@
 		uint16_t size16 = data.size();
 		size16 = htons(size16);
 		m_conn->write(Swift::createSafeByteArray(std::string((char *) &opcode, 1)
 			+ std::string((char *) &size7, 1)
 			+ std::string((char *) &size16, 2)
 			+ std::string((char *) &mask_bits[0], 4)
 			+ payload));
+	}
 	LOG4CXX_INFO(logger, m_user << ": > " << data);
+}
-void WebSocketClient::handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) {
+void WebSocketClient::handleDataRead(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::SafeByteArray> data) {
 	std::string d = Swift::safeByteArrayToString(*data);
 	m_buffer += d;
 	if (!m_upgraded) {
 		if (m_buffer.find("\r\n\r\n") != std::string::npos) {
 			m_buffer.erase(0, m_buffer.find("\r\n\r\n") + 4);
 			m_upgraded = true;
 			onWebSocketConnected();
+		}
 		else {
 			return;
+		}

spectrum/src/frontends/slack/SlackFrontend.cpp

➞

Show inline comments

+}
 void SlackFrontend::sendPresence(Swift::Presence::ref presence) {
+}
 void SlackFrontend::sendVCard(Swift::VCard::ref vcard, Swift::JID to) {
+}
 void SlackFrontend::sendRosterRequest(Swift::RosterPayload::ref payload, Swift::JID to) {
+}
-void SlackFrontend::sendMessage(boost::shared_ptr<Swift::Message> message) {
+void SlackFrontend::sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message) {
 	return static_cast<SlackUserManager *>(m_userManager)->sendMessage(message);
+}
-void SlackFrontend::sendIQ(boost::shared_ptr<Swift::IQ> iq) {
+void SlackFrontend::sendIQ(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq) {
+}
-boost::shared_ptr<Swift::DiscoInfo> SlackFrontend::sendCapabilitiesRequest(Swift::JID to) {
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> SlackFrontend::sendCapabilitiesRequest(Swift::JID to) {
 	return Swift::DiscoInfo::ref();
+}
 void SlackFrontend::reconnectUser(const std::string &user) {
 	return static_cast<SlackUserManager *>(m_userManager)->reconnectUser(user);
+}
 RosterManager *SlackFrontend::createRosterManager(User *user, Component *component) {
 	return new SlackRosterManager(user, component);
+}

spectrum/src/frontends/slack/SlackFrontend.h

➞

Show inline comments

@@ @@ -44,41 +44,41 @@ namespace Transport { @@
 			virtual void init(Component *component, Swift::EventLoop *loop, Swift::NetworkFactories *factories, Config *config, UserRegistry *userRegistry);
 			virtual void connectToServer();
 			virtual void disconnectFromServer();
 			virtual void sendPresence(Swift::Presence::ref presence);
 			virtual void sendVCard(Swift::VCard::ref vcard, Swift::JID to);
 			virtual void sendRosterRequest(Swift::RosterPayload::ref, Swift::JID to);
-			virtual void sendMessage(boost::shared_ptr<Swift::Message> message);
+			virtual void sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message);
-			virtual void sendIQ(boost::shared_ptr<Swift::IQ>);
+			virtual void sendIQ(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ>);
 			virtual void reconnectUser(const std::string &user);
 			virtual RosterManager *createRosterManager(User *user, Component *component);
 			virtual User *createUser(const Swift::JID &jid, UserInfo &userInfo, Component *component, UserManager *userManager);
 			virtual UserManager *createUserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend = NULL);
-			virtual boost::shared_ptr<Swift::DiscoInfo> sendCapabilitiesRequest(Swift::JID to);
+			virtual SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> sendCapabilitiesRequest(Swift::JID to);
 			virtual void clearRoomList();
 			virtual void addRoomToRoomList(const std::string &handle, const std::string &name);
 			virtual std::string setOAuth2Code(const std::string &code, const std::string &state);
 			virtual std::string getOAuth2URL(const std::vector<std::string> &args);
 			virtual std::string getRegistrationFields();
-			void handleMessage(boost::shared_ptr<Swift::Message> message);
+			void handleMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message);
 			ThreadPool *getThreadPool() {
 				return m_tp;
+			}
 		private:
 			Config* m_config;
 			Swift::JID m_jid;
 			Component *m_transport;
 			UserManager *m_userManager;
 			ThreadPool *m_tp;
 	};

spectrum/src/frontends/slack/SlackFrontendPlugin.cpp

➞

Show inline comments

@@ @@ -34,19 +34,19 @@ SlackFrontendPlugin::~SlackFrontendPlugin() { @@
+}
 std::string SlackFrontendPlugin::name() const {
 	return "slack";
+}
 Frontend *SlackFrontendPlugin::createFrontend() {
 	return new SlackFrontend();
+}
 // SlackFrontendPlugin plugin;
 boost::shared_ptr<FrontendPlugin> get_slack_frontend_plugin() {
 	return boost::make_shared<SlackFrontendPlugin>();
 SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<FrontendPlugin> get_slack_frontend_plugin() {
 	return SWIFTEN_SHRPTR_NAMESPACE::make_shared<SlackFrontendPlugin>();
+}
 // BOOST_DLL_AUTO_ALIAS(plugin)
+}

spectrum/src/frontends/slack/SlackFrontendPlugin.h

➞

Show inline comments

@@ @@ -27,18 +27,18 @@ @@
 namespace Transport {
 class SlackFrontendPlugin : public FrontendPlugin {
 	public:
 		SlackFrontendPlugin();
 		virtual ~SlackFrontendPlugin();
 		std::string name() const;
 		Frontend *createFrontend();
 };
-boost::shared_ptr<FrontendPlugin> get_slack_frontend_plugin();
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<FrontendPlugin> get_slack_frontend_plugin();
+}
 BOOST_DLL_ALIAS(Transport::get_slack_frontend_plugin, create_slack_frontend_plugin)

spectrum/src/frontends/slack/SlackSession.cpp

➞

Show inline comments

@@ @@ -109,25 +109,25 @@ void SlackSession::sendOnlineBuddies() { @@
+}
 void SlackSession::sendMessageToAll(const std::string &msg) {
 	std::vector<std::string> channels;
 	for (std::map<std::string, std::string>::const_iterator it = m_jid2channel.begin(); it != m_jid2channel.end(); it++) {
 		if (std::find(channels.begin(), channels.end(), it->second) == channels.end()) {
 			channels.push_back(it->second);
 			m_rtm->getAPI()->sendMessage("Spectrum 2", it->second, msg);
+		}
+	}
+}
-void SlackSession::sendMessage(boost::shared_ptr<Swift::Message> message) {
+void SlackSession::sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message) {
 	if (m_user) {
 		std::map<std::string, Conversation *> convs = m_user->getConversationManager()->getConversations();
 		for (std::map<std::string, Conversation *> ::const_iterator it = convs.begin(); it != convs.end(); it++) {
 			Conversation *conv = it->second;
 			if (!conv) {
 				continue;
+			}
 			if (conv->getNickname() == message->getFrom().getResource()) {
 				return;
+			}
+		}
 // 		m_storageBackend->setUser(m_uinfo);
 // 	}
 	LOG4CXX_INFO(logger, m_uinfo.jid << ": Channel " << args[5] << " is created. Joining the room on legacy network.");
 	m_jid2channel[to] = slackChannel;
 	m_channel2jid[slackChannel] = to;
 	Swift::Presence::ref presence = Swift::Presence::create();
 	presence->setFrom(Swift::JID(m_uinfo.jid + "/default"));
 	presence->setTo(Swift::JID(to + "/" + name));
 	presence->setType(Swift::Presence::Available);
-	presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
+	presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 	m_component->getFrontend()->onPresenceReceived(presence);
 	m_onlineBuddiesTimer->start();
+}
 void SlackSession::handleJoinMessage(const std::string &message, std::vector<std::string> &args, bool quiet) {
 	if (args[5][0] == '#') {
 		args[5].erase(0, 1);
+	}
 	boost::algorithm::to_lower(args[3]);
 	boost::algorithm::to_lower(args[4]);
 	LOG4CXX_INFO(logger, m_uinfo.jid << ": Going to join the room " << args[3] << "@" << args[4] << ", transporting it to channel " << args[5]);
 	m_api->createChannel(args[5], m_idManager->getSelfId(), boost::bind(&SlackSession::handleJoinRoomCreated, this, _1, args));
+}
 void SlackSession::handleSlackChannelCreated(const std::string &channelId) {
 	m_slackChannel = channelId;
 	LOG4CXX_INFO(logger, m_uinfo.jid << ": Main Slack Channel created, connecting the legacy network");
 	Swift::Presence::ref presence = Swift::Presence::create();
 	presence->setFrom(Swift::JID(m_uinfo.jid + "/default"));
 	presence->setTo(m_component->getJID());
 	presence->setType(Swift::Presence::Available);
-	presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
+	presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 	m_component->getFrontend()->onPresenceReceived(presence);
+}
 void SlackSession::leaveRoom(const std::string &channel_) {
 	std::string channel = channel_;
 	if (channel[0] == '#') {
 		channel.erase(0, 1);
+	}
 	std::string channelId = m_idManager->getId(channel);
 	std::string to = m_channel2jid[channelId];
 	if (to.empty()) {
 		LOG4CXX_ERROR(logger, "Spectrum 2 is not configured to transport this Slack channel.")
 		return;
+	}
 	LOG4CXX_INFO(logger, m_uinfo.jid << ": Leaving the legacy network room " << to);
 	Swift::Presence::ref presence = Swift::Presence::create();
 	presence->setFrom(Swift::JID(m_uinfo.jid + "/default"));
 	presence->setTo(Swift::JID(to + "/" + m_uinfo.uin));
 	presence->setType(Swift::Presence::Unavailable);
-	presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
+	presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 	m_component->getFrontend()->onPresenceReceived(presence);
+}
 void SlackSession::handleMessageReceived(const std::string &channel, const std::string &user, const std::string &message, const std::string &ts, bool quiet) {
 	std::string to = m_channel2jid[channel];
 	if (m_idManager->getName(user) == m_idManager->getSelfName()) {
 		return;
+	}
 	if (!to.empty()) {
-		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setType(Swift::Message::Groupchat);
 		msg->setTo(to);
 		msg->setFrom(Swift::JID(m_uinfo.jid + "/default"));
 		msg->setBody("<" + m_idManager->getName(user) + "> " + message);
 		m_component->getFrontend()->onMessageReceived(msg);
+	}
 	else {
 		// When changing the purpose, we do not want to spam to room with the info,
 		// so remove the purpose message.
 // 			if (message.find("set the channel purpose") != std::string::npos) {
 // 				m_rtm->getAPI()->deleteMessage(channel, ts);
 // 			}
 			if (!b) {
 				continue;
+			}
 			if (!(b->getStatus(s, statusMessage))) {
 				continue;
+			}
 			if (s.getType() == Swift::StatusShow::None) {
 				continue;
+			}
-			boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 			msg->setTo(b->getJID());
 			msg->setFrom(Swift::JID(m_uinfo.jid + "/default"));
 			msg->setBody("<" + m_idManager->getName(user) + "> " + message);
 			m_component->getFrontend()->onMessageReceived(msg);
+		}
+	}
+}
 void SlackSession::handleDisconnected() {
 	m_disconnected = true;
+}

spectrum/src/frontends/slack/SlackSession.h

➞

Show inline comments

@@ @@ -20,46 +20,47 @@ @@
 #pragma once
 #include "transport/StorageBackend.h"
 #include "rapidjson/document.h"
 #include <string>
 #include <algorithm>
 #include <map>
 #include "Swiften/Elements/Message.h"
 #include "Swiften/Network/Timer.h"
 #include "Swiften/SwiftenCompat.h"
 #include <boost/signal.hpp>
 namespace Transport {
 class Component;
 class StorageBackend;
 class HTTPRequest;
 class SlackRTM;
 class SlackAPI;
 class User;
 class SlackIdManager;
 class SlackSession {
 	public:
 		SlackSession(Component *component, StorageBackend *storageBackend, UserInfo uinfo);
 		virtual ~SlackSession();
 		boost::signal<void (const std::string &user)> onInstallationDone;
-		void sendMessage(boost::shared_ptr<Swift::Message> message);
+		void sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message);
 		void sendMessageToAll(const std::string &msg);
 		void setPurpose(const std::string &purpose, const std::string &channel = "");
 		void setUser(User *user);
 		void handleDisconnected();
 		void handleConnected();
 		void handleJoinMessage(const std::string &message, std::vector<std::string> &args, bool quiet = false);
 		void leaveRoom(const std::string &channel);

spectrum/src/frontends/slack/SlackUser.cpp

➞

Show inline comments

@@ @@ -22,26 +22,24 @@ @@
 #include "SlackFrontend.h"
 #include "SlackSession.h"
 #include "SlackUserManager.h"
 #include "transport/Transport.h"
 #include "transport/UserManager.h"
 #include "transport/Logging.h"
 #include <boost/foreach.hpp>
 #include <stdio.h>
 #include <stdlib.h>
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "SlackUser");
 SlackUser::SlackUser(const Swift::JID &jid, UserInfo &userInfo, Component *component, UserManager *userManager) : User(jid, userInfo, component, userManager) {
 	m_jid = jid.toBare();
 	m_component = component;
 	m_userManager = userManager;
 	m_userInfo = userInfo;
 	m_session = static_cast<SlackUserManager *>(userManager)->moveTempSession(m_jid.toString());

spectrum/src/frontends/slack/SlackUserManager.cpp

➞

Show inline comments

 		LOG4CXX_ERROR(logger, "User " << user << " tried to reconnect, but he's not registered.");
 		return;
+	}
 	LOG4CXX_INFO(logger, "Connecting user " << user << " to Slack network.");
 	m_tempSessions[user] = new SlackSession(m_component, m_storageBackend, uinfo);
+}
 void SlackUserManager::sendVCard(unsigned int id, Swift::VCard::ref vcard) {
+}
-void SlackUserManager::sendMessage(boost::shared_ptr<Swift::Message> message) {
+void SlackUserManager::sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message) {
 	User *user = getUser(message->getTo().toBare().toString());
 	if (!user) {
 		LOG4CXX_ERROR(logger, "Received message for unknown user " << message->getTo().toBare().toString());
 		return;
+	}
 	static_cast<SlackUser *>(user)->getSession()->sendMessage(message);
+}
 SlackSession *SlackUserManager::moveTempSession(const std::string &user) {
 	if (m_tempSessions.find(user) != m_tempSessions.end()) {
 		SlackSession *session = m_tempSessions[user];

spectrum/src/frontends/slack/SlackUserManager.h

➞

Show inline comments

@@ @@ -48,25 +48,25 @@ class SlackUserManager : public UserManager { @@
 		virtual ~SlackUserManager();
 		void reconnectUser(const std::string &user);
 		virtual void sendVCard(unsigned int id, Swift::VCard::ref vcard);
 		UserRegistration *getUserRegistration();
 		std::string handleOAuth2Code(const std::string &code, const std::string &state);
 		std::string getOAuth2URL(const std::vector<std::string> &args);
-		void sendMessage(boost::shared_ptr<Swift::Message> message);
+		void sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message);
 		SlackSession *moveTempSession(const std::string &user);
 		void moveTempSession(const std::string &user, SlackSession *session);
 	private:
 		void handleUserCreated(User *user);
 		void handleAdminInterfaceSet();
 	private:
 		Component *m_component;
 		UserRegistration *m_userRegistration;
 		StorageBackend *m_storageBackend;

spectrum/src/frontends/xmpp/BlockPayload.h

➞

Show inline comments

@@ @@ -3,23 +3,25 @@ @@
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <vector>
 #include <string>
 #include <boost/shared_ptr.hpp>
 #include <Swiften/Elements/Payload.h>
 #include "Swiften/SwiftenCompat.h"
 // This payload is NOT part of ANY XEP and it is only
 // libtransport related extension.
 namespace Transport {
 	class BlockPayload : public Swift::Payload {
 		public:
-			typedef boost::shared_ptr<BlockPayload> ref;
+			typedef SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<BlockPayload> ref;
 		public:
 			BlockPayload();
 	};
+}

spectrum/src/frontends/xmpp/BlockSerializer.cpp

➞

Show inline comments

@@ @@ -10,19 +10,19 @@ @@
 #include <Swiften/Serializer/XML/XMLTextNode.h>
 #include <Swiften/Serializer/XML/XMLRawTextNode.h>
 #include <Swiften/Serializer/XML/XMLElement.h>
 namespace Transport {
 // This payload is NOT part of ANY XEP and it is only
 // libtransport related extension.
 BlockSerializer::BlockSerializer() : Swift::GenericPayloadSerializer<BlockPayload>() {
+}
-std::string BlockSerializer::serializePayload(boost::shared_ptr<BlockPayload> attention)  const {
+std::string BlockSerializer::serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<BlockPayload> attention)  const {
 	Swift::XMLElement attentionElement("block", "urn:xmpp:block:0");
 	return attentionElement.serialize();
+}
+}

spectrum/src/frontends/xmpp/BlockSerializer.h

➞

Show inline comments

 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <Swiften/Serializer/GenericPayloadSerializer.h>
 #include <BlockPayload.h>
 #include "Swiften/SwiftenCompat.h"
 // This payload is NOT part of ANY XEP and it is only
 // libtransport related extension.
 namespace Transport {
 	class BlockSerializer : public Swift::GenericPayloadSerializer<BlockPayload> {
 		public:
 			BlockSerializer();
-			virtual std::string serializePayload(boost::shared_ptr<BlockPayload>)  const;
+			virtual std::string serializePayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<BlockPayload>)  const;
 	};
+}

spectrum/src/frontends/xmpp/RosterResponder.h

➞

Show inline comments

@@ @@ -14,39 +14,40 @@ @@
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <vector>
 #include "Swiften/Queries/Responder.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/SwiftenCompat.h"
 #include <boost/signal.hpp>
 namespace Transport {
 class UserManager;
 class Buddy;
 class RosterResponder : public Swift::Responder<Swift::RosterPayload> {
 	public:
 		RosterResponder(Swift::IQRouter *router, UserManager *userManager);
 		~RosterResponder();
 		boost::signal<void (Buddy *, const Swift::RosterItemPayload &item)> onBuddyUpdated;
 		boost::signal<void (Buddy *)> onBuddyRemoved;
 		boost::signal<void (Buddy *, const Swift::RosterItemPayload &item)> onBuddyAdded;
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> payload);
 		UserManager *m_userManager;
 		Swift::IQRouter *m_router;
 };
+}

spectrum/src/frontends/xmpp/XMPPFrontend.cpp

➞

Show inline comments

@@ @@ -57,25 +57,24 @@ @@
 #include "Swiften/Parser/PayloadParsers/MUCPayloadParser.h"
 #include "BlockParser.h"
 #include "BlockSerializer.h"
 #include "Swiften/Parser/PayloadParsers/InvisibleParser.h"
 #include "Swiften/Serializer/PayloadSerializers/InvisibleSerializer.h"
 #include "Swiften/Parser/GenericPayloadParserFactory.h"
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "discoitemsresponder.h"
 #include "Swiften/Elements/InBandRegistrationPayload.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "XMPPFrontend");
 XMPPFrontend::XMPPFrontend() {
+}
 void XMPPFrontend::init(Component *transport, Swift::EventLoop *loop, Swift::NetworkFactories *factories, Config *config, Transport::UserRegistry *userRegistry) {
 	m_transport = transport;
 	m_component = NULL;
 	m_server = NULL;
 	m_payloadSerializers.push_back(new Swift::GatewayPayloadSerializer());
 	if (CONFIG_BOOL(m_config, "service.server_mode")) {
 		LOG4CXX_INFO(logger, "Creating component in server mode on port " << CONFIG_INT(m_config, "service.port"));
 		m_server = new Swift::Server(loop, factories, userRegistry, m_jid, CONFIG_STRING(m_config, "service.server"), CONFIG_INT(m_config, "service.port"));
 		if (!CONFIG_STRING(m_config, "service.cert").empty()) {
 #ifndef _WIN32
 #ifndef __APPLE__
 //TODO: fix
 			LOG4CXX_INFO(logger, "Using PKCS#12 certificate " << CONFIG_STRING(m_config, "service.cert"));
 			LOG4CXX_INFO(logger, "SSLv23_server_method used.");
 			TLSServerContextFactory *f = new OpenSSLServerContextFactory();
-			CertificateWithKey::ref certificate = boost::make_shared<PKCS12Certificate>(CONFIG_STRING(m_config, "service.cert"), createSafeByteArray(CONFIG_STRING(m_config, "service.cert_password")));
+			CertificateWithKey::ref certificate = SWIFTEN_SHRPTR_NAMESPACE::make_shared<PKCS12Certificate>(CONFIG_STRING(m_config, "service.cert"), createSafeByteArray(CONFIG_STRING(m_config, "service.cert_password")));
 			m_server->addTLSEncryption(f, certificate);
 #endif
 #endif
+		}
 		else {
 			LOG4CXX_WARN(logger, "No PKCS#12 certificate used. TLS is disabled.");
+		}
 // 		m_server->start();
 		m_stanzaChannel = m_server->getStanzaChannel();
 		m_iqRouter = m_server->getIQRouter();
 		m_server->onDataRead.connect(boost::bind(&XMPPFrontend::handleDataRead, this, _1));
 		m_server->onDataWritten.connect(boost::bind(&XMPPFrontend::handleDataWritten, this, _1));
+	}
 	else {
 		LOG4CXX_INFO(logger, "Creating component in gateway mode");
 #if HAVE_SWIFTEN_3
 		m_component = new Swift::Component(m_jid, CONFIG_STRING(m_config, "service.password"), factories);
 #else
 		m_component = new Swift::Component(loop, factories, m_jid, CONFIG_STRING(m_config, "service.password"));
 #endif
 		m_component->setSoftwareVersion("Spectrum", SPECTRUM_VERSION);
 		m_component->onConnected.connect(bind(&XMPPFrontend::handleConnected, this));
+		m_component->onConnected.connect(boost::bind(&XMPPFrontend::handleConnected, this));
 		m_component->onError.connect(boost::bind(&XMPPFrontend::handleConnectionError, this, _1));
 		m_component->onDataRead.connect(boost::bind(&XMPPFrontend::handleDataRead, this, _1));
 		m_component->onDataWritten.connect(boost::bind(&XMPPFrontend::handleDataWritten, this, _1));
 		BOOST_FOREACH(Swift::PayloadParserFactory *factory, m_parserFactories) {
 			m_component->addPayloadParserFactory(factory);
+		}
 		BOOST_FOREACH(Swift::PayloadSerializer *serializer, m_payloadSerializers) {
 			m_component->addPayloadSerializer(serializer);
+		}
@@ @@ -192,64 +191,64 @@ XMPPFrontend::~XMPPFrontend() { @@
 	m_parserFactories.clear();
 	BOOST_FOREACH(Swift::PayloadSerializer *serializer, m_payloadSerializers) {
 		delete serializer;
+	}
 	m_payloadSerializers.clear();
+}
 void XMPPFrontend::handleGeneralPresence(Swift::Presence::ref presence) {
 	onPresenceReceived(presence);
+}
-void XMPPFrontend::handleMessage(boost::shared_ptr<Swift::Message> message) {
+void XMPPFrontend::handleMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message) {
 	onMessageReceived(message);
+}
 void XMPPFrontend::clearRoomList() {
 	static_cast<XMPPUserManager *>(m_userManager)->getDiscoItemsResponder()->clearRooms();
+}
 void XMPPFrontend::addRoomToRoomList(const std::string &handle, const std::string &name) {
 	static_cast<XMPPUserManager *>(m_userManager)->getDiscoItemsResponder()->addRoom(handle, name);
+}
 void XMPPFrontend::sendPresence(Swift::Presence::ref presence) {
 	if (!presence->getFrom().getNode().empty()) {
-		presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::CapsInfo(static_cast<XMPPUserManager *>(m_userManager)->getDiscoItemsResponder()->getBuddyCapsInfo())));
+		presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::CapsInfo(static_cast<XMPPUserManager *>(m_userManager)->getDiscoItemsResponder()->getBuddyCapsInfo())));
+	}
 	m_stanzaChannel->sendPresence(presence);
+}
 void XMPPFrontend::sendVCard(Swift::VCard::ref vcard, Swift::JID to) {
-	boost::shared_ptr<Swift::GenericRequest<Swift::VCard> > request(new Swift::GenericRequest<Swift::VCard>(Swift::IQ::Result, to, vcard, m_iqRouter));
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::GenericRequest<Swift::VCard> > request(new Swift::GenericRequest<Swift::VCard>(Swift::IQ::Result, to, vcard, m_iqRouter));
 	request->send();
+}
 void XMPPFrontend::sendRosterRequest(Swift::RosterPayload::ref payload, Swift::JID to) {
 	Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, to, m_iqRouter);
 	request->send();
+}
-void XMPPFrontend::sendMessage(boost::shared_ptr<Swift::Message> message) {
+void XMPPFrontend::sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message) {
 	m_stanzaChannel->sendMessage(message);
+}
-void XMPPFrontend::sendIQ(boost::shared_ptr<Swift::IQ> iq) {
+void XMPPFrontend::sendIQ(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq) {
 	m_iqRouter->sendIQ(iq);
+}
-boost::shared_ptr<Swift::DiscoInfo> XMPPFrontend::sendCapabilitiesRequest(Swift::JID to) {
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> XMPPFrontend::sendCapabilitiesRequest(Swift::JID to) {
 	Swift::DiscoInfo::ref caps = m_entityCapsManager->getCaps(to);
 	if (caps != Swift::DiscoInfo::ref()) {
 		onCapabilitiesReceived(to, caps);
 		return caps;
+	}
 #ifdef SUPPORT_LEGACY_CAPS
 	else {
 		GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(to, m_iqRouter);
 		discoInfoRequest->onResponse.connect(boost::bind(&XMPPFrontend::handleDiscoInfoResponse, this, _1, _2, to));
 		discoInfoRequest->send();
+	}
 #endif
 User *XMPPFrontend::createUser(const Swift::JID &jid, UserInfo &userInfo, Component *component, UserManager *userManager) {
 	return new XMPPUser(jid, userInfo, component, userManager);
+}
 UserManager *XMPPFrontend::createUserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend) {
 	if (m_userManager) {
 		delete m_userManager;
+	}
 	m_userManager = new XMPPUserManager(component, userRegistry, storageBackend);
 	return m_userManager;
+}
-bool XMPPFrontend::handleIQ(boost::shared_ptr<Swift::IQ> iq) {
+bool XMPPFrontend::handleIQ(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq) {
 	if (!m_rawXML) {
 		return false;
+	}
 	if (iq->getPayload<Swift::RosterPayload>() != NULL) { return false; }
 	if (iq->getPayload<Swift::InBandRegistrationPayload>() != NULL) { return false; }
 	if (iq->getPayload<Swift::StatsPayload>() != NULL) { return false; }
 	if (iq->getTo().getNode().empty()) {
 		return false;
+	}
@@ @@ -325,26 +324,26 @@ void XMPPFrontend::connectToServer() { @@
 		LOG4CXX_INFO(logger, "Connecting XMPP server " << CONFIG_STRING(m_config, "service.server") << " port " << CONFIG_INT(m_config, "service.port"));
 		if (CONFIG_INT(m_config, "service.port") == 5222) {
 			LOG4CXX_WARN(logger, "Port 5222 is usually used for client connections, not for component connections! Are you sure you are using right port?");
+		}
 		m_component->connect(CONFIG_STRING(m_config, "service.server"), CONFIG_INT(m_config, "service.port"));
+	}
 	else if (m_server) {
 		LOG4CXX_INFO(logger, "Starting XMPPFrontend in server mode on port " << CONFIG_INT(m_config, "service.port"));
 		m_server->start();
 		//Type casting to BoostConnectionServer since onStopped signal is not defined in ConnectionServer
 		//Ideally, onStopped must be defined in ConnectionServer
 		if (boost::dynamic_pointer_cast<Swift::BoostConnectionServer>(m_server->getConnectionServer())) {
 			boost::dynamic_pointer_cast<Swift::BoostConnectionServer>(m_server->getConnectionServer())->onStopped.connect(boost::bind(&XMPPFrontend::handleServerStopped, this, _1));
 		if (SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::BoostConnectionServer>(m_server->getConnectionServer())) {
 			SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::BoostConnectionServer>(m_server->getConnectionServer())->onStopped.connect(boost::bind(&XMPPFrontend::handleServerStopped, this, _1));
+		}
 		// We're connected right here, because we're in server mode...
 		handleConnected();
+	}
+}
 void XMPPFrontend::disconnectFromServer() {
 	if (m_component) {
 		// TODO: Call this once swiften will fix assert(!session_);
 // 		m_component->disconnect();
+	}
+}
 void XMPPFrontend::handleDataRead(const Swift::SafeByteArray &data) {
 	std::string d = safeByteArrayToString(data);
 	m_transport->handleDataRead(d);
+}
 void XMPPFrontend::handleDataWritten(const Swift::SafeByteArray &data) {
 	std::string d = safeByteArrayToString(data);
 	m_transport->handleDataWritten(d);
+}
-void XMPPFrontend::handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid) {
+void XMPPFrontend::handleDiscoInfoResponse(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid) {
 #ifdef SUPPORT_LEGACY_CAPS
 	onCapabilitiesReceived(jid, info);
 #endif
+}
 void XMPPFrontend::handleCapsChanged(const Swift::JID& jid) {
 	onCapabilitiesReceived(jid, m_entityCapsManager->getCaps(jid));
+}
 std::string XMPPFrontend::getRegistrationFields() {
 	std::string fields = "Jabber ID";
 // 	if (CONFIG_BOOL(m_config, "registration.needRegistration")) {

spectrum/src/frontends/xmpp/XMPPFrontend.h

➞

Show inline comments

@@ @@ -58,66 +58,66 @@ namespace Transport { @@
 			virtual void init(Component *component, Swift::EventLoop *loop, Swift::NetworkFactories *factories, Config *config, UserRegistry *userRegistry);
 			virtual void connectToServer();
 			virtual void disconnectFromServer();
 			virtual void sendPresence(Swift::Presence::ref presence);
 			virtual void sendVCard(Swift::VCard::ref vcard, Swift::JID to);
 			virtual void sendRosterRequest(Swift::RosterPayload::ref, Swift::JID to);
-			virtual void sendMessage(boost::shared_ptr<Swift::Message> message);
+			virtual void sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message);
-			virtual void sendIQ(boost::shared_ptr<Swift::IQ>);
+			virtual void sendIQ(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ>);
 			virtual void reconnectUser(const std::string &user);
 			virtual RosterManager *createRosterManager(User *user, Component *component);
 			virtual User *createUser(const Swift::JID &jid, UserInfo &userInfo, Component *component, UserManager *userManager);
 			virtual UserManager *createUserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend = NULL);
-			virtual boost::shared_ptr<Swift::DiscoInfo> sendCapabilitiesRequest(Swift::JID to);
+			virtual SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> sendCapabilitiesRequest(Swift::JID to);
 			virtual void clearRoomList();
 			virtual void addRoomToRoomList(const std::string &handle, const std::string &name);
-			void handleMessage(boost::shared_ptr<Swift::Message> message);
+			void handleMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message);
 			Swift::StanzaChannel *getStanzaChannel();
 			Swift::IQRouter *getIQRouter() { return m_iqRouter; }
 			bool inServerMode() { return m_server != NULL; }
 			bool isRawXMLEnabled() {
 				return m_rawXML;
+			}
 			std::string getRegistrationFields();
 		private:
 			void handleConnected();
 			void handleConnectionError(const Swift::ComponentError &error);
 			void handleServerStopped(boost::optional<Swift::BoostConnectionServer::Error> e);
 			void handleGeneralPresence(Swift::Presence::ref presence);
 			void handleDataRead(const Swift::SafeByteArray &data);
 			void handleDataWritten(const Swift::SafeByteArray &data);
-			void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);
+			void handleDiscoInfoResponse(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);
 			void handleCapsChanged(const Swift::JID& jid);
 			void handleBackendConfigChanged();
-			bool handleIQ(boost::shared_ptr<Swift::IQ>);
+			bool handleIQ(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ>);
 			Swift::NetworkFactories *m_factories;
 			Swift::Component *m_component;
 			Swift::Server *m_server;
 			Swift::EntityCapsManager *m_entityCapsManager;
 			Swift::CapsManager *m_capsManager;
 			Swift::CapsMemoryStorage *m_capsMemoryStorage;
 			Swift::StanzaChannel *m_stanzaChannel;
 			Swift::IQRouter *m_iqRouter;
 			VCardResponder *m_vcardResponder;
 			Config* m_config;

spectrum/src/frontends/xmpp/XMPPFrontendPlugin.cpp

➞

Show inline comments

@@ @@ -34,19 +34,19 @@ XMPPFrontendPlugin::~XMPPFrontendPlugin() { @@
+}
 std::string XMPPFrontendPlugin::name() const {
 	return "xmpp";
+}
 Frontend *XMPPFrontendPlugin::createFrontend() {
 	return new XMPPFrontend();
+}
 // XMPPFrontendPlugin plugin;
 boost::shared_ptr<FrontendPlugin> get_xmpp_frontend_plugin() {
 	return boost::make_shared<XMPPFrontendPlugin>();
 SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<FrontendPlugin> get_xmpp_frontend_plugin() {
 	return SWIFTEN_SHRPTR_NAMESPACE::make_shared<XMPPFrontendPlugin>();
+}
 // BOOST_DLL_AUTO_ALIAS(plugin)
+}

spectrum/src/frontends/xmpp/XMPPFrontendPlugin.h

➞

Show inline comments

@@ @@ -27,18 +27,18 @@ @@
 namespace Transport {
 class XMPPFrontendPlugin : public FrontendPlugin {
 	public:
 		XMPPFrontendPlugin();
 		virtual ~XMPPFrontendPlugin();
 		std::string name() const;
 		Frontend *createFrontend();
 };
-boost::shared_ptr<FrontendPlugin> get_xmpp_frontend_plugin();
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<FrontendPlugin> get_xmpp_frontend_plugin();
+}
 BOOST_DLL_ALIAS(Transport::get_xmpp_frontend_plugin, create_xmpp_frontend_plugin)

spectrum/src/frontends/xmpp/XMPPRosterManager.cpp

➞

Show inline comments

 				m_component->getFrontend()->sendPresence(presence);
+			}
+		}
+	}
 	else {
 		LOG4CXX_WARN(logger, "handleBuddyRosterPushResponse called for unknown buddy " << key);
+	}
 	m_requests.remove(request);
 	request->onResponse.disconnect_all_slots();
+}
-void XMPPRosterManager::handleRemoteRosterResponse(boost::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref error) {
+void XMPPRosterManager::handleRemoteRosterResponse(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref error) {
 	m_remoteRosterRequest.reset();
 	if (error) {
 		m_supportRemoteRoster = false;
 		LOG4CXX_INFO(logger, m_user->getJID().toString() << ": This server does not support remote roster protoXEP");
 		return;
+	}
 	LOG4CXX_INFO(logger, m_user->getJID().toString() << ": This server supports remote roster protoXEP");
 	m_supportRemoteRoster = true;
 	//If we receive empty RosterPayload on login (not register) initiate full RosterPush
 	if(!m_buddies.empty() && payload->getItems().empty()){
@@ @@ -268,19 +268,19 @@ void XMPPRosterManager::sendRIE() { @@
+		}
 		Swift::RosterItemExchangePayload::Item item;
 		item.setJID(buddy->getJID().toBare());
 		item.setName(buddy->getAlias());
 		item.setAction(Swift::RosterItemExchangePayload::Item::Add);
 		item.setGroups(buddy->getGroups());
 		payload->addItem(item);
+	}
 	BOOST_FOREACH(Swift::JID &jid, jidWithRIE) {
 		LOG4CXX_INFO(logger, "Sending RIE stanza to " << jid.toString());
-		boost::shared_ptr<Swift::GenericRequest<Swift::RosterItemExchangePayload> > request(new Swift::GenericRequest<Swift::RosterItemExchangePayload>(Swift::IQ::Set, jid, payload, static_cast<XMPPFrontend *>(m_component->getFrontend())->getIQRouter()));
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::GenericRequest<Swift::RosterItemExchangePayload> > request(new Swift::GenericRequest<Swift::RosterItemExchangePayload>(Swift::IQ::Set, jid, payload, static_cast<XMPPFrontend *>(m_component->getFrontend())->getIQRouter()));
 		request->send();
+	}
+}
+}

spectrum/src/frontends/xmpp/XMPPRosterManager.h

➞

Show inline comments

@@ @@ -23,40 +23,41 @@ @@
 #include "transport/RosterManager.h"
 #include <string>
 #include <algorithm>
 #include <map>
 #include <boost/pool/pool_alloc.hpp>
 #include <boost/pool/object_pool.hpp>
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Queries/GenericRequest.h"
 #include "Swiften/Roster/SetRosterRequest.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/Network/Timer.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Transport {
 class Buddy;
 class User;
 class Component;
 class StorageBackend;
 class RosterStorage;
 // TODO: Once Swiften GetRosterRequest will support setting to="", this can be removed
 class AddressedRosterRequest : public Swift::GenericRequest<Swift::RosterPayload> {
 	public:
-		typedef boost::shared_ptr<AddressedRosterRequest> ref;
+		typedef SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<AddressedRosterRequest> ref;
 		AddressedRosterRequest(Swift::IQRouter* router, Swift::JID to) :
-				Swift::GenericRequest<Swift::RosterPayload>(Swift::IQ::Get, to, boost::shared_ptr<Swift::Payload>(new Swift::RosterPayload()), router) {
+				Swift::GenericRequest<Swift::RosterPayload>(Swift::IQ::Get, to, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::RosterPayload()), router) {
+		}
 };
 /// Manages roster of one XMPP user.
 class XMPPRosterManager : public RosterManager {
 	public:
 		typedef std::map<std::string, Buddy *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > > BuddiesMap;
 		/// Creates new XMPPRosterManager.
 		/// \param user User associated with this XMPPRosterManager.
 		/// \param component Transport instance associated with this roster.
 		XMPPRosterManager(User *user, Component *component);
@@ @@ -73,25 +74,25 @@ class XMPPRosterManager : public RosterManager { @@
 			return m_supportRemoteRoster;
+		}
 		void handleBuddyChanged(Buddy *buddy);
 		void sendBuddyRosterPush(Buddy *buddy);
 		void sendBuddyRosterRemove(Buddy *buddy);
 	private:
 		void sendRIE();
 		void handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error, Swift::SetRosterRequest::ref request, const std::string &key);
-		void handleRemoteRosterResponse(boost::shared_ptr<Swift::RosterPayload> roster, Swift::ErrorPayload::ref error);
+		void handleRemoteRosterResponse(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> roster, Swift::ErrorPayload::ref error);
 		Component *m_component;
 		RosterStorage *m_rosterStorage;
 		User *m_user;
 		Swift::Timer::ref m_setBuddyTimer;
 		Swift::Timer::ref m_RIETimer;
 		std::list <Swift::SetRosterRequest::ref> m_requests;
 		bool m_supportRemoteRoster;
 		AddressedRosterRequest::ref m_remoteRosterRequest;
 };
+}

spectrum/src/frontends/xmpp/XMPPUser.cpp

➞

Show inline comments

@@ @@ -22,90 +22,88 @@ @@
 #include "XMPPFrontend.h"
 #include "transport/Transport.h"
 #include "transport/UserManager.h"
 #include "transport/Logging.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/StreamError.h"
 #include "Swiften/Elements/SpectrumErrorPayload.h"
 #include "Swiften/Queries/IQRouter.h"
 #include <boost/foreach.hpp>
 #include <stdio.h>
 #include <stdlib.h>
 using namespace boost;
 #define foreach         BOOST_FOREACH
 namespace Transport {
 DEFINE_LOGGER(logger, "XMPPUser");
 XMPPUser::XMPPUser(const Swift::JID &jid, UserInfo &userInfo, Component *component, UserManager *userManager) : User(jid, userInfo, component, userManager) {
 	m_jid = jid.toBare();
 	m_component = component;
 	m_userManager = userManager;
 	m_userInfo = userInfo;
-	m_rooms = boost::shared_ptr<Swift::DiscoItems>(new Swift::DiscoItems());
+	m_rooms = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoItems>(new Swift::DiscoItems());
+}
 XMPPUser::~XMPPUser(){
 	if (m_component->inServerMode()) {
 #if HAVE_SWIFTEN_3
-		dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend*>(m_component->getFrontend())->getStanzaChannel())->finishSession(m_jid, boost::shared_ptr<Swift::ToplevelElement>());
+		dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend*>(m_component->getFrontend())->getStanzaChannel())->finishSession(m_jid, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ToplevelElement>());
 #else
-		dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend*>(m_component->getFrontend())->getStanzaChannel())->finishSession(m_jid, boost::shared_ptr<Swift::Element>());
+		dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend*>(m_component->getFrontend())->getStanzaChannel())->finishSession(m_jid, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element>());
 #endif
+	}
 	if (m_vcardRequests.size() != 0) {
 		LOG4CXX_INFO(logger, m_jid.toString() <<  ": Removing " << m_vcardRequests.size() << " unresponded IQs");
 		BOOST_FOREACH(Swift::GetVCardRequest::ref request, m_vcardRequests) {
 			request->onResponse.disconnect_all_slots();
 			static_cast<XMPPFrontend *>(m_component->getFrontend())->getIQRouter()->removeHandler(request);
+		}
 		m_vcardRequests.clear();
+	}
+}
 void XMPPUser::disconnectUser(const std::string &error, Swift::SpectrumErrorPayload::Error e) {
 	// In server mode, server finishes the session and pass unavailable session to userManager if we're connected to legacy network,
 	// so we can't removeUser() in server mode, because it would be removed twice.
 	// Once in finishSession and once in m_userManager->removeUser.
 	if (m_component->inServerMode()) {
 		// Remove user later just to be sure there won't be double-free.
 		// We can't be sure finishSession sends unavailable presence everytime, so check if user gets removed
 		// in finishSession(...) call and if not, remove it here.
 		std::string jid = m_jid.toBare().toString();
 #if HAVE_SWIFTEN_3
-		dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend*>(m_component->getFrontend())->getStanzaChannel())->finishSession(m_jid, boost::shared_ptr<Swift::ToplevelElement>(new Swift::StreamError(Swift::StreamError::UndefinedCondition, error)));
+		dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend*>(m_component->getFrontend())->getStanzaChannel())->finishSession(m_jid, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ToplevelElement>(new Swift::StreamError(Swift::StreamError::UndefinedCondition, error)));
 #else
-		dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend*>(m_component->getFrontend())->getStanzaChannel())->finishSession(m_jid, boost::shared_ptr<Swift::Element>(new Swift::StreamError(Swift::StreamError::UndefinedCondition, error)));
+		dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend*>(m_component->getFrontend())->getStanzaChannel())->finishSession(m_jid, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element>(new Swift::StreamError(Swift::StreamError::UndefinedCondition, error)));
 #endif
+	}
+}
-void XMPPUser::handleVCardReceived(boost::shared_ptr<Swift::VCard> vcard, Swift::ErrorPayload::ref error, Swift::GetVCardRequest::ref request) {
+void XMPPUser::handleVCardReceived(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> vcard, Swift::ErrorPayload::ref error, Swift::GetVCardRequest::ref request) {
 	m_vcardRequests.remove(request);
 	request->onResponse.disconnect_all_slots();
 	m_component->getFrontend()->onVCardUpdated(this, vcard);
+}
 void XMPPUser::requestVCard() {
 	LOG4CXX_INFO(logger, m_jid.toString() << ": Requesting VCard");
 	Swift::GetVCardRequest::ref request = Swift::GetVCardRequest::create(m_jid, static_cast<XMPPFrontend *>(m_component->getFrontend())->getIQRouter());
 	request->onResponse.connect(boost::bind(&XMPPUser::handleVCardReceived, this, _1, _2, request));
 	request->send();
 	m_vcardRequests.push_back(request);
+}
 void XMPPUser::clearRoomList() {
-	m_rooms = boost::shared_ptr<Swift::DiscoItems>(new Swift::DiscoItems());
+	m_rooms = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoItems>(new Swift::DiscoItems());
+}
 void XMPPUser::addRoomToRoomList(const std::string &handle, const std::string &name) {
 	m_rooms->addItem(Swift::DiscoItems::Item(name, handle));
+}
+}

spectrum/src/frontends/xmpp/XMPPUser.h

➞

Show inline comments

@@ @@ -53,29 +53,29 @@ class XMPPUser : public User { @@
 		/// Destroyes User.
 		virtual ~XMPPUser();
 		void disconnectUser(const std::string &error, Swift::SpectrumErrorPayload::Error e);
 		void requestVCard();
 		void clearRoomList();
 		void addRoomToRoomList(const std::string &handle, const std::string &name);
-		boost::shared_ptr<Swift::DiscoItems> getRoomList() {
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoItems> getRoomList() {
 			return m_rooms;
+		}
 	private:
 		void onConnectingTimeout();
-		void handleVCardReceived(boost::shared_ptr<Swift::VCard> vcard, Swift::ErrorPayload::ref error, Swift::GetVCardRequest::ref request);
+		void handleVCardReceived(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> vcard, Swift::ErrorPayload::ref error, Swift::GetVCardRequest::ref request);
 		Swift::JID m_jid;
 		Component *m_component;
 		UserManager *m_userManager;
 		UserInfo m_userInfo;
 		std::list <Swift::GetVCardRequest::ref> m_vcardRequests;
-		boost::shared_ptr<Swift::DiscoItems> m_rooms;
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoItems> m_rooms;
 };
+}

spectrum/src/frontends/xmpp/XMPPUserManager.cpp

➞

Show inline comments

@@ @@ -121,21 +121,21 @@ XMPPUserManager::~XMPPUserManager() { @@
 	delete m_settings;
+}
 void XMPPUserManager::sendVCard(unsigned int id, Swift::VCard::ref vcard) {
 	m_vcardResponder->sendVCard(id, vcard);
+}
 void XMPPUserManager::handleVCardRequired(User *user, const std::string &name, unsigned int id) {
 	m_component->getFrontend()->onVCardRequired(user, name, id);
+}
-void XMPPUserManager::handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> vcard) {
+void XMPPUserManager::handleVCardUpdated(User *user, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> vcard) {
 	m_component->getFrontend()->onVCardUpdated(user, vcard);
+}
 UserRegistration *XMPPUserManager::getUserRegistration() {
 	return m_userRegistration;
+}
+}

spectrum/src/frontends/xmpp/XMPPUserManager.h

➞

Show inline comments

@@ @@ -49,25 +49,25 @@ class XMPPUserManager : public UserManager { @@
 		virtual ~XMPPUserManager();
 		virtual void sendVCard(unsigned int id, Swift::VCard::ref vcard);
 		UserRegistration *getUserRegistration();
 		DiscoItemsResponder *getDiscoItemsResponder() {
 			return m_discoItemsResponder;
+		}
 	private:
 		void handleVCardRequired(User *, const std::string &name, unsigned int id);
-		void handleVCardUpdated(User *, boost::shared_ptr<Swift::VCard> vcard);
+		void handleVCardUpdated(User *, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> vcard);
 		StorageResponder *m_storageResponder;
 		VCardResponder *m_vcardResponder;
 		Component *m_component;
 		XMPPUserRegistration *m_userRegistration;
 		GatewayResponder *m_gatewayResponder;
 		AdHocManager *m_adHocManager;
 		SettingsAdHocCommandFactory *m_settings;
 		RosterResponder *m_rosterResponder;
 		DiscoItemsResponder *m_discoItemsResponder;
 };

spectrum/src/frontends/xmpp/XMPPUserRegistration.cpp

➞

Show inline comments

 	return true;
+}
 bool XMPPUserRegistration::doUserUnregistration(const UserInfo &row) {
 	// Check if the server supports remoteroster XEP by sending request for the registered user's roster.
 	AddressedRosterRequest::ref request = AddressedRosterRequest::ref(new AddressedRosterRequest(static_cast<XMPPFrontend *>(m_component->getFrontend())->getIQRouter(), row.jid));
 	request->onResponse.connect(boost::bind(&XMPPUserRegistration::handleUnregisterRemoteRosterResponse, this, _1, _2, row));
 	request->send();
 	return true;
+}
-void XMPPUserRegistration::handleRegisterRemoteRosterResponse(boost::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref remoteRosterNotSupported, const UserInfo &row){
+void XMPPUserRegistration::handleRegisterRemoteRosterResponse(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref remoteRosterNotSupported, const UserInfo &row){
 	if (remoteRosterNotSupported || !payload) {
 		// Remote roster is not support, so send normal Subscribe presence to add transport.
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setFrom(m_component->getJID());
 		response->setTo(Swift::JID(row.jid));
 		response->setType(Swift::Presence::Subscribe);
 		m_component->getFrontend()->sendPresence(response);
+	}
 	else {
 		// Remote roster is support, so use remoteroster XEP to add transport.
 		Swift::RosterPayload::ref payload = Swift::RosterPayload::ref(new Swift::RosterPayload());
 		Swift::RosterItemPayload item;
 		item.setJID(m_component->getJID());
 		item.setSubscription(Swift::RosterItemPayload::Both);
 		payload->addItem(item);
 		Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, row.jid, static_cast<XMPPFrontend *>(m_component->getFrontend())->getIQRouter());
 		request->send();
+	}
 	onUserRegistered(row);
 	// If the JID for registration notification is configured, send the notification message.
 	std::vector<std::string> const &x = CONFIG_VECTOR(m_component->getConfig(),"registration.notify_jid");
 	BOOST_FOREACH(const std::string &notify_jid, x) {
-		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody(std::string("registered: ") + row.jid);
 		msg->setTo(notify_jid);
 		msg->setFrom(m_component->getJID());
 		m_component->getFrontend()->sendMessage(msg);
+	}
+}
-void XMPPUserRegistration::handleUnregisterRemoteRosterResponse(boost::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref remoteRosterNotSupported, const UserInfo &userInfo) {
+void XMPPUserRegistration::handleUnregisterRemoteRosterResponse(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref remoteRosterNotSupported, const UserInfo &userInfo) {
 	if (remoteRosterNotSupported || !payload) {
 		// Remote roster is ont support, so get the buddies from database
 		// and send Unsubsribe and Unsubscribed presence to them.
 		std::list<BuddyInfo> roster;
 		m_storageBackend->getBuddies(userInfo.id, roster);
 		for(std::list<BuddyInfo>::iterator u = roster.begin(); u != roster.end() ; u++){
 			std::string name = (*u).legacyName;
 			if ((*u).flags & BUDDY_JID_ESCAPING) {
 				name = Swift::JID::getEscapedNode((*u).legacyName);
+			}
 			else {
 				if (name.find_last_of("@") != std::string::npos) {
 		Swift::RosterItemPayload item;
 		item.setJID(m_component->getJID());
 		item.setSubscription(Swift::RosterItemPayload::Remove);
 		payload->addItem(item);
 		Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, userInfo.jid, static_cast<XMPPFrontend *>(m_component->getFrontend())->getIQRouter());
 		request->send();
+	}
 	// If the JID for registration notification is configured, send the notification message.
 	std::vector<std::string> const &x = CONFIG_VECTOR(m_component->getConfig(),"registration.notify_jid");
 	BOOST_FOREACH(const std::string &notify_jid, x) {
-		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody(std::string("unregistered: ") + userInfo.jid);
 		msg->setTo(notify_jid);
 		msg->setFrom(m_component->getJID());
 		m_component->getFrontend()->sendMessage(msg);
+	}
+}
 Form::ref XMPPUserRegistration::generateRegistrationForm(const UserInfo &res, bool registered) {
 	Form::ref form(new Form(Form::FormType));
 	form->setTitle("Registration");
 	form->setInstructions(CONFIG_STRING(m_config, "registration.instructions"));
 	if (registered) {
 		FormUtils::addBooleanField(form, "unregister", "0", "Remove your registration");
+	}
 	else if (CONFIG_BOOL(m_config,"registration.require_local_account")) {
 		std::string localUsernameField = CONFIG_STRING(m_config, "registration.local_username_label");
 		FormUtils::addTextSingleField(form, "local_username", "", localUsernameField, true);
 		FormUtils::addTextSingleField(form, "local_password", "", "Local password", true);
+	}
 	return form;
+}
 boost::shared_ptr<InBandRegistrationPayload> XMPPUserRegistration::generateInBandRegistrationPayload(const Swift::JID& from) {
 	boost::shared_ptr<InBandRegistrationPayload> reg(new InBandRegistrationPayload());
 SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<InBandRegistrationPayload> XMPPUserRegistration::generateInBandRegistrationPayload(const Swift::JID& from) {
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<InBandRegistrationPayload> reg(new InBandRegistrationPayload());
 	UserInfo res;
 	bool registered = m_storageBackend->getUser(from.toBare().toString(), res);
 	reg->setInstructions(CONFIG_STRING(m_config, "registration.instructions"));
 	reg->setRegistered(registered);
 	reg->setUsername(res.uin);
 	if (CONFIG_BOOL_DEFAULTED(m_config, "registration.needPassword", true)) {
 		reg->setPassword("");
+	}
 	Form::ref form = generateRegistrationForm(res, registered);
 	reg->setForm(form);
 	return reg;
+}
-bool XMPPUserRegistration::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::InBandRegistrationPayload> payload) {
+bool XMPPUserRegistration::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::InBandRegistrationPayload> payload) {
 	// TODO: backend should say itself if registration is needed or not...
 	if (CONFIG_STRING(m_config, "service.protocol") == "irc") {
 		sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);
 		return true;
+	}
 	if (!CONFIG_BOOL(m_config,"registration.enable_public_registration")) {
 		std::vector<std::string> const &x = CONFIG_VECTOR(m_config,"service.allowed_servers");
 		if (std::find(x.begin(), x.end(), from.getDomain()) == x.end()) {
 			LOG4CXX_INFO(logger, from.toBare().toString() << ": This user has no permissions to register an account")
 			sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);
 			return true;
+		}
+	}
-	boost::shared_ptr<InBandRegistrationPayload> reg = generateInBandRegistrationPayload(from);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<InBandRegistrationPayload> reg = generateInBandRegistrationPayload(from);
 	sendResponse(from, id, reg);
 	return true;
+}
-bool XMPPUserRegistration::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::InBandRegistrationPayload> payload) {
+bool XMPPUserRegistration::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::InBandRegistrationPayload> payload) {
 	// TODO: backend should say itself if registration is needed or not...
 	if (CONFIG_STRING(m_config, "service.protocol") == "irc") {
 		sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);
 		return true;
+	}
 	std::string barejid = from.toBare().toString();
 	if (!CONFIG_BOOL(m_config,"registration.enable_public_registration")) {
 		std::vector<std::string> const &x = CONFIG_VECTOR(m_config,"service.allowed_servers");
 		if (std::find(x.begin(), x.end(), from.getDomain()) == x.end()) {
 			LOG4CXX_INFO(logger, barejid << ": This user has no permissions to register an account")

spectrum/src/frontends/xmpp/XMPPUserRegistration.h

➞

Show inline comments

@@ @@ -14,24 +14,26 @@ @@
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include "Swiften/Queries/Responder.h"
 #include "Swiften/Elements/InBandRegistrationPayload.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/SwiftenCompat.h"
 #include <boost/signal.hpp>
 #include <Swiften/Version.h>
 #include "transport/UserRegistration.h"
 #define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)
 namespace Transport {
 struct UserInfo;
 class Component;
 class StorageBackend;
 class UserManager;
 class Config;
 		/// Registers new user. This function stores user into database and subscribe user to transport.
 		/// \param userInfo UserInfo struct with informations about registered user
 		/// \return false if user is already registered
 		virtual bool doUserRegistration(const UserInfo &userInfo);
 		/// Unregisters user. This function removes all data about user from databa, unsubscribe all buddies
 		/// managed by this transport and disconnects user if he's connected.
 		/// \param barejid bare JID of user to unregister
 		/// \return false if there is no such user registered
 		virtual bool doUserUnregistration(const UserInfo &userInfo);
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::InBandRegistrationPayload> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::InBandRegistrationPayload> payload);
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::InBandRegistrationPayload> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::InBandRegistrationPayload> payload);
 		void handleRegisterRemoteRosterResponse(boost::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref error, const UserInfo &row);
 		void handleUnregisterRemoteRosterResponse(boost::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref error, const UserInfo &row);
 		boost::shared_ptr<Swift::InBandRegistrationPayload> generateInBandRegistrationPayload(const Swift::JID& from);
 		void handleRegisterRemoteRosterResponse(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref error, const UserInfo &row);
 		void handleUnregisterRemoteRosterResponse(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref error, const UserInfo &row);
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::InBandRegistrationPayload> generateInBandRegistrationPayload(const Swift::JID& from);
 		Swift::Form::ref generateRegistrationForm(const UserInfo &res, bool registered);
 		Component *m_component;
 		StorageBackend *m_storageBackend;
 		UserManager *m_userManager;
 		Config *m_config;
 };
+}

spectrum/src/frontends/xmpp/adhoccommand.h

➞

Show inline comments

@@ @@ -18,42 +18,43 @@ @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include <map>
 #include <time.h>
 #include "Swiften/Elements/FormField.h"
 #include "Swiften/Elements/Command.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Transport {
 class Component;
 class UserManager;
 class StorageBackend;
 class AdHocCommand {
 	public:
 		/// Creates new AdHocManager.
 		/// \param component Transport instance associated with this AdHocManager.
 		AdHocCommand(Component *component, UserManager *userManager, StorageBackend *storageBackend, const Swift::JID &initiator, const Swift::JID &to);
 		/// Destructor.
 		virtual ~AdHocCommand();
-		virtual boost::shared_ptr<Swift::Command> handleRequest(boost::shared_ptr<Swift::Command> payload) = 0;
+		virtual SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> handleRequest(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload) = 0;
 		const std::string &getId() {
 			return m_id;
+		}
 		void refreshLastActivity() {
 			m_lastActivity = time(NULL);
+		}
 		time_t getLastActivity() {
 			return m_lastActivity;
+		}

spectrum/src/frontends/xmpp/adhocmanager.cpp

➞

Show inline comments

@@ @@ -119,29 +119,29 @@ void AdHocManager::removeOldSessions() { @@
+		}
+	}
 	BOOST_FOREACH(std::string &key, toRemove) {
 		m_sessions.erase(key);
+	}
 	if (removedCommands > 0) {
 		LOG4CXX_INFO(logger, "Removed " << removedCommands << " old commands sessions.");
+	}
+}
-bool AdHocManager::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::Command> payload) {
+bool AdHocManager::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload) {
 	return false;
+}
-bool AdHocManager::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::Command> payload) {
+bool AdHocManager::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload) {
 	AdHocCommand *command = NULL;
 	// Try to find AdHocCommand according to 'from' and session_id
 	if (!payload->getSessionID().empty() && m_sessions.find(from) != m_sessions.end()) {
 		if (m_sessions[from].find(payload->getSessionID()) != m_sessions[from].end()) {
 			command = m_sessions[from][payload->getSessionID()];
+		}
 		else {
 			LOG4CXX_ERROR(logger, from.toString() << ": Unknown session id " << payload->getSessionID() << " - ignoring");
 			sendError(from, id, Swift::ErrorPayload::BadRequest, Swift::ErrorPayload::Modify);
 			return true;
+		}
+	}
 	else {
 		LOG4CXX_INFO(logger, from.toString() << ": Unknown node " << payload->getNode() << ". Can't start AdHoc command session.");
 		sendError(from, id, Swift::ErrorPayload::BadRequest, Swift::ErrorPayload::Modify);
 		return true;
+	}
 	if (!command) {
 		LOG4CXX_ERROR(logger, from.toString() << ": createAdHocCommand for node " << payload->getNode() << " returned NULL pointer");
 		sendError(from, id, Swift::ErrorPayload::BadRequest, Swift::ErrorPayload::Modify);
 		return true;
+	}
-	boost::shared_ptr<Swift::Command> response = command->handleRequest(payload);
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> response = command->handleRequest(payload);
 	if (!response) {
 		LOG4CXX_ERROR(logger, from.toString() << ": handleRequest for node " << payload->getNode() << " returned NULL pointer");
 		sendError(from, id, Swift::ErrorPayload::BadRequest, Swift::ErrorPayload::Modify);
 		return true;
+	}
 	response->setSessionID(command->getId());
 	sendResponse(from, id, response);
 	command->refreshLastActivity();

spectrum/src/frontends/xmpp/adhocmanager.h

➞

Show inline comments

@@ @@ -18,24 +18,25 @@ @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include <map>
 #include "Swiften/Queries/Responder.h"
 #include "Swiften/Elements/Command.h"
 #include "Swiften/Network/Timer.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Transport {
 class Conversation;
 class User;
 class Component;
 class DiscoItemsResponder;
 class AdHocCommandFactory;
 class AdHocCommand;
 class UserManager;
 class StorageBackend;
 		/// Stops handling AdHoc commands payloads and destroys all existing
 		/// AdHoc commands sessions.
 		void stop();
 		/// Adds factory to create new AdHoc commands sessions of particular type.
 		void addAdHocCommand(AdHocCommandFactory *factory);
 		/// Remove sessions older than N seconds.
 		void removeOldSessions();
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::Command> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::Command> payload);
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload);
 		void handleUserCreated(User *user);
 		Component *m_component;
 		DiscoItemsResponder *m_discoItemsResponder;
 		std::map<std::string, AdHocCommandFactory *> m_factories;
 		SessionsMap m_sessions;
 		Swift::Timer::ref m_collectTimer;
 		UserManager *m_userManager;
 		StorageBackend *m_storageBackend;
 };

spectrum/src/frontends/xmpp/blockresponder.cpp

➞

Show inline comments

@@ @@ -22,39 +22,38 @@ @@
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "BlockPayload.h"
 #include "transport/UserManager.h"
 #include "transport/User.h"
 #include "transport/Buddy.h"
 #include "transport/RosterManager.h"
 #include "transport/Logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "BlockResponder");
 BlockResponder::BlockResponder(Swift::IQRouter *router, UserManager *userManager) : Swift::SetResponder<BlockPayload>(router) {
 	m_userManager = userManager;
+}
 BlockResponder::~BlockResponder() {
+}
-bool BlockResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Transport::BlockPayload> info) {
+bool BlockResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Transport::BlockPayload> info) {
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": User is not logged in");
 		return true;
+	}
 	Buddy *buddy = Buddy::JIDToBuddy(to, user);
 	if (!buddy) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": Buddy " << Buddy::JIDToLegacyName(to, user) << " does not exist");
 		return true;
+	}

spectrum/src/frontends/xmpp/blockresponder.h

➞

Show inline comments

@@ @@ -29,18 +29,18 @@ namespace Transport { @@
 class UserManager;
 class Buddy;
 class BlockResponder : public Swift::SetResponder<Transport::BlockPayload> {
 	public:
 		BlockResponder(Swift::IQRouter *router, UserManager *userManager);
 		~BlockResponder();
 		boost::signal<void (Buddy *)> onBlockToggled;
 	private:
-		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Transport::BlockPayload> payload);
+		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Transport::BlockPayload> payload);
 		UserManager *m_userManager;
 };
+}

spectrum/src/frontends/xmpp/discoinforesponder.cpp

➞

Show inline comments

@@ @@ -25,39 +25,38 @@ @@
 #include <boost/algorithm/string.hpp>
 #include "Swiften/Disco/DiscoInfoResponder.h"
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "transport/Config.h"
 #include "transport/Logging.h"
 #include "Swiften/Disco/CapsInfoGenerator.h"
 #include "XMPPFrontend.h"
 #include "transport/UserManager.h"
 #include "XMPPUser.h"
 using namespace Swift;
 using namespace boost;
 DEFINE_LOGGER(logger, "DiscoInfoResponder");
 namespace Transport {
 DiscoInfoResponder::DiscoInfoResponder(Swift::IQRouter *router, Config *config, UserManager *userManager) : Swift::GetResponder<DiscoInfo>(router) {
 	m_config = config;
 	m_config->onBackendConfigUpdated.connect(boost::bind(&DiscoInfoResponder::updateFeatures, this));
 	m_buddyInfo = NULL;
 	m_transportInfo.addIdentity(DiscoInfo::Identity(CONFIG_STRING(m_config, "identity.name"),
 													CONFIG_STRING(m_config, "identity.category"),
 													CONFIG_STRING(m_config, "identity.type")));
 #if HAVE_SWIFTEN_3
-	crypto = boost::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());
+	crypto = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());
 #endif
 	updateFeatures();
 	m_userManager = userManager;
+}
 DiscoInfoResponder::~DiscoInfoResponder() {
 	delete m_buddyInfo;
+}
 void DiscoInfoResponder::updateFeatures() {
 	std::list<std::string> features2;
 	boost::algorithm::to_lower(j);
 	m_rooms[j] = name;
+}
 void DiscoInfoResponder::clearRooms() {
 	m_rooms.clear();
+}
 void DiscoInfoResponder::addAdHocCommand(const std::string &node, const std::string &name) {
 	m_commands[node] = node;
+}
-bool DiscoInfoResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoInfo> info) {
+bool DiscoInfoResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> info) {
 	// disco#info for transport
 	if (to.getNode().empty()) {
 		// Adhoc command
 		if (m_commands.find(info->getNode()) != m_commands.end()) {
-			boost::shared_ptr<DiscoInfo> res(new DiscoInfo());
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DiscoInfo> res(new DiscoInfo());
 			res->addFeature("http://jabber.org/protocol/commands");
 			res->addFeature("jabber:x:data");
 			res->addIdentity(DiscoInfo::Identity(m_commands[info->getNode()], "automation", "command-node"));
 			res->setNode(info->getNode());
 			sendResponse(from, to, id, res);
+		}
 		else if (info->getNode() == "http://jabber.org/protocol/commands") {
-			boost::shared_ptr<DiscoInfo> res(new DiscoInfo());
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DiscoInfo> res(new DiscoInfo());
 			res->addIdentity(DiscoInfo::Identity("Commands", "automation", "command-list"));
 			res->setNode(info->getNode());
 			sendResponse(from, to, id, res);
+		}
 		else {
 			if (!info->getNode().empty()) {
 				sendError(from, id, ErrorPayload::ItemNotFound, ErrorPayload::Cancel);
 				return true;
+			}
-			boost::shared_ptr<DiscoInfo> res(new DiscoInfo(m_transportInfo));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DiscoInfo> res(new DiscoInfo(m_transportInfo));
 			res->setNode(info->getNode());
 			sendResponse(from, id, res);
+		}
 		return true;
+	}
 	// disco#info for room
 	if (m_rooms.find(to.toBare().toString()) != m_rooms.end()) {
-		boost::shared_ptr<DiscoInfo> res(new DiscoInfo());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DiscoInfo> res(new DiscoInfo());
 		res->addIdentity(DiscoInfo::Identity(m_rooms[to.toBare().toString()], "conference", "text"));
 		res->addFeature("http://jabber.org/protocol/muc");
 		res->setNode(info->getNode());
 		sendResponse(from, to, id, res);
 		return true;
+	}
 	// disco#info for per-user rooms (like Skype/Facebook groupchats)
 	XMPPUser *user = static_cast<XMPPUser *>(m_userManager->getUser(from.toBare().toString()));
 	if (user) {
 		BOOST_FOREACH(const DiscoItems::Item &item, user->getRoomList()->getItems()) {
 			LOG4CXX_INFO(logger, "XXX " << item.getNode() << " " << to.toBare().toString());
 			if (item.getJID().toString() == to.toBare().toString()) {
-				boost::shared_ptr<DiscoInfo> res(new DiscoInfo());
+				SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DiscoInfo> res(new DiscoInfo());
 				res->addIdentity(DiscoInfo::Identity(item.getName(), "conference", "text"));
 				res->addFeature("http://jabber.org/protocol/muc");
 				res->setNode(info->getNode());
 				sendResponse(from, to, id, res);
 				return true;
+			}
+		}
+	}
 	// disco#info for buddy
-	boost::shared_ptr<DiscoInfo> res(new DiscoInfo(*m_buddyInfo));
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DiscoInfo> res(new DiscoInfo(*m_buddyInfo));
 	res->setNode(info->getNode());
 	sendResponse(from, to, id, res);
 	return true;
+}
+}

spectrum/src/frontends/xmpp/discoinforesponder.h

➞

Show inline comments

@@ @@ -17,24 +17,25 @@ @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <vector>
 #include <list>
 #include <boost/signal.hpp>
 #include "Swiften/Queries/GetResponder.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "Swiften/Elements/CapsInfo.h"
 #include "Swiften/SwiftenCompat.h"
 #include <Swiften/Version.h>
 #define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)
 #if HAVE_SWIFTEN_3
 #include <Swiften/Crypto/CryptoProvider.h>
 #include <Swiften/Crypto/PlatformCryptoProvider.h>
 #endif
 namespace Transport {
 class Config;
 class UserManager;
 		void addRoom(const std::string &jid, const std::string &name);
 		void clearRooms();
 		void addAdHocCommand(const std::string &node, const std::string &name);
 		boost::signal<void (const Swift::CapsInfo &capsInfo)> onBuddyCapsInfoChanged;
 		Swift::CapsInfo &getBuddyCapsInfo() {
 				return m_capsInfo;
+		}
 	private:
-		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoInfo> payload);
+		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> payload);
 		void updateFeatures();
 		Swift::DiscoInfo m_transportInfo;
 		Swift::DiscoInfo *m_buddyInfo;
 		Config *m_config;
 		Swift::CapsInfo m_capsInfo;
 		std::map<std::string, std::string> m_rooms;
 		std::map<std::string, std::string> m_commands;
 #if HAVE_SWIFTEN_3
-		boost::shared_ptr<Swift::CryptoProvider> crypto;
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::CryptoProvider> crypto;
 #endif
 		UserManager *m_userManager;
 };
+}

spectrum/src/frontends/xmpp/discoitemsresponder.cpp

➞

Show inline comments

@@ @@ -24,86 +24,85 @@ @@
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "transport/Transport.h"
 #include "transport/Logging.h"
 #include "transport/Config.h"
 #include "discoinforesponder.h"
 #include "XMPPFrontend.h"
 #include "transport/Frontend.h"
 #include "transport/UserManager.h"
 #include "XMPPUser.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "DiscoItemsResponder");
 DiscoItemsResponder::DiscoItemsResponder(Component *component, UserManager *userManager) : Swift::GetResponder<DiscoItems>(static_cast<XMPPFrontend *>(component->getFrontend())->getIQRouter()) {
 	m_component = component;
-	m_commands = boost::shared_ptr<DiscoItems>(new DiscoItems());
+	m_commands = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DiscoItems>(new DiscoItems());
 	m_commands->setNode("http://jabber.org/protocol/commands");
-	m_rooms = boost::shared_ptr<DiscoItems>(new DiscoItems());
+	m_rooms = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DiscoItems>(new DiscoItems());
 	m_discoInfoResponder = new DiscoInfoResponder(static_cast<XMPPFrontend *>(component->getFrontend())->getIQRouter(), component->getConfig(), userManager);
 	m_discoInfoResponder->start();
 	m_userManager = userManager;
+}
 DiscoItemsResponder::~DiscoItemsResponder() {
 	delete m_discoInfoResponder;
+}
 void DiscoItemsResponder::addAdHocCommand(const std::string &node, const std::string &name) {
 	m_commands->addItem(DiscoItems::Item(name, m_component->getJID(), node));
 	m_discoInfoResponder->addAdHocCommand(node, name);
+}
 void DiscoItemsResponder::addRoom(const std::string &node, const std::string &name) {
 	if (m_rooms->getItems().size() > CONFIG_INT(m_component->getConfig(), "service.max_room_list_size")) {
 		return;
+	}
 	m_rooms->addItem(DiscoItems::Item(name, node));
 	m_discoInfoResponder->addRoom(node, name);
+}
 void DiscoItemsResponder::clearRooms() {
-	m_rooms = boost::shared_ptr<DiscoItems>(new DiscoItems());
+	m_rooms = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DiscoItems>(new DiscoItems());
 	m_discoInfoResponder->clearRooms();
+}
 Swift::CapsInfo &DiscoItemsResponder::getBuddyCapsInfo() {
 	return m_discoInfoResponder->getBuddyCapsInfo();
+}
-bool DiscoItemsResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoItems> info) {
+bool DiscoItemsResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoItems> info) {
 	LOG4CXX_INFO(logger, "get request received with node " << info->getNode());
 	if (info->getNode() == "http://jabber.org/protocol/commands") {
 		sendResponse(from, id, m_commands);
+	}
 	else if (to.getNode().empty() && info->getNode().empty()) {
 		XMPPUser *user = static_cast<XMPPUser *>(m_userManager->getUser(from.toBare().toString()));
 		if (!user) {
 			sendResponse(from, id, m_rooms);
 			return true;
+		}
-		boost::shared_ptr<DiscoItems> rooms = boost::shared_ptr<DiscoItems>(new DiscoItems());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DiscoItems> rooms = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DiscoItems>(new DiscoItems());
 		BOOST_FOREACH(const DiscoItems::Item &item, m_rooms->getItems()) {
 			rooms->addItem(item);
+		}
 		BOOST_FOREACH(const DiscoItems::Item &item, user->getRoomList()->getItems()) {
 			rooms->addItem(item);
+		}
 		sendResponse(from, id, rooms);
+	}
 	else {
-		sendResponse(from, id, boost::shared_ptr<DiscoItems>(new DiscoItems()));
+		sendResponse(from, id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<DiscoItems>(new DiscoItems()));
+	}
 	return true;
+}
+}

spectrum/src/frontends/xmpp/discoitemsresponder.h

➞

Show inline comments

@@ @@ -15,45 +15,46 @@ @@
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <vector>
 #include "Swiften/Queries/GetResponder.h"
 #include "Swiften/Elements/DiscoItems.h"
 #include "Swiften/Elements/CapsInfo.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Transport {
 class Component;
 class DiscoInfoResponder;
 class UserManager;
 class DiscoItemsResponder : public Swift::GetResponder<Swift::DiscoItems> {
 	public:
 		DiscoItemsResponder(Component *component, UserManager *userManager);
 		~DiscoItemsResponder();
 		Swift::CapsInfo &getBuddyCapsInfo();
 		void addAdHocCommand(const std::string &node, const std::string &name);
 // 		void removeAdHocCommand(const std::string &node);
 		void addRoom(const std::string &node, const std::string &name);
 		void clearRooms();
 	private:
-		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoItems> payload);
+		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoItems> payload);
 	private:
 		Component *m_component;
 		boost::shared_ptr<Swift::DiscoItems> m_commands;
 		boost::shared_ptr<Swift::DiscoItems> m_rooms;
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoItems> m_commands;
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoItems> m_rooms;
 		DiscoInfoResponder *m_discoInfoResponder;
 		UserManager *m_userManager;
 };
+}

spectrum/src/frontends/xmpp/formutils.cpp

➞

Show inline comments

@@ @@ -12,138 +12,140 @@ @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "formutils.h"
 #include "adhoccommand.h"
 #include "Swiften/SwiftenCompat.h"
 #if HAVE_SWIFTEN_3
 #include <Swiften/Elements/Form.h>
 #endif
 using namespace Swift;
 namespace Transport {
 namespace FormUtils {
 static
 #if HAVE_SWIFTEN_3
 FormField::ref
 #else
 HiddenFormField::ref
 #endif
 createHiddenField(const std::string &name, const std::string &value) {
 #if HAVE_SWIFTEN_3
-	FormField::ref field = boost::make_shared<FormField>(FormField::HiddenType, value);
+	FormField::ref field = SWIFTEN_SHRPTR_NAMESPACE::make_shared<FormField>(FormField::HiddenType, value);
 #else
 	HiddenFormField::ref field = HiddenFormField::create();
 	field->setValue(value);
 #endif
 	field->setName(name);
 	return field;
+}
 static
 #if HAVE_SWIFTEN_3
 FormField::ref
 #else
 TextSingleFormField::ref
 #endif
 createTextSingleField(const std::string &name, const std::string &value, const std::string &label, bool required) {
 #if HAVE_SWIFTEN_3
-	FormField::ref field = boost::make_shared<FormField>(FormField::TextSingleType, value);
+	FormField::ref field = SWIFTEN_SHRPTR_NAMESPACE::make_shared<FormField>(FormField::TextSingleType, value);
 #else
 	TextSingleFormField::ref field = TextSingleFormField::create();
 	field->setValue(value);
 #endif
 	field->setName(name);
 	field->setLabel(label);
 	field->setRequired(required);
 	return field;
+}
 static
 #if HAVE_SWIFTEN_3
 FormField::ref
 #else
 TextPrivateFormField::ref
 #endif
 createTextPrivateField(const std::string &name, const std::string &label, bool required) {
 #if HAVE_SWIFTEN_3
-	FormField::ref field = boost::make_shared<FormField>(FormField::TextPrivateType);
+	FormField::ref field = SWIFTEN_SHRPTR_NAMESPACE::make_shared<FormField>(FormField::TextPrivateType);
 #else
 	TextPrivateFormField::ref field = TextPrivateFormField::create();
 #endif
 	field->setName(name);
 	field->setLabel(label);
 	field->setRequired(required);
 	return field;
+}
 static
 #if HAVE_SWIFTEN_3
 FormField::ref
 #else
 ListSingleFormField::ref
 #endif
 createListSingleField(const std::string &name, Swift::FormField::Option value, const std::string &label, const std::string &def, bool required) {
 #if HAVE_SWIFTEN_3
-	FormField::ref field = boost::make_shared<FormField>(FormField::ListSingleType);
+	FormField::ref field = SWIFTEN_SHRPTR_NAMESPACE::make_shared<FormField>(FormField::ListSingleType);
 #else
 	ListSingleFormField::ref field = ListSingleFormField::create();
 #endif
 	field->setName(name);
 	field->setLabel(label);
 	field->addOption(value);
 #if HAVE_SWIFTEN_3
 	field->addValue(def);
 #else
 	field->setValue(def);
 #endif
 	return field;
+}
 static
 #if HAVE_SWIFTEN_3
 FormField::ref
 #else
 BooleanFormField::ref
 #endif
 createBooleanField(const std::string &name, const std::string &value, const std::string &label, bool required) {
 #if HAVE_SWIFTEN_3
-	FormField::ref field = boost::make_shared<FormField>(FormField::BooleanType, value);
+	FormField::ref field = SWIFTEN_SHRPTR_NAMESPACE::make_shared<FormField>(FormField::BooleanType, value);
 #else
 	BooleanFormField::ref field = BooleanFormField::create();
 	field->setValue(value == "1");
 #endif
 	field->setName(name);
 	field->setLabel(label);
 	field->setRequired(required);
 	return field;
+}
 static
 #if HAVE_SWIFTEN_3
 FormField::ref
 #else
 FixedFormField::ref
 #endif
 createTextFixedField(const std::string &value) {
 #if HAVE_SWIFTEN_3
-	FormField::ref field = boost::make_shared<FormField>(FormField::FixedType, value);
+	FormField::ref field = SWIFTEN_SHRPTR_NAMESPACE::make_shared<FormField>(FormField::FixedType, value);
 #else
 	FixedFormField::ref field = FixedFormField::create(value);
 #endif
 	return field;
+}
 void addHiddenField(Form::ref form, const std::string &name, const std::string &value) {
 	form->addField(createHiddenField(name, value));
+}
 void addTextSingleField(Swift::Form::ref form, const std::string &name, const std::string &value, const std::string &label, bool required) {
 	form->addField(createTextSingleField(name, value, label, required));
+}
 void addTextFixedField(Swift::Form::ref form, const std::string &value) {
 	form->addField(createTextFixedField(value));
+}
 std::string fieldValue(Swift::FormField::ref field) {
 #if HAVE_SWIFTEN_3
 	const std::vector<std::string> values = field->getValues();
 	return values.empty() ? "" : values[0];
 #else
-	TextSingleFormField::ref textSingle = boost::dynamic_pointer_cast<TextSingleFormField>(field);
+	TextSingleFormField::ref textSingle = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<TextSingleFormField>(field);
 	if (textSingle) {
 		return textSingle->getValue();
+	}
-	TextPrivateFormField::ref textPrivate = boost::dynamic_pointer_cast<TextPrivateFormField>(field);
+	TextPrivateFormField::ref textPrivate = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<TextPrivateFormField>(field);
 	if (textPrivate) {
 		return textPrivate->getValue();
+	}
-	ListSingleFormField::ref listSingle = boost::dynamic_pointer_cast<ListSingleFormField>(field);
+	ListSingleFormField::ref listSingle = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<ListSingleFormField>(field);
 	if (listSingle) {
 		return listSingle->getValue();
+	}
-	BooleanFormField::ref boolean = boost::dynamic_pointer_cast<BooleanFormField>(field);
+	BooleanFormField::ref boolean = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<BooleanFormField>(field);
 	if (boolean) {
 		return boolean->getValue() ? "1" : "0";
+	}
 	return "";
 #endif
+}
 std::string fieldValue(Swift::Form::ref form, const std::string &key, const std::string &def) {
 	const std::vector<FormField::ref> fields = form->getFields();
 	for (std::vector<FormField::ref>::const_iterator it = fields.begin(); it != fields.end(); it++) {
 #if HAVE_SWIFTEN_3
 		FormField::ref field = *it;
 		const std::vector<std::string> values = field->getValues();
 		if (field->getName() == key) {
 			return values.empty() ? "" : values[0];
+		}
 #else
-		TextSingleFormField::ref textSingle = boost::dynamic_pointer_cast<TextSingleFormField>(*it);
+		TextSingleFormField::ref textSingle = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<TextSingleFormField>(*it);
 		if (textSingle && textSingle->getName() == key) {
 			return textSingle->getValue();
+		}
-		TextPrivateFormField::ref textPrivate = boost::dynamic_pointer_cast<TextPrivateFormField>(*it);
+		TextPrivateFormField::ref textPrivate = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<TextPrivateFormField>(*it);
 		if (textPrivate && textPrivate->getName() == key) {
 			return textPrivate->getValue();
+		}
-		ListSingleFormField::ref listSingle = boost::dynamic_pointer_cast<ListSingleFormField>(*it);
+		ListSingleFormField::ref listSingle = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<ListSingleFormField>(*it);
 		if (listSingle && listSingle->getName() == key) {
 			return listSingle->getValue();
+		}
-		BooleanFormField::ref boolean = boost::dynamic_pointer_cast<BooleanFormField>(*it);
+		BooleanFormField::ref boolean = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<BooleanFormField>(*it);
 		if (boolean && boolean->getName() == key) {
 			return boolean->getValue() ? "1" : "0";
+		}
 #endif
+	}
 	return def;
+}
+}
+}

spectrum/src/frontends/xmpp/gatewayresponder.cpp

➞

Show inline comments

@@ @@ -22,56 +22,55 @@ @@
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Elements/RawXMLPayload.h"
 #include "transport/UserManager.h"
 #include "transport/User.h"
 #include "transport/Transport.h"
 #include "transport/Logging.h"
 #include "transport/Config.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "GatewayResponder");
 GatewayResponder::GatewayResponder(Swift::IQRouter *router, UserManager *userManager) : Swift::Responder<GatewayPayload>(router) {
 	m_userManager = userManager;
+}
 GatewayResponder::~GatewayResponder() {
+}
-bool GatewayResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::GatewayPayload> payload) {
+bool GatewayResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::GatewayPayload> payload) {
 	std::string prompt = CONFIG_STRING(m_userManager->getComponent()->getConfig(), "gateway_responder.prompt");
 	std::string label = CONFIG_STRING(m_userManager->getComponent()->getConfig(), "gateway_responder.label");
-	sendResponse(from, id, boost::shared_ptr<GatewayPayload>(new GatewayPayload(Swift::JID(), label, prompt)));
+	sendResponse(from, id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<GatewayPayload>(new GatewayPayload(Swift::JID(), label, prompt)));
 	return true;
+}
-bool GatewayResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::GatewayPayload> payload) {
+bool GatewayResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::GatewayPayload> payload) {
 	std::string prompt = payload->getPrompt();
 	std::string escaped = Swift::JID::getEscapedNode(prompt);
 	if (!CONFIG_BOOL_DEFAULTED(m_userManager->getComponent()->getConfig(), "service.jid_escaping", true)) {
 		escaped = prompt;
 		if (escaped.find_last_of("@") != std::string::npos) {
 			escaped.replace(escaped.find_last_of("@"), 1, "%");
+		}
+	}
 	// This code is here to workaround Gajim (and probably other clients bug too) bug
 	// https://trac.gajim.org/ticket/7277
 	if (prompt.find("\\40") != std::string::npos) {
 		LOG4CXX_WARN(logger, from.toString() << " Received already escaped JID " << prompt << ". Not escaping again.");
 		escaped = prompt;
+	}
 	std::string jid = escaped + "@" + m_userManager->getComponent()->getJID().toBare().toString();
-	sendResponse(from, id, boost::shared_ptr<GatewayPayload>(new GatewayPayload(jid)));
+	sendResponse(from, id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<GatewayPayload>(new GatewayPayload(jid)));
 	return true;
+}
+}

spectrum/src/frontends/xmpp/gatewayresponder.h

➞

Show inline comments

@@ @@ -14,29 +14,30 @@ @@
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <vector>
 #include "Swiften/Queries/Responder.h"
 #include "Swiften/Elements/GatewayPayload.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Transport {
 class UserManager;
 class GatewayResponder : public Swift::Responder<Swift::GatewayPayload> {
 	public:
 		GatewayResponder(Swift::IQRouter *router, UserManager *userManager);
 		~GatewayResponder();
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::GatewayPayload> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::GatewayPayload> payload);
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::GatewayPayload> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::GatewayPayload> payload);
 		UserManager *m_userManager;
 };
+}

spectrum/src/frontends/xmpp/rosterresponder.cpp

➞

Show inline comments

@@ @@ -25,54 +25,53 @@ @@
 #include "Swiften/Queries/IQRouter.h"
 #include "transport/User.h"
 #include "transport/UserManager.h"
 #include "transport/RosterManager.h"
 #include "transport/Buddy.h"
 #include "transport/Logging.h"
 #include "transport/Factory.h"
 #include "transport/Transport.h"
 #include "XMPPFrontend.h"
 #include "transport/Frontend.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "RosterResponder");
 RosterResponder::RosterResponder(Swift::IQRouter *router, UserManager *userManager) : Swift::Responder<RosterPayload>(router) {
 	m_userManager = userManager;
 	m_router = router;
+}
 RosterResponder::~RosterResponder() {
+}
-bool RosterResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload) {
+bool RosterResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> payload) {
 	// Get means we're in server mode and user wants to fetch his roster.
 	// For now we send empty reponse, but TODO: Get buddies from database and send proper stored roster.
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {
-		sendResponse(from, id, boost::shared_ptr<RosterPayload>(new RosterPayload()));
+		sendResponse(from, id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<RosterPayload>(new RosterPayload()));
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": User is not logged in");
 		return true;
+	}
 	sendResponse(from, id, user->getRosterManager()->generateRosterPayload());
 	user->getRosterManager()->sendCurrentPresences(from);
 	return true;
+}
 bool RosterResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload) {
 	sendResponse(from, id, boost::shared_ptr<RosterPayload>(new RosterPayload()));
 bool RosterResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> payload) {
 	sendResponse(from, id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<RosterPayload>(new RosterPayload()));
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": User is not logged in");
 		return true;
+	}
 	if (payload->getItems().size() == 0) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": Roster push with no item");
 		return true;
+	}

spectrum/src/frontends/xmpp/settingsadhoccommand.cpp

➞

Show inline comments

@@ @@ -30,44 +30,44 @@ @@
 namespace Transport {
 DEFINE_LOGGER(logger, "SettingsAdHocCommand");
 SettingsAdHocCommand::SettingsAdHocCommand(Component *component, UserManager *userManager, StorageBackend *storageBackend, const Swift::JID &initiator, const Swift::JID &to) : AdHocCommand(component, userManager, storageBackend, initiator, to) {
 	m_state = Init;
+}
 SettingsAdHocCommand::~SettingsAdHocCommand() {
+}
-boost::shared_ptr<Swift::Command> SettingsAdHocCommand::getForm() {
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> SettingsAdHocCommand::getForm() {
 	if (!m_storageBackend) {
 		boost::shared_ptr<Swift::Command> response(new Swift::Command("settings", m_id, Swift::Command::Completed));
 		boost::shared_ptr<Swift::Form> form(new Swift::Form());
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> response(new Swift::Command("settings", m_id, Swift::Command::Completed));
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Form> form(new Swift::Form());
 		FormUtils::addTextFixedField(form, "This server does not support transport settings. There is no storage backend configured");
 		response->setForm(form);
 		return response;
+	}
 	UserInfo user;
 	if (m_storageBackend->getUser(m_initiator.toBare().toString(), user) == false) {
 		boost::shared_ptr<Swift::Command> response(new Swift::Command("settings", m_id, Swift::Command::Completed));
 		boost::shared_ptr<Swift::Form> form(new Swift::Form());
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> response(new Swift::Command("settings", m_id, Swift::Command::Completed));
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Form> form(new Swift::Form());
 		FormUtils::addTextFixedField(form, "You are not registered.");
 		response->setForm(form);
 		return response;
+	}
 	boost::shared_ptr<Swift::Command> response(new Swift::Command("settings", m_id, Swift::Command::Executing));
 	boost::shared_ptr<Swift::Form> form(new Swift::Form());
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> response(new Swift::Command("settings", m_id, Swift::Command::Executing));
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Form> form(new Swift::Form());
 	std::string value;
 	int type = (int) TYPE_BOOLEAN;
 	value = "1";
 	m_storageBackend->getUserSetting(user.id, "enable_transport", type, value);
 	FormUtils::addBooleanField(form, "enable_transport", value, "Enable transport");
 	value = CONFIG_BOOL_DEFAULTED(m_component->getConfig(), "settings.send_headlines", false) ? "1" : "0";
 	m_storageBackend->getUserSetting(user.id, "send_headlines", type, value);
 	FormUtils::addBooleanField(form, "send_headlines", value, "Allow sending messages as headlines");
 	return response;
+}
 void SettingsAdHocCommand::updateUserSetting(Swift::Form::ref form, UserInfo &user, const std::string &name) {
 	std::string value = FormUtils::fieldValue(form, name, "");
 	if (value.empty()) {
 		return;
+	}
 	m_storageBackend->updateUserSetting(user.id, name, value);
+}
-boost::shared_ptr<Swift::Command> SettingsAdHocCommand::handleResponse(boost::shared_ptr<Swift::Command> payload) {
+SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> SettingsAdHocCommand::handleResponse(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload) {
 	UserInfo user;
 	bool registered = m_storageBackend->getUser(m_initiator.toBare().toString(), user);
 	if (registered && payload->getForm()) {
 		updateUserSetting(payload->getForm(), user, "enable_transport");
 		updateUserSetting(payload->getForm(), user, "send_headlines");
 		updateUserSetting(payload->getForm(), user, "stay_connected");
+	}
-	boost::shared_ptr<Swift::Command> response(new Swift::Command("settings", m_id, Swift::Command::Completed));
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> response(new Swift::Command("settings", m_id, Swift::Command::Completed));
 	return response;
+}
 boost::shared_ptr<Swift::Command> SettingsAdHocCommand::handleRequest(boost::shared_ptr<Swift::Command> payload) {
 	boost::shared_ptr<Swift::Command> response;
 SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> SettingsAdHocCommand::handleRequest(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload) {
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> response;
 	if (payload->getAction() == Swift::Command::Cancel) {
-		response = boost::shared_ptr<Swift::Command>(new Swift::Command("settings", m_id, Swift::Command::Canceled));
+		response = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command>(new Swift::Command("settings", m_id, Swift::Command::Canceled));
 		return response;
+	}
 	switch (m_state) {
 		case Init:
 			response = getForm();
 			m_state = WaitingForResponse;
 			break;
 		case WaitingForResponse:
 			response = handleResponse(payload);
 			break;
 		default:

spectrum/src/frontends/xmpp/settingsadhoccommand.h

➞

Show inline comments

@@ @@ -36,31 +36,31 @@ class UserManager; @@
 class StorageBackend;
 class UserInfo;
 class SettingsAdHocCommand : public AdHocCommand {
 	public:
 		typedef enum { Init, WaitingForResponse } State;
 		SettingsAdHocCommand(Component *component, UserManager *userManager, StorageBackend *storageBackend, const Swift::JID &initiator, const Swift::JID &to);
 		/// Destructor.
 		virtual ~SettingsAdHocCommand();
-		virtual boost::shared_ptr<Swift::Command> handleRequest(boost::shared_ptr<Swift::Command> payload);
+		virtual SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> handleRequest(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload);
 	private:
 		void updateUserSetting(Swift::Form::ref form, UserInfo &user, const std::string &name);
 		boost::shared_ptr<Swift::Command> getForm();
 		boost::shared_ptr<Swift::Command> handleResponse(boost::shared_ptr<Swift::Command> payload);
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> getForm();
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> handleResponse(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload);
 		State m_state;
 };
 class SettingsAdHocCommandFactory : public AdHocCommandFactory {
 	public:
 		SettingsAdHocCommandFactory() {
 			m_userSettings["send_headlines"] = "0";
 			m_userSettings["stay_connected"] = "0";
+		}
 		virtual ~SettingsAdHocCommandFactory() {}

spectrum/src/frontends/xmpp/statsresponder.cpp

➞

Show inline comments

@@ @@ -28,25 +28,24 @@ @@
 #include "transport/RosterManager.h"
 #include "transport/MemoryUsage.h"
 #include "transport/NetworkPluginServer.h"
 #include "transport/Logging.h"
 #include "transport/Frontend.h"
 #include "transport/Transport.h"
 #include "transport/Buddy.h"
 #include "XMPPFrontend.h"
 #include <boost/foreach.hpp>
 #include <boost/lexical_cast.hpp>
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "StatsResponder");
 StatsResponder::StatsResponder(Component *component, UserManager *userManager, NetworkPluginServer *server, StorageBackend *storageBackend) : Swift::Responder<StatsPayload>(static_cast<XMPPFrontend *>(component->getFrontend())->getIQRouter()) {
 	m_component = component;
 	m_userManager = userManager;
 	m_server = server;
 	m_storageBackend = storageBackend;
 	m_start = time(0);
+}
@@ @@ -62,26 +61,26 @@ unsigned long StatsResponder::usedMemory() { @@
 	process_mem_usage(shared, rss);
 #endif
 	rss -= shared;
 	const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();
 	BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {
 		rss += backend->res - backend->shared;
+	}
 	return (unsigned long) rss;
+}
 bool StatsResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<StatsPayload> stats) {
 	boost::shared_ptr<StatsPayload> response(new StatsPayload());
 bool StatsResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<StatsPayload> stats) {
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<StatsPayload> response(new StatsPayload());
 	if (stats->getItems().empty()) {
 		response->addItem(StatsPayload::Item("uptime"));
 		response->addItem(StatsPayload::Item("users/online"));
 		response->addItem(StatsPayload::Item("contacts/online"));
 		response->addItem(StatsPayload::Item("contacts/total"));
 		response->addItem(StatsPayload::Item("messages/from-xmpp"));
 		response->addItem(StatsPayload::Item("messages/to-xmpp"));
 		response->addItem(StatsPayload::Item("backends/running"));
 		response->addItem(StatsPayload::Item("backends/crashed"));
 		response->addItem(StatsPayload::Item("memory-usage"));
+	}
+			}
 			else if (item.getName() == "messages/to-xmpp") {
 				response->addItem(StatsPayload::Item("messages/to-xmpp", "messages", boost::lexical_cast<std::string>(m_userManager->getMessagesToXMPP())));
+			}
+		}
+	}
 	sendResponse(from, id, response);
 	return true;
+}
-bool StatsResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<StatsPayload> stats) {
+bool StatsResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<StatsPayload> stats) {
 	return false;
+}
+}

spectrum/src/frontends/xmpp/statsresponder.h

➞

Show inline comments

@@ @@ -14,39 +14,40 @@ @@
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <vector>
 #include "Swiften/Queries/SetResponder.h"
 #include "Swiften/Elements/StatsPayload.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Transport {
 class Component;
 class UserManager;
 class NetworkPluginServer;
 class StorageBackend;
 class StatsResponder : public Swift::Responder<Swift::StatsPayload> {
 	public:
 		StatsResponder(Component *component, UserManager *userManager, NetworkPluginServer *server, StorageBackend *storageBackend);
 		~StatsResponder();
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::StatsPayload> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::StatsPayload> payload);
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::StatsPayload> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::StatsPayload> payload);
 		unsigned long usedMemory();
 		Component *m_component;
 		UserManager *m_userManager;
 		NetworkPluginServer *m_server;
 		StorageBackend *m_storageBackend;
 		time_t m_start;
 };
+}

spectrum/src/frontends/xmpp/storageresponder.cpp

➞

Show inline comments

@@ @@ -22,68 +22,67 @@ @@
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Elements/RawXMLPayload.h"
 #include "Swiften/Elements/Storage.h"
 #include "Swiften/Serializer/PayloadSerializers/StorageSerializer.h"
 #include "transport/UserManager.h"
 #include "transport/User.h"
 #include "transport/Logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "StorageResponder");
 StorageResponder::StorageResponder(Swift::IQRouter *router, StorageBackend *storageBackend, UserManager *userManager) : Swift::Responder<PrivateStorage>(router) {
 	m_storageBackend = storageBackend;
 	m_userManager = userManager;
+}
 StorageResponder::~StorageResponder() {
+}
-bool StorageResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::PrivateStorage> payload) {
+bool StorageResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::PrivateStorage> payload) {
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": User is not logged in");
 		sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Cancel);
 		return true;
+	}
 	int type = 0;
 	std::string value = "";
 	m_storageBackend->getUserSetting(user->getUserInfo().id, "storage", type, value);
 	LOG4CXX_INFO(logger, from.toBare().toString() << ": Sending jabber:iq:storage");
-	sendResponse(from, id, boost::shared_ptr<PrivateStorage>(new PrivateStorage(boost::shared_ptr<RawXMLPayload>(new RawXMLPayload(value)))));
+	sendResponse(from, id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<PrivateStorage>(new PrivateStorage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<RawXMLPayload>(new RawXMLPayload(value)))));
 	return true;
+}
-bool StorageResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::PrivateStorage> payload) {
+bool StorageResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::PrivateStorage> payload) {
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {
 		sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Cancel);
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": User is not logged in");
 		return true;
+	}
-	boost::shared_ptr<Storage> storage = boost::dynamic_pointer_cast<Storage>(payload->getPayload());
+	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Storage> storage = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Storage>(payload->getPayload());
 	if (storage) {
 		StorageSerializer serializer;
-		std::string value = serializer.serializePayload(boost::dynamic_pointer_cast<Storage>(payload->getPayload()));
+		std::string value = serializer.serializePayload(SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Storage>(payload->getPayload()));
 		m_storageBackend->updateUserSetting(user->getUserInfo().id, "storage", value);
 		LOG4CXX_INFO(logger, from.toBare().toString() << ": Storing jabber:iq:storage");
-		sendResponse(from, id, boost::shared_ptr<PrivateStorage>());
+		sendResponse(from, id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<PrivateStorage>());
+	}
 	else {
 		LOG4CXX_INFO(logger, from.toBare().toString() << ": Unknown element. Libtransport does not support serialization of this.");
 		sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Cancel);
+	}
 	return true;
+}
+}

spectrum/src/frontends/xmpp/storageresponder.h

➞

Show inline comments

@@ @@ -15,31 +15,32 @@ @@
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <vector>
 #include "Swiften/Queries/Responder.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Elements/PrivateStorage.h"
 #include "Swiften/SwiftenCompat.h"
 namespace Transport {
 class StorageBackend;
 class UserManager;
 class StorageResponder : public Swift::Responder<Swift::PrivateStorage> {
 	public:
 		StorageResponder(Swift::IQRouter *router, StorageBackend *storageBackend, UserManager *userManager);
 		~StorageResponder();
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::PrivateStorage> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::PrivateStorage> payload);
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::PrivateStorage> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::PrivateStorage> payload);
 		StorageBackend *m_storageBackend;
 		UserManager *m_userManager;
 };
+}

spectrum/src/frontends/xmpp/vcardresponder.cpp

➞

Show inline comments

@@ @@ -22,42 +22,41 @@ @@
 #include <iostream>
 #include <boost/bind.hpp>
 #include "transport/User.h"
 #include "transport/Buddy.h"
 #include "transport/UserManager.h"
 #include "transport/Transport.h"
 #include "transport/Logging.h"
 #include "Swiften/Queries/IQRouter.h"
 #include <boost/foreach.hpp>
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "VCardResponder");
 VCardResponder::VCardResponder(Swift::IQRouter *router, Swift::NetworkFactories *factories, UserManager *userManager) : Swift::Responder<VCard>(router) {
 	m_id = 0;
 	m_userManager = userManager;
 	m_collectTimer = factories->getTimerFactory()->createTimer(20000);
 	m_collectTimer->onTick.connect(boost::bind(&VCardResponder::collectTimeouted, this));
 	m_collectTimer->start();
+}
 VCardResponder::~VCardResponder() {
+}
-void VCardResponder::sendVCard(unsigned int id, boost::shared_ptr<Swift::VCard> vcard) {
+void VCardResponder::sendVCard(unsigned int id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> vcard) {
 	if (m_queries.find(id) == m_queries.end()) {
 		LOG4CXX_WARN(logger, "Unexpected VCard from legacy network with id " << id);
 		return;
+	}
 	LOG4CXX_INFO(logger, m_queries[id].from.toString() << ": Forwarding VCard of " << m_queries[id].to.toString() << " from legacy network");
 	sendResponse(m_queries[id].from, m_queries[id].to, m_queries[id].id, vcard);
 	m_queries.erase(id);
+}
 void VCardResponder::collectTimeouted() {
@@ @@ -66,30 +65,30 @@ void VCardResponder::collectTimeouted() { @@
 	std::vector<unsigned int> candidates;
 	for(std::map<unsigned int, VCardData>::iterator it = m_queries.begin(); it != m_queries.end(); it++) {
 		if (now - (*it).second.received > 40) {
 			candidates.push_back((*it).first);
+		}
+	}
 	if (candidates.size() != 0) {
 		LOG4CXX_INFO(logger, "Removing " << candidates.size() << " timeouted VCard requests");
+	}
 	BOOST_FOREACH(unsigned int id, candidates) {
-		sendVCard(id, boost::shared_ptr<Swift::VCard>(new Swift::VCard()));
+		sendVCard(id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard>(new Swift::VCard()));
+	}
 	m_collectTimer->start();
+}
-bool VCardResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::VCard> payload) {
+bool VCardResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> payload) {
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": User is not logged in");
 		return false;
+	}
 	Swift::JID to_ = to;
 	std::string name = to_.getUnescapedNode();
 	if (name.empty()) {
 		to_ = user->getJID();
+	}
+	}
 	LOG4CXX_INFO(logger, from.toBare().toString() << ": Requested VCard of " << name);
 	m_queries[m_id].from = from;
 	m_queries[m_id].to = to;
 	m_queries[m_id].id = id;
 	m_queries[m_id].received = time(NULL);
 	onVCardRequired(user, name, m_id++);
 	return true;
+}
-bool VCardResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::VCard> payload) {
+bool VCardResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> payload) {
 	if (!to.getNode().empty() && from.toBare().toString() != to.toBare().toString()) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": Tried to set VCard of somebody else");
 		return false;
+	}
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": User is not logged in");
 		return false;
+	}
 	LOG4CXX_INFO(logger, from.toBare().toString() << ": Setting VCard");
 	onVCardUpdated(user, payload);
-	sendResponse(from, id, boost::shared_ptr<VCard>(new VCard()));
+	sendResponse(from, id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<VCard>(new VCard()));
 	return true;
+}
+}

spectrum/src/frontends/xmpp/vcardresponder.h

➞

Show inline comments

@@ @@ -16,49 +16,50 @@ @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <vector>
 #include "Swiften/Queries/Responder.h"
 #include "Swiften/Elements/VCard.h"
 #include "Swiften/Network/NetworkFactories.h"
 #include "Swiften/Network/Timer.h"
 #include "Swiften/SwiftenCompat.h"
 #include <boost/signal.hpp>
 namespace Transport {
 class StorageBackend;
 class UserManager;
 class User;
 class VCardResponder : public Swift::Responder<Swift::VCard> {
 	public:
 		VCardResponder(Swift::IQRouter *router, Swift::NetworkFactories *factories, UserManager *userManager);
 		~VCardResponder();
-		void sendVCard(unsigned int id, boost::shared_ptr<Swift::VCard> vcard);
+		void sendVCard(unsigned int id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> vcard);
 		boost::signal<void (User *, const std::string &name, unsigned int id)> onVCardRequired;
-		boost::signal<void (User *, boost::shared_ptr<Swift::VCard> vcard)> onVCardUpdated;
+		boost::signal<void (User *, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> vcard)> onVCardUpdated;
 		void collectTimeouted();
 	private:
 		struct VCardData {
 			Swift::JID from;
 			Swift::JID to;
 			std::string id;
 			time_t received;
 		};
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::VCard> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::VCard> payload);
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> payload);
 		UserManager *m_userManager;
 		std::map<unsigned int, VCardData> m_queries;
 		unsigned int m_id;
 		Swift::Timer::ref m_collectTimer;
 };
+}

spectrum/src/main.cpp

➞

Show inline comments

@@ @@ -9,24 +9,25 @@ @@
 #include "transport/UserRegistration.h"
 #include "transport/UserRegistry.h"
 #include "transport/NetworkPluginServer.h"
 #include "transport/AdminInterface.h"
 #include "transport/UsersReconnecter.h"
 #include "transport/Util.h"
 #include "transport/Logging.h"
 #include "transport/Frontend.h"
 #include "frontends/xmpp/XMPPFrontendPlugin.h"
 #include "frontends/slack/SlackFrontendPlugin.h"
 #include "Swiften/EventLoop/SimpleEventLoop.h"
 #include "Swiften/Network/BoostNetworkFactories.h"
 #include <boost/thread.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 #ifndef WIN32
 #include "sys/signal.h"
 #include "sys/stat.h"
 #include <pwd.h>
 #include <grp.h>
 #include <sys/resource.h>
 #include "libgen.h"
 #ifndef __FreeBSD__
 #ifndef __MACH__
 #include <malloc.h>
@@ @@ -214,28 +215,28 @@ int mainloop() { @@
 	Swift::SimpleEventLoop eventLoop;
 	Swift::BoostNetworkFactories *factories = new Swift::BoostNetworkFactories(&eventLoop);
 	UserRegistry userRegistry(config_, factories);
 	Frontend *frontend = NULL;
 	std::string frontend_name = CONFIG_STRING_DEFAULTED(config_, "service.frontend", "xmpp");
 	std::string plugin_fc = "create_" + frontend_name + "_frontend_plugin";
 	dll::shared_library self(dll::program_location());
-	boost::function<boost::shared_ptr<FrontendPlugin>()> creator;
+	boost::function<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<FrontendPlugin>()> creator;
 	try {
-		creator = self.get_alias<boost::shared_ptr<FrontendPlugin>()>(plugin_fc);
+		creator = self.get_alias<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<FrontendPlugin>()>(plugin_fc);
 	} catch(boost::system::system_error& e) {
 		LOG4CXX_ERROR(logger, "Error when loading frontend " << e.what());
 		return -3;
+	}
 	if (!creator) {
 		LOG4CXX_ERROR(logger, "Unknown Frontend name " << frontend_name);
 		return -3;
+	}
 	frontend = creator()->createFrontend();

spectrum_manager/src/main.cpp

➞

Show inline comments

@@ @@ -12,26 +12,24 @@ @@
 #include <iterator>
 #include <algorithm>
 #include <boost/filesystem.hpp>
 #include <cstdlib>
 #include "signal.h"
 #include "sys/wait.h"
 using namespace Transport;
 using namespace boost::filesystem;
 using namespace boost;
 int main(int argc, char **argv)
+{
 	ManagerConfig config;
 	std::string config_file;
 	std::vector<std::string> command;
 	boost::program_options::variables_map vm;
 	int ret = 0;
 	boost::program_options::options_description desc("Usage: spectrum [OPTIONS] <COMMAND>\n"
 													 "       spectrum [OPTIONS] <instance_JID> <other>\nCommands:\n"
 													 " start - start all local Spectrum2 instances\n"
 													 " stop  - stop all local Spectrum2 instances\n"

spectrum_manager/src/methods.cpp

➞

Show inline comments

@@ @@ -9,36 +9,36 @@ @@
 #include <pthread.h>
 #include <boost/foreach.hpp>
 #include <iostream>
 #include <fstream>
 #include <iterator>
 #include <algorithm>
 #include <boost/filesystem.hpp>
 #include <cstdlib>
 #include "signal.h"
 #include "sys/wait.h"
 #include "Swiften/SwiftenCompat.h"
 #define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \
 	wrap.set_type(TYPE); \
 	wrap.set_payload(MESSAGE); \
 	wrap.SerializeToString(&MESSAGE);
 using namespace Transport;
 using namespace boost::filesystem;
 using namespace boost;
 std::string _data;
 static std::string response;
 std::string get_response() {
 	return response;
+}
 std::string searchForBinary(const std::string &binary) {
 	std::vector<std::string> path_list;
 	char * env_path = getenv("PATH");
 	if (env_path != NULL) {
@@ @@ -431,25 +431,25 @@ int show_status(ManagerConfig *config) { @@
+					}
+				}
+			}
+		}
+	}
 	catch (const filesystem_error& ex) {
 		std::cerr << "Filesystem error: " << ex.what() << "\n";
 		exit(5);
+	}
 	return ret;
+}
-static void handleDataRead(boost::shared_ptr<Swift::Connection> m_conn, boost::shared_ptr<Swift::SafeByteArray> data) {
+static void handleDataRead(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> m_conn, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::SafeByteArray> data) {
 	_data += std::string(data->begin(), data->end());
 	// Parse data while there are some
 	while (_data.size() != 0) {
 		// expected_size of wrapper message
 		unsigned int expected_size;
 		// if data is >= 4, we have whole header and we can
 		// read expected_size.
 		if (_data.size() >= 4) {
 			expected_size = *((unsigned int*) &_data[0]);
 			expected_size = ntohl(expected_size);
 			m_conn->onDataRead.disconnect(boost::bind(&handleDataRead, m_conn, _1));
 			m_conn->disconnect();
 			response = payload.config();
 			if (response.empty()) {
 				response = "Empty response";
+			}
 			std::cout << payload.config() << "\n";
 // 			exit(0);
+		}
+	}
+}
-static void handleConnected(boost::shared_ptr<Swift::Connection> m_conn, const std::string &msg, bool error) {
+static void handleConnected(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> m_conn, const std::string &msg, bool error) {
 		m_conn->onConnectFinished.disconnect(boost::bind(&handleConnected, m_conn, msg, _1));
 	if (error) {
 		std::cerr << "Can't connect the server\n";
 		response = "Can't connect the server\n";
 		m_conn->onDataRead.disconnect(boost::bind(&handleDataRead, m_conn, _1));
 // 		exit(50);
+	}
 	else {
 		pbnetwork::BackendConfig m;
 		m.set_config(msg);
 				Config cfg;
 				if (cfg.load(itr->path().string()) == false) {
 					std::cerr << "Can't load config file " << itr->path().string() << ". Skipping...\n";
 					continue;
+				}
 				if (CONFIG_STRING(&cfg, "service.jid") != jid) {
 					continue;
+				}
 				found = true;
-				boost::shared_ptr<Swift::Connection> m_conn;
+				SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> m_conn;
 				m_conn = networkFactories.getConnectionFactory()->createConnection();
 				m_conn->onDataRead.connect(boost::bind(&handleDataRead, m_conn, _1));
 				m_conn->onConnectFinished.connect(boost::bind(&handleConnected, m_conn, message, _1));
 				m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(CONFIG_STRING(&cfg, "service.backend_host")), getPort(CONFIG_STRING(&cfg, "service.portfile"))));
+			}
+		}
 		if (!found) {
 			response = "Error: Config file for Spectrum instance with this JID was not found\n";
+		}
+	}
 	catch (const filesystem_error& ex) {

tests/libtransport/AdminInterface.cpp

➞

Show inline comments

 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/SwiftenCompat.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "BasicSlackTest.h"
 #include "transport/AdminInterface.h"
 #if !HAVE_SWIFTEN_3
 #define get_value_or(X) substr()
 #endif
 using namespace Transport;
 			serv = new NetworkPluginServer(component, cfg, userManager, NULL);
 			admin = new AdminInterface(component, userManager, serv, storage, NULL);
 			component->setAdminInterface(admin);
+		}
 		void tearDown (void) {
 			delete admin;
 			delete serv;
 			tearMeDown();
+		}
 	std::string sendAdminMessage(const std::string &cmd) {
-		Swift::Message::ref msg = boost::shared_ptr<Swift::Message>(new Swift::Message());
+		Swift::Message::ref msg = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message>(new Swift::Message());
 		msg->setFrom(Swift::JID("me@localhost"));
 		msg->setTo(Swift::JID("localhost"));
 		msg->setBody(cmd);
 		admin->handleMessageReceived(msg);
 		return msg->getBody().get_value_or("");
+	}
 	void helpCommand() {
 		std::string resp = sendAdminMessage("help");
 		CPPUNIT_ASSERT(resp.find("   VAR   status - Shows instance status\n") != std::string::npos);
+	}

tests/libtransport/VCardResponder.cpp

➞

Show inline comments

+		}
 		void tearDown (void) {
 			tearMeDown();
+		}
 	void handleVCardRequired(User *user, const std::string &name, unsigned int id) {
 		vcardName = name;
 		vcardId = id;
+	}
 	void handleGetRequestMUC() {
 		boost::shared_ptr<Swift::VCard> payload(new Swift::VCard());
 		boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "foobar", payload);
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> payload(new Swift::VCard());
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "foobar", payload);
 		iq->setFrom("user@localhost/me");
 		iq->setTo("#room@localhost/user");
 		injectIQ(iq);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room/user"), vcardName);
 		userManager->sendVCard(vcardId, payload);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());

tests/libtransport/basictest.cpp

➞

Show inline comments

@@ @@ -79,25 +79,25 @@ void BasicTest::setMeUp (void) { @@
 	_payloadSerializers.push_back(new Swift::InvisibleSerializer());
 	_payloadSerializers.push_back(new Swift::StatsSerializer());
 	_payloadSerializers.push_back(new Swift::SpectrumErrorSerializer());
 	_payloadSerializers.push_back(new Swift::GatewayPayloadSerializer());
 	BOOST_FOREACH(Swift::PayloadSerializer *serializer, _payloadSerializers) {
 		payloadSerializers->addSerializer(serializer);
+	}
 	parser = new Swift::XMPPParser(this, payloadParserFactories, factories->getXMLParserFactory());
 	parser2 = new Swift::XMPPParser(this, payloadParserFactories, factories->getXMLParserFactory());
-	serverFromClientSession = boost::shared_ptr<Swift::ServerFromClientSession>(new Swift::ServerFromClientSession("id", factories->getConnectionFactory()->createConnection(),
+	serverFromClientSession = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ServerFromClientSession>(new Swift::ServerFromClientSession("id", factories->getConnectionFactory()->createConnection(),
 			payloadParserFactories, payloadSerializers, userRegistry, factories->getXMLParserFactory(), Swift::JID("user@localhost/resource")));
 	serverFromClientSession->startSession();
 	serverFromClientSession->onDataWritten.connect(boost::bind(&BasicTest::handleDataReceived, this, _1));
 	dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend *>(component->getFrontend())->getStanzaChannel())->addSession(serverFromClientSession);
 	parser->parse("<stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' to='localhost' version='1.0'>");
 	parser2->parse("<stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' to='localhost' version='1.0'>");
 	received.clear();
 	received2.clear();
 	receivedData.clear();
 	loop->processEvents();
 void BasicTest::handleStreamStart(const Swift::ProtocolHeader&) {
+}
 void BasicTest::dumpReceived() {
 	std::cout << "\nStream1:\n";
 	std::cout << receivedData << "\n";
 	std::cout << "Stream2:\n";
 	std::cout << receivedData2 << "\n";
+}
 #if HAVE_SWIFTEN_3
-void BasicTest::handleElement(boost::shared_ptr<Swift::ToplevelElement> element) {
+void BasicTest::handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ToplevelElement> element) {
 #else
-void BasicTest::handleElement(boost::shared_ptr<Swift::Element> element) {
+void BasicTest::handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element> element) {
 #endif
 	if (stream1_active) {
 		received.push_back(element);
+	}
 	else {
 		received2.push_back(element);
+	}
+}
 void BasicTest::handleStreamEnd() {
 	streamEnded = true;
+}
-void BasicTest::injectPresence(boost::shared_ptr<Swift::Presence> &response) {
+void BasicTest::injectPresence(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Presence> &response) {
 	dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend *>(component->getFrontend())->getStanzaChannel())->onPresenceReceived(response);
+}
-void BasicTest::injectIQ(boost::shared_ptr<Swift::IQ> iq) {
+void BasicTest::injectIQ(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq) {
 	dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend *>(component->getFrontend())->getStanzaChannel())->onIQReceived(iq);
+}
-void BasicTest::injectMessage(boost::shared_ptr<Swift::Message> msg) {
+void BasicTest::injectMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg) {
 	dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend *>(component->getFrontend())->getStanzaChannel())->onMessageReceived(msg);
+}
-Swift::Stanza *BasicTest::getStanza(boost::shared_ptr<Swift::Element> element) {
+Swift::Stanza *BasicTest::getStanza(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element> element) {
 	Swift::Stanza *stanza = dynamic_cast<Swift::Stanza *>(element.get());
 	CPPUNIT_ASSERT(stanza);
 	return stanza;
+}
 void BasicTest::connectUser() {
 	CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 	userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 	userRegistry->onPasswordValid(Swift::JID("user@localhost/resource"));
 	loop->processEvents();
 	CPPUNIT_ASSERT_EQUAL(1, userManager->getUserCount());
@@ @@ -217,25 +217,25 @@ void BasicTest::connectUser() { @@
 	user->setConnected(true);
 	CPPUNIT_ASSERT(user->isConnected() == true);
 	CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 	CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 	received.clear();
 	receivedData.clear();
+}
 void BasicTest::connectSecondResource() {
-	serverFromClientSession2 = boost::shared_ptr<Swift::ServerFromClientSession>(new Swift::ServerFromClientSession("id", factories->getConnectionFactory()->createConnection(),
+	serverFromClientSession2 = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ServerFromClientSession>(new Swift::ServerFromClientSession("id", factories->getConnectionFactory()->createConnection(),
 			payloadParserFactories, payloadSerializers, userRegistry, factories->getXMLParserFactory(), Swift::JID("user@localhost/resource2")));
 	serverFromClientSession2->startSession();
 	serverFromClientSession2->onDataWritten.connect(boost::bind(&BasicTest::handleDataReceived2, this, _1));
 	dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend *>(component->getFrontend())->getStanzaChannel())->addSession(serverFromClientSession2);
 	userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource2"), serverFromClientSession2.get(), Swift::createSafeByteArray("password"));
 	userRegistry->onPasswordValid(Swift::JID("user@localhost/resource2"));
 	loop->processEvents();

tests/libtransport/basictest.h

➞

Show inline comments

@@ @@ -38,74 +38,76 @@ @@
 #include "discoitemsresponder.h"
 #include "transport/LocalBuddy.h"
 #include "transport/StorageBackend.h"
 #include "transport/Factory.h"
 #include "XMPPFrontend.h"
 #include "XMPPUserRegistration.h"
 #include <Swiften/Swiften.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/SwiftenCompat.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "Swiften/SwiftenCompat.h"
 #define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)
 using namespace Transport;
 class TestingConversation : public Conversation {
 	public:
 		TestingConversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false) : Conversation(conversationManager, legacyName, muc) {
+		}
 		// Called when there's new message to legacy network from XMPP network
-		void sendMessage(boost::shared_ptr<Swift::Message> &message) {
+		void sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &message) {
 			onMessageToSend(this, message);
+		}
-		boost::signal<void (TestingConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;
+		boost::signal<void (TestingConversation *, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &)> onMessageToSend;
 };
 class TestingFactory : public Factory {
 	public:
 		TestingFactory() {
+		}
 		// Creates new conversation (NetworkConversation in this case)
 		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMuc = false) {
 			TestingConversation *nc = new TestingConversation(conversationManager, legacyName, isMuc);
 			nc->onMessageToSend.connect(boost::bind(&TestingFactory::handleMessageToSend, this, _1, _2));
 			return nc;
+		}
-		void handleMessageToSend(TestingConversation *_conv, boost::shared_ptr<Swift::Message> &_msg) {
+		void handleMessageToSend(TestingConversation *_conv, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &_msg) {
 			onMessageToSend(_conv, _msg);
+		}
 		// Creates new LocalBuddy
 		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {
 			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id, buddyInfo.legacyName, buddyInfo.alias, buddyInfo.groups, (BuddyFlag) buddyInfo.flags);
 			if (!buddy->isValid()) {
 				delete buddy;
 				return NULL;
+			}
 			buddy->setSubscription(Buddy::Ask);
 			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())
 				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);
 			return buddy;
+		}
-		boost::signal<void (TestingConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;
+		boost::signal<void (TestingConversation *, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &)> onMessageToSend;
 };
 class TestingStorageBackend : public StorageBackend {
 	public:
 		bool connected;
 		std::map<std::string, UserInfo> users;
 		std::map<std::string, bool> online_users;
 		std::map<int, std::map<std::string, std::string> > settings;
 		long buddyid;
 		TestingStorageBackend() {
 			buddyid = 0;
@@ @@ -219,70 +221,70 @@ class TestingStorageBackend : public StorageBackend { @@
 class BasicTest : public Swift::XMPPParserClient {
 	public:
 		void setMeUp (void);
 		void tearMeDown (void);
 	void handleDataReceived(const Swift::SafeByteArray &data);
 	void handleDataReceived2(const Swift::SafeByteArray &data);
 	void handleStreamStart(const Swift::ProtocolHeader&);
 #if HAVE_SWIFTEN_3
-	void handleElement(boost::shared_ptr<Swift::ToplevelElement> element);
+	void handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ToplevelElement> element);
 #else
-	void handleElement(boost::shared_ptr<Swift::Element> element);
+	void handleElement(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element> element);
 #endif
 	void handleStreamEnd();
 	void injectPresence(boost::shared_ptr<Swift::Presence> &response);
 	void injectIQ(boost::shared_ptr<Swift::IQ> iq);
 	void injectMessage(boost::shared_ptr<Swift::Message> msg);
 	void injectPresence(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Presence> &response);
 	void injectIQ(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq);
 	void injectMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg);
 	void dumpReceived();
 	void addUser() {
 		UserInfo user;
 		user.id = 1;
 		user.jid = "user@localhost";
 		user.uin = "legacyname";
 		user.password = "password";
 		user.vip = 0;
 		storage->setUser(user);
+	}
 	void connectUser();
 	void connectSecondResource();
 	void disconnectUser();
 	void add2Buddies();
-	Swift::Stanza *getStanza(boost::shared_ptr<Swift::Element> element);
+	Swift::Stanza *getStanza(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element> element);
 	protected:
 		bool streamEnded;
 		UserManager *userManager;
 		boost::shared_ptr<Swift::ServerFromClientSession> serverFromClientSession;
 		boost::shared_ptr<Swift::ServerFromClientSession> serverFromClientSession2;
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ServerFromClientSession> serverFromClientSession;
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ServerFromClientSession> serverFromClientSession2;
 		Swift::FullPayloadSerializerCollection* payloadSerializers;
 		Swift::FullPayloadParserFactoryCollection* payloadParserFactories;
 		Swift::XMPPParser *parser;
 		Swift::XMPPParser *parser2;
 		UserRegistry *userRegistry;
 		Config *cfg;
 		Swift::Server *server;
 		Swift::DummyNetworkFactories *factories;
 		Swift::DummyEventLoop *loop;
 		TestingFactory *factory;
 		Component *component;
 		std::vector<boost::shared_ptr<Swift::Element> > received;
 		std::vector<boost::shared_ptr<Swift::Element> > received2;
 		std::vector<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element> > received;
 		std::vector<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element> > received2;
 		std::string receivedData;
 		std::string receivedData2;
 		StorageBackend *storage;
 		XMPPUserRegistration *userRegistration;
 		DiscoItemsResponder *itemsResponder;
 		bool stream1_active;
 		Transport::XMPPFrontend *frontend;
 		std::vector<Swift::PayloadParserFactory *> parserFactories;
 		std::vector<Swift::PayloadSerializer *> _payloadSerializers;
 };

tests/libtransport/component.cpp

➞

Show inline comments

 			onUserPresenceReceived = false;
 			onCapabilitiesReceived = false;
 			setMeUp();
 			component->onUserPresenceReceived.connect(boost::bind(&ComponentTest::handleUserPresenceReceived, this, _1));
 			component->getFrontend()->onCapabilitiesReceived.connect(boost::bind(&ComponentTest::handleUserDiscoInfoReceived, this, _1, _2));
+		}
 		void tearDown (void) {
 			tearMeDown();
+		}
-	void handleUserDiscoInfoReceived(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info) {
+	void handleUserDiscoInfoReceived(const Swift::JID& jid, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> info) {
 		onCapabilitiesReceived = true;
+	}
 	void handleUserPresenceReceived(Swift::Presence::ref presence) {
 		onUserPresenceReceived = true;
+	}
 	void handlePresenceWithNode() {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("somebody@localhost");
 		response->setFrom("user@localhost/resource");
 		dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend *>(component->getFrontend())->getStanzaChannel())->onPresenceReceived(response);

tests/libtransport/conversationmanager.cpp

➞

Show inline comments

 	CPPUNIT_TEST(handleParticipantChangedEscaped2);
 	CPPUNIT_TEST(handleParticipantChangedTwoResources);
 	CPPUNIT_TEST(handleParticipantChangedIconHash);
 	CPPUNIT_TEST(handlePMFromXMPP);
 	CPPUNIT_TEST(handleGroupchatRemoved);
 	CPPUNIT_TEST(handleNicknameConflict);
 	CPPUNIT_TEST(handleNotAuthorized);
 	CPPUNIT_TEST(handleSetNickname);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		TestingConversation *m_conv;
-		boost::shared_ptr<Swift::Message> m_msg;
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> m_msg;
 		void setUp (void) {
 			m_conv = NULL;
 			m_msg.reset();
 			setMeUp();
 			connectUser();
 			add2Buddies();
 			factory->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			disconnectUser();
 			factory->onMessageToSend.disconnect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 			tearMeDown();
+		}
 	void conversationSize() {
 		std::cout << " = " << sizeof(Conversation) << " B";
+	}
-	void handleMessageReceived(TestingConversation *_conv, boost::shared_ptr<Swift::Message> &_msg) {
+	void handleMessageReceived(TestingConversation *_conv, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> &_msg) {
 		m_conv = _conv;
 		m_msg = _msg;
+	}
 	void handleChatstateMessages() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "buddy1");
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->addPayload(boost::make_shared<Swift::ChatState>(Swift::ChatState::Composing));
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->addPayload(SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::ChatState>(Swift::ChatState::Composing));
 		// Forward it
 		conv->handleMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0]))->getPayload<Swift::ChatState>());
 		received.clear();
 		// send response
 		msg->setFrom("user@localhost/resource");
 		received.clear();
+	}
 	void handleSubjectMessages() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		conv->setNickname("nickname");
 		conv->addJID("user@localhost/resource");
-		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setSubject("subject");
 		msg->setType(Swift::Message::Groupchat);
 		conv->handleMessage(msg);
 		loop->processEvents();
 		// No response, because presence with code 110 has not been sent yet and we must not send
 		// subject before this one.
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		// this user presence - status code 110
 		conv->handleParticipantChanged("nickname", Conversation::PARTICIPANT_FLAG_MODERATOR, Swift::StatusShow::Away, "my status message");
 		received.clear();
 		delete conv;
+	}
 	void handleNormalMessages() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "buddy1@test");
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
-		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there<>!");
 		// Forward it
 		conv->handleMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there<>!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody().get_value_or(""));
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40test@localhost/bot"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
 		// send response
 		msg->setFrom("user@localhost/resource");
 		msg->setTo("buddy1\\40test@localhost/bot");
 		msg->setBody("response<>!");
 		injectMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT(m_msg);
 		CPPUNIT_ASSERT_EQUAL(std::string("response<>!"), m_msg->getBody().get_value_or(""));
 		// send another message from legacy network, should be sent to user@localhost/resource now
-		boost::shared_ptr<Swift::Message> msg2(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg2(new Swift::Message());
 		msg2->setBody("hi there!");
 		// Forward it
 		conv->handleMessage(msg2);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody().get_value_or(""));
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40test@localhost/bot"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody().get_value_or(""));
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1%test@localhost/bot"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
 		received.clear();
+	}
 	void handleNormalMessagesInitiatedFromXMPP() {
 		User *user = userManager->getUser("user@localhost");
-		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setFrom("user@localhost/resource");
 		msg->setTo("buddy1@localhost/bot");
 		msg->setBody("hi there<>!");
 		injectMessage(msg);
 		// Forward it
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT(m_msg);
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there<>!"), m_msg->getBody().get_value_or(""));
 		CPPUNIT_ASSERT_EQUAL(std::string("BuddY1"), m_conv->getLegacyName());
 		CPPUNIT_ASSERT(conv);
 		CPPUNIT_ASSERT_EQUAL(std::string("BuddY1"), conv->getLegacyName());
+	}
 	void handleNormalMessagesHeadline() {
 		User *user = userManager->getUser("user@localhost");
 		user->addUserSetting("send_headlines", "1");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "buddy1@test");
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
-		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there<>!");
 		msg->setType(Swift::Message::Headline);
 		// Forward it
 		conv->handleMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::Message::Headline, dynamic_cast<Swift::Message *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there<>!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody().get_value_or(""));
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 	void handleGroupchatMessages() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		conv->setNickname("nickname");
 		conv->addJID("user@localhost/resource");
 		// reset resources should not touch this resource
 		user->getConversationManager()->resetResources();
-		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there!");
 		// Forward it
 		conv->handleMessage(msg, "anotheruser");
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody().get_value_or(""));
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getShow());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/alias"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getFrom().toString());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::MUCUserPayload>());
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Member, *getStanza(received[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].affiliation);
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Participant, *getStanza(received[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].role);
 		received.clear();
 		// reset resources should not touch this resource
 		user->getConversationManager()->resetResources();
-		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there!");
 		// Forward it
 		conv->handleMessage(msg, "anotheruser");
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody().get_value_or(""));
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/alias"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
+	}
 	void handleGroupchatMessagesBouncer() {
 		User *user = userManager->getUser("user@localhost");
 		user->addUserSetting("stay_connected", "1");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		conv->setNickname("nickname");
 		conv->addJID("user@localhost/resource");
-		boost::shared_ptr<Swift::Message> msg0(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg0(new Swift::Message());
 		msg0->setSubject("subject");
 		conv->handleMessage(msg0, "anotheruser");
 		CPPUNIT_ASSERT(!user->shouldCacheMessages());
 		// disconnectUser
 		userManager->disconnectUser("user@localhost");
 		dynamic_cast<Swift::DummyTimerFactory *>(factories->getTimerFactory())->setTime(10);
 		loop->processEvents();
 		CPPUNIT_ASSERT(user->shouldCacheMessages());
 		// reset resources should not touch this resource
 		user->getConversationManager()->resetResources();
-		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there!");
 		conv->handleMessage(msg, "anotheruser");
-		boost::shared_ptr<Swift::Message> msg2(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg2(new Swift::Message());
 		msg2->setBody("hi there2!");
 		conv->handleMessage(msg2, "anotheruser");
 		loop->processEvents();
 		// Presence from the room when disconnecting the user
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		received.clear();
 		userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 		userRegistry->onPasswordValid(Swift::JID("user@localhost/resource"));
 		loop->processEvents();
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("#room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
-		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(7, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[2])));
 		CPPUNIT_ASSERT_EQUAL(Swift::Presence::Unavailable, dynamic_cast<Swift::Presence *>(getStanza(received[2]))->getType());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Presence *>(getStanza(received[2]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/hanzz"), dynamic_cast<Swift::Presence *>(getStanza(received[2]))->getFrom().toString());
 		CPPUNIT_ASSERT(getStanza(received[2])->getPayload<Swift::MUCUserPayload>());
 		CPPUNIT_ASSERT_EQUAL(std::string("nickname"), *getStanza(received[2])->getPayload<Swift::MUCUserPayload>()->getItems()[0].nick);
 		CPPUNIT_ASSERT_EQUAL(303, getStanza(received[2])->getPayload<Swift::MUCUserPayload>()->getStatusCodes()[2].code);
 		conv->setNickname("nickname");
 		conv->addJID("user@localhost/resource");
 		CPPUNIT_ASSERT(!user->shouldCacheMessages());
 		Swift::Presence::ref response3 = Swift::Presence::create();
 		response3->setType(Swift::Presence::Unavailable);
 		response3->setTo("#room@localhost/hanzz");
 		response3->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload3 = new Swift::MUCPayload();
 		payload3->setPassword("password");
-		response3->addPayload(boost::shared_ptr<Swift::Payload>(payload3));
+		response3->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(payload3));
 		injectPresence(response3);
 		loop->processEvents();
 		CPPUNIT_ASSERT(!user->shouldCacheMessages());
 		// reset resources should not touch this resource
 		user->getConversationManager()->resetResources();
-		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there!");
 		conv->handleMessage(msg, "anotheruser");
-		boost::shared_ptr<Swift::Message> msg2(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg2(new Swift::Message());
 		msg2->setBody("hi there2!");
 		conv->handleMessage(msg2, "anotheruser");
 		loop->processEvents();
 		// Presence to ack the user leave
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		received.clear();
 		userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 		userRegistry->onPasswordValid(Swift::JID("user@localhost/resource"));
 		loop->processEvents();
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("#room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
-		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(6, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[2])));
 		CPPUNIT_ASSERT_EQUAL(Swift::Presence::Unavailable, dynamic_cast<Swift::Presence *>(getStanza(received[2]))->getType());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Presence *>(getStanza(received[2]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/hanzz"), dynamic_cast<Swift::Presence *>(getStanza(received[2]))->getFrom().toString());
 		CPPUNIT_ASSERT(getStanza(received[2])->getPayload<Swift::MUCUserPayload>());
 		CPPUNIT_ASSERT_EQUAL(std::string("nickname"), *getStanza(received[2])->getPayload<Swift::MUCUserPayload>()->getItems()[0].nick);
 		CPPUNIT_ASSERT_EQUAL(303, getStanza(received[2])->getPayload<Swift::MUCUserPayload>()->getStatusCodes()[2].code);
 		received2.clear();
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		conv->setNickname("nickname");
 		conv->addJID("user@localhost/resource");
 		conv->addJID("user@localhost/resource2");
 		// reset resources should not touch this resource
 		user->getConversationManager()->resetResources();
-		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there!");
 		// Forward it
 		conv->handleMessage(msg, "anotheruser");
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received2.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received2[0])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received2[0]))->getBody().get_value_or(""));
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource2"), dynamic_cast<Swift::Message *>(getStanza(received2[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Message *>(getStanza(received2[0]))->getFrom().toString());
 	void handlePMFromXMPP() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		conv->setNickname("nickname");
 		conv->setJID("user@localhost/resource");
 		conv->handleParticipantChanged("anotheruser", Conversation::PARTICIPANT_FLAG_NONE, Swift::StatusShow::Away, "my status message");
 		loop->processEvents();
 		received.clear();
-		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there!");
 		msg->setFrom("user@localhost/resource");
 		msg->setTo("#room@localhost/anotheruser");
 		msg->setBody("hi there!");
 		injectMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT(m_msg);
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), m_msg->getBody().get_value_or(""));
 		CPPUNIT_ASSERT_EQUAL(std::string("#room/anotheruser"), m_conv->getLegacyName());
 		Conversation *pmconv = user->getConversationManager()->getConversation("#room/anotheruser");
-		boost::shared_ptr<Swift::Message> msg2(new Swift::Message());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg2(new Swift::Message());
 		msg2->setBody("response!");
 		pmconv->handleMessage(msg2);
+	}
 	void handleGroupchatRemoved() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		conv->setNickname("nickname");
 		conv->addJID("user@localhost/resource");
 		received.clear();
 		conv->destroyRoom();

tests/libtransport/discoitemsresponder.cpp

➞

Show inline comments

 		void setUp (void) {
 			setMeUp();
+		}
 		void tearDown (void) {
 			received.clear();
 			tearMeDown();
+		}
 	void roomList() {
 		itemsResponder->addRoom("#room@localhost", "#room");
 		boost::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
 		boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		iq->setFrom("user@localhost");
 		injectIQ(iq);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoItems>());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost"), getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems()[0].getJID().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room"), getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems()[0].getName());
+	}
 	void roomListUser() {
 		connectUser();
 		User *user = userManager->getUser("user@localhost");
 		user->addRoomToRoomList("#room2@localhost", "#room2");
 		itemsResponder->addRoom("#room@localhost", "#room");
 		boost::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
 		boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		iq->setFrom("user@localhost");
 		injectIQ(iq);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoItems>());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost"), getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems()[0].getJID().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room"), getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems()[0].getName());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room2@localhost"), getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems()[1].getJID().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room2"), getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems()[1].getName());
+	}
 	void roomInfoUser() {
 		connectUser();
 		User *user = userManager->getUser("user@localhost");
 		user->addRoomToRoomList("#room2@localhost", "#room2");
 		itemsResponder->addRoom("#room@localhost", "#room");
 		boost::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 		boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		iq->setFrom("user@localhost");
 		iq->setTo("#room2@localhost");
 		injectIQ(iq);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room2"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getName());
 		CPPUNIT_ASSERT_EQUAL(std::string("conference"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getCategory());
 		CPPUNIT_ASSERT_EQUAL(std::string("text"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getType());
+	}
 	void roomInfo() {
 		itemsResponder->addRoom("#room@localhost", "#room");
 		boost::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 		boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		iq->setFrom("user@localhost");
 		iq->setTo("#room@localhost");
 		injectIQ(iq);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getName());
 		CPPUNIT_ASSERT_EQUAL(std::string("conference"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getCategory());
 		CPPUNIT_ASSERT_EQUAL(std::string("text"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getType());
+	}
 	void roomListEscaping() {
 		itemsResponder->addRoom(Swift::JID::getEscapedNode("19:room@localhost") + "@" + component->getJID().toString(), "#room");
 		boost::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
 		boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		iq->setFrom("user@localhost");
 		injectIQ(iq);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoItems>());
 		CPPUNIT_ASSERT_EQUAL(std::string("19\\3aroom\\40localhost@localhost"), getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems()[0].getJID().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room"), getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems()[0].getName());
+	}
 	void roomInfoEscaping() {
 		itemsResponder->addRoom(Swift::JID::getEscapedNode("19:room@localhost") + "@" + component->getJID().toString(), "#room");
 		boost::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 		boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		iq->setFrom("user@localhost");
 		iq->setTo("19\\3aroom\\40localhost@localhost");
 		injectIQ(iq);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getName());
 		CPPUNIT_ASSERT_EQUAL(std::string("conference"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getCategory());
 		CPPUNIT_ASSERT_EQUAL(std::string("text"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getType());
+	}
 	void clearRooms() {
 		itemsResponder->addRoom("#room@localhost", "#room");
 		itemsResponder->clearRooms();
 		boost::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
 		boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		iq->setFrom("user@localhost");
 		injectIQ(iq);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoItems>());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems().empty());
+	}
 	void receipts() {
 		boost::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 		boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		iq->setFrom("user@localhost");
 		iq->setTo("buddy@localhost");
 		injectIQ(iq);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		CPPUNIT_ASSERT(!getStanza(received[0])->getPayload<Swift::DiscoInfo>()->hasFeature("urn:xmpp:receipts"));
 		received.clear();
 		cfg->updateBackendConfig("[features]\nreceipts=1\n");

tests/libtransport/gatewayresponder.cpp

➞

Show inline comments

 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			disconnectUser();
 			delete m_gatewayResponder;
 			tearMeDown();
+		}
 		void escape() {
-			boost::shared_ptr<Swift::IQ> iq(new Swift::IQ(Swift::IQ::Set));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq(new Swift::IQ(Swift::IQ::Set));
 			iq->setTo("icq.localhost");
 			iq->setFrom("user@localhost");
-			iq->addPayload(boost::shared_ptr<Swift::GatewayPayload>(new Swift::GatewayPayload(Swift::JID(), "", "a@b")));
+			iq->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::GatewayPayload>(new Swift::GatewayPayload(Swift::JID(), "", "a@b")));
 			iq->setID("123");
 			injectIQ(iq);
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::GatewayPayload>());
 			CPPUNIT_ASSERT_EQUAL(std::string("a\\40b@localhost"), getStanza(received[0])->getPayload<Swift::GatewayPayload>()->getJID().toString());
+		}
 		void noEscapeEscaped() {
-			boost::shared_ptr<Swift::IQ> iq(new Swift::IQ(Swift::IQ::Set));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq(new Swift::IQ(Swift::IQ::Set));
 			iq->setTo("icq.localhost");
 			iq->setFrom("user@localhost");
-			iq->addPayload(boost::shared_ptr<Swift::GatewayPayload>(new Swift::GatewayPayload(Swift::JID(), "", "a\\40b")));
+			iq->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::GatewayPayload>(new Swift::GatewayPayload(Swift::JID(), "", "a\\40b")));
 			iq->setID("123");
 			injectIQ(iq);
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::GatewayPayload>());
 			CPPUNIT_ASSERT_EQUAL(std::string("a\\40b@localhost"), getStanza(received[0])->getPayload<Swift::GatewayPayload>()->getJID().toString());
+		}
 };

tests/libtransport/networkpluginserver.cpp

➞

Show inline comments

 	public:
 		NetworkPluginServer *serv;
 		NetworkPluginServer::Backend backend;
 		Swift::SafeByteArray protobufData;
 		void setUp (void) {
 			setMeUp();
 			serv = new NetworkPluginServer(component, cfg, userManager, NULL);
 			connectUser();
 			User *user = userManager->getUser("user@localhost");
 			user->setData(&backend);
-			boost::shared_ptr<Swift::Connection> client1 = factories->getConnectionFactory()->createConnection();
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> client1 = factories->getConnectionFactory()->createConnection();
 			dynamic_cast<Swift::DummyConnection *>(client1.get())->onDataSent.connect(boost::bind(&NetworkPluginServerTest::handleDataSent, this, _1));
 			backend.connection = client1;
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			disconnectUser();
 			delete serv;
 			tearMeDown();
+		}

tests/libtransport/rosterresponder.cpp

➞

Show inline comments

 		m_buddy = buddy->getName();
+	}
 	void addEmptyBuddy() {
 		Swift::RosterPayload::ref p = Swift::RosterPayload::ref(new Swift::RosterPayload());
 		Swift::RosterItemPayload item;
 		item.setJID("icq.localhost");
 		item.setSubscription(Swift::RosterItemPayload::Both);
 		p->addItem(item);
 		Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(p, "user@localhost", static_cast<XMPPFrontend *>(component->getFrontend())->getIQRouter());
-		boost::shared_ptr<Swift::IQ> iq(new Swift::IQ(Swift::IQ::Set));
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq(new Swift::IQ(Swift::IQ::Set));
 		iq->setTo("icq.localhost");
 		iq->setFrom("user@localhost");
 		iq->addPayload(p);
 		iq->setID("123");
 		injectIQ(iq);
 		CPPUNIT_ASSERT_EQUAL(std::string("none"), m_buddy);
+	}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (RosterResponderTest);

tests/libtransport/settingsadhoccommand.cpp

➞

Show inline comments

 	public:
 		void setUp (void) {
 			setMeUp();
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			tearMeDown();
+		}
 		void getItems() {
-			boost::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
 			payload->setNode("http://jabber.org/protocol/commands");
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoItems>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems()[0].getNode());
+		}
 		void getInfo() {
-			boost::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 			payload->setNode("settings");
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 			CPPUNIT_ASSERT_EQUAL(std::string("automation"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getCategory());
 			CPPUNIT_ASSERT_EQUAL(std::string("command-node"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getType());
+		}
 		void getInfoBare() {
-			boost::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 			payload->setNode("http://jabber.org/protocol/commands");
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 			CPPUNIT_ASSERT_EQUAL(std::string("automation"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getCategory());
 			CPPUNIT_ASSERT_EQUAL(std::string("command-list"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getType());
+		}
 		void executeNotRegistered() {
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Completed, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
+		}
 		void execute() {
 			addUser();
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			// form element
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm()->getField("enable_transport"));
 			// set enabled_transport = 0
 			Swift::FormField::ref f = getStanza(received[0])->getPayload<Swift:: Command>()->getForm()->getField("enable_transport");
 #if (SWIFTEN_VERSION >= 0x030000)
 			f->setBoolValue(false);
 #else
-			boost::dynamic_pointer_cast<Swift::BooleanFormField>(f)->setValue(false);
+			SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::BooleanFormField>(f)->setValue(false);
 #endif
 			std::string sessionId = getStanza(received[0])->getPayload<Swift::Command>()->getSessionID();
+			{
 			std::string value = "0";
 			int type;
 			storage->getUserSetting(1, "enable_transport", type, value);
 			CPPUNIT_ASSERT_EQUAL(std::string("1"), value);
+			}
 			// finish the command
-			payload = boost::shared_ptr<Swift::Command>(new Swift::Command("settings"));
+			payload = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command>(new Swift::Command("settings"));
 			payload->setSessionID(sessionId);
 			payload->setForm(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Completed, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
+			{
 			std::string value = "1";
 			int type;
 			storage->getUserSetting(1, "enable_transport", type, value);
 			CPPUNIT_ASSERT_EQUAL(std::string("0"), value);
+			}
 			received.clear();
-			payload = boost::shared_ptr<Swift::Command>(new Swift::Command("settings"));
+			payload = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command>(new Swift::Command("settings"));
 			iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			// form element
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm()->getField("enable_transport"));
 			// set enabled_transport = 0
 			f = getStanza(received[0])->getPayload<Swift:: Command>()->getForm()->getField("enable_transport");
 #if (SWIFTEN_VERSION >= 0x030000)
 			CPPUNIT_ASSERT_EQUAL(false, f->getBoolValue());
 #else
-			CPPUNIT_ASSERT_EQUAL(false, boost::dynamic_pointer_cast<Swift::BooleanFormField>(f)->getValue());
+			CPPUNIT_ASSERT_EQUAL(false, SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::BooleanFormField>(f)->getValue());
 #endif
+		}
 		void executeTwoCommands() {
 			addUser();
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			// form element
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm()->getField("enable_transport"));
 			received.clear();
-			payload = boost::shared_ptr<Swift::Command>(new Swift::Command("settings"));
+			payload = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command>(new Swift::Command("settings"));
 			iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			// form element
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm()->getField("enable_transport"));
+		}
 		void executeBadSessionID() {
 			addUser();
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			std::string sessionId = "somethingwrong";
 			// finish the command
-			payload = boost::shared_ptr<Swift::Command>(new Swift::Command("settings"));
+			payload = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command>(new Swift::Command("settings"));
 			payload->setSessionID(sessionId);
 			payload->setForm(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Error, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
+		}
 		void cancel() {
 			addUser();
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			std::string sessionId = getStanza(received[0])->getPayload<Swift::Command>()->getSessionID();
 			// cancel the command
-			payload = boost::shared_ptr<Swift::Command>(new Swift::Command("settings"));
+			payload = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command>(new Swift::Command("settings"));
 			payload->setSessionID(sessionId);
 			payload->setAction(Swift::Command::Cancel);
 			iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Canceled, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
+		}
 		void propagateUserSetting() {
 			connectUser();
 			User *user = userManager->getUser("user@localhost");
 			CPPUNIT_ASSERT_EQUAL(std::string("0"), user->getUserSetting("send_headlines"));
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			// form element
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm()->getField("send_headlines"));
 			// set enabled_transport = 0
 			Swift::FormField::ref f = getStanza(received[0])->getPayload<Swift:: Command>()->getForm()->getField("send_headlines");
 #if (SWIFTEN_VERSION >= 0x030000)
 			f->setBoolValue(true);
 #else
-			boost::dynamic_pointer_cast<Swift::BooleanFormField>(f)->setValue(true);
+			SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::BooleanFormField>(f)->setValue(true);
 #endif
 			std::string sessionId = getStanza(received[0])->getPayload<Swift::Command>()->getSessionID();
 			// finish the command
-			payload = boost::shared_ptr<Swift::Command>(new Swift::Command("settings"));
+			payload = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command>(new Swift::Command("settings"));
 			payload->setSessionID(sessionId);
 			payload->setForm(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(std::string("1"), user->getUserSetting("send_headlines"));
+		}
 		void defaultAccordingToConfig() {
 			std::istringstream ifs("service.server_mode = 1\nservice.jid_escaping=0\nservice.jid=localhost\nsettings.send_headlines=1\n");
 			cfg->load(ifs);
 			connectUser();
 			User *user = userManager->getUser("user@localhost");
 			CPPUNIT_ASSERT_EQUAL(std::string("1"), user->getUserSetting("send_headlines"));
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			// form element
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm()->getField("send_headlines"));
 			Swift::FormField::ref f = getStanza(received[0])->getPayload<Swift:: Command>()->getForm()->getField("send_headlines");
 #if (SWIFTEN_VERSION >= 0x030000)
 			CPPUNIT_ASSERT_EQUAL(true, f->getBoolValue());
 #else
-			CPPUNIT_ASSERT_EQUAL(true, boost::dynamic_pointer_cast<Swift::BooleanFormField>(f)->getValue());
+			CPPUNIT_ASSERT_EQUAL(true, SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::BooleanFormField>(f)->getValue());
 #endif
+		}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (SettingsAdHocCommandTest);

tests/libtransport/user.cpp

➞

Show inline comments

 			frontend->onVCardUpdated.connect(boost::bind(&UserTest::handleVCardUpdated, this, _1, _2));
+		}
 		void tearDown (void) {
 			received.clear();
 			if (!disconnected) {
 				disconnectUser();
+			}
 			userManager->removeAllUsers();
 			tearMeDown();
+		}
-	void handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> v) {
+	void handleVCardUpdated(User *user, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> v) {
 		photo = Swift::byteArrayToString(v->getPhoto());
+	}
 	void handleUserCreated(User *user) {
 		user->onReadyToConnect.connect(boost::bind(&UserTest::handleUserReadyToConnect, this, user));
 		user->onPresenceChanged.connect(boost::bind(&UserTest::handleUserPresenceChanged, this, user, _1));
 		user->onRoomJoined.connect(boost::bind(&UserTest::handleRoomJoined, this, user, _1, _2, _3, _4));
 		user->onRoomLeft.connect(boost::bind(&UserTest::handleRoomLeft, this, user, _1));
+	}
 	void handleUserReadyToConnect(User *user) {
 		readyToConnect = true;
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, changedPresence->getShow());
+	}
 	void handlePresenceJoinRoom() {
 		User *user = userManager->getUser("user@localhost");
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
-		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz"), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), roomPassword);
 		room = "";
 		roomNickname = "";
 		roomPassword = "";
 		Conversation *conv = user->getConversationManager()->getConversation("room");
 		conv->handleParticipantChanged("anotheruser", Conversation::PARTICIPANT_FLAG_NONE, Swift::StatusShow::Away, "my status message");
 		// Connect 2nd resource
 		connectSecondResource();
 		received2.clear();
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource2");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
-		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		CPPUNIT_ASSERT_EQUAL(2, (int) received2.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received2[1])));
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, dynamic_cast<Swift::Presence *>(getStanza(received2[1]))->getShow());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource2"), dynamic_cast<Swift::Presence *>(getStanza(received2[1]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("room@localhost/anotheruser"), dynamic_cast<Swift::Presence *>(getStanza(received2[1]))->getFrom().toString());
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Participant, *getStanza(received2[1])->getPayload<Swift::MUCUserPayload>()->getItems()[0].role);
+	}
 	void handlePresenceLeaveRoom() {
 		received.clear();
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
-		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 // 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 // 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 // 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResources() {
 		handlePresenceJoinRoomTwoResources();
 		received.clear();
 		// User is still connected from resource2, so he should not leave the room
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
-		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		// disconnect also from resource
 		// User is still connected from resource2, so he should not leave the room
 		response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource2");
 		response->setType(Swift::Presence::Unavailable);
 		payload = new Swift::MUCPayload();
 		payload->setPassword("password");
-		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResourcesOneDisconnects() {
 		handlePresenceJoinRoomTwoResources();
+	}
 	void handlePresenceLeaveRoomBouncer() {
 		User *user = userManager->getUser("user@localhost");
 		user->addUserSetting("stay_connected", "1");
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
-		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResourcesBouncer() {
 		User *user = userManager->getUser("user@localhost");
 		user->addUserSetting("stay_connected", "1");
 		handlePresenceJoinRoomTwoResources();
 		received.clear();
 		// User is still connected from resource2, so he should not leave the room
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
-		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		room = "something";
 		// disconnect also from resource
 		// User is still connected from resource2, so he should not leave the room
 		response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource2");
 		response->setType(Swift::Presence::Unavailable);
 		payload = new Swift::MUCPayload();
 		payload->setPassword("password");
-		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("something"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResourcesOneDisconnectsBouncer() {
 		room = "something";
+	}
 	void joinRoomBeforeConnected() {
 		User *user = userManager->getUser("user@localhost");
 		user->setConnected(false);
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
-		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		user->setConnected(true);
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz"), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), roomPassword);
 		received.clear();
 		handlePresenceJoinRoom();
+	}
 	void requestVCard() {
 		User *user = userManager->getUser("user@localhost");
 		user->setStorageBackend(storage);
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost/resource");
-		response->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::VCardUpdate("hash")));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::VCardUpdate("hash")));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 		Swift::VCard::ref payload1 = getStanza(received[1])->getPayload<Swift::VCard>();
 		CPPUNIT_ASSERT(payload1);
-		boost::shared_ptr<Swift::VCard> vcard(new Swift::VCard());
+		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCard> vcard(new Swift::VCard());
 		vcard->setPhoto(Swift::createByteArray("photo"));
 		injectIQ(Swift::IQ::createResult(getStanza(received[1])->getFrom(), getStanza(received[1])->getTo(), getStanza(received[1])->getID(), vcard));
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("photo"), photo);
 		received.clear();
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
+	}

tests/libtransport/usermanager.cpp

➞

Show inline comments

 		response->setTo("localhost");
 		response->setFrom("user@localhost");
 		response->setType(Swift::Presence::Error);
 		dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend *>(component->getFrontend())->getStanzaChannel())->onPresenceReceived(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost");
 		response->setType(Swift::Presence::Error);
-		response->addPayload(boost::shared_ptr<Swift::ErrorPayload>(new Swift::ErrorPayload(Swift::ErrorPayload::SubscriptionRequired)));
+		response->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ErrorPayload>(new Swift::ErrorPayload(Swift::ErrorPayload::SubscriptionRequired)));
 		dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend *>(component->getFrontend())->getStanzaChannel())->onPresenceReceived(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		presence = dynamic_cast<Swift::Presence *>(getStanza(received[0]));
 		CPPUNIT_ASSERT(presence);
 		CPPUNIT_ASSERT_EQUAL(Swift::Presence::Subscribe, presence->getType());
 		storage->removeUser(1);
 		received.clear();
 		response = Swift::Presence::create();
 		response->setTo("localhost");

tests/libtransport/userregistration.cpp

➞

Show inline comments

 	public:
 		void setUp (void) {
 			setMeUp();
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			tearMeDown();
+		}
 		void getForm() {
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(new Swift::InBandRegistrationPayload()));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::InBandRegistrationPayload()));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>());
 			CPPUNIT_ASSERT_EQUAL(false, getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->isRegistered());
 			CPPUNIT_ASSERT_EQUAL(std::string(""), *getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->getUsername());
 			CPPUNIT_ASSERT_EQUAL(std::string(""), *getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->getPassword());
+		}
 		void getFormRegistered() {
 			UserInfo user;
 			user.id = -1;
 			user.jid = "user@localhost";
 			user.uin = "legacyname";
 			user.password = "password";
 			storage->setUser(user);
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(new Swift::InBandRegistrationPayload()));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::InBandRegistrationPayload()));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>());
 			CPPUNIT_ASSERT_EQUAL(true, getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->isRegistered());
 			CPPUNIT_ASSERT_EQUAL(std::string("legacyname"), *getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->getUsername());
 			CPPUNIT_ASSERT_EQUAL(std::string(""), *getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->getPassword());
+		}
 		void registerUser() {
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setUsername("legacyname");
 			reg->setPassword("password");
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[1]))->getType());
-			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID(), boost::shared_ptr<Swift::Payload>(new Swift::RosterPayload()));
+			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID(), SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::RosterPayload()));
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Set, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT_EQUAL(std::string("localhost"), getStanza(received[0])->getPayload<Swift::RosterPayload>()->getItems()[0].getJID().toString());
 			UserInfo user;
 			CPPUNIT_ASSERT_EQUAL(true, storage->getUser("user@localhost", user));
 			CPPUNIT_ASSERT_EQUAL(std::string("legacyname"), user.uin);
 			CPPUNIT_ASSERT_EQUAL(std::string("password"), user.password);
+		}
 		void registerUserWithoutRR(){
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setUsername("legacyname");
 			reg->setPassword("password");
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[1]))->getType());
 			iq = Swift::IQ::createError(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID());
 			received.clear();
 			loop->processEvents();
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::Presence::Subscribe, dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getType());
+		}
 		void unregisterUser() {
 			registerUser();
 			received.clear();
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setRemove(true);
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[1]))->getType());
-			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID(), boost::shared_ptr<Swift::Payload>(new Swift::RosterPayload()));
+			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID(), SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::RosterPayload()));
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Set, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			UserInfo user;
 			CPPUNIT_ASSERT_EQUAL(false, storage->getUser("user@localhost", user));
+		}
 		void registerUserNotify() {
 			std::istringstream ifs("service.server_mode = 1\nregistration.notify_jid=user@localhost\nservice.jid=localhost\nservice.more_resources=1\n");
 			cfg->load(ifs);
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setUsername("legacyname");
 			reg->setPassword("password");
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[1]))->getType());
-			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID(), boost::shared_ptr<Swift::Payload>(new Swift::RosterPayload()));
+			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID(), SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::RosterPayload()));
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Set, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT_EQUAL(std::string("localhost"), getStanza(received[0])->getPayload<Swift::RosterPayload>()->getItems()[0].getJID().toString());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(true, storage->getUser("user@localhost", user));
 			CPPUNIT_ASSERT_EQUAL(std::string("legacyname"), user.uin);
 			CPPUNIT_ASSERT_EQUAL(std::string("password"), user.password);
+		}
 		void unregisterUserNotify() {
 			registerUserNotify();
 			received.clear();
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setRemove(true);
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[1]))->getType());
-			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID(), boost::shared_ptr<Swift::Payload>(new Swift::RosterPayload()));
+			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID(), SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::RosterPayload()));
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Set, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(std::string("unregistered: user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getBody().get_value_or(""));
 			UserInfo user;
 			CPPUNIT_ASSERT_EQUAL(false, storage->getUser("user@localhost", user));
+		}
 		void changePassword() {
 			registerUser();
 			received.clear();
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setUsername("legacyname");
 			reg->setPassword("another");
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			UserInfo user;
 			CPPUNIT_ASSERT_EQUAL(true, storage->getUser("user@localhost", user));
 			CPPUNIT_ASSERT_EQUAL(std::string("legacyname"), user.uin);
 			CPPUNIT_ASSERT_EQUAL(std::string("another"), user.password);
+		}
 		void registerUserEmpty() {
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setUsername("");
 			reg->setPassword("password");
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Error, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			UserInfo user;
 			CPPUNIT_ASSERT_EQUAL(false, storage->getUser("user@localhost", user));
+		}
 		void unregisterEmptyPayload() {
 			registerUser();
 			received.clear();
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setRemove(true);
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[1]))->getType());
 			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::Presence::Unsubscribe, dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(Swift::Presence::Unsubscribed, dynamic_cast<Swift::Presence *>(getStanza(received[1]))->getType());
+		}
 		void registerUserNoNeedPassword() {
 			cfg->updateBackendConfig("[registration]\nneedPassword=0\n");
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setUsername("legacyname");
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[1]))->getType());
-			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID(), boost::shared_ptr<Swift::Payload>(new Swift::RosterPayload()));
+			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID(), SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::RosterPayload()));
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Set, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT_EQUAL(std::string("localhost"), getStanza(received[0])->getPayload<Swift::RosterPayload>()->getItems()[0].getJID().toString());
 			UserInfo user;
 			CPPUNIT_ASSERT_EQUAL(true, storage->getUser("user@localhost", user));
 			CPPUNIT_ASSERT_EQUAL(std::string("legacyname"), user.uin);
 			CPPUNIT_ASSERT_EQUAL(std::string(""), user.password);
+		}
 		void registerUserFormUnknownType() {
 #if HAVE_SWIFTEN_3
 			Swift::Form::ref form(new Swift::Form(Swift::Form::FormType));
-			Swift::FormField::ref type = boost::make_shared<Swift::FormField>(Swift::FormField::UnknownType, "jabber:iq:register");
+			Swift::FormField::ref type = SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::FormField>(Swift::FormField::UnknownType, "jabber:iq:register");
 			type->setName("FORM_TYPE");
 			form->addField(type);
-			Swift::FormField::ref username = boost::make_shared<Swift::FormField>(Swift::FormField::UnknownType, "legacyname");
+			Swift::FormField::ref username = SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::FormField>(Swift::FormField::UnknownType, "legacyname");
 			username->setName("username");
 			form->addField(username);
-			Swift::FormField::ref password = boost::make_shared<Swift::FormField>(Swift::FormField::UnknownType, "password");
+			Swift::FormField::ref password = SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::FormField>(Swift::FormField::UnknownType, "password");
 			password->setName("password");
 			form->addField(password);
-			Swift::FormField::ref language = boost::make_shared<Swift::FormField>(Swift::FormField::UnknownType, "language");
+			Swift::FormField::ref language = SWIFTEN_SHRPTR_NAMESPACE::make_shared<Swift::FormField>(Swift::FormField::UnknownType, "language");
 			language->setName("en");
 			form->addField(language);
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setForm(form);
-			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
+			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[1]))->getType());
 			iq = Swift::IQ::createError(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID());
 			received.clear();

tests/libtransport/userregistry.cpp

➞

Show inline comments

@@ @@ -58,59 +58,59 @@ class UserRegistryTest : public CPPUNIT_NS :: TestFixture { @@
 			client1.reset();
 			dynamic_cast<Swift::DummyConnection *>(client2.get())->onDataSent.disconnect_all_slots();
 			client2.reset();
 			connectionServer.reset();
 			delete userRegistry;
 			delete factories;
 			delete loop;
 			delete cfg;
 			received1.clear();
 			received2.clear();
+		}
-		void send(boost::shared_ptr<Swift::Connection> conn, const std::string &data) {
+		void send(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> conn, const std::string &data) {
 			dynamic_cast<Swift::DummyConnection *>(conn.get())->receive(Swift::createSafeByteArray(data));
 			loop->processEvents();
+		}
-		void sendCredentials(boost::shared_ptr<Swift::Connection> conn, const std::string &username, const std::string &password, const std::string &b64) {
+		void sendCredentials(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> conn, const std::string &username, const std::string &password, const std::string &b64) {
 			std::vector<std::string> &received = conn == client1 ? received1 : received2;
 			send(conn, "<stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' to='localhost' version='1.0'>");
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(received[0].find("<?xml version=\"1.0\"?>") == 0);
 			CPPUNIT_ASSERT(received[1].find("PLAIN") != std::string::npos);
 			received.clear();
 			// username:test
 			send(conn, "<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='PLAIN'>" + b64 + "</auth>");
 			if (conn == client1)
 				CPPUNIT_ASSERT_EQUAL(Connecting, state1);
 // 			else
 // 				CPPUNIT_ASSERT_EQUAL(Connecting, state2);
 			CPPUNIT_ASSERT_EQUAL(password, userRegistry->getUserPassword(username));
 			CPPUNIT_ASSERT_EQUAL(std::string(""), userRegistry->getUserPassword("unknown@localhost"));
+		}
-		void bindSession(boost::shared_ptr<Swift::Connection> conn) {
+		void bindSession(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> conn) {
 			std::vector<std::string> &received = conn == client1 ? received1 : received2;
 			send(conn, "<stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' to='localhost' version='1.0'>");
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(received[0].find("<?xml version=\"1.0\"?>") == 0);
 			CPPUNIT_ASSERT(received[1].find("urn:ietf:params:xml:ns:xmpp-bind") != std::string::npos);
 			CPPUNIT_ASSERT(received[1].find("urn:ietf:params:xml:ns:xmpp-session") != std::string::npos);
+		}
-		void handleDataReceived(const Swift::SafeByteArray &data, boost::shared_ptr<Swift::Connection> conn) {
+		void handleDataReceived(const Swift::SafeByteArray &data, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> conn) {
 			if (conn == client1) {
 				received1.push_back(safeByteArrayToString(data));
 // 				std::cout << received1.back() << "\n";
+			}
 			else {
 				received2.push_back(safeByteArrayToString(data));
 // 				std::cout << received2.back() << "\n";
+			}
+		}
 		void handleConnectUser(const Swift::JID &user) {
 			state1 = Connecting;
 	private:
 		typedef enum {
 			Init,
 			Connecting,
 			Disconnected,
 		} State;
 		UserRegistry *userRegistry;
 		Config *cfg;
 		Swift::Server *server;
 		Swift::DummyNetworkFactories *factories;
 		Swift::DummyEventLoop *loop;
 		boost::shared_ptr<Swift::ConnectionServer> connectionServer;
 		boost::shared_ptr<Swift::Connection> client1;
 		boost::shared_ptr<Swift::Connection> client2;
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ConnectionServer> connectionServer;
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> client1;
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> client2;
 		std::vector<std::string> received1;
 		std::vector<std::string> received2;
 		State state1;
 		State state2;
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (UserRegistryTest);

0 comments (0 inline, 0 general)