libtransport.git Changeset - d39705842a2a

Changeset - d39705842a2a

Parent rev.

Child rev.

[Not reviewed]

0 13 0

HanzZ - 14 years ago 2011-06-06 10:48:27
hanzz.k@gmail.com

Comments + refactorization

13 files changed with 178 insertions and 54 deletions:

include/transport/buddy.h

include/transport/config.h

include/transport/conversation.h

include/transport/conversationmanager.h

include/transport/localbuddy.h

include/transport/transport.h

src/buddy.cpp

src/conversation.cpp

src/conversationmanager.cpp

src/networkpluginserver.cpp

src/rostermanager.cpp

src/rosterstorage.cpp

src/user.cpp

0 comments (0 inline, 0 general)

include/transport/buddy.h

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * 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
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include "transport/transport.h"
 #include "Swiften/Swiften.h"
 namespace Transport {
 class RosterManager;
 typedef enum { 	BUDDY_NO_FLAG = 0,
 				BUDDY_JID_ESCAPING = 2,
 				BUDDY_IGNORE = 4
 			} BuddyFlag;
 /// Represents one legacy network Buddy.
 class Buddy {
 	public:
 		/// Constructor.
 		/// \param rosterManager RosterManager associated with this buddy.
 		/// \param id ID which identifies the buddy in database or -1 if it's new buddy which is
 		/// not in database yet.
 		Buddy(RosterManager *rosterManager, long id = -1);
 		/// Destructor
 		virtual ~Buddy();
 		/// Sets unique ID used to identify this buddy by StorageBackend. This is set
 		/// Sets unique ID used to identify this buddy by StorageBackend.
 		/// This is set
 		/// by RosterStorage class once the buddy is stored into database or when the
 		/// buddy is loaded from database.
 		/// You should not need to set this ID manually.
 		/// \param id ID
 		void setID(long id);
 		/// Returns unique ID used to identify this buddy by StorageBackend.
 		/// \see Buddy::setID(long)
 		/// \return ID
 		/// \return ID which identifies the buddy in database or -1 if it's new buddy which is
 		/// not in database yet.
 		long getID();
 		/// Returns full JID of this buddy.
 		/// \param hostname hostname used as domain in returned JID
 		/// \return full JID of this buddy
 		const Swift::JID &getJID();
 		/// Generates whole Presennce stanza with current status/show for this buddy.
 		/// Presence stanza does not containt "to" attribute, it has to be added manually.
 		/// \param features features used in returned stanza
 		/// \param only_new if True, this function returns Presence stanza only if it's different
 		/// than the previously generated one.
 		/// \return Presence stanza or NULL.
 		Swift::Presence::ref generatePresenceStanza(int features, bool only_new = false);
 		/// Marks this buddy as available.
 		void setOnline();
 		/// Marks this buddy as offline.
 		void setOffline();
 		/// Returns true if this buddy is marked as available/online.
 		/// \return true if this buddy is marked as available/online.
 		bool isOnline();
 		/// Sets current subscription.
 		/// \param subscription "to", "from", "both", "ask"
 		void setSubscription(const std::string &subscription);
 		/// Returns current subscription
 		/// \return subscription "to", "from", "both", "ask"
 		const std::string &getSubscription();
 		/// Sets this buddy's flags.
 		/// \param flags flags
 		void setFlags(BuddyFlag flags);
 		/// Returns this buddy's flags.
 		/// \param flags flags
 		BuddyFlag getFlags();
 		/// Returns RosterManager associated with this buddy
 		/// \return rosterManager
 		/// Returns RosterManager associated with this buddy.
 		/// \return RosterManager associated with this buddy.
 		RosterManager *getRosterManager() { return m_rosterManager; }
 		/// Returns legacy network username which does not contain unsafe characters,
 		/// so it can be used in JIDs.
 		std::string getSafeName();
 		void buddyChanged();
 		/// This method should be called whenever some information returned by virtual functions changes.
 		/// This method sends presence to XMPP user.
 		void handleBuddyChanged();
-		void handleVCardReceived(const std::string &id, const Swift::JID &to, Swift::VCard::ref vcard);
+		/// Handles VCard from legacy network and forwards it to XMPP user.
 		/// \param id ID used in IQ-result.
 		/// \param vcard VCard which will be sent.
 		void handleVCardReceived(const std::string &id, Swift::VCard::ref vcard);
 		/// This signal is emitted when buddyChanged method is called.
 		boost::signal<void ()> onBuddyChanged;
-		virtual void getVCard(const std::string &id, const Swift::JID &to) = 0;
+		/// Returns legacy network username of this buddy. (for example UIN for ICQ, JID for Jabber, ...).
 		/// Returns legacy network username of this buddy. (for example UIN for ICQ,
 		/// JID for Jabber, ...).
 		/// \return legacy network username
 		virtual std::string getName() = 0;
 		/// Returns alias (nickname) of this buddy.
 		/// \return alias (nickname)
 		virtual std::string getAlias() = 0;
 		/// Returns list of groups this buddy is in.
 		/// \return groups
 		virtual std::vector<std::string> getGroups() = 0;
 		/// Returns current legacy network status and statuMessage of this buddy.
 		/// \param status current status/show is stored here
 		/// \param statusMessage current status message is stored here
 		/// \return true if status was stored successfully
 		virtual bool getStatus(Swift::StatusShow &status, std::string &statusMessage) = 0;
 		/// Returns SHA-1 hash of buddy icon (avatar) or empty string if there is no avatar
 		/// for this buddy.
 		/// Returns SHA-1 hash of buddy icon (avatar) or empty string if there is no avatar for this buddy.
 		/// \return avatar hash or empty string.
 		virtual std::string getIconHash() = 0;
 		/// Returns legacy name of buddy from JID.
 		/// \param jid Jabber ID.
 		/// \return legacy name of buddy from JID.
 		static std::string JIDToLegacyName(const Swift::JID &jid);
 	private:
 		void generateJID();
 		long m_id;
 		bool m_online;
 		std::string m_subscription;
 		Swift::Presence::ref m_lastPresence;
 		Swift::JID m_jid;
 		BuddyFlag m_flags;
 		RosterManager *m_rosterManager;
 };
+}

