ADD_DEFINITIONS(-DBOOST_THREAD_USE_LIB)

endif()

if(CMAKE_BUILD_TYPE MATCHES Debug)

	if (CMAKE_COMPILER_IS_GNUCXX)

		ADD_DEFINITIONS(-O0)

#include "../TwitterResponseParser.h"

#include "transport/Logging.h"

#include <string>

#include <boost/function.hpp>

#include <boost/bind.hpp>

#include <iostream>

#include "transport/Logging.h"

#include "transport/Config.h"

#include <string>

#include <boost/function.hpp>

#include <boost/bind.hpp>

#include <iostream>

#include "sys/signal.h"

#endif

#include <boost/algorithm/string.hpp>

#include <boost/thread.hpp>

#include <boost/thread/mutex.hpp>

#pragma once

#include <boost/shared_ptr.hpp>

#include "Swiften/SwiftenCompat.h"

			virtual void stop();

			virtual void cancel();

		private:

			void handleStreamInitiationRequestResponse(StreamInitiation::ref, ErrorPayload::ref);

#include <Swiften/Network/DummyConnectionServer.h>

#include <boost/bind.hpp>

#include <boost/system/system_error.hpp>

#include <boost/asio/placeholders.hpp>

#include <string>

#include <boost/bind.hpp>

#include <boost/foreach.hpp>

#include "Swiften/Base/String.h"

#include "Swiften/Network/Connection.h"

	if (serverFromClientConnectionServer) {

		serverFromClientConnectionServer->stop();

			connection.disconnect();

		}

		serverFromClientConnectionServerSignalConnections.clear();

#include <boost/shared_ptr.hpp>

#include <boost/optional.hpp>

#include <vector>

#include "Swiften/Network/BoostIOServiceThread.h"

#include "Swiften/SwiftenCompat.h"

#include <Swiften/TLS/CertificateWithKey.h>

#include <Swiften/Parser/PlatformXMLParserFactory.h>

namespace Swift {

	class ConnectionServer;

				return serverFromClientConnectionServer;

			}

			void addTLSEncryption(TLSServerContextFactory* tlsContextFactory, CertificateWithKey::ref cert);

			NetworkFactories* networkFactories_;

			bool stopping;

			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ConnectionServer> serverFromClientConnectionServer;

			std::list<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> > serverFromClientSessions;

			JID selfJID;

			StanzaChannel *stanzaChannel_;

#include <boost/shared_ptr.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <string>

#include <Swiften/Session/Session.h>

					Swift::JID remoteJID = Swift::JID());

			~ServerFromClientSession();

			void setAllowSASLEXTERNAL();

			const std::string &getUser() {

				return user_;

#include <string>

#include <Swiften/Base/SafeByteArray.h>

#include "Swiften/Server/ServerFromClientSession.h"

namespace Swift {

 * See Documentation/Licenses/GPLv3.txt for more information.

 */

#include "Swiften/Base/SafeByteArray.h"

#include "Swiften/StreamStack/StreamLayer.h"

#include "Swiften/TLS/Certificate.h"

			}

		public:

		private:

			TLSServerContext* context;

 * 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,

#if (SWIFTEN_VERSION >= 0x040000)

#define SWIFTEN_UNIQUE_PTR std::unique_ptr

#define SWIFTEN_SHRPTR_NAMESPACE std

#define SWIFTEN_SIGNAL_NAMESPACE boost::signals2

#define SWIFT_HOSTADDRESS(x) *(Swift::HostAddress::fromString(x))

#else

#define SWIFTEN_UNIQUE_PTR std::auto_ptr

#define SWIFTEN_SHRPTR_NAMESPACE boost

#define SWIFT_HOSTADDRESS(x) Swift::HostAddress(x)

#endif

#pragma once

#include <boost/shared_ptr.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;

			virtual ByteArray getFinishMessage() const = 0;

		public:

	};

}

#include <boost/algorithm/string.hpp>

#include <boost/assign.hpp>

#include <boost/bind.hpp>

namespace Transport {

		const std::string &getConfigFile() { return m_file; }

		/// This signal is emitted when config is loaded/reloaded.

		void updateBackendConfig(const std::string &backendConfig);

		static Config *createFromArgs(int argc, char **argv, std::string &error, std::string &host, int &port);

#include "Swiften/Elements/Presence.h"

#include "Swiften/SwiftenCompat.h"

namespace Transport {

class Config;

		virtual bool isRawXMLEnabled() { return false; }

};

}

#include <string.h>

#include "rapidjson/document.h"

namespace Transport {

