// 				CLIENT_FEATURE_CHATSTATES = 16

	// 				} SpectrumImportantFeatures;

	// 

	class StorageBackend;

	class DiscoInfoResponder;

	class DiscoItemsResponder;

	class Factory;

	/// Represents one transport instance.

	/// It's used to connect

	/// the Jabber server and provides transaction layer between Jabber server

			Swift::StanzaChannel *m_stanzaChannel;

			Swift::IQRouter *m_iqRouter;

			Swift::UserRegistry *m_userRegistry;

			StorageBackend *m_storageBackend;

 			DiscoInfoResponder *m_discoInfoResponder;

			DiscoItemsResponder *m_discoItemsResponder;

			int m_reconnectCount;

			Config* m_config;

			std::string m_protocol;

			Swift::JID m_jid;

			Factory *m_factory;

namespace Transport {

class User;

class Component;

class StorageBackend;

class StorageResponder;

/// Manages online XMPP Users.

/// This class handles presences and creates User classes when new user connects.

/// It also removes the User class once the last user's resource disconnected.

class UserManager {

		long m_onlineBuddies;

		User *m_cachedUser;

		std::map<std::string, User *> m_users;

		Component *m_component;

		StorageBackend *m_storageBackend;

		StorageResponder *m_storageResponder;

};

}

			NetworkConversation *nc = new NetworkConversation(conversationManager, legacyName);

			nc->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, m_nps, _1, _2));

			return nc;

		}

		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {

		}

	private:

		NetworkPluginServer *m_nps;

};

#define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \

	m_rosterStorage = NULL;

	m_user = user;

	m_component = component;

	m_setBuddyTimer = m_component->getFactories()->getTimerFactory()->createTimer(1000);

	m_RIETimer = m_component->getFactories()->getTimerFactory()->createTimer(5000);

	m_RIETimer->onTick.connect(boost::bind(&RosterManager::sendRIE, this));

}

RosterManager::~RosterManager() {

	m_setBuddyTimer->stop();

	m_RIETimer->stop();

	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

void RosterManager::setStorageBackend(StorageBackend *storageBackend) {

	if (m_rosterStorage) {

		m_rosterStorage->storeBuddies();

		delete m_rosterStorage;

	}

	m_rosterStorage = new RosterStorage(m_user, storageBackend);

}

}

using namespace Swift;

using namespace boost;

namespace Transport {

}

RosterResponder::~RosterResponder() {

}

bool RosterResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::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.

	sendResponse(from, id, boost::shared_ptr<RosterPayload>(new RosterPayload()));

	return true;

}

}

 */

#pragma once

#include <vector>

#include "Swiften/Swiften.h"

#include "Swiften/Elements/RosterPayload.h"

namespace Transport {

	public:

		~RosterResponder();

	private:

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

};

}

							int STATEMENT##_id = 1;\

							int STATEMENT##_id_get = 0;\

							(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 GET_INT(STATEMENT)	sqlite3_column_int(STATEMENT, STATEMENT##_id_get++)

#define GET_STR(STATEMENT)	(const char *) sqlite3_column_text(STATEMENT, STATEMENT##_id_get++)

#define EXECUTE_STATEMENT(STATEMENT, NAME) 	if(sqlite3_step(STATEMENT) != SQLITE_DONE) {\

		onStorageError(NAME, (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));\

			}

	PREP_STMT(m_removeUserBuddies, "DELETE FROM " + m_prefix + "buddies WHERE user_id=?");

	PREP_STMT(m_removeUserSettings, "DELETE FROM " + m_prefix + "users_settings WHERE user_id=?");

	PREP_STMT(m_removeUserBuddiesSettings, "DELETE FROM " + m_prefix + "buddies_settings WHERE user_id=?");

	PREP_STMT(m_addBuddy, "INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)");

	PREP_STMT(m_updateBuddy, "UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?");

	PREP_STMT(m_getBuddiesSettings, "SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC");

	PREP_STMT(m_getUserSetting, "SELECT type, value FROM " + m_prefix + "users_settings WHERE user_id=? AND var=?");

	PREP_STMT(m_setUserSetting, "INSERT INTO " + m_prefix + "users_settings (user_id, var, type, value) VALUES (?,?,?,?)");

	PREP_STMT(m_updateUserSetting, "UPDATE " + m_prefix + "users_settings SET value=? WHERE user_id=? AND var=?");

	return true;

	BIND_STR(m_updateBuddy, buddyInfo.legacyName);

	EXECUTE_STATEMENT(m_updateBuddy, "updateBuddy query");

}