include/transport/config.h

➞

Show inline comments

@@ @@ -8,76 +8,83 @@ @@
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * 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
  */
 #pragma once
 #include <boost/program_options.hpp>
 #include <boost/foreach.hpp>
 #include <boost/format.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/assign.hpp>
 #include <boost/bind.hpp>
 #include <boost/signal.hpp>
 #define CONFIG_STRING(PTR, KEY) (*PTR)[KEY].as<std::string>()
 #define CONFIG_INT(PTR, KEY) (*PTR)[KEY].as<int>()
 #define CONFIG_BOOL(PTR, KEY) (*PTR)[KEY].as<bool>()
 #define CONFIG_LIST(PTR, KEY) (*PTR)[KEY].as<std::list<std::string> >()
 namespace Transport {
 /// Represents variable:value pairs.
 typedef boost::program_options::variables_map Variables;
 /// Represents config file.
 /// It's used to load config file and allows others parts of libtransport to be configured
 /// properly. Config files are text files which use "ini" format. Variables are divided into multiple
 /// sections. Every class is configurable with some variables which change its behavior. Check particular
 /// class documentation to get a list of all relevant variables for that class.
 class Config {
 	public:
 		/// Constructor.
 		Config() {}
 		/// Destructor
 		virtual ~Config() {}
 		/// Loads data from config file. You can pass your extra options which will be recognized by
 		/// Loads data from config file.
 		/// You can pass your extra options which will be recognized by
 		/// the parser using opts parameter.
 		/// \param configfile path to config file
 		/// \param opts extra options which will be recognized by a parser
 		bool load(const std::string &configfile, boost::program_options::options_description &opts);
 		/// Loads data from config file. This function loads only config variables needed by libtransport.
 		/// Loads data from config file.
 		/// This function loads only config variables needed by libtransport.
 		/// \see load(const std::string &, boost::program_options::options_description &)
 		/// \param configfile path to config file
 		bool load(const std::string &configfile);
 		/// Returns value of variable defined by key. For variables in sections you can use "section.variable" key format.
 		/// Returns value of variable defined by key.
 		/// For variables in sections you can use "section.variable" key format.
 		/// \param key config variable name
 		const boost::program_options::variable_value &operator[] (const std::string &key) {
 			return m_variables[key];
+		}
 		/// Returns path to config file from which data were loaded.
 		const std::string &getConfigFile() { return m_file; }
 		/// This signal is emitted when config is loaded/reloaded.
 		boost::signal<void ()> onConfigReloaded;
 	private:
 		Variables m_variables;
 		std::string m_file;
 };
+}

include/transport/conversation.h

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * 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
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include "transport/transport.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Elements/Message.h"
 namespace Transport {
 class ConversationManager;
 /// Represents one XMPP-Legacy network conversation.
 class Conversation {
 	public:
 		/// Type of participants in MUC rooms.
 		enum ParticipantFlag {None, Moderator};
 		/// Constructor.
 		Conversation(ConversationManager *conversationManager, const std::string &legacyName, bool m_muc = false);
 		/// Creates new conversation.
 		/// Destructor
 		/// \param conversationManager ConversationManager associated with this Conversation.
 		/// \param legacyName Legacy network name of recipient.
 		/// \param muc True if this conversation is Multi-user chat.
 		Conversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false);
 		/// Destructor.
 		virtual ~Conversation();
 		/// Returns legacy network name of this conversation.
 		/// \return legacy network name of this conversation.
 		const std::string &getLegacyName() { return m_legacyName; }
 		/// Handles new message from Legacy network and forwards it to XMPP.
 		/// \param message Message received from legacy network.
 		/// \param nickname For MUC conversation this is nickname of room participant who sent this message.
 		void handleMessage(boost::shared_ptr<Swift::Message> &message, const std::string &nickname = "");
 		/// Handles participant change in MUC.
 		/// \param nickname Nickname of participant which changed.
 		/// \param flag ParticipantFlag.
 		/// \param status Current status of this participant.
 		/// \param statusMessage Current status message of this participant.
 		/// \param newname If participant was renamed, this variable contains his new name.
 		void handleParticipantChanged(const std::string &nickname, int flag, int status = Swift::StatusShow::None, const std::string &statusMessage = "", const std::string &newname = "");
 		/// Sets XMPP user nickname in MUC rooms.
 		/// \param nickname XMPP user nickname in MUC rooms.
 		void setNickname(const std::string &nickname) {
 			m_nickname = nickname;
+		}
 		/// Sends message to Legacy network.
 		/// \param message Message.
 		virtual void sendMessage(boost::shared_ptr<Swift::Message> &message) = 0;
 		/// Returns ConversationManager associated with this Conversation.
 		/// \return  ConversationManager associated with this Conversation.
 		ConversationManager *getConversationManager() {
 			return m_conversationManager;
+		}
 		/// Returns True if this conversation is MUC room.
 		/// \return  True if this conversation is MUC room.
 		bool isMUC() {
 			return m_muc;
+		}
 		/// Sets room name associated with this Conversation.
 		/// This is used to detect Private messages associated with particular room.
 		/// \param room room name associated with this Conversation.
 		void setRoom(const std::string &room) {
 			m_room = room;
+		}
 		/// Returns room name associated with this Conversation.
 		/// \return room name associated with this Conversation.
 		const std::string &getRoom() {
 			return m_room;
+		}
 	private:
 		ConversationManager *m_conversationManager;
 		std::string m_legacyName;
 		std::string m_nickname;
 		std::string m_room;
 		bool m_muc;
 };
+}