			return m_url;

		}

		static void globalInit() {

			curl_global_init(CURL_GLOBAL_ALL);

#include <string>

#include <map>

#include "Swiften/FileTransfer/ReadBytestream.h"

#include "Swiften/SwiftenCompat.h"

		void setFinished() { m_finished = true; }

		bool isFinished() const;

	private:

		bool m_finished;

#include <map>

#include <string>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Client/StanzaChannel.h>

namespace Transport {

		void clearPresences(const Swift::JID& bareJID);

	public:

	private:

		void handleIncomingPresence(Swift::Presence::ref presence);

#include <string>

#include <algorithm>

#include <map>

#include <boost/pool/pool_alloc.hpp>

#include <boost/pool/object_pool.hpp>

// #include "rosterstorage.h"

#include "Swiften/Roster/SetRosterRequest.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Network/Timer.h"

namespace Transport {

		/// Called when new Buddy is added to this roster.

		/// \param buddy newly added Buddy

		/// Called when Buddy has been removed from this roster.

		/// \param buddy removed Buddy

		void handleBuddyChanged(Buddy *buddy);

#include <boost/thread.hpp>

#include <boost/thread/mutex.hpp>

#include <queue>

#include <iostream>

#include "Swiften/EventLoop/EventLoop.h"

namespace Transport {

	boost::mutex criticalregion;

	Swift::EventLoop *loop;

	public:

	ThreadPool(Swift::EventLoop *loop, int maxthreads);

#pragma once

#include <vector>

#include <boost/bind.hpp>

#include "Swiften/Network/BoostTimerFactory.h"

#include "Swiften/Network/BoostIOServiceThread.h"

			/// This signal is emitted when server disconnects the transport because of some error.

			/// \param error disconnection error

			/// This signal is emitted when transport successfully connects the server.

			/// This signal is emitted when XML stanza is sent to server.

			/// (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.

			void handlePresence(Swift::Presence::ref presence);

			void handleConnected();

#pragma once

#include <time.h>

#include "transport/StorageBackend.h"

#include <Swiften/FileTransfer/OutgoingFileTransfer.h>

		void leaveRoom(const std::string &room);

	private:

		void onConnectingTimeout();

#pragma once

#include <string>

#include <map>

#include "Swiften/Elements/Message.h"

		/// Called when new User class is created.

		/// \param user newly created User class

		/// Called when User class is going to be removed

		/// \param user removed User class

		/// Returns true if user is connected.

		/// \return True if user is connected.

#include "Swiften/Queries/Responder.h"

#include "Swiften/Elements/InBandRegistrationPayload.h"

#include "Swiften/Elements/RosterPayload.h"

#include <Swiften/Version.h>

#define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)

namespace Transport {

		/// Called when new user has been registered.

		/// \param userInfo UserInfo struct with informations about user

		/// Called when user has been unregistered.

		/// \param userInfo UserInfo struct with informations about user

		/// Called when user's registration has been updated.

		/// \param userInfo UserInfo struct with informations about user

	private:

		Component *m_component;

		const std::string getUserPassword(const std::string &barejid);

		/// Emitted when user wants to connect legacy network to validate the password.

		/// Emitted when user disconnected XMPP server and therefore should disconnect legacy network.

	private:

		typedef struct {

#include <algorithm>

#include <map>

namespace Transport {

class Component;

		void write(const std::string &data);

	private:

		void handleDNSResult(const std::vector<Swift::HostAddress>&, boost::optional<Swift::DomainNameResolveError>);

#include "Swiften/Elements/SpectrumErrorPayload.h"

#include "boost/date_time/posix_time/posix_time.hpp"

#include "transport/utf8.h"

			onMessageToSend(this, message);

		}

};

class NetworkFactory : public Factory {

#include <algorithm>

#include <map>

namespace Transport {

class Component;

#include <algorithm>

#include <map>

namespace Transport {

class SlackIdManager {

#include <algorithm>

#include <map>

namespace Transport {

class Component;

		void sendMessage(const std::string &channel, const std::string &message);

		SlackAPI *getAPI() {

			return m_api;

		}

#ifndef LIBTRANSPORT_TEST

	private:

#include "Swiften/Network/Timer.h"

#include "Swiften/SwiftenCompat.h"

namespace Transport {

class Component;

		virtual ~SlackSession();

		void sendMessage(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> message);

#include "transport/UserRegistration.h"

namespace Transport {

struct UserInfo;

#include "Swiften/Elements/RosterPayload.h"

#include "Swiften/SwiftenCompat.h"

namespace Transport {

class UserManager;

		RosterResponder(Swift::IQRouter *router, UserManager *userManager);

		~RosterResponder();

	private:

		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> payload);

#include "Swiften/Elements/RosterPayload.h"

#include "Swiften/SwiftenCompat.h"

#include <Swiften/Version.h>

#include "transport/UserRegistration.h"

#define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)

#include <vector>

#include "Swiften/Queries/SetResponder.h"

#include "BlockPayload.h"

namespace Transport {

		BlockResponder(Swift::IQRouter *router, UserManager *userManager);

		~BlockResponder();

	private:

		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Transport::BlockPayload> payload);

#include <vector>

#include <list>

#include "Swiften/Queries/GetResponder.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "Swiften/Elements/CapsInfo.h"

		void addAdHocCommand(const std::string &node, const std::string &name);

		Swift::CapsInfo &getBuddyCapsInfo() {

				return m_capsInfo;