bool SQLite3Backend::getBuddies(long id, std::list<BuddyInfo> &roster) {

	BEGIN(m_getBuddies);

	BIND_INT(m_getBuddies, id);

// 	"SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC"

	BEGIN(m_getBuddiesSettings);

	BIND_INT(m_getBuddiesSettings, id);

	long buddy_id = -1;

	std::string key;

	int ret;

	while((ret = sqlite3_step(m_getBuddies)) == SQLITE_ROW) {

		BuddyInfo b;

		b.id = GET_INT(m_getBuddies);

		b.legacyName = GET_STR(m_getBuddies);

		b.subscription = GET_STR(m_getBuddies);

		b.alias = GET_STR(m_getBuddies);

		b.groups.push_back(GET_STR(m_getBuddies));

		b.flags = GET_INT(m_getBuddies);

				std::cout << "Adding buddy info " << key << "=" << val << "\n";

				b.settings[key] = var;

				buddy_id = -1;

			}

		}

		roster.push_back(b);

	}

	if (ret != SQLITE_DONE) {

		onStorageError("getBuddies query", (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));

#include "transport/transport.h"

#include <boost/bind.hpp>

#include "transport/storagebackend.h"

#include "transport/factory.h"

#include "discoinforesponder.h"

#include "discoitemsresponder.h"

#include "storageparser.h"

using namespace Swift;

using namespace boost;

namespace Transport {

	m_discoInfoResponder = new DiscoInfoResponder(m_iqRouter);

	m_discoInfoResponder->start();

	m_discoItemsResponder = new DiscoItemsResponder(m_iqRouter);

	m_discoItemsResponder->start();

// 

// 	m_registerHandler = new SpectrumRegisterHandler(m_component);

// 	m_registerHandler->start();

}

Component::~Component() {

	delete m_presenceOracle;

	delete m_entityCapsManager;

	delete m_capsManager;

	delete m_capsMemoryStorage;

	delete m_discoInfoResponder;

	if (m_component)

		delete m_component;

	if (m_server)

		delete m_server;

	if (m_userRegistry)

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/storagebackend.h"

#include "transport/conversationmanager.h"

#include "transport/rostermanager.h"

#include "storageresponder.h"

namespace Transport {

UserManager::UserManager(Component *component, StorageBackend *storageBackend) {

	m_cachedUser = NULL;

	m_onlineBuddies = 0;

	m_component = component;

	m_storageBackend = storageBackend;

	m_storageResponder = new StorageResponder(component->getIQRouter(), m_storageBackend, this);

	m_storageResponder->start();

	component->onUserPresenceReceived.connect(bind(&UserManager::handlePresence, this, _1));

	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&UserManager::handleMessageReceived, this, _1));

	m_component->getStanzaChannel()->onPresenceReceived.connect(bind(&UserManager::handleGeneralPresenceReceived, this, _1));

// 	component->onDiscoInfoResponse.connect(bind(&UserManager::handleDiscoInfoResponse, this, _1, _2, _3));

}

UserManager::~UserManager(){

	m_storageResponder->stop();

	delete m_storageResponder;

}

void UserManager::addUser(User *user) {

	m_users[user->getJID().toBare().toString()] = user;

	onUserCreated(user);

}