include/transport/conversationmanager.h

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * 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
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include <map>
 #include "Swiften/Swiften.h"
 namespace Transport {
 class Conversation;
 class User;
 class Component;
 /// Manages all Conversations of particular User.
 class ConversationManager {
 	public:
 		/// Creates new ConversationManager.
 		/// \param user User associated with this ConversationManager.
-		/// \param component Transport instance associated with this roster.
+		/// \param component Transport instance associated with this ConversationManager.
 		ConversationManager(User *user, Component *component);
 		/// Destructor.
 		virtual ~ConversationManager();
 		/// Returns user associated with this manager.
 		/// \return User
 		User *getUser() { return m_user; }
 		/// Returns component associated with this ConversationManager.
 		/// \return component associated with this ConversationManager.
 		Component *getComponent() { return m_component; }
 		/// Returns Conversation by its legacy network name (for example by UIN in case of ICQ).
 		/// \param name legacy network name.
 		/// \return Conversation or NULL.
 		Conversation *getConversation(const std::string &name) {
 			return m_convs[name];
+		}
 		void setConversation(Conversation *conv);
 		/// Adds new Conversation to the manager.
 		/// \param conv Conversation.
 		void addConversation(Conversation *conv);
 		/// Removes Conversation from the manager.
 		void unsetConversation(Conversation *conv);
 		/// \param conv Conversation.
 		void removeConversation(Conversation *conv);
 	private:
 		void handleMessageReceived(Swift::Message::ref message);
 		Component *m_component;
 		User *m_user;
 		std::map<std::string, Conversation *> m_convs;
 		friend class UserManager;
 };
+}

include/transport/localbuddy.h

➞

Show inline comments

@@ @@ -11,62 +11,60 @@ @@
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * 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
  */
 #ifndef SPECTRUM_BUDDY_H
 #define SPECTRUM_BUDDY_H
 #include <string>
 #include <algorithm>
 #include "transport/buddy.h"
 #include "transport/rostermanager.h"
 namespace Transport {
 class LocalBuddy : public Buddy {
 	public:
 		LocalBuddy(RosterManager *rosterManager, long id);
 		virtual ~LocalBuddy();
 		std::string getAlias() { return m_alias; }
 		void setAlias(const std::string &alias) { m_alias = alias; }
 		std::string getName() { return m_name; }
 		void setName(const std::string &name) { m_name = name; }
 		bool getStatus(Swift::StatusShow &status, std::string &statusMessage) {
 			status = m_status;
 			m_statusMessage = statusMessage;
 			return true;
+		}
 		void setStatus(const Swift::StatusShow &status, const std::string &statusMessage) {
 			m_status = status;
 			m_statusMessage = statusMessage;
+		}
 		std::string getIconHash() { return m_iconHash; }
 		void setIconHash(const std::string &iconHash) { m_iconHash = iconHash; }
 		std::vector<std::string> getGroups() { return m_groups; }
 		void setGroups(const std::vector<std::string> &groups) { m_groups = groups; }
 		void getVCard(const std::string &id, const Swift::JID &to) {}
 	private:
 		std::string m_name;
 		std::string m_alias;
 		std::vector<std::string> m_groups;
 		std::string m_statusMessage;
 		std::string m_iconHash;
 		Swift::StatusShow m_status;
 };
+}
 #endif

include/transport/transport.h

➞

Show inline comments

