/// Returns user associated with this roster.

		/// \return User

		User *getUser() { return m_user; }

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

		/// \param buddy newly added Buddy

		boost::signal<void (Buddy *buddy)> onBuddySet;

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

		/// \param buddy removed Buddy

		boost::signal<void (Buddy *buddy)> onBuddyUnset;

	private:

		void setBuddyCallback(Buddy *buddy);

		void sendBuddyRosterPush(Buddy *buddy);

		void sendRIE();

		void handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error, const std::string &key);

		std::map<std::string, Buddy *> m_buddies;

		Component *m_component;

		User *m_user;

		Swift::Timer::ref m_setBuddyTimer;

			/// This signal is emitted when presence from XMPP user (for example "user@domain.tld")

			/// is received. It's emitted only for presences addressed to transport itself

			/// (for example to="j2j.domain.tld").

			/// \param presence presence data

			boost::signal<void (Swift::Presence::ref presence)> onUserPresenceReceived;

// 			boost::signal<void (boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid)> onDiscoInfoResponse;

		private:

			void handleConnected();

			void handleConnectionError(const Swift::ComponentError &error);

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

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

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

// 			void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);

			void handleCapsChanged(const Swift::JID& jid);

			Swift::BoostNetworkFactories *m_factories;

			Swift::Component *m_component;

			Swift::Server *m_server;

			Swift::Timer::ref m_reconnectTimer;

			Swift::BoostIOServiceThread m_boostIOServiceThread;

			Swift::EntityCapsManager *m_entityCapsManager;

		ConversationManager *getConversationManager() { return m_conversationManager; }

		Component *getComponent() { return m_component; }

		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);

		/// Returns language.

		/// \return language

		const char *getLang() { return "en"; }

		void handleDisconnected(const std::string &error);

		boost::signal<void ()> onReadyToConnect;

		boost::signal<void ()> onDisconnected;

	private:

		void onConnectingTimeout();

		/// Called when new User class is created.

		/// \param user newly created User class

		boost::signal<void (User *user)> onUserCreated;

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

		/// \param user removed User class

		boost::signal<void (User *user)> onUserDestroyed;

	private:

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

		void handleMessageReceived(Swift::Message::ref message);

// 		void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);

		void addUser(User *user);

		long m_onlineBuddies;

		User *m_cachedUser;

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

		Component *m_component;

		StorageBackend *m_storageBackend;

};

}

		item.jid = buddy->getJID().toBare();

		item.name = buddy->getAlias();

		item.action = Swift::RosterItemExchangePayload::Add;

		item.groups = buddy->getGroups();

		payload->addItem(item);

	}

	boost::shared_ptr<Swift::GenericRequest<Swift::RosterItemExchangePayload> > request(new Swift::GenericRequest<Swift::RosterItemExchangePayload>(Swift::IQ::Set, m_user->getJID(), payload, m_component->getIQRouter()));

	request->send();

}

}

		m_iqRouter = m_server->getIQRouter();

		m_server->onDataRead.connect(bind(&Component::handleDataRead, this, _1));

		m_server->onDataWritten.connect(bind(&Component::handleDataWritten, this, _1));

	}

	else {

		m_component = new Swift::Component(loop, m_factories, m_jid, CONFIG_STRING(m_config, "service.password"));

		m_component->setSoftwareVersion("", "");

		m_component->onConnected.connect(bind(&Component::handleConnected, this));

		m_component->onError.connect(bind(&Component::handleConnectionError, this, _1));

		m_component->onDataRead.connect(bind(&Component::handleDataRead, this, _1));

		m_component->onDataWritten.connect(bind(&Component::handleDataWritten, this, _1));

		m_stanzaChannel = m_component->getStanzaChannel();

		m_iqRouter = m_component->getIQRouter();

	}

	m_capsMemoryStorage = new CapsMemoryStorage();

	m_capsManager = new CapsManager(m_capsMemoryStorage, m_stanzaChannel, m_iqRouter);

	m_entityCapsManager = new EntityCapsManager(m_capsManager, m_stanzaChannel);

 	m_entityCapsManager->onCapsChanged.connect(boost::bind(&Component::handleCapsChanged, this, _1));

	m_presenceOracle = new PresenceOracle(m_stanzaChannel);

	m_presenceOracle->onPresenceChange.connect(bind(&Component::handlePresence, this, _1));

	m_reconnectTimer->start();

}

void Component::handleDataRead(const std::string &data) {

	onXMLIn(data);

}

void Component::handleDataWritten(const std::string &data) {

	onXMLOut(data);

}

void Component::handlePresence(Swift::Presence::ref presence) {

	bool isMUC = presence->getPayload<MUCPayload>() != NULL;

	// filter out login/logout presence spam

	if (!presence->getTo().getNode().empty() && isMUC == false)

		return;

	// filter out bad presences

	if (!presence->getFrom().isValid()) {

		Swift::Presence::ref response = Swift::Presence::create();

		response->setTo(presence->getFrom());

		response->setFrom(presence->getTo());

			std::cout << "has capsInfo " << haveFeatures << "\n";

		}

// 		else {

// 			GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(presence->getFrom(), m_iqRouter);

// 			discoInfoRequest->onResponse.connect(boost::bind(&Component::handleDiscoInfoResponse, this, _1, _2, presence->getFrom()));

// 			discoInfoRequest->send();

// 		}

	}

	onUserPresenceReceived(presence);

}

void Component::handleCapsChanged(const Swift::JID& jid) {

	bool haveFeatures = m_entityCapsManager->getCaps(jid) != DiscoInfo::ref();

	std::cout << "has capsInfo " << haveFeatures << "\n";

}

}

		highest->setFrom(m_component->getJID());

		m_component->getStanzaChannel()->sendPresence(highest);

	}

	else {

		Swift::Presence::ref response = Swift::Presence::create();

		response->setTo(m_jid.toBare());

		response->setFrom(m_component->getJID());

		response->setType(Swift::Presence::Unavailable);

		m_component->getStanzaChannel()->sendPresence(response);

	}

}

void User::onConnectingTimeout() {

	if (m_connected || m_readyForConnect)

		return;

	m_reconnectTimer->stop();

	m_readyForConnect = true;

	onReadyToConnect();

}

void User::handleDisconnected(const std::string &error) {

	onDisconnected();

	boost::shared_ptr<Swift::Message> msg(new Swift::Message());

#include "transport/conversationmanager.h"

namespace Transport {

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

	m_cachedUser = NULL;

	m_onlineBuddies = 0;

	m_component = component;

	m_storageBackend = storageBackend;

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

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

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

}

UserManager::~UserManager(){

}

void UserManager::addUser(User *user) {

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

	onUserCreated(user);

}

User *UserManager::getUser(const std::string &barejid){

	}

}

void UserManager::handleMessageReceived(Swift::Message::ref message) {

	User *user = getUser(message->getFrom().toBare().toString());

	if (!user ){

		return;

	}

	user->getConversationManager()->handleMessageReceived(message);

}

}