+ return path / Hexify::hexify(SHA1::getHash(certificate->toDER()));

+ boost::filesystem::path profilePath = basePath / profile.toString();

+ std::string nick = nickResolver_->jidToNick(toJID_);

+ std::string startMessage("Starting chat with " + nick);

+ if (theirPresence && !theirPresence->getStatus().empty()) {

+void ChatController::handleContactNickChanged(const JID& jid, const std::string& /*oldNick*/) {

+void ChatController::postSendMessage(const std::string& body, boost::shared_ptr<Stanza> sentStanza) {

+ std::string id = addMessage(body, "me", true, labelsEnabled_ ? chatWindow_->getSelectedSecurityLabel() : boost::optional<SecurityLabel>(), std::string(avatarManager_->getAvatarPath(selfJID_).string()), boost::posix_time::microsec_clock::universal_time());

+ std::string id = unackedStanzas_[stanza];

+ std::map<boost::shared_ptr<Stanza>, std::string>::iterator it = unackedStanzas_.begin();

+std::string ChatController::senderDisplayNameFromMessage(const JID& from) {

+std::string ChatController::getStatusChangeString(boost::shared_ptr<Presence> presence) {

+ std::string nick = senderDisplayNameFromMessage(presence->getFrom());

+ std::string response = nick;

+ if (!presence->getStatus().empty()) {

+ std::string newStatusChangeString = getStatusChangeString(newPresence);

+ std::string getStatusChangeString(boost::shared_ptr<Presence> presence);

+ void postSendMessage(const std::string &body, boost::shared_ptr<Stanza> sentStanza);

+ std::string senderDisplayNameFromMessage(const JID& from);

+ void handleContactNickChanged(const JID& jid, const std::string& /*oldNick*/);

+ std::string lastStatusChangeString_;

+ std::map<boost::shared_ptr<Stanza>, std::string> unackedStanzas_;

+#include <boost/algorithm/string.hpp>

+#include "Swiften/Base/String.h"

+ chatWindow_->addSystemMessage("The day is now " + std::string(boost::posix_time::to_iso_extended_string(now)).substr(0,10));

+void ChatControllerBase::handleSendMessageRequest(const std::string &body) {

+ if (!stanzaChannel_->isAvailable() || body.empty()) {

+std::string ChatControllerBase::addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, const boost::optional<SecurityLabel>& label, const std::string& avatarPath, const boost::posix_time::ptime& time) {

+ if (boost::starts_with(message, "/me ")) {

+ return chatWindow_->addAction(String::getSplittedAtFirst(message, ' ').second, senderName, senderIsSelf, label, avatarPath, time);

+ std::string body = message->getBody();

+ std::string errorMessage = getErrorMessage(message->getPayload<ErrorPayload>());

+ chatWindow_->addSystemMessage(std::string(s.str()));

+ addMessage(body, senderDisplayNameFromMessage(from), isIncomingMessageFromMe(message), maybeLabel, std::string(avatarManager_->getAvatarPath(from).string()), timeStamp);

+std::string ChatControllerBase::getErrorMessage(boost::shared_ptr<ErrorPayload> error) {

+ std::string defaultMessage = "Error sending message";

+ if (!error->getText().empty()) {

+#include <string>

+ std::string addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, const boost::optional<SecurityLabel>& label, const std::string& avatarPath, const boost::posix_time::ptime& time);

+ virtual void postSendMessage(const std::string&, boost::shared_ptr<Stanza>) {};

+ virtual std::string senderDisplayNameFromMessage(const JID& from) = 0;

+ void handleSendMessageRequest(const std::string &body);

+ std::string getErrorMessage(boost::shared_ptr<ErrorPayload>);

+void ChatsManager::handleChatRequest(const std::string &contact) {

+void ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::optional<std::string>& nickMaybe, bool autoJoin) {

+ std::string nick = nickMaybe ? nickMaybe.get() : jid_.getNode();

+ if (!event->isReadable() && !message->getPayload<ChatState>() && message->getSubject().empty()) {

+#include <string>

+ void handleChatRequest(const std::string& contact);

+ void handleJoinMUCRequest(const JID& muc, const boost::optional<std::string>& nick, bool autoJoin);

+#include <boost/algorithm/string.hpp>

+ const std::string &nick,

+ std::string errorMessage = "Unable to join this room";

+ std::string rejoinNick;

+ if (!rejoinNick.empty()) {

+void MUCController::handleJoinComplete(const std::string& nick) {

+ std::string joinMessage = "You have joined room " + toJID_.toString() + " as " + nick;

+ std::string path = avatarManager_->getAvatarPath(jid).string();

+ std::string joinString = occupant.getNick() + " has joined the room";

+void MUCController::addPresenceMessage(const std::string& message) {

+std::string MUCController::roleToFriendlyName(MUCOccupant::Role role) {

+JID MUCController::nickToJID(const std::string& nick) {

+ std::string stringRegexp(".*\\b" + boost::to_lower_copy(nick_) + "\\b.*");

+ boost::regex myRegexp(stringRegexp);

+ return boost::regex_match(boost::to_lower_copy(message->getBody()), myRegexp);

+ std::string nick = message->getFrom().getResource();

+ if (!message->getSubject().empty() && message->getBody().empty()) {

+void MUCController::handleOccupantRoleChanged(const std::string& nick, const MUCOccupant& occupant, const MUCOccupant::Role& oldRole) {

+std::string MUCController::roleToGroupName(MUCOccupant::Role role) {

+ std::string result;

+void MUCController::handleOccupantLeft(const MUCOccupant& occupant, MUC::LeavingType, const std::string& reason) {

+ std::string partMessage = (occupant.getNick() != nick_) ? occupant.getNick() + " has left the room" : "You have left the room";

+ if (!reason.empty()) {

+std::string MUCController::senderDisplayNameFromMessage(const JID& from) {

+std::string MUCController::concatenateListOfNames(const std::vector<NickJoinPart>& joinParts) {

+ std::string result;

+std::string MUCController::generateJoinPartString(const std::vector<NickJoinPart>& joinParts) {

+ std::string eventStrings[4];

+ std::string result;

+ std::string eventString = concatenateListOfNames(sorted[i]);

+ if (!eventString.empty()) {

+ std::string haveHas = sorted[i].size() > 1 ? " have" : " has";

+#include <string>

+ NickJoinPart(const std::string& nick, JoinPart type) : nick(nick), type(type) {};

+ std::string nick;

+ MUCController(const JID& self, MUC::ref muc, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController);

+ static std::string generateJoinPartString(const std::vector<NickJoinPart>& joinParts);

+ static std::string concatenateListOfNames(const std::vector<NickJoinPart>& joinParts);

+ std::string senderDisplayNameFromMessage(const JID& from);

+ void addPresenceMessage(const std::string& message);

+ void handleOccupantLeft(const MUCOccupant& occupant, MUC::LeavingType type, const std::string& reason);

+ void handleOccupantRoleChanged(const std::string& nick, const MUCOccupant& occupant,const MUCOccupant::Role& oldRole);

+ void handleJoinComplete(const std::string& nick);

+ std::string roleToGroupName(MUCOccupant::Role role);

+ JID nickToJID(const std::string& nick);

+ std::string roleToFriendlyName(MUCOccupant::Role role);

+ std::string nick_;

+ std::string desiredNick_;

+ std::set<std::string> currentOccupants_;

+#include <Swiften/Base/String.h>

+static const std::string SEARCHED_SERVICES = "searchedServices";

+ foreach (std::string stringItem, String::split(settings_->getStringSetting(SEARCHED_SERVICES), '\n')) {

+ std::string collapsed;

+ if (!collapsed.empty()) {

+ std::string name;

+#include <string>

+ MUCRoom(const std::string& node, const std::string& name, int occupants) : node_(node), name_(name), occupants_(occupants) {}

+ std::string getNode() {return node_;}

+ std::string getName() {return name_;}

+ std::string node_;

+ std::string name_;

+ void setName(const std::string& name) {

+ std::string getName() const {

+ void setError(const std::string& errorText) {error_ = true; errorText_ = errorText;}

+ std::string name_;

+ std::string errorText_;

+ DiscoInfo::ref getCaps(const std::string&) const {return DiscoInfo::ref(new DiscoInfo());}

+ std::string body("This is a legible message. >HEH@)oeueu");

+ std::string body1("This is a legible message. >HEH@)oeueu");

+ std::string body2("This is a legible message. .cmaulm.chul");

+ std::string messageJIDString("testling@test.com");

+ std::string bareJIDString("testling@test.com");

+ std::string fullJIDString("testling@test.com/resource1");

+ std::string body("This is a legible message. mjuga3089gm8G(*>M)@*(");

+ std::string messageJIDString1("testling1@test.com");

+ std::string messageJIDString2("testling2@test.com");

+ std::string bareJIDString("testling@test.com");

+ std::string fullJIDString1("testling@test.com/resource1");

+ std::string fullJIDString2("testling@test.com/resource2");

+ std::string messageBody1("This is a legible message.");

+ std::string messageBody2("This is another legible message.");

+ uiEventStream_->send(boost::shared_ptr<JoinMUCUIEvent>(new JoinMUCUIEvent(muc, std::string("nick"))));

+ std::string messageJIDString1("testling@test.com/1");

+ std::string messageJIDString2("testling@test.com/2");

+ std::string messageJIDString3("testling@test.com/3");

+ std::string body3("This is a legible message3.");

+ std::string body2b("This is a legible message2b.");

+#include <boost/algorithm/string.hpp>

+ message->setBody("Hi " + boost::to_lower_copy(nick_) + ".");

+ message->setBody("Hi " + boost::to_lower_copy(nick_) + "ie.");

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev has joined the room."), MUCController::generateJoinPartString(list));

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev has joined and Remko has left the room."), MUCController::generateJoinPartString(list));

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev and Bert have joined and Remko has left the room."), MUCController::generateJoinPartString(list));

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev, Bert and Ernie have joined and Remko has left the room."), MUCController::generateJoinPartString(list));

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev joined then left the room."), MUCController::generateJoinPartString(list));

+ CPPUNIT_ASSERT_EQUAL(std::string("Remko has left and Kev joined then left the room."), MUCController::generateJoinPartString(list));

+ CPPUNIT_ASSERT_EQUAL(std::string("Remko has left, Kev joined then left and Bert left then rejoined the room."), MUCController::generateJoinPartString(list));

+ CPPUNIT_ASSERT_EQUAL(std::string("Remko has left, Kev and Ernie joined then left and Bert left then rejoined the room."), MUCController::generateJoinPartString(list));

+ std::string nick_;

+ std::vector<std::string> features = info->getFeatures();

+ std::map<std::string, std::string> fields;

+#include <string>

+ UserSearchResult(const JID& jid, const std::map<std::string, std::string>& fields) : jid_(jid), fields_(fields) {}

+ const std::map<std::string, std::string>& getFields() const {return fields_;}

+ std::map<std::string, std::string> fields_;

+void ContactEditController::handleChangeContactRequest(const std::string& name, const std::set<std::string>& newGroups) {

+ std::vector<std::string> oldGroupsVector = currentContact->getGroups();

+ std::set<std::string> oldGroups(oldGroupsVector.begin(), oldGroupsVector.end());

+ newContact.setGroups(std::vector<std::string>(newGroups.begin(), newGroups.end()));

+#include <string>

+ void handleChangeContactRequest(const std::string& name, const std::set<std::string>& groups);

+ if (item.getNode().empty()) {

+#include <string>

+ std::string title = nickResolver->jidToNick(jid);

+ if (!messageEvent->getStanza()->isError() && !messageEvent->getStanza()->getBody().empty()) {

+ std::string title = "";

+ std::string message = nickResolver->jidToNick(jid) + " wants to add you to his/her roster";

+#include <string>

+static const std::string CLIENT_NAME = "Swift";

+static const std::string CLIENT_NODE = "http://swift.im";

+static const std::string SHOW_NOTIFICATIONS = "showNotifications";

+ std::string selectedLoginJID = settings_->getStringSetting("lastLoginJID");

+ std::string cachedPassword;

+ std::string cachedCertificate;

+ foreach (std::string profile, settings->getAvailableProfiles()) {

+ std::string password = profileSettings.getStringSetting("pass");

+ std::string certificate = profileSettings.getStringSetting("certificate");

+ std::string jid = profileSettings.getStringSetting("jid");

+void MainController::handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText) {

+ if (!vCardPhotoHash_.empty()) {

+void MainController::handleLoginRequest(const std::string &username, const std::string &password, const std::string& certificateFile, bool remember, bool loginAutomatically) {

+void MainController::handlePurgeSavedLoginRequest(const std::string& username) {

+ if (!certificateFile_.empty()) {

+ std::string message;

+ std::string certificateErrorMessage;

+ if (!certificateErrorMessage.empty()) {

+#include <string>

+ void handleLoginRequest(const std::string& username, const std::string& password, const std::string& certificateFile, bool remember, bool loginAutomatically);

+ void handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText);

+ void handlePurgeSavedLoginRequest(const std::string& username);

+ std::string vCardPhotoHash_;

+ std::string password_;

+ std::string certificateFile_;

+ std::string name = nickResolver->jidToNick(jid);

+ std::string title = name + " (" + getStatusType(jid) + ")";

+ std::string message = getStatusMessage(jid);

+std::string PresenceNotifier::getStatusType(const JID& jid) const {

+std::string PresenceNotifier::getStatusMessage(const JID& jid) const {

+ return std::string();

+ std::string getStatusType(const JID&) const;

+ std::string getStatusMessage(const JID&) const;

+void PreviousStatusStore::addStatus(StatusShow::Type status, const std::string& message) {

+std::vector<TypeStringPair> PreviousStatusStore::exactMatchSuggestions(StatusShow::Type status, const std::string& message) {

+std::vector<TypeStringPair> PreviousStatusStore::getSuggestions(const std::string& message) {

+ } else if (status.second.find(message) != std::string::npos) {

+#include <string>

+ typedef std::pair<StatusShow::Type, std::string> TypeStringPair;

+ void addStatus(StatusShow::Type status, const std::string& message);

+ std::vector<TypeStringPair> getSuggestions(const std::string& message);

+ std::vector<TypeStringPair> exactMatchSuggestions(StatusShow::Type status, const std::string& message);

+ ProfileSettingsProvider(const std::string& profile, SettingsProvider* provider) : profile_(profile) {

+ foreach (std::string existingProfile, provider->getAvailableProfiles()) {

+ virtual std::string getStringSetting(const std::string &settingPath) {return provider_->getStringSetting(profileSettingPath(settingPath));};

+ virtual void storeString(const std::string &settingPath, const std::string &settingValue) {provider_->storeString(profileSettingPath(settingPath), settingValue);};

+ virtual int getIntSetting(const std::string& settingPath, int defaultValue) {return provider_->getIntSetting(settingPath, defaultValue);}

+ virtual void storeInt(const std::string& settingPath, int settingValue) {provider_->storeInt(settingPath, settingValue);}

+ std::string profileSettingPath(const std::string &settingPath) {return profile_ + ":" + settingPath;};

+ std::string profile_;

+ContactRosterItem::ContactRosterItem(const JID& jid, const JID& displayJID, const std::string& name, GroupRosterItem* parent) : RosterItem(name, parent), jid_(jid), displayJID_(displayJID) {

+std::string ContactRosterItem::getStatusText() const {

+void ContactRosterItem::setAvatarPath(const std::string& path) {

+const std::string& ContactRosterItem::getAvatarPath() const {

+typedef std::pair<std::string, boost::shared_ptr<Presence> > StringPresencePair;

+void ContactRosterItem::applyPresence(const std::string& resource, boost::shared_ptr<Presence> presence) {

+ if (resource.empty()) {

+const std::vector<std::string> ContactRosterItem::getGroups() const {

+void ContactRosterItem::addGroup(const std::string& group) {

+void ContactRosterItem::removeGroup(const std::string& group) {

+#include <string>

+ ContactRosterItem(const JID& jid, const JID& displayJID, const std::string& name, GroupRosterItem* parent);

+ std::string getStatusText() const;

+ void setAvatarPath(const std::string& path);

+ const std::string& getAvatarPath() const;

+ void applyPresence(const std::string& resource, boost::shared_ptr<Presence> presence);

+ const std::vector<std::string> getGroups() const;

+ void addGroup(const std::string& group);

+ void removeGroup(const std::string& group);

+ std::string avatarPath_;

+ std::map<std::string, boost::shared_ptr<Presence> > presences_;

+ std::vector<std::string> groups_;

+GroupRosterItem::GroupRosterItem(const std::string& name, GroupRosterItem* parent, bool sortByStatus) : RosterItem(name, parent), sortByStatus_(sortByStatus) {

+GroupRosterItem* GroupRosterItem::removeGroupChild(const std::string& groupName) {

+#include <string>

+ GroupRosterItem(const std::string& name, GroupRosterItem* parent, bool sortByStatus);

+ GroupRosterItem* removeGroupChild(const std::string& group);

+ std::string name_;

+#include <string>

+GroupRosterItem* Roster::getGroup(const std::string& groupName) {

+void Roster::removeGroup(const std::string& group) {

+void Roster::addContact(const JID& jid, const JID& displayJID, const std::string& name, const std::string& groupName, const std::string& avatarPath) {

+ foreach (std::string existingGroup, itemMap_[fullJIDMapping_ ? jid : jid.toBare()][0]->getGroups()) {

+void Roster::removeContactFromGroup(const JID& jid, const std::string& groupName) {

+#include <string>

+ void addContact(const JID& jid, const JID& displayJID, const std::string& name, const std::string& group, const std::string& avatarPath);

+ void removeContactFromGroup(const JID& jid, const std::string& group);

+ void removeGroup(const std::string& group);

+ GroupRosterItem* getGroup(const std::string& groupName);

+#include "Swiften/JID/JID.h"

+static const std::string SHOW_OFFLINE = "showOffline";

+void RosterController::handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText) {

+ std::vector<std::string> groups = xmppRoster_->getGroupsForJID(jid);

+ std::string name = nickResolver_->jidToNick(jid);

+ foreach(const std::string& group, groups) {

+void RosterController::handleOnJIDUpdated(const JID& jid, const std::string& oldName, const std::vector<std::string> passedOldGroups) {

+ std::vector<std::string> groups = xmppRoster_->getGroupsForJID(jid);

+ std::vector<std::string> oldGroups = passedOldGroups;

+ std::string name = nickResolver_->jidToNick(jid);

+ std::string contactsGroup = "Contacts";

+ foreach(const std::string& group, groups) {

+ foreach(const std::string& group, oldGroups) {

+ std::string group = renameGroupEvent->getGroup();

+ std::vector<std::string> groups = item.getGroups();

+ if ( (group.empty() && groups.empty()) || std::find(groups.begin(), groups.end(), group) != groups.end()) {

+void RosterController::setContactGroups(const JID& jid, const std::vector<std::string>& groups) {

+ std::string text = "Server " + myJID_.getDomain() + " rejected roster change to item '" + rosterPayload->getItems()[0].getJID().toString() + "'";

+ if (!error->getText().empty()) {

+void RosterController::handleSubscriptionRequest(const JID& jid, const std::string& message) {

+ std::string path = avatarManager_->getAvatarPath(jid).string();

+std::set<std::string> RosterController::getGroups() const {

+#include <string>

+ boost::signal<void (StatusShow::Type, const std::string&)> onChangeStatusRequest;

+ std::set<std::string> getGroups() const;

+ void setContactGroups(const JID& jid, const std::vector<std::string>& groups);

+ void handleOnJIDUpdated(const JID &jid, const std::string& oldName, const std::vector<std::string> oldGroups);

+ void handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText);

+ void handleSubscriptionRequest(const JID& jid, const std::string& message);

+#include "Swiften/Base/String.h"

+ std::string displayName = group->getDisplayName();

+ std::string setting;

+ foreach (const std::string& group, collapsed_) {

+ if (!setting.empty()) {

+ std::string saved = settings_->getStringSetting(SettingPath);

+ std::vector<std::string> collapsed = String::split(saved, '\n');

+const std::string RosterGroupExpandinessPersister::SettingPath = "GroupExpandiness";

+ std::set<std::string> collapsed_;

+ static const std::string SettingPath;

+#include <boost/algorithm/string.hpp>

+

+RosterItem::RosterItem(const std::string& name, GroupRosterItem* parent) : name_(name), sortableDisplayName_(boost::to_lower_copy(name_)), parent_(parent) {

+void RosterItem::setDisplayName(const std::string& name) {

+ sortableDisplayName_ = boost::to_lower_copy(name_);

+std::string RosterItem::getDisplayName() const {

+std::string RosterItem::getSortableDisplayName() const {

+#include <string>

+ RosterItem(const std::string& name, GroupRosterItem* parent);

+ void setDisplayName(const std::string& name);

+ std::string getDisplayName() const;

+ std::string getSortableDisplayName() const;

+ std::string name_;

+ std::string sortableDisplayName_;

+ SetAvatar(const JID& jid, const std::string& path, JID::CompareType compareType = JID::WithoutResource) : RosterItemOperation(true, jid), jid_(jid), path_(path), compareType_(compareType) {

+ std::string path_;

+ SetName(const std::string& name, const JID& jid, JID::CompareType compareType = JID::WithoutResource) : RosterItemOperation(true, jid), name_(name), jid_(jid), compareType_(compareType) {

+ std::string name_;

+ JID withResource(const JID& jid, const std::string& resource) {

+ std::vector<std::string> groups;

+ std::vector<std::string> groups;

+ std::vector<std::string> groups;

+ std::vector<std::string> groups;

+ std::vector<std::string> groups;

+ //CPPUNIT_ASSERT_EQUAL(std::string("Bob"), xmppRoster_->getNameForJID(JID("foo@bar.com")));

+ std::vector<std::string> groups;

+ std::vector<std::string> groups;

+ CPPUNIT_ASSERT_EQUAL(std::string("name"), groupChild(0)->getChildren()[0]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("NewName"), groupChild(0)->getChildren()[0]->getDisplayName());

+ std::vector<std::string> oldGroups;

+ std::vector<std::string> newGroups;

+ std::vector<std::string> newestGroups;

+ CPPUNIT_ASSERT_EQUAL(std::string("new name"), groupChild(0)->getChildren()[0]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("A Group"), groupChild(0)->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("new name"), groupChild(0)->getChildren()[0]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("Best Group"), groupChild(0)->getDisplayName());

+ std::vector<std::string> groups;

+ CPPUNIT_ASSERT_EQUAL(std::string("Robert"), item.getName());

+ void assertVectorsEqual(const std::vector<std::string>& v1, const std::vector<std::string>& v2, int line) {

+ foreach (const std::string& entry, v1) {

+ stream << "Couldn't find " << entry << " in v2 (line " << line << ")";

+ CPPUNIT_ASSERT_EQUAL(std::string("group1"), roster_->getRoot()->getChildren()[0]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("group2"), roster_->getRoot()->getChildren()[1]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("Bert"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[0]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("Cookie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[1]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("Ernie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[1])->getChildren()[0]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("Bert"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[0]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("Cookie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[1]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("Bert"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[0]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("Cookie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[1]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("Bert"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[0]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("Ernie"), children[0]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("Bert"), children[1]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("Bird"), children[2]->getDisplayName());

+ virtual std::string getStringSetting(const std::string&) {return "";}

+ virtual void storeString(const std::string &, const std::string &) {}

+ virtual bool getBoolSetting(const std::string &, bool ) {return true;}

+ virtual void storeBool(const std::string &, bool ) {}

+ virtual int getIntSetting(const std::string &, int ) {return 0;}

+ virtual void storeInt(const std::string &, int ) {}

+ virtual std::vector<std::string> getAvailableProfiles() {return std::vector<std::string>();}

+ virtual void createProfile(const std::string& ) {}

+ virtual void removeProfile(const std::string& ) {}

+#include <string>

+ virtual std::string getStringSetting(const std::string &settingPath) = 0;

+ virtual void storeString(const std::string &settingPath, const std::string &settingValue) = 0;

+ virtual bool getBoolSetting(const std::string &settingPath, bool defaultValue) = 0;

+ virtual void storeBool(const std::string &settingPath, bool settingValue) = 0;

+ virtual int getIntSetting(const std::string &settingPath, int defaultValue) = 0;

+ virtual void storeInt(const std::string &settingPath, int settingValue) = 0;

+ virtual std::vector<std::string> getAvailableProfiles() = 0;

+ virtual void createProfile(const std::string& profile) = 0;

+ virtual void removeProfile(const std::string& profile) = 0;

+#include <string>

+ AddContactUIEvent(const JID& jid, const std::string& name) : jid_(jid), name_(name) {};

+ std::string getName() {return name_;};

+ std::string name_;

+#include <string>

+ JoinMUCUIEvent(const JID& jid, const boost::optional<std::string>& nick = boost::optional<std::string>()) : jid_(jid), nick_(nick) {};

+ boost::optional<std::string> getNick() {return nick_;};

+ boost::optional<std::string> nick_;

+#include <string>

+ RenameGroupUIEvent(const std::string& group, const std::string& newName) : group(group), newName(newName) {

+ const std::string& getGroup() const {

+ const std::string& getNewName() const {

+ std::string group;

+ std::string newName;

+ RenameRosterItemUIEvent(const JID& jid, const std::string& newName) : jid_(jid), newName_(newName) {}

+ const std::string& getNewName() const {return newName_;}

+ std::string newName_;

+#include <string>

+#include <string>

+ virtual std::string addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, const boost::optional<SecurityLabel>& label, const std::string& avatarPath, const boost::posix_time::ptime& time) = 0;

+ virtual std::string addAction(const std::string& message, const std::string& senderName, bool senderIsSelf, const boost::optional<SecurityLabel>& label, const std::string& avatarPath, const boost::posix_time::ptime& time) = 0;

+ virtual void addSystemMessage(const std::string& message) = 0;

+ virtual void addPresenceMessage(const std::string& message) = 0;

+ virtual void addErrorMessage(const std::string& message) = 0;

+ virtual void setName(const std::string& name) = 0;

+ virtual void replaceLastMessage(const std::string& message) = 0;

+ virtual void setAckState(const std::string& id, AckState state) = 0;

+ boost::signal<void (const std::string&)> onSendMessageRequest;

+#include <string>

+ virtual void setContact(const JID& jid, const std::string& name, const std::vector<std::string>& groups, const std::set<std::string>& allGroups) = 0;

+ boost::signal<void (const std::string& /* name */, const std::set<std::string>& /* groups */)> onChangeContactRequest;

+#include <string>

+ virtual void setNick(const std::string& nick) = 0;

+ virtual void setMUC(const std::string& nick) = 0;

+ boost::signal<void (const JID& /* muc */, const std::string& /* nick */, bool /* autoJoin */)> onJoinMUC;

+#include <string>

+ virtual void selectUser(const std::string&) = 0;

+ virtual void setMessage(const std::string&) = 0;

+ virtual void addAvailableAccount(const std::string& defaultJID, const std::string& defaultPassword, const std::string& defaultCertificate) = 0;

+ virtual void removeAvailableAccount(const std::string& jid) = 0;

+ boost::signal<void (const std::string&, const std::string&, const std::string& /* certificateFile */, bool /* remember password*/, bool /* login automatically */)> onLoginRequest;

+ virtual bool askUserToTrustCertificatePermanently(const std::string& message, Certificate::ref) = 0;

+ boost::signal<void (const std::string&)> onPurgeSavedLoginRequest;

+

+#include <string>

+#include <string>

+ virtual void setMyNick(const std::string& name) = 0;

+ virtual void setMyAvatarPath(const std::string& path) = 0;

+ virtual void setMyStatusText(const std::string& status) = 0;

+ boost::signal<void (StatusShow::Type, const std::string&)> onChangeStatusRequest;

+ virtual void setError(const std::string&) = 0;

+#include <string>

+#include <string>

+namespace Swift {

+ virtual void handleDataRead(const std::string& data) = 0;

+ virtual void handleDataWritten(const std::string& data) = 0;

+ virtual std::string addMessage(const std::string& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, const boost::optional<SecurityLabel>& /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime&) {lastMessageBody_ = message; return "";};

+ virtual std::string addAction(const std::string& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, const boost::optional<SecurityLabel>& /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime&) {lastMessageBody_ = message; return "";};

+ virtual void addSystemMessage(const std::string& /*message*/) {};

+ virtual void addErrorMessage(const std::string& /*message*/) {};

+ virtual void addPresenceMessage(const std::string& /*message*/) {};

+ virtual void setName(const std::string& name) {name_ = name;};

+ virtual void replaceLastMessage(const std::string&) {};

+ void setAckState(const std::string& /*id*/, AckState /*state*/) {};

+ boost::signal<void (const std::string&)> onSendMessageRequest;

+ std::string name_;

+ std::string lastMessageBody_;

+ virtual void setMyNick(const std::string& /*name*/) {};;

+ virtual void setMyAvatarPath(const std::string& /*path*/) {};

+ virtual void setMyStatusText(const std::string& /*status*/) {};

+ roster->addContact(user1.toBare(), "User 1", std::vector<std::string>(), RosterItemPayload::Both);

+ std::string subject = notifier->notifications[0].subject;

+ CPPUNIT_ASSERT(subject.find("User 1") != std::string::npos);

+ std::string subject = notifier->notifications[0].subject;

+ CPPUNIT_ASSERT(subject.find(user1.toBare().toString()) != std::string::npos);

+ std::string subject = notifier->notifications[0].subject;

+ CPPUNIT_ASSERT(subject.find("Away") != std::string::npos);

+ CPPUNIT_ASSERT(notifier->notifications[0].description.find("Status Message") != std::string::npos);

+void XMLConsoleController::handleDataRead(const std::string& data) {

+void XMLConsoleController::handleDataWritten(const std::string& data) {

+

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

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

+#include <string>

+ ErrorEvent(const JID& jid, const std::string& text) : jid_(jid), text_(text){};

+ const std::string& getText() const {return text_;};

+ std::string text_;

+ return getStanza()->isError() || !getStanza()->getBody().empty();

+#include <string>

+ SubscriptionRequestEvent(const JID& jid, const std::string& reason) : jid_(jid), reason_(reason){};

+ const std::string& getReason() const {return reason_;};

+ std::string reason_;