@@ @@ -7,161 +7,195 @@ @@
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * 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
  */
 #pragma once
 #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 <boost/bind.hpp>
 #include "transport/config.h"
 #include "transport/factory.h"
 #define tr(lang,STRING)    (STRING)
 #define _(STRING)    (STRING)
 namespace Transport {
 	// typedef enum { 	CLIENT_FEATURE_ROSTERX = 2,
 	// 				CLIENT_FEATURE_XHTML_IM = 4,
 	// 				CLIENT_FEATURE_FILETRANSFER = 8,
 	// 				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
 	/// and other classes.
 	/// It's used to connect the Jabber server and provides transaction layer
 	/// between Jabber server and other classes.
 	///
 	/// In server mode it represents Jabber server to which users can connect and use
 	/// it as transport.
 	class Component {
 		public:
 			/// Creates new Component instance.
 			/// \param loop main event loop
 			/// \param config cofiguration, this class uses following Config values:
 			/// \param loop Main event loop.
 			/// \param config Cofiguration; this class uses following Config values:
 			/// 	- service.jid
 			/// 	- service.password
 			/// 	- service.server
 			/// 	- service.port
 			/// 	- service.server_mode
 			/// \param factory Transport Abstract factory used to create basic transport structures.
 			Component(Swift::EventLoop *loop, Config *config, Factory *factory);
 			/// Component destructor.
 			~Component();
 			/// Returns Swift::Component associated with this Transport::Component.
 			/// You can use it to send presences and other stanzas.
 			/// \return Swift::Component associated with this Transport::Component
 			/// Returns Swift::StanzaChannel associated with this Transport::Component.
 			/// It can be used to send presences and other stanzas.
 			/// \return Swift::StanzaChannel associated with this Transport::Component.
 			Swift::StanzaChannel *getStanzaChannel();
 			/// 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
+			/// \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; }
 			/// Returns user password from internal UserRegistry.
 			/// In server mode, the password user used for login can be obtained by
 			/// this method.
 			/// \param barejid User's bare JID.
 			/// \return User's password.
 			const std::string &getUserRegistryPassword(const std::string &barejid);
 			/// Connects the Jabber server.
 			/// \see Component()
 			/// In server mode this function does nothing.
 			void connect();
 			/// Sets disco#info features which are sent as answer to
 			/// disco#info IQ-get. This sets features of transport contact (For example "j2j.domain.tld").
 			/// Sets disco#info features which are sent as answer to disco#info IQ-get.
 			/// This sets features of transport contact (For example "j2j.domain.tld").
 			/// \param features list of features as sent in disco#info response
 			void setTransportFeatures(std::list<std::string> &features);
 			/// Sets disco#info features which are sent as answer to
 			/// disco#info IQ-get. This sets features of legacy network buddies (For example "me\40gmail.com@j2j.domain.tld").
 			/// Sets disco#info features which are sent as answer to disco#info IQ-get.
 			/// This sets features of legacy network buddies (For example "me\40gmail.com@j2j.domain.tld").
 			/// \param features list of features as sent in disco#info response
 			void setBuddyFeatures(std::list<std::string> &features);
 			/// Returns Jabber ID of this transport.
 			/// \return Jabber ID of this transport
 			Swift::JID &getJID() { return m_jid; }
 			Swift::BoostNetworkFactories *getFactories() { return m_factories; }
 			/// Returns Swift::NetworkFactories which can be used to create new connections.
 			/// \return Swift::NetworkFactories which can be used to create new connections.
 			Swift::BoostNetworkFactories *getNetworkFactories() { return m_factories; }
 			/// Returns Transport Factory used to create basic Transport components.
 			/// \return Transport Factory used to create basic Transport components.
 			Factory *getFactory() { return m_factory; }
 			/// This signal is emitted when server disconnects the transport because of some error.
 			/// \param error disconnection error
 			boost::signal<void (const Swift::ComponentError &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.
 			/// \param xml xml stanza
 			boost::signal<void (const std::string &xml)> onXMLOut;
 			/// This signal is emitted when XML stanza is received from server.
 			/// \param xml xml stanza
 			boost::signal<void (const std::string &xml)> onXMLIn;
 			/// 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
 			/// This signal is emitted when presence from XMPP user 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 Swift::SafeByteArray &data);
 			void handleDataWritten(const Swift::SafeByteArray &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;
 			Swift::CapsManager *m_capsManager;
 			Swift::CapsMemoryStorage *m_capsMemoryStorage;
 			Swift::PresenceOracle *m_presenceOracle;
 			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;
 		friend class User;
 		friend class UserRegistration;
 		friend class NetworkPluginServer;
 	};
+}

src/buddy.cpp

➞

Show inline comments

 	if (!statusMessage.empty())
 		presence->setStatus(statusMessage);
 	if (s.getType() == Swift::StatusShow::None)
 		presence->setType(Swift::Presence::Unavailable);
 	presence->setShow(s.getType());
 	if (presence->getType() != Swift::Presence::Unavailable) {
 		// caps
 // 		presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::CapsInfo (CONFIG().caps)));
 // 		if (features & 0/*TRANSPORT_FEATURE_AVATARS*/) {
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::VCardUpdate (getIconHash())));
 // 		}
+	}
 	if (only_new) {
 		if (m_lastPresence)
 			m_lastPresence->setTo(Swift::JID(""));
 		if (m_lastPresence == presence) {
 			return Swift::Presence::ref();
+		}
 		m_lastPresence = presence;
+	}
 	return presence;
