}

					case Swift::StatusShow::XA: {

						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_EXTENDED_AWAY))

							st = PURPLE_STATUS_AWAY;

						else

							st = PURPLE_STATUS_EXTENDED_AWAY;

						break;

					}

					case Swift::StatusShow::None: {

						st = PURPLE_STATUS_OFFLINE;

						break;

					}

						st = PURPLE_STATUS_INVISIBLE;

						break;

					default:

						st = PURPLE_STATUS_AVAILABLE;

						break;

				}

				gchar *_markup = purple_markup_escape_text(statusMessage.c_str(), -1);

				std::string markup(_markup);

				g_free(_markup);

				// we are already connected so we have to change status

				const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, (PurpleStatusPrimitive) st);

#include <vector>

#include "Swiften/Swiften.h"

#include "Swiften/Server/Server.h"

#include "Swiften/Disco/GetDiscoInfoRequest.h"

#include "Swiften/Disco/EntityCapsManager.h"

#include "Swiften/Disco/CapsManager.h"

#include "Swiften/Disco/CapsMemoryStorage.h"

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Network/BoostTimerFactory.h"

#include "Swiften/Network/BoostIOServiceThread.h"

#include "Swiften/Server/UserRegistry.h"

#include "Swiften/Base/SafeByteArray.h"

#include <boost/bind.hpp>

#include "transport/config.h"

#include "transport/factory.h"

namespace Transport {

	// typedef enum { 	CLIENT_FEATURE_ROSTERX = 2,

	// 				CLIENT_FEATURE_XHTML_IM = 4,

	// 				CLIENT_FEATURE_FILETRANSFER = 8,

	// 				CLIENT_FEATURE_CHATSTATES = 16

	// 				} SpectrumImportantFeatures;

	// 

			/// Returns Swift::IQRouter associated with this Component.

			/// \return Swift::IQRouter associated with this Component.

			Swift::IQRouter *getIQRouter() { return m_iqRouter; }

			/// Returns Swift::PresenceOracle associated with this Transport::Component.

			/// You can use it to check current resource connected for particular user.

			/// \return Swift::PresenceOracle associated with this Transport::Component.

			Swift::PresenceOracle *getPresenceOracle();

			/// Returns True if the component is in server mode.

			/// \return True if the component is in server mode.

			bool inServerMode() { return m_server != NULL; }

			/// Connects the Jabber server.

			void start();

			void stop();

			/// Sets disco#info features which are sent as answer to disco#info IQ-get.

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

			Swift::NetworkFactories *m_factories;

			Swift::Component *m_component;

			Swift::Server *m_server;

			Swift::Timer::ref m_reconnectTimer;

			Swift::EntityCapsManager *m_entityCapsManager;

			Swift::CapsManager *m_capsManager;

			Swift::CapsMemoryStorage *m_capsMemoryStorage;

			Swift::PresenceOracle *m_presenceOracle;

			Swift::StanzaChannel *m_stanzaChannel;

			Swift::IQRouter *m_iqRouter;

			Transport::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;

			Swift::EventLoop *m_loop;

		friend class User;

 *

 * 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 <time.h>

#include "Swiften/Swiften.h"

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Disco/EntityCapsManager.h"

#include "storagebackend.h"

namespace Transport {

class Component;

class RosterManager;

class ConversationManager;

class UserManager;

struct UserInfo;

/// Represents online XMPP user.

	public:

		/// Creates new User class.

		/// \param jid XMPP JID associated with this user

		/// \param userInfo UserInfo struct with informations needed to connect

		/// this user to legacy network

		/// \param component Component associated with this user

		User(const Swift::JID &jid, UserInfo &userInfo, Component * component, UserManager *userManager);

		/// Destroyes User.

		virtual ~User();

		/// Returns JID of XMPP user who is currently connected using this User class.

		/// \return full JID

		const Swift::JID &getJID();

		/// Returns full JID which supports particular feature or invalid JID.

		/// \param feature disco#info feature.

		/// \return full JID which supports particular feature or invalid JID.

		Swift::JID getJIDWithFeature(const std::string &feature);

		/// Returns UserInfo struct with informations needed to connect the legacy network.

		/// \return UserInfo struct

		UserInfo &getUserInfo() { return m_userInfo; }

		RosterManager *getRosterManager() { return m_rosterManager; }

		ConversationManager *getConversationManager() { return m_conversationManager; }

		Component *getComponent() { return m_component; }

		void setData(void *data) { m_data = data; }

		void *getData() { return m_data; }

/// Basic user creation process:

/**

	\msc

	Component,UserManager,User,StorageBackend,Slot;

	---  [ label = "Available presence received"];

	Component->UserManager [label="handlePresence(...)", URL="\ref UserManager::handlePresence()"];

	UserManager->StorageBackend [label="getUser(...)", URL="\ref StorageBackend::getUser()"];

	UserManager->User [label="User::User(...)", URL="\ref User"];

	UserManager->Slot [label="onUserCreated(...)", URL="\ref UserManager::onUserCreated()"];

	UserManager->User [label="handlePresence(...)", URL="\ref User::handlePresence()"];

	\endmsc

*/

	public:

		/// Creates new UserManager.

		/// \param component Component which's presence will be handled

		/// \param storageBackend Storage backend used to fetch UserInfos

		UserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend = NULL);

		/// Destroys UserManager.

		~UserManager();

		/// Returns user according to his bare JID.

		/// \param barejid bare JID of user

		/// \return User class associated with this user

		/// Returns number of online users.

		/// \return number of online users

		int getUserCount();

		/// Removes user. This function disconnects user and safely removes

		/// User class. This does *not* remove user from StorageBackend.

		/// \param user User class to remove

		void removeUser(User *user);

		void removeAllUsers();

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

		/// Returns true if user is connected.

		/// \return True if user is connected.

		bool isUserConnected(const std::string &barejid) const {

			return m_users.find(barejid) != m_users.end();

	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_discoInfoResponder = new DiscoInfoResponder(m_iqRouter, m_config);

	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;

	delete m_discoItemsResponder;

		}

		if (discoInfo->hasFeature(feature)) {

			LOG4CXX_INFO(logger, m_jid.toString() << ": Found JID with " << feature << " feature: " << presence->getFrom().toString());

			return presence->getFrom();

		}

	}

	LOG4CXX_INFO(logger, m_jid.toString() << ": No JID with " << feature << " feature " << m_legacyCaps.size());

	return jid;

}

void User::sendCurrentPresence() {

	if (m_component->inServerMode()) {

		return;

	}

	if (m_connected) {

		Swift::Presence::ref highest = m_presenceOracle->getHighestPriorityPresence(m_jid.toBare());

		if (highest) {

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

			response->setTo(m_jid);

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

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

	if (m_cachedUser && barejid == m_cachedUser->getJID().toBare().toString()) {

		return m_cachedUser;

	}

	if (m_users.find(barejid) != m_users.end()) {

		User *user = m_users[barejid];

		m_cachedUser = user;

		return user;

	}

	return NULL;

}

void UserManager::removeUser(User *user) {

	m_users.erase(user->getJID().toBare().toString());

	if (m_cachedUser == user)

		m_cachedUser = NULL;

	if (m_component->inServerMode()) {

		disconnectUser(user->getJID());

	}

	if (m_storageBackend) {

		m_storageBackend->setUserOnline(user->getUserInfo().id, false);

	}