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 handleAdminMessage(Swift::Message::ref /*message*/) { 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 (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;

};

}

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

			/// \param error disconnection error

			boost::signal<void (const std::string &error)> onConnectionError;

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

			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;

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

			void handleConnected();

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

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

			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;

			Swift::JID m_jid;

			Factory *m_factory;

			Swift::EventLoop *m_loop;

			Frontend *m_frontend;

		friend class User;

		friend class UserRegistration;

		friend class NetworkPluginServer;

	};

}

 * 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 "transport/LocalBuddy.h"

#include "transport/User.h"

#include "transport/RosterManager.h"

#include "transport/Transport.h"

namespace Transport {

LocalBuddy::LocalBuddy(RosterManager *rosterManager, long id, const std::string &name, const std::string &alias, const std::vector<std::string> &groups, BuddyFlag flags) : Buddy(rosterManager, id, flags) {

	m_status = Swift::StatusShow::None;

	m_alias = alias;

	m_name = name;

	m_groups = groups;

	try {

		generateJID();

	} catch (...) {

	}

			}

		}

	}

	m_groups = groups;

	if (changed) {

		getRosterManager()->doUpdateBuddy(this);

		getRosterManager()->storeBuddy(this);

	}

}

bool LocalBuddy::getStatus(Swift::StatusShow &status, std::string &statusMessage) {

		return false;

	}

	status = m_status;

	statusMessage = m_statusMessage;

	return true;

}

}

DEFINE_LOGGER(logger, "Component");

DEFINE_LOGGER(logger_xml, "Component.RAW");

Component::Component(Frontend *frontend, Swift::EventLoop *loop, Swift::NetworkFactories *factories, Config *config, Factory *factory, Transport::UserRegistry *userRegistry) {

	m_frontend = frontend;

	m_userRegistry = NULL;

	m_reconnectCount = 0;

	m_config = config;

	m_factory = factory;

	m_loop = loop;

	m_userRegistry = userRegistry;

	m_jid = Swift::JID(CONFIG_STRING(m_config, "service.jid"));

	m_factories = factories;

	m_reconnectTimer = m_factories->getTimerFactory()->createTimer(3000);

	m_reconnectTimer->onTick.connect(boost::bind(&Component::start, this)); 

	m_presenceOracle = new Transport::PresenceOracle(frontend);

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

	m_frontend->init(this, loop, factories, config, userRegistry);

}

		double elapsedTime() const {

			return m_elapsedTime;

		}

};

class NetworkPluginServerTest : public CPPUNIT_NS :: TestFixture, public BasicTest {

	CPPUNIT_TEST_SUITE(NetworkPluginServerTest);

	CPPUNIT_TEST(handleBuddyChangedPayload);

	CPPUNIT_TEST(handleBuddyChangedPayloadNoEscaping);

	CPPUNIT_TEST(handleBuddyChangedPayloadUserContactInRoster);

	CPPUNIT_TEST(handleMessageHeadline);

	CPPUNIT_TEST(handleConvMessageAckPayload);

	CPPUNIT_TEST(benchmarkHandleBuddyChangedPayload);

	CPPUNIT_TEST(benchmarkSendUnavailablePresence);

	CPPUNIT_TEST_SUITE_END();

	public:

		NetworkPluginServer *serv;

		void setUp (void) {

			setMeUp();

			serv = new NetworkPluginServer(component, cfg, userManager, NULL);