+}
 std::string Buddy::getSafeName() {
 	if (m_jid.isValid()) {
 		return m_jid.getNode();
+	}
 	std::string name = getName();
 // 	Transport::instance()->protocol()->prepareUsername(name, purple_buddy_get_account(m_buddy));
 	if (getFlags() & BUDDY_JID_ESCAPING) {
 		name = Swift::JID::getEscapedNode(name);
+	}
 	else {
 		if (name.find_last_of("@") != std::string::npos) {
 			name.replace(name.find_last_of("@"), 1, "%");
+		}
+	}
 // 	if (name.empty()) {
 // 		Log("SpectrumBuddy::getSafeName", "Name is EMPTY! Previous was " << getName() << ".");
 // 	}
 	return name;
+}
-void Buddy::buddyChanged() {
+void Buddy::handleBuddyChanged() {
 	Swift::Presence::ref presence = generatePresenceStanza(255);
 	if (presence) {
 		m_rosterManager->getUser()->getComponent()->getStanzaChannel()->sendPresence(presence);
+	}
 	onBuddyChanged();
+}
-void Buddy::handleVCardReceived(const std::string &id, const Swift::JID &to, Swift::VCard::ref vcard) {
 void Buddy::handleVCardReceived(const std::string &id, Swift::VCard::ref vcard) {
 	boost::shared_ptr<Swift::GenericRequest<Swift::VCard> > request(new Swift::GenericRequest<Swift::VCard>(Swift::IQ::Result, m_rosterManager->getUser()->getJID(), vcard, m_rosterManager->getUser()->getComponent()->getIQRouter()));
 	request->send();
+}
 std::string Buddy::JIDToLegacyName(const Swift::JID &jid) {
 	std::string name;
 	if (jid.getUnescapedNode() == jid.getNode()) {
 		name = jid.getNode();
 		if (name.find_last_of("%") != std::string::npos) {
 			name.replace(name.find_last_of("%"), 1, "@");
+		}
+	}
 	else {
 		name = jid.getUnescapedNode();
+	}
 	return name;
+}
+}

src/conversation.cpp

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * 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 <iostream>
 #include "transport/conversation.h"
 #include "transport/conversationmanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/buddy.h"
 #include "transport/rostermanager.h"
 namespace Transport {
 Conversation::Conversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMUC) : m_conversationManager(conversationManager) {
 	m_legacyName = legacyName;
-	m_conversationManager->setConversation(this);
+	m_conversationManager->addConversation(this);
 	m_muc = isMUC;
+}
 Conversation::~Conversation() {
-	m_conversationManager->unsetConversation(this);
+	m_conversationManager->removeConversation(this);
+}
 void Conversation::handleMessage(boost::shared_ptr<Swift::Message> &message, const std::string &nickname) {
 	if (m_muc) {
 		message->setType(Swift::Message::Groupchat);
+	}
 	else {
 		message->setType(Swift::Message::Chat);
+	}
 	if (message->getType() != Swift::Message::Groupchat) {
 		message->setTo(m_conversationManager->getUser()->getJID().toBare());
 		// normal message
 		if (nickname.empty()) {
 			Buddy *buddy = m_conversationManager->getUser()->getRosterManager()->getBuddy(m_legacyName);
 			if (buddy) {
 				std::cout << m_legacyName << " 222222\n";
 				message->setFrom(buddy->getJID());
+			}
 			else {
 				std::cout << m_legacyName << " 1111111\n";
 				// TODO: escape from and setFrom
+			}
+		}
 		// PM message
 		else {
 			if (m_room.empty()) {
 				message->setFrom(Swift::JID(nickname, m_conversationManager->getComponent()->getJID().toBare(), "user"));
+			}
 			else {
 				message->setFrom(Swift::JID(m_room, m_conversationManager->getComponent()->getJID().toBare(), nickname));
+			}
+		}
 		m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(message);
+	}
 	else {
 		message->setTo(m_conversationManager->getUser()->getJID().toString());
 		message->setFrom(Swift::JID(m_legacyName, m_conversationManager->getComponent()->getJID().toBare(), nickname));
 		m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(message);
+	}
+}
 void Conversation::handleParticipantChanged(const std::string &nick, int flag, int status, const std::string &statusMessage, const std::string &newname) {
 	std::string nickname = nick;
 	Swift::Presence::ref presence = Swift::Presence::create();
  	presence->setFrom(Swift::JID(m_legacyName, m_conversationManager->getComponent()->getJID().toBare(), nickname));
 	presence->setTo(m_conversationManager->getUser()->getJID().toString());
 	presence->setType(Swift::Presence::Available);

src/conversationmanager.cpp

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * 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/conversationmanager.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/buddy.h"
 #include "transport/factory.h"
 #include "transport/user.h"
 #include "Swiften/Roster/SetRosterRequest.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Elements/RosterItemPayload.h"
 namespace Transport {
 ConversationManager::ConversationManager(User *user, Component *component){
 	m_user = user;
 	m_component = component;
+}
 ConversationManager::~ConversationManager() {
 	while(!m_convs.empty()) {
 		delete (*m_convs.begin()).second;
+	}
+}
-void ConversationManager::setConversation(Conversation *conv) {
+void ConversationManager::addConversation(Conversation *conv) {
 	m_convs[conv->getLegacyName()] = conv;
+}
-void ConversationManager::unsetConversation(Conversation *conv) {
+void ConversationManager::removeConversation(Conversation *conv) {
 	for (std::map<std::string, Conversation *>::const_iterator it = m_convs.begin(); it != m_convs.end(); it++) {
 		if ((*it).second->getRoom() == conv->getLegacyName()) {
 			(*it).second->setRoom("");
+		}
+	}
 	m_convs.erase(conv->getLegacyName());
+}
 void ConversationManager::handleMessageReceived(Swift::Message::ref message) {
 	std::string name = message->getTo().getUnescapedNode();
 	if (name.find_last_of("%") != std::string::npos) {
 		name.replace(name.find_last_of("%"), 1, "@");
+	}
 	if (!m_convs[name]) {
 		m_convs[name] = m_component->getFactory()->createConversation(this, name);
+	}
 	else if (m_convs[name]->isMUC() && message->getType() != Swift::Message::Groupchat) {
 		std::string room_name = name;
 		name = message->getTo().getResource();
 		if (!m_convs[name]) {
 			m_convs[name] = m_component->getFactory()->createConversation(this, name);
 			m_convs[name]->setRoom(room_name);
+		}
+	}
 	m_convs[name]->sendMessage(message);
+}
+}
@@ \ No newline at end of file @@

src/networkpluginserver.cpp

➞

Show inline comments

@@ @@ -75,107 +75,107 @@ class NetworkFactory : public Factory { @@
 			return buddy;
+		}
 	private:
 		NetworkPluginServer *m_nps;
 };
 #define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \
 	wrap.set_type(TYPE); \
 	wrap.set_payload(MESSAGE); \
 	wrap.SerializeToString(&MESSAGE);
 static int exec_(const char *path, const char *host, const char *port, const char *config) {
 // 	char *argv[] = {(char*)script_name, '\0'};
 	int status = 0;
 	pid_t pid = fork();
 	if ( pid == 0 ) {
 		// child process
 		execlp(path, path, "--host", host, "--port", port, config, NULL);
 		exit(1);
 	} else if ( pid < 0 ) {
 		// fork failed
 		status = -1;
+	}
 	return status;
+}
 static void SigCatcher(int n) {
 	wait3(NULL,WNOHANG,NULL);
+}
 static void handleBuddyPayload(LocalBuddy *buddy, const pbnetwork::Buddy &payload) {
 	buddy->setName(payload.buddyname());
 	buddy->setAlias(payload.alias());
 	std::vector<std::string> groups;
 	groups.push_back(payload.groups());
 	buddy->setGroups(groups);
 	buddy->setStatus(Swift::StatusShow((Swift::StatusShow::Type) payload.status()), payload.statusmessage());
 	buddy->setIconHash(payload.iconhash());
+}
 NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager) {
 	m_userManager = userManager;
 	m_config = config;
 	m_component = component;
 	m_component->m_factory = new NetworkFactory(this);
 	m_userManager->onUserCreated.connect(boost::bind(&NetworkPluginServer::handleUserCreated, this, _1));
 	m_userManager->onUserDestroyed.connect(boost::bind(&NetworkPluginServer::handleUserDestroyed, this, _1));
-	m_pingTimer = component->getFactories()->getTimerFactory()->createTimer(10000);
+	m_pingTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(10000);
 	m_pingTimer->onTick.connect(boost::bind(&NetworkPluginServer::pingTimeout, this));
 	m_vcardResponder = new VCardResponder(component->getIQRouter(), userManager);
 	m_vcardResponder->onVCardRequired.connect(boost::bind(&NetworkPluginServer::handleVCardRequired, this, _1, _2, _3));
 	m_vcardResponder->start();
 	m_rosterResponder = new RosterResponder(component->getIQRouter(), userManager);
 	m_rosterResponder->start();
-	m_server = component->getFactories()->getConnectionFactory()->createConnectionServer(10000);
+	m_server = component->getNetworkFactories()->getConnectionFactory()->createConnectionServer(10000);
 	m_server->onNewConnection.connect(boost::bind(&NetworkPluginServer::handleNewClientConnection, this, _1));
 	m_server->start();
 	signal(SIGCHLD, SigCatcher);
 	exec_(CONFIG_STRING(m_config, "service.backend").c_str(), "localhost", "10000", m_config->getConfigFile().c_str());
+}
 NetworkPluginServer::~NetworkPluginServer() {
 	m_pingTimer->stop();
 	delete m_vcardResponder;
 	delete m_rosterResponder;
+}
 void NetworkPluginServer::handleNewClientConnection(boost::shared_ptr<Swift::Connection> c) {
 	Client *client = new Client;
 	client->pongReceived = true;
 	client->connection = c;
 	m_clients.push_back(client);
 	c->onDisconnected.connect(boost::bind(&NetworkPluginServer::handleSessionFinished, this, client));
 	c->onDataRead.connect(boost::bind(&NetworkPluginServer::handleDataRead, this, client, _1));
 	sendPing(client);
 	m_pingTimer->start();
+}
 void NetworkPluginServer::handleSessionFinished(Client *c) {
 	for (std::list<User *>::const_iterator it = c->users.begin(); it != c->users.end(); it++) {
 		(*it)->setData(NULL);
 		(*it)->handleDisconnected("Internal Server Error, please reconnect.");
+	}
 	m_clients.remove(c);
 	delete c;
 	// Execute new session only if there's no free one after this crash/disconnection
 	for (std::list<Client *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		if ((*it)->users.size() < 1) {
 			return;
+		}
+	}
 	exec_(CONFIG_STRING(m_config, "service.backend").c_str(), "localhost", "10000", m_config->getConfigFile().c_str());
+}
 void NetworkPluginServer::handleConnectedPayload(const std::string &data) {
 	pbnetwork::Connected payload;
 	std::cout << "CONNECTED LOGIN 2 " << payload.user() << "\n";
+}
 void NetworkPluginServer::handleDisconnectedPayload(const std::string &data) {
 	pbnetwork::Disconnected payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.user());
 	if (!user) {
 		return;
+	}
 	m_component->m_userRegistry->onPasswordInvalid(payload.user());
 	user->handleDisconnected(payload.message());
+}
 void NetworkPluginServer::handleVCardPayload(const std::string &data) {
 	pbnetwork::VCard payload;
 	if (payload.ParseFromString(data) == false) {
 		std::cout << "PARSING ERROR\n";
 		// TODO: ERROR
 		return;
+	}
 	std::cout << "OMG?\n";
 	boost::shared_ptr<Swift::VCard> vcard(new Swift::VCard());
 	vcard->setFullName(payload.fullname());
 	vcard->setPhoto(Swift::createByteArray(payload.photo()));
 	vcard->setNickname(payload.nickname());
 	m_vcardResponder->sendVCard(payload.id(), vcard);
+}
 void NetworkPluginServer::handleBuddyChangedPayload(const std::string &data) {
 	pbnetwork::Buddy payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(payload.buddyname());
 	if (buddy) {
 		handleBuddyPayload(buddy, payload);
-		buddy->buddyChanged();
+		buddy->handleBuddyChanged();
+	}
 	else {
 		buddy = new LocalBuddy(user->getRosterManager(), -1);
 		handleBuddyPayload(buddy, payload);
 		user->getRosterManager()->setBuddy(buddy);
+	}
+}
 void NetworkPluginServer::handleParticipantChangedPayload(const std::string &data) {
 	pbnetwork::Participant payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.room());
 	if (!conv) {
 		return;
+	}
 	conv->handleParticipantChanged(payload.nickname(), payload.flag(), payload.status(), payload.statusmessage(), payload.newname());
 // 	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(payload.buddyname());
 // 	if (buddy) {
 // 		handleBuddyPayload(buddy, payload);
 // 		buddy->buddyChanged();
 // 	}
 // 	else {
 // 		buddy = new LocalBuddy(user->getRosterManager(), -1);
 // 		handleBuddyPayload(buddy, payload);
 // 		user->getRosterManager()->setBuddy(buddy);
 // 	}
 // 	std::cout << payload.nickname() << "\n";
+}
 void NetworkPluginServer::handleRoomChangedPayload(const std::string &data) {
 	pbnetwork::Room payload;
 	if (payload.ParseFromString(data) == false) {
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;

src/rostermanager.cpp

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * 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/rostermanager.h"
 #include "transport/rosterstorage.h"
 #include "transport/storagebackend.h"
 #include "transport/buddy.h"
 #include "transport/usermanager.h"
 #include "transport/buddy.h"
 #include "transport/user.h"
 #include "Swiften/Roster/SetRosterRequest.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Elements/RosterItemPayload.h"
 #include "Swiften/Elements/RosterItemExchangePayload.h"
 namespace Transport {
 RosterManager::RosterManager(User *user, Component *component){
 	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_setBuddyTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(1000);
 	m_RIETimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(5000);
 	m_RIETimer->onTick.connect(boost::bind(&RosterManager::sendRIE, this));
+}
 RosterManager::~RosterManager() {
 	m_setBuddyTimer->stop();
 	m_RIETimer->stop();
 	if (m_rosterStorage) {
 // 		for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {
 // 			Buddy *buddy = (*it).second;
 // 			m_rosterStorage->storeBuddy(buddy);
 // 		}
 		m_rosterStorage->storeBuddies();
+	}
 	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {
 		Buddy *buddy = (*it).second;
 		delete buddy;
+	}
 	if (m_rosterStorage)
 		delete m_rosterStorage;
+}
 void RosterManager::setBuddy(Buddy *buddy) {
 // 	m_setBuddyTimer->onTick.connect(boost::bind(&RosterManager::setBuddyCallback, this, buddy));
 // 	m_setBuddyTimer->start();
 	setBuddyCallback(buddy);
+}
 void RosterManager::sendBuddyRosterPush(Buddy *buddy) {
 	Swift::RosterPayload::ref payload = Swift::RosterPayload::ref(new Swift::RosterPayload());
 	Swift::RosterItemPayload item;
 	item.setJID(buddy->getJID().toBare());
 	item.setName(buddy->getAlias());
 	item.setGroups(buddy->getGroups());
 	payload->addItem(item);
 	Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, m_user->getJID().toBare(), m_component->getIQRouter());
 	request->onResponse.connect(boost::bind(&RosterManager::handleBuddyRosterPushResponse, this, _1, buddy->getName()));
 	request->send();
+}
 void RosterManager::setBuddyCallback(Buddy *buddy) {
 	m_setBuddyTimer->onTick.disconnect(boost::bind(&RosterManager::setBuddyCallback, this, buddy));
 	if (m_rosterStorage) {
 		buddy->onBuddyChanged.connect(boost::bind(&RosterStorage::storeBuddy, m_rosterStorage, buddy));
+	}
 	std::cout << "ADDING " << buddy->getName() << "\n";
 	m_buddies[buddy->getName()] = buddy;
 	onBuddySet(buddy);
 	// In server mode the only way is to send jabber:iq:roster push.
 	// In component mode we send RIE or Subscribe presences, based on features.
 	if (m_component->inServerMode()) {
 		sendBuddyRosterPush(buddy);
+	}
 	else {
 		if (m_setBuddyTimer->onTick.empty()) {
 			m_setBuddyTimer->stop();
 			if (true /*&& rie_is_supported*/) {
 				m_RIETimer->start();
+			}
+		}
+	}
 	if (m_rosterStorage)
 		m_rosterStorage->storeBuddy(buddy);
+}
 void RosterManager::unsetBuddy(Buddy *buddy) {
 	m_buddies.erase(buddy->getName());
 	if (m_rosterStorage)
 		m_rosterStorage->removeBuddyFromQueue(buddy);
 	onBuddyUnset(buddy);
+}
 void RosterManager::handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error, const std::string &key) {
 	if (m_buddies[key] != NULL) {
-		m_buddies[key]->buddyChanged();
+		m_buddies[key]->handleBuddyChanged();
+	}
+}
 Buddy *RosterManager::getBuddy(const std::string &name) {
 	return m_buddies[name];
+}
 void RosterManager::sendRIE() {
 	m_RIETimer->stop();
 	Swift::RosterItemExchangePayload::ref payload = Swift::RosterItemExchangePayload::ref(new Swift::RosterItemExchangePayload());
 	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {
 		Buddy *buddy = (*it).second;
 		Swift::RosterItemExchangePayload::Item item;
 		item.setJID(buddy->getJID().toBare());
 		item.setName(buddy->getAlias());
 		item.setAction(Swift::RosterItemExchangePayload::Item::Add);
 		item.setGroups(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();
+}
 void RosterManager::handleSubscription(Swift::Presence::ref presence) {
 	std::string legacyName = Buddy::JIDToLegacyName(presence->getTo());
+}
 void RosterManager::setStorageBackend(StorageBackend *storageBackend) {
 	if (m_rosterStorage) {
 		return;
+	}
 	m_rosterStorage = new RosterStorage(m_user, storageBackend);
 	std::list<BuddyInfo> roster;
 	storageBackend->getBuddies(m_user->getUserInfo().id, roster);
 	for (std::list<BuddyInfo>::const_iterator it = roster.begin(); it != roster.end(); it++) {
 		Buddy *buddy = m_component->getFactory()->createBuddy(this, *it);
 		std::cout << "CREATING BUDDY FROM DATABASE CACHE " << buddy->getName() << "\n";
 		m_buddies[buddy->getName()] = buddy;
 		buddy->onBuddyChanged.connect(boost::bind(&RosterStorage::storeBuddy, m_rosterStorage, buddy));
 		onBuddySet(buddy);
+	}
+}

src/rosterstorage.cpp

➞

Show inline comments

@@ @@ -32,97 +32,97 @@ namespace Transport { @@
 // 	AbstractUser *user = s->user;
 // 	long id = s->id;
 // 	if (purple_value_get_type(value) == PURPLE_TYPE_BOOLEAN) {
 // 		if (purple_value_get_boolean(value))
 // 			Transport::instance()->sql()->addBuddySetting(user->storageId(), id, key, "1", purple_value_get_type(value));
 // 		else
 // 			Transport::instance()->sql()->addBuddySetting(user->storageId(), id, key, "0", purple_value_get_type(value));
 // 	}
 // 	else if (purple_value_get_type(value) == PURPLE_TYPE_STRING) {
 // 		const char *str = purple_value_get_string(value);
 // 		Transport::instance()->sql()->addBuddySetting(user->storageId(), id, key, str ? str : "", purple_value_get_type(value));
 // 	}
 // }
 //
 // static gboolean storeAbstractSpectrumBuddy(gpointer key, gpointer v, gpointer data) {
 // 	AbstractUser *user = (AbstractUser *) data;
 // 	AbstractSpectrumBuddy *s_buddy = (AbstractSpectrumBuddy *) v;
 // 	if (s_buddy->getFlags() & SPECTRUM_BUDDY_IGNORE)
 // 		return TRUE;
 //
 // 	// save PurpleBuddy
 // 	std::string alias = s_buddy->getAlias();
 // 	std::string name = s_buddy->getName();
 // 	long id = s_buddy->getId();
 //
 // 	// Buddy is not in DB
 // 	if (id != -1) {
 // 		Transport::instance()->sql()->addBuddy(user->storageId(), name, s_buddy->getSubscription(), s_buddy->getGroup(), alias, s_buddy->getFlags());
 // 	}
 // 	else {
 // 		id = Transport::instance()->sql()->addBuddy(user->storageId(), name, s_buddy->getSubscription(), s_buddy->getGroup(), alias, s_buddy->getFlags());
 // 		s_buddy->setId(id);
 // 	}
 // 	Log("buddyListSaveNode", id << " " << name << " " << alias << " " << s_buddy->getSubscription());
 // 	if (s_buddy->getBuddy() && id != -1) {
 // 		PurpleBuddy *buddy = s_buddy->getBuddy();
 // 		SaveData *s = new SaveData;
 // 		s->user = user;
 // 		s->id = id;
 // 		g_hash_table_foreach(buddy->node.settings, save_settings, s);
 // 		delete s;
 // 	}
 // 	return TRUE;
 // }
 RosterStorage::RosterStorage(User *user, StorageBackend *storageBackend) {
 	m_user = user;
 	m_storageBackend = storageBackend;
-	m_storageTimer = m_user->getComponent()->getFactories()->getTimerFactory()->createTimer(5000);
+	m_storageTimer = m_user->getComponent()->getNetworkFactories()->getTimerFactory()->createTimer(5000);
 	m_storageTimer->onTick.connect(boost::bind(&RosterStorage::storeBuddies, this));
+}
 RosterStorage::~RosterStorage() {
 	m_storageTimer->stop();
+}
 void RosterStorage::storeBuddy(Buddy *buddy) {
 	m_buddies[buddy->getName()] = buddy;
 	m_storageTimer->start();
+}
 bool RosterStorage::storeBuddies() {
 	if (m_buddies.size() == 0) {
 		return false;
+	}
 	m_storageBackend->beginTransaction();
 	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {
 		Buddy *buddy = (*it).second;
 		BuddyInfo buddyInfo;
 		buddyInfo.alias = buddy->getAlias();
 		buddyInfo.legacyName = buddy->getName();
 		buddyInfo.groups = buddy->getGroups();
 		buddyInfo.subscription = buddy->getSubscription();
 		buddyInfo.id = buddy->getID();
 		buddyInfo.flags = buddy->getFlags();
 		buddyInfo.settings["icon_hash"].s = buddy->getIconHash();
 		buddyInfo.settings["icon_hash"].type = TYPE_STRING;
 		// Buddy is in DB
 		if (buddyInfo.id != -1) {
 			m_storageBackend->updateBuddy(m_user->getUserInfo().id, buddyInfo);
+		}
 		else {
 			buddyInfo.id = m_storageBackend->addBuddy(m_user->getUserInfo().id, buddyInfo);
 			buddy->setID(buddyInfo.id);
+		}
 // 		Log("buddyListSaveNode", id << " " << name << " " << alias << " " << s_buddy->getSubscription());
 // 		if (s_buddy->getBuddy() && id != -1) {
 // 			PurpleBuddy *buddy = s_buddy->getBuddy();
 // 			SaveData *s = new SaveData;
 // 			s->user = user;
 // 			s->id = id;
 // 			g_hash_table_foreach(buddy->node.settings, save_settings, s);
 // 			delete s;

src/user.cpp

➞

Show inline comments

 /**
  * libtransport -- C++ library for easy XMPP Transports development
+ *
  * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * 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/user.h"
 #include "transport/transport.h"
 #include "transport/storagebackend.h"
 #include "transport/rostermanager.h"
 #include "transport/usermanager.h"
 #include "transport/conversationmanager.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/StreamError.h"
 #include "Swiften/Elements/MUCPayload.h"
 namespace Transport {
 User::User(const Swift::JID &jid, UserInfo &userInfo, Component *component, UserManager *userManager) {
 	m_jid = jid;
 	m_component = component;
 	m_presenceOracle = component->m_presenceOracle;
 	m_entityCapsManager = component->m_entityCapsManager;
 	m_userManager = userManager;
 	m_userInfo = userInfo;
 	m_connected = false;
 	m_readyForConnect = false;
-	m_reconnectTimer = m_component->getFactories()->getTimerFactory()->createTimer(10000);
+	m_reconnectTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(10000);
 	m_reconnectTimer->onTick.connect(boost::bind(&User::onConnectingTimeout, this));
 	m_rosterManager = new RosterManager(this, m_component);
 	m_conversationManager = new ConversationManager(this, m_component);
+}
 User::~User(){
 	m_reconnectTimer->stop();
 	delete m_rosterManager;
 	delete m_conversationManager;
+}
 const Swift::JID &User::getJID() {
 	return m_jid;
+}
 void User::handlePresence(Swift::Presence::ref presence) {
 	Swift::Presence::ref highest = m_presenceOracle->getHighestPriorityPresence(m_jid.toBare());
 	if (!m_connected) {
 		// we are not connected to legacy network, so we should do it when disco#info arrive :)
 		if (m_readyForConnect == false) {
 			// Forward status message to legacy network, but only if it's sent from active resource
 // 					if (m_activeResource == presence->getFrom().getResource().getUTF8String()) {
 // 						forwardStatus(presenceShow, stanzaStatus);
 // 					}
 			boost::shared_ptr<Swift::CapsInfo> capsInfo = presence->getPayload<Swift::CapsInfo>();
 			if (capsInfo && capsInfo->getHash() == "sha-1") {
 				if (m_entityCapsManager->getCaps(presence->getFrom()) != Swift::DiscoInfo::ref()) {
 					m_readyForConnect = true;
 					onReadyToConnect();
+				}
+			}
 			else if (m_component->inServerMode()) {
 					m_readyForConnect = true;
 					onReadyToConnect();
+			}
 			else {
 				m_reconnectTimer->start();
+			}
+		}
+	}
 	std::cout << "HANDLE PRESENCE\n";
 	bool isMUC = presence->getPayload<Swift::MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';
 	if (isMUC) {
 		std::cout << "AAAAAAAAA\n";
 		if (presence->getType() == Swift::Presence::Unavailable) {

0 comments (0 inline, 0 general)