date_time/local_time/local_time.hpp \

date_time/c_local_time_adjustor.hpp \

date_time/gregorian/gregorian_types.hpp \

filesystem.hpp \

filesystem/fstream.hpp \

format.hpp \

random/uniform_int.hpp \

regex.hpp \

scope_exit.hpp \

serialization/serialization.hpp \

serialization/vector.hpp \

serialization/list.hpp \

system/src/error_code.cpp \

phoenix/support/detail/iterate.hpp \

type_traits.hpp \

$TARGET_DIR

cp $1/LICENSE_1_0.txt $TARGET_DIR

#include <boost/bind.hpp>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/RosterPayload.h>

#include <Swiften/LinkLocal/LinkLocalServiceBrowser.h>

}

boost::optional<LinkLocalService> LinkLocalPresenceManager::getServiceForJID(const JID& j) const {

if (service.getJID() == j) {

return service;

}

std::shared_ptr<RosterPayload> LinkLocalPresenceManager::getRoster() const {

std::shared_ptr<RosterPayload> roster(new RosterPayload());

roster->addItem(getRosterItem(service));

}

return roster;

std::vector<std::shared_ptr<Presence> > LinkLocalPresenceManager::getAllPresence() const {

std::vector<std::shared_ptr<Presence> > result;

result.push_back(getPresence(service));

}

return result;

}

RosterItemPayload LinkLocalPresenceManager::getRosterItem(const LinkLocalService& service) const {

}

std::string LinkLocalPresenceManager::getRosterName(const LinkLocalService& service) const {

#include <boost/bind.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/LinkLocal/DNSSD/PlatformDNSSDQuerierFactory.h>

#include <Swiften/LinkLocal/LinkLocalService.h>

#include <Swiften/LinkLocal/LinkLocalServiceBrowser.h>

void MainController::handleServicesChanged() {

std::vector<std::string> names;

std::string description = service.getDescription();

if (description != service.getName()) {

description += " (" + service.getName() + ")";

#include <string>

#include <Slimber/Menulet.h>

MenuletController::MenuletController(Menulet* menulet) :

else {

menulet->setIcon("UsersOnline");

menulet->addItem("Online users:");

menulet->addItem(std::string(" ") + user);

}

}

#include <Slimber/Server.h>

#include <string>

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/String.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/RosterPayload.h>

serverFromClientSession->finishSession();

}

serverFromClientSession.reset();

session->finishSession();

}

linkLocalSessions.clear();

connector->cancel();

}

connectors.clear();

if (serverFromNetworkConnectionServer) {

serverFromNetworkConnectionServer->stop();

connection.disconnect();

}

serverFromNetworkConnectionServerSignalConnections.clear();

}

if (serverFromClientConnectionServer) {

serverFromClientConnectionServer->stop();

connection.disconnect();

}

serverFromClientConnectionServerSignalConnections.clear();

if (iq->getType() == IQ::Get) {

session->sendElement(IQ::createResult(iq->getFrom(), iq->getID(), presenceManager->getRoster()));

rosterRequested = true;

session->sendElement(presence);

}

}

new OutgoingLinkLocalSession(

selfJID, connector->getService().getJID(), connector->getConnection(),

&payloadParserFactories, &payloadSerializers, &xmlParserFactory));

outgoingSession->queueElement(element);

}

registerLinkLocalSession(outgoingSession);

}

std::shared_ptr<Session> Server::getLinkLocalSessionForJID(const JID& jid) {

if (session->getRemoteJID() == jid) {

return session;

}

}

std::shared_ptr<LinkLocalConnector> Server::getLinkLocalConnectorForJID(const JID& jid) {

if (connector->getService().getJID() == jid) {

return connector;

}

#include <lua.hpp>

#include <Sluift/Lua/Check.h>

#include <Sluift/Lua/Value.h>

#include <Sluift/LuaElementConvertors.h>

if (!payload->getNotes().empty()) {

std::vector<Lua::Value> notes;

Lua::Table noteTable;

if (!note.note.empty()) {

noteTable["note"] = Lua::valueRef(note.note);

if (!payload->getAvailableActions().empty()) {

std::vector<Lua::Value> availableActions;

if (action != Command::NoAction) {

availableActions.push_back(convertActionToString(action));

}

#include <lua.hpp>

#include <Swiften/Elements/RawXMLPayload.h>

#include <Swiften/Parser/Attribute.h>

#include <Swiften/Parser/AttributeMap.h>

if (!attributes.getEntries().empty()) {

lua_newtable(L);

int i = 1;

lua_pushnumber(L, i);

lua_newtable(L);

lua_pushstring(L, entry.getAttribute().getName().c_str());

#include <lua.hpp>

#include <Sluift/Lua/Check.h>

#include <Sluift/Lua/Value.h>

}

if (!field->getOptions().empty()) {

Lua::Array options;

Lua::Table luaOption = boost::assign::map_list_of

("label", Lua::valueRef(option.label))

("value", Lua::valueRef(option.value));

Lua::Array convertFieldListToLua(const std::vector< std::shared_ptr<FormField> >& fieldList) {

Lua::Array fields;

fields.push_back(convertFieldToLua(field));

}

return fields;

lua_getfield(L, -1, "fields");

if (lua_istable(L, -1)) {

result->addField(formField);

}

}

lua_getfield(L, -1, "reported_fields");

if (lua_istable(L, -1)) {

result->addReportedField(formField);

}

}

if (!payload->getItems().empty()) {

Lua::Array luaItems;

if (!item.empty()) {

luaItems.push_back(convertFieldListToLua(item));

}

form->clearReportedFields();

std::vector< std::shared_ptr<FormField> > fields(form->getFields());

form->clearFields();

if (field->getType() == FormField::FixedType) {

continue;

}

#include <lua.hpp>

#include <Swiften/Elements/Delay.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/Message.h>

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

if (!payload->getAffiliations().empty()) {

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

lua_createtable(L, boost::numeric_cast<int>(payload->getData().size()), 0);

{

int i = 0;

if (convertors->convertToLua(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

lua_createtable(L, boost::numeric_cast<int>(payload->getItems().size()), 0);

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

lua_createtable(L, boost::numeric_cast<int>(payload->getRetracts().size()), 0);

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

lua_createtable(L, boost::numeric_cast<int>(payload->getData().size()), 0);

{

int i = 0;

if (convertors->convertToLua(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

if (!payload->getItems().empty()) {

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

if (!payload->getAffiliations().empty()) {

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

if (!payload->getSubscriptions().empty()) {

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

lua_createtable(L, boost::numeric_cast<int>(payload->getItems().size()), 0);

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

lua_createtable(L, boost::numeric_cast<int>(payload->getItems().size()), 0);

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

if (!payload->getSubscriptions().empty()) {

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

#include <lua.hpp>

using namespace Swift;

SecurityLabelConvertor::SecurityLabelConvertor() :

lua_createtable(L, boost::numeric_cast<int>(payload->getEquivalentLabels().size()), 0);

{

int i = 0;

lua_pushstring(L, item.c_str());

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

#include <boost/numeric/conversion/cast.hpp>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Payload.h>

lua_createtable(L, boost::numeric_cast<int>(stanza->getPayloads().size()), 0);

{

int i = 0;

if (convertors->convertToLua(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

#include <Sluift/Lua/FunctionRegistry.h>

#include <Sluift/Lua/Exception.h>

#include <Sluift/Lua/LuaUtils.h>

#include <Sluift/globals.h>

}

void FunctionRegistry::addFunctionsToTable(lua_State* L, const std::string& type) {

if (registration.type == type) {

lua_pushcclosure(L, registration.function, 0);

if (!registration.helpDescription.empty()) {

#include <lualib.h>

}

using namespace Swift;

using namespace Swift::Lua;

void operator()(const std::map<std::string, std::shared_ptr<Value> >& table) const {

lua_createtable(state, 0, boost::numeric_cast<int>(table.size()));

boost::apply_visitor(PushVisitor(state), *i.second);

lua_setfield(state, -2, i.first.c_str());

}

#include <memory>

#include <Sluift/ElementConvertors/BodyConvertor.h>

#include <Sluift/ElementConvertors/CarbonsReceivedConvertor.h>

#include <Sluift/ElementConvertors/CarbonsSentConvertor.h>

std::shared_ptr<Element> LuaElementConvertors::convertFromLuaUntyped(lua_State* L, int index, const std::string& type) {

index = Lua::absoluteOffset(L, index);

if (std::shared_ptr<Element> result = convertor->convertFromLua(L, index, type)) {

return result;

}

if (!payload) {

return LuaElementConvertor::NO_RESULT;

}

if (boost::optional<std::string> type = convertor->convertToLua(L, payload)) {

return *type;

}

#include <boost/lambda/lambda.hpp>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Disco/ClientDiscoManager.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/Message.h>

SluiftClient* client = getClient(L);

Lua::Table contactsTable;

std::string subscription;

switch(item.getSubscription()) {

case RosterItemPayload::None: subscription = "none"; break;

#include <boost/lambda/lambda.hpp>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/MAMQuery.h>

#include <Swiften/Elements/Message.h>

* See the COPYING file for more information.

*/

#include <string>

#include <vector>

#include <boost/program_options/options_description.hpp>

#include <boost/program_options/variables_map.hpp>

#include <boost/version.hpp>

#include <Sluift/globals.h>

#include <Sluift/Console.h>

#include <Sluift/StandardTerminal.h>

// Load file

checkResult(L, luaL_loadfile(L, script.c_str()));

lua_pushstring(L, scriptArgument.c_str());

}

checkResult(L, Console::call(L, boost::numeric_cast<int>(scriptArguments.size()), false));

lua_getglobal(L, "sluift");

std::vector<std::string> globalImports = boost::assign::list_of

("help")("with");

lua_getfield(L, -1, globalImport.c_str());

lua_setglobal(L, globalImport.c_str());

}

#include <lua.hpp>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/sleep.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Crypto/PlatformCryptoProvider.h>

lua_rawgeti(L, LUA_REGISTRYINDEX, Sluift::globals.coreLibIndex);

std::vector<std::string> coreLibExports = boost::assign::list_of

("tprint")("disco")("help")("get_help")("copy")("with")("read_file")("create_form");

lua_getfield(L, -1, coreLibExport.c_str());

lua_setfield(L, -3, coreLibExport.c_str());

}

// Load client metatable

lua_rawgeti(L, LUA_REGISTRYINDEX, Sluift::globals.coreLibIndex);

std::vector<std::string> tables = boost::assign::list_of("Client");

lua_getfield(L, -1, table.c_str());

Lua::FunctionRegistry::getInstance().addFunctionsToTable(L, table);

lua_pop(L, 1);

// Load component metatable

lua_rawgeti(L, LUA_REGISTRYINDEX, Sluift::globals.coreLibIndex);

std::vector<std::string> comp_tables = boost::assign::list_of("Component");

lua_getfield(L, -1, table.c_str());

Lua::FunctionRegistry::getInstance().addFunctionsToTable(L, table);

lua_pop(L, 1);

lua_pop(L, 1);

// Register documentation for all elements

boost::optional<LuaElementConvertor::Documentation> documentation = convertor->getDocumentation();

if (documentation) {

Lua::registerClassHelp(L, documentation->className, documentation->description);

#include <Swiften/Base/Log.h>

#include <Swiften/Base/Paths.h>

namespace Swift {

boost::filesystem::path ApplicationPathProvider::getResourcePath(const std::string& resource) const {

std::vector<boost::filesystem::path> resourcePaths = getResourceDirs();

boost::filesystem::path r(resourcePath / resource);

if (boost::filesystem::exists(r)) {

return r;

#include <stdlib.h>

#include <boost/algorithm/string.hpp>

#include <unistd.h>

#include <Swiften/Base/String.h>

namespace Swift {

if (xdgDataDirs) {

std::vector<std::string> dataDirs = String::split(xdgDataDirs, ':');

if (!dataDirs.empty()) {

resourceDirs.push_back(boost::filesystem::path(dir) / "swift");

}

return;

boost::filesystem::create_directories(dataPath);

}

catch (const boost::filesystem::filesystem_error& e) {

}

return dataPath;

}

#include <boost/bind.hpp>

#include <Swiften/Base/Path.h>

#include <Swiften/Network/ConnectionFactory.h>

namespace Swift {

message << "Notifications-Count: " << getAllTypes().size() << "\r\n";

std::vector<Notifier::Type> defaultTypes = getDefaultTypes();

std::vector<Notifier::Type> allTypes = getAllTypes();

message << "\r\n";

message << "Notification-Name: " << typeToString(type) << "\r\n";

message << "Notification-Enabled: " << (std::find(defaultTypes.begin(), defaultTypes.end(), type) == defaultTypes.end() ? "false" : "true") << "\r\n";

#include <boost/algorithm/string.hpp>

namespace Swift {

void TabComplete::addWord(const std::string& word) {

} else {

lastShort_ = boost::to_lower_copy(word);

lastCompletionCandidates_.clear();

if (boost::starts_with(boost::to_lower_copy(candidate), boost::to_lower_copy(word))) {

lastCompletionCandidates_.push_back(candidate);

}

#include <boost/bind.hpp>

#include <Swiften/AdHoc/OutgoingAdHocCommandSession.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swift/Controllers/UIEvents/RequestAdHocUIEvent.h>

}

void AdHocManager::setOnline(bool online) {

controller->setOnline(online);

}

}

void AdHocManager::handleServerDiscoItemsResponse(std::shared_ptr<DiscoItems> items, ErrorPayload::ref error) {

std::vector<DiscoItems::Item> commands;

if (!error) {

if (item.getNode() != "http://isode.com/xmpp/commands#test") {

commands.push_back(item);

}

#include <boost/signals2.hpp>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/DiscoItems.h>

class MainWindow;

class UIEventStream;

class AdHocCommandWindowFactory;

class AdHocManager {

public:

AdHocManager(const JID& jid, AdHocCommandWindowFactory* factory, IQRouter* iqRouter, UIEventStream* uiEventStream, MainWindow* mainWindow);

void removeController(std::shared_ptr<AdHocController> contoller);

void setServerDiscoInfo(std::shared_ptr<DiscoInfo> info);

void setOnline(bool online);

private:

void handleServerDiscoItemsResponse(std::shared_ptr<DiscoItems>, ErrorPayload::ref error);

void handleUIEvent(std::shared_ptr<UIEvent> event);

boost::signals2::signal<void (const AdHocController&)> onControllerComplete;

JID jid_;

IQRouter* iqRouter_;

UIEventStream* uiEventStream_;

#include <boost/bind.hpp>

#include <Swiften/Base/format.h>

#include <Swiften/Client/ClientBlockListManager.h>

}

void BlockListController::blockListDifferences(const std::vector<JID> &newBlockList, std::vector<JID> &jidsToUnblock, std::vector<JID> &jidsToBlock) const {

if (std::find(newBlockList.begin(), newBlockList.end(), jid) == newBlockList.end()) {

jidsToUnblock.push_back(jid);

}

}

if (std::find(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid) == blockListBeforeEdit.end()) {

jidsToBlock.push_back(jid);

}

blockListDifferences(blockListEditorWidget_->getCurrentBlockList(), jidsToUnblock, jidsToBlock);

blockListBeforeEdit = blockListManager_->getBlockList()->getItems();

if (std::find(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid) == blockListBeforeEdit.end()) {

blockListBeforeEdit.push_back(jid);

}

}

blockListBeforeEdit.erase(std::remove(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid), blockListBeforeEdit.end());

}

#include <boost/bind.hpp>

#include <boost/regex.hpp>

#include <boost/algorithm/string.hpp>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/format.h>

#include <Swiften/Base/Tristate.h>

#include <Swiften/Client/BlockList.h>

void MUCController::handleBareJIDCapsChanged(const JID& /*jid*/) {

Tristate support = Yes;

bool any = false;

DiscoInfo::ref disco = entityCapsProvider_->getCaps(toJID_.toBare().toString() + "/" + nick);

if (disco && disco->hasFeature(DiscoInfo::MessageCorrectionFeature)) {

any = true;

std::map<std::string, JID> MUCController::getParticipantJIDs() const {

std::map<std::string, JID> participants;

std::map<std::string, MUCOccupant> occupants = muc_->getOccupants();

if (occupant.first != nick_) {

participants[occupant.first] = occupant.second.getRealJID().is_initialized() ? occupant.second.getRealJID().get().toBare() : JID();

}

}

void MUCController::sendInvites(const std::vector<JID>& jids, const std::string& reason) const {

muc_->invitePerson(jid, reason, isImpromptu_);

}

}

std::string MUCController::generateJoinPartString(const std::vector<NickJoinPart>& joinParts, bool isImpromptu) {

std::vector<NickJoinPart> sorted[4];

std::string eventStrings[4];

sorted[event.type].push_back(event);

}

std::string result;

// Check for existing bookmark for this room and, if it exists, use it instead.

std::vector<MUCBookmark> bookmarks = mucBookmarkManager_->getBookmarks();

if (bookmark.getRoom() == jid.toBare()) {

roomBookmark = bookmark;

break;

void MUCController::handleUIEvent(std::shared_ptr<UIEvent> event) {

std::shared_ptr<InviteToMUCUIEvent> inviteEvent = std::dynamic_pointer_cast<InviteToMUCUIEvent>(event);

if (inviteEvent && inviteEvent->getRoom() == muc_->getJID()) {

muc_->invitePerson(jid, inviteEvent->getReason(), isImpromptu_);

}

}

muc_->requestAffiliationList(MUCOccupant::Outcast);

}

void MUCController::handleChangeAffiliationsRequest(const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes) {

std::set<JID> addedJIDs;

if (change.first != MUCOccupant::NoAffiliation) {

addedJIDs.insert(change.second);

}

}

if (change.first != MUCOccupant::NoAffiliation || addedJIDs.find(change.second) == addedJIDs.end()) {

muc_->changeAffiliation(change.second, change.first);

}

joinContext_ = historyController_->getMUCContext(selfJID_, toJID_, lastActivity_);

bool senderIsSelf = nick_ == message.getFromJID().getResource();

// the chatWindow uses utc timestamps

JID jid = newMessage->getFrom();

boost::optional<boost::posix_time::ptime> time = newMessage->getTimestamp();

boost::posix_time::ptime messageTime = message.getTime() - boost::posix_time::hours(message.getOffset());

if (time && time < messageTime) {

break;

Form::ref result = std::make_shared<Form>(Form::SubmitType);

std::string impromptuConfigs[] = { "muc#roomconfig_enablelogging", "muc#roomconfig_persistentroom", "muc#roomconfig_publicroom", "muc#roomconfig_whois"};

std::set<std::string> impromptuConfigsMissing(impromptuConfigs, impromptuConfigs + 4);

std::shared_ptr<FormField> resultField;

if (field->getName() == "muc#roomconfig_enablelogging") {

resultField = std::make_shared<FormField>(FormField::BooleanType, "0");

}

}

if (config == "muc#roomconfig_publicroom") {

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "This server doesn't support hiding your chat from other users.")), ChatWindow::DefaultDirection);

} else if (config == "muc#roomconfig_whois") {

void MUCController::setImpromptuWindowTitle() {

std::string title;

std::map<std::string, MUCOccupant> occupants = muc_->getOccupants();

if (occupants.size() <= 1) {

title = QT_TRANSLATE_NOOP("", "Empty Chat");

} else {

if (pair.first != nick_) {

title += (title.empty() ? "" : ", ") + pair.first;

}

CPPUNIT_TEST(testChatControllerHighlightingNotificationTesting);

CPPUNIT_TEST(testChatControllerHighlightingNotificationDeduplicateSounds);

CPPUNIT_TEST(testChatControllerMeMessageHandling);

CPPUNIT_TEST(testChatControllerMeMessageHandlingInMUC);

// Carbons tests

uiEventStream_->send(std::make_shared<RequestChatUIEvent>(sender));

// The sender supports delivery receipts.

DiscoInfo::ref disco = std::make_shared<DiscoInfo>();

disco->addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

// Two resources respond with message receipts.

Message::ref receiptReply = std::make_shared<Message>();

receiptReply->setFrom(senderJID);

receiptReply->setTo(ownJID);

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

// Two resources respond with message receipts.

Message::ref receiptReply = std::make_shared<Message>();

receiptReply->setFrom(senderJID);

receiptReply->setTo(ownJID);

uiEventStream_->send(std::make_shared<RequestChatUIEvent>(sender));

// The sender supports delivery receipts.

DiscoInfo::ref disco = std::make_shared<DiscoInfo>();

disco->addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

// Two resources respond with message receipts.

Message::ref reply = std::make_shared<Message>();

reply->setFrom(senderJID);

reply->setTo(ownJID);

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

// Two resources respond with message receipts.

Message::ref receiptReply = std::make_shared<Message>();

receiptReply->setFrom(senderJID);

receiptReply->setTo(ownJID);

#include <hippomocks.h>

#include <Swiften/Avatars/NullAvatarManager.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Client/NickResolver.h>

occupants.insert(occupant_map::value_type("Ernie", MUCOccupant("Ernie", MUCOccupant::Participant, MUCOccupant::Owner)));

/* populate the MUC with fake users */

muc_->insertOccupant(occupant.second);

}

alterations.push_back(MUCOccupant("Remko", MUCOccupant::NoRole, MUCOccupant::NoAffiliation));

alterations.push_back(MUCOccupant("Ernie", MUCOccupant::Visitor, MUCOccupant::Outcast));

/* perform an alteration to a user's role and affiliation */

occupant_map::iterator occupant = occupants.find(alteration.getNick());

CPPUNIT_ASSERT(occupant != occupants.end());

void testRoleAffiliationStatesVerify(const std::map<std::string, MUCOccupant> &occupants) {

/* verify that the roster is in sync */

GroupRosterItem* group = window_->getRosterModel()->getRoot();

GroupRosterItem* child = dynamic_cast<GroupRosterItem*>(rosterItem);

CPPUNIT_ASSERT(child);

ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(childItem);

CPPUNIT_ASSERT(item);

std::map<std::string, MUCOccupant>::const_iterator occupant = occupants.find(item->getJID().getResource());

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/String.h>

#include <Swiften/Disco/DiscoServiceWalker.h>

#include <Swiften/Disco/GetDiscoInfoRequest.h>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

void UserSearchController::handleDiscoServiceFound(const JID& jid, std::shared_ptr<DiscoInfo> info) {

//bool isUserDirectory = false;

bool supports55 = false;

if ((identity.getCategory() == "directory"

&& identity.getType() == "user")) {

//isUserDirectory = true;

if (resultsPayload->getForm()) {

window_->setResultsForm(resultsPayload->getForm());

} else {

JID jid(item.jid);

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

fields["first"] = item.first;

std::vector<Contact::ref>::iterator i = suggestions.begin();

while (i != suggestions.end()) {

bool found = false;

if ((*i)->jid == jid) {

found = true;

break;

void UserSearchController::handleJIDUpdateRequested(const std::vector<JID>& jids) {

if (window_) {

std::vector<Contact::ref> updates;

updates.push_back(convertJIDtoContact(jid));

}

window_->updateContacts(updates);

void UserSearchController::handleJIDAddRequested(const std::vector<JID>& jids) {

std::vector<Contact::ref> contacts;

contacts.push_back(convertJIDtoContact(jid));

}

window_->addContacts(contacts);

void UserSearchController::loadSavedDirectories() {

savedDirectories_.clear();

if(!stringItem.empty()) {

savedDirectories_.push_back(JID(stringItem));

}

std::string collapsed;

int i = 0;

if (i >= 15) {

break;

}

#include <Swift/Controllers/ChatMessageSummarizer.h>

#include <Swiften/Base/format.h>

#include <Swift/Controllers/Intl.h>

vector<UnreadPair> others;

int currentUnread = 0;

int otherCount = 0;

if (unread.first == current) {

currentUnread += unread.second;

} else {

#include <boost/lambda/lambda.hpp>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/ContactProvider.h>

std::vector<Contact::ref> ContactSuggester::getSuggestions(const std::string& search, bool withMUCNicks) const {

std::vector<Contact::ref> results;

append(results, provider->getContacts(withMUCNicks));

}

#include <Swift/Controllers/ContactsFromXMPPRoster.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Roster/XMPPRosterItem.h>

std::vector<Contact::ref> ContactsFromXMPPRoster::getContacts(bool /*withMUCNicks*/) {

std::vector<Contact::ref> results;

std::vector<XMPPRosterItem> rosterItems = roster_->getItems();

Contact::ref contact = std::make_shared<Contact>(rosterItem.getName().empty() ? rosterItem.getJID().toString() : rosterItem.getName(), rosterItem.getJID(), StatusShow::None,"");

contact->statusType = presenceOracle_->getAccountPresence(contact->jid) ? presenceOracle_->getAccountPresence(contact->jid)->getShow() : StatusShow::None;

contact->avatarPath = avatarManager_->getAvatarPath(contact->jid);

#include <boost/signals2.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/FileTransfer/FileTransferManager.h>

namespace Swift {

FileTransferOverview::~FileTransferOverview() {

onNewFileTransferController.disconnect(boost::bind(&FileTransferOverview::handleNewFileTransferController, this, _1));

fileTransferManager->onIncomingFileTransfer.disconnect(boost::bind(&FileTransferOverview::handleIncomingFileTransfer, this, _1));

controller->onStateChanged.disconnect(boost::bind(&FileTransferOverview::handleFileTransferStateChanged, this));

}

}

bool FileTransferOverview::isClearable() const {

bool isClearable = false;

if(controller->getState().type == FileTransfer::State::Finished

|| controller->getState().type == FileTransfer::State::Failed

|| controller->getState().type == FileTransfer::State::Canceled) {

#include <boost/regex.hpp>

#include <boost/serialization/vector.hpp>

#include <Swift/Controllers/Highlighter.h>

#include <Swift/Controllers/SettingConstants.h>

#include <Swift/Controllers/Settings/SettingsProvider.h>

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/lambda/lambda.hpp>

#include <Swiften/Base/Regex.h>

namespace Swift {

void HighlightRule::updateRegex() const

{

keywordRegex_.clear();

keywordRegex_.push_back(regexFromString(k));

}

senderRegex_.clear();

senderRegex_.push_back(regexFromString(s));

}

}

// check if a keyword matches

if (!matchesKeyword && !keywords_.empty()) {

if (boost::regex_search(body, keyword)) {

matchesKeyword = true;

break;

}

}

if (boost::regex_search(sender, rx)) {

matchesSender = true;

break;

#include <Swift/Controllers/Highlighter.h>

#include <Swift/Controllers/HighlightManager.h>

namespace Swift {

#include <Swift/Controllers/HistoryViewController.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/Path.h>

#include <Swiften/Client/NickResolver.h>

#include <Swiften/History/HistoryMessage.h>

historyWindow_->setDate(currentResultDate_);

addNewMessage(message, false);

}

}

std::vector<HistoryMessage> messages = historyController_->getMessagesFromPreviousDate(selfJID_, selectedItem_->getJID(), selectedItemType_, date);

addNewMessage(message, true);

}

historyWindow_->resetConversationViewTopInsertPoint();

std::vector<HistoryMessage> messages = historyController_->getMessagesFromNextDate(selfJID_, selectedItem_->getJID(), selectedItemType_, date);

addNewMessage(message, false);

}

}

std::vector<HistoryMessage> messages = historyController_->getMessagesFromDate(selfJID_, selectedItem_->getJID(), selectedItemType_, currentResultDate_);

historyWindow_->setDate(currentResultDate_);

addNewMessage(message, false);

}

}

std::vector<HistoryMessage> messages = historyController_->getMessagesFromDate(selfJID_, selectedItem_->getJID(), selectedItemType_, currentResultDate_);

historyWindow_->setDate(currentResultDate_);

addNewMessage(message, false);

}

}

newDate = date;

}

else if (date < currentResultDate_) {

if (current > date) {

newDate = current;

break;

}

}

else {

if (current < date) {

newDate = current;

break;

std::vector<HistoryMessage> messages = historyController_->getMessagesFromDate(selfJID_, selectedItem_->getJID(), selectedItemType_, currentResultDate_);

historyWindow_->setDate(currentResultDate_);

addNewMessage(message, false);

}

}

return presence;

}

if (presence.get() && presence->getFrom() == jid) {

return presence;

}

#include <Swift/Controllers/PreviousStatusStore.h>

namespace Swift {

PreviousStatusStore::PreviousStatusStore() {

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

std::vector<TypeStringPair> suggestions;

if (status.second == message) {

suggestions.clear();

suggestions.push_back(status);

namespace Swift {

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

class PreviousStatusStore {

public:

PreviousStatusStore();

#include <Swift/Controllers/ProfileSettingsProvider.h>

namespace Swift {

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

profile_(profile) {

provider_ = provider;

bool found = false;

if (existingProfile == profile) {

found = true;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

namespace Swift {

class ProfileSettingsProvider {

public:

ProfileSettingsProvider(const std::string& profile, SettingsProvider* provider);

private:

std::string profileSettingPath(const std::string &settingPath);

SettingsProvider* provider_;

std::string profile_;

};

#include <boost/date_time/posix_time/posix_time.hpp>

#include <Swiften/Base/DateTime.h>

#include <Swiften/Elements/Idle.h>

#include <Swiften/Elements/Presence.h>

#include <boost/bind.hpp>

#include <Swiften/Base/String.h>

#include <Swift/Controllers/Roster/GroupRosterItem.h>

#include <Swift/Controllers/SettingConstants.h>

void RosterGroupExpandinessPersister::save() {

std::string setting;

if (!setting.empty()) {

setting += "\n";

}

#include <boost/cast.hpp>

#include <boost/numeric/conversion/cast.hpp>

#include <Swiften/Network/Timer.h>

#include <Swiften/Network/TimerFactory.h>

// Get a model for the new roster

std::vector<Section> newSections;

if (model) {

if (GroupRosterItem* groupItem = boost::polymorphic_downcast<GroupRosterItem*>(item)) {

//std::cerr << "* " << groupItem->getDisplayName() << std::endl;

Section section(groupItem->getDisplayName());

if (ContactRosterItem* contact = boost::polymorphic_downcast<ContactRosterItem*>(groupChildItem)) {

//std::cerr << " - " << contact->getDisplayJID() << std::endl;

section.items.push_back(Item(contact->getDisplayName(), contact->getStatusText(), contact->getDisplayJID(), contact->getStatusShow(), contact->getAvatarPath()));

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/Settings/SettingsProviderHierachy.h>

#include <Swiften/Base/Log.h>

namespace Swift {

SettingsProviderHierachy::~SettingsProviderHierachy() {

}

bool SettingsProviderHierachy::hasSetting(const std::string& key) {

if (provider->hasSetting(key)) {

return true;

}

std::string SettingsProviderHierachy::getSetting(const Setting<std::string>& setting) {

std::string value = setting.getDefaultValue();

std::string providerSetting = provider->getSetting(setting);

if (provider->hasSetting(setting.getKey())) {

value = providerSetting;

bool SettingsProviderHierachy::getSetting(const Setting<bool>& setting) {

bool value = setting.getDefaultValue();

bool providerSetting = provider->getSetting(setting);

if (provider->hasSetting(setting.getKey())) {

value = providerSetting;

int SettingsProviderHierachy::getSetting(const Setting<int>& setting) {

int value = setting.getDefaultValue();

int providerSetting = provider->getSetting(setting);

if (provider->hasSetting(setting.getKey())) {

value = providerSetting;

bool SettingsProviderHierachy::getIsSettingFinal(const std::string& settingPath) {

bool isFinal = false;

isFinal |= provider->getIsSettingFinal(settingPath);

}

return isFinal;

#include <boost/bind.hpp>

#include <boost/date_time/posix_time/posix_time.hpp>

#include <Swiften/VCards/VCardManager.h>

#include <Swift/Controllers/UIEvents/ShowProfileForRosterItemUIEvent.h>

}

ShowProfileController::~ShowProfileController() {

jidWndPair.second->onWindowAboutToBeClosed.disconnect(boost::bind(&ShowProfileController::handleProfileWindowAboutToBeClosed, this, _1));

delete jidWndPair.second;

}

#include <boost/filesystem/fstream.hpp>

#include <Swiften/Base/String.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/StringCodecs/Hexify.h>

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/Storages/CertificateMemoryStorage.h>

using namespace Swift;

CertificateMemoryStorage::CertificateMemoryStorage() {

}

bool CertificateMemoryStorage::hasCertificate(Certificate::ref certificate) const {

if (storedCert->toDER() == certificate->toDER()) {

return true;

}

#include <Swiften/Base/Path.h>

#include <Swiften/Base/String.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/Entity/GenericPayloadPersister.h>

#include <boost/filesystem/path.hpp>

#include <boost/signals2.hpp>

#include <Swiften/Elements/StatusShow.h>

#include <Swiften/MUC/MUCBookmark.h>

if (impromptuJIDs.empty()) {

return jid.toBare() == other.jid.toBare()

&& isMUC == other.isMUC;

bool found = false;

if (jid.second.toBare() == otherJID.second.toBare()) {

found = true;

break;

avatarPath = path;

}

std::string getImpromptuTitle() const {

std::string title;

if (title.empty()) {

title += pair.first;

} else {

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swift/Controllers/ContactSuggester.h>

using namespace Swift;

std::vector<Contact::ref> contacts;

std::vector<std::string> words = wordList();

std::vector<StatusShow::Type> statuses = statusList();

contacts.push_back(std::make_shared<Contact>(name, jid, status, ""));

}

}

/* a = a */

bool isReflexive(const boost::function<bool (const Contact::ref&, const Contact::ref&)>& comparitor) {

std::vector<Contact::ref> contacts = contactList();

if (!comparitor(a, a)) {

return false;

}

/* a = b -> b = a */

bool isSymmetric(const boost::function<bool (const Contact::ref&, const Contact::ref&)>& comparitor) {

std::vector<Contact::ref> contacts = contactList();

if (comparitor(a, b)) {

if (!comparitor(b, a)) {

return false;

/* a = b && b = c -> a = c */

bool isTransitive(const boost::function<bool (const Contact::ref&, const Contact::ref&)>& comparitor) {

std::vector<Contact::ref> contacts = contactList();

if (comparitor(a, b) && comparitor(b, c)) {

if (!comparitor(a, c)) {

return false;

void sortTest() {

std::vector<std::string> words = wordList();

CPPUNIT_ASSERT(isTransitive(boost::bind(Contact::sortPredicate, _1, _2, word)));

}

}

#include <boost/bind.hpp>

#include <Swiften/Client/NickResolver.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Whiteboard/WhiteboardSessionManager.h>

#include <Swift/Controllers/UIEvents/ShowWhiteboardUIEvent.h>

namespace Swift {

WhiteboardManager::WhiteboardManager(WhiteboardWindowFactory* whiteboardWindowFactory, UIEventStream* uiEventStream, NickResolver* nickResolver, WhiteboardSessionManager* whiteboardSessionManager) : whiteboardWindowFactory_(whiteboardWindowFactory), uiEventStream_(uiEventStream), nickResolver_(nickResolver), whiteboardSessionManager_(whiteboardSessionManager) {

#ifdef SWIFT_EXPERIMENTAL_WB

}

WhiteboardManager::~WhiteboardManager() {

delete whiteboardWindowPair.second;

}

}

#include <boost/bind.hpp>

#include <boost/numeric/conversion/cast.hpp>

#include <Swift/Controllers/XMPPEvents/ErrorEvent.h>

#include <Swift/Controllers/XMPPEvents/IncomingFileTransferEvent.h>

#include <Swift/Controllers/XMPPEvents/MUCInviteEvent.h>

}

EventController::~EventController() {

event->onConclusion.disconnect(boost::bind(&EventController::handleEventConcluded, this, event));

}

}

/* If it's a duplicate subscription request, remove the previous request first */

if (subscriptionEvent) {

EventList existingEvents(events_);

std::shared_ptr<SubscriptionRequestEvent> existingSubscriptionEvent = std::dynamic_pointer_cast<SubscriptionRequestEvent>(existingEvent);

if (existingSubscriptionEvent) {

if (existingSubscriptionEvent->getJID() == subscriptionEvent->getJID()) {

#include <QList>

#include <Swift/QtUI/ChatList/ChatListItem.h>

namespace Swift {

int row(ChatListItem* item) {return items_.indexOf(item);}

QVariant data(int role) const {return (role == Qt::DisplayRole) ? name_ : QVariant();}

void clear() {

delete item;

}

items_.clear();

}

private:

static bool pointerItemLessThan(const ChatListItem* first, const ChatListItem* second) {

QString myName = first->data(Qt::DisplayRole).toString().toLower();

recents_->clear();

endRemoveRows();

beginInsertRows(recentsIndex_, 0, recents.size());

recents_->addItem(new ChatListRecentItem(chat, recents_));

//whiteboards_->addItem(new ChatListRecentItem(chat, whiteboards_));

}

}

dataStream << P2QSTRING(chat.jid.toString());

} else {

dataStream << P2QSTRING(jid.second.toString());

}

}

ChatListItem* baseItem = index.isValid() ? static_cast<ChatListItem*>(index.internalPointer()) : nullptr;

contextMenuItem_ = baseItem;

action->setEnabled(isOnline_);

}

ChatSnippet::Direction ChatSnippet::getDirection(const ChatWindow::ChatMessage& message) {

std::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;

std::string text = "";

if ((textPart = std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(part))) {

text = textPart->text;

break;

#include <QDateTime>

#include <QString>

#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

#include <Swift/QtUI/QtChatTheme.h>

#include "CocoaUIHelpers.h"

#include <memory>

#include <boost/type_traits.hpp>

#include <Cocoa/Cocoa.h>

#include <Security/Security.h>

#include <SecurityInterface/SFCertificatePanel.h>

#pragma GCC diagnostic ignored "-Wold-style-cast"

namespace Swift {

void CocoaUIHelpers::displayCertificateChainAsSheet(QWidget* parent, const std::vector<Certificate::ref>& chain) {

NSWindow* parentWindow = [((NSView*)parent->winId()) window];

NSMutableArray* certificates = [[NSMutableArray alloc] init];

// convert chain to SecCertificateRef

ByteArray certAsDER = cert->toDER();

std::shared_ptr<boost::remove_pointer<CFDataRef>::type> certData(CFDataCreate(nullptr, certAsDER.data(), certAsDER.size()), CFRelease);

[certificates addObject: (id)macCert.get()];

}

SFCertificatePanel* panel = [[SFCertificatePanel alloc] init];

//[panel setPolicies:(id)policies.get()];

[panel beginSheetForWindow:parentWindow modalDelegate:nil didEndSelector:nullptr contextInfo:nullptr certificates:certificates showGroup:YES];

}

EventModel::~EventModel() {

delete event;

}

delete event;

}

}

void QtAdHocCommandWindow::handleNextStageReceived(Command::ref command) {

QString notes;

if (!notes.isEmpty()) {

notes += "\n";

}

void QtAdHocCommandWindow::setAvailableActions(Command::ref /*commandResult*/) {

okButton_->show();

okButton_->setEnabled(true);

OutgoingAdHocCommandSession::ActionState state = command_->getActionState(pair.first);

if (state & OutgoingAdHocCommandSession::Present) {

okButton_->hide();

void QtAffiliationEditor::handleCurrentIndexChanged(int index) {

ui_.list->clear();

ui_.list->addItem(P2QSTRING(jid.toString()));

}

}

#include <QStyledItemDelegate>

#include <QValidator>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/JID/JID.h>

void QtBlockListEditorWindow::setCurrentBlockList(const std::vector<JID> &blockedJIDs) {

ui->blockListTreeWidget->clear();

QTreeWidgetItem* item = new QTreeWidgetItem(QStringList(P2QSTRING(jid.toString())) << "");

item->setFlags(item->flags() | Qt::ItemIsEditable);

ui->blockListTreeWidget->addTopLevelItem(item);

#include <QStringList>

#include <QTreeWidgetItem>

#include <Swift/QtUI/ui_QtCertificateViewerDialog.h>

namespace Swift {

// convert Swift certificate chain to qt certificate chain (root goes first)

currentChain.clear();

ByteArray certAsDer = cert->toDER();

QByteArray dataArray(reinterpret_cast<const char*>(certAsDer.data()), certAsDer.size());

currentChain.push_front(QSslCertificate(dataArray, QSsl::Der));

#endif

if (!altNames.empty()) {

ADD_SECTION(tr("Alternate Subject Names"));

if (type == QSsl::EmailEntry) {

ADD_FIELD(tr("E-mail Address"), name);

} else {

}

QtChatTabs::~QtChatTabs() {

delete shortcut;

}

#include <QShortcut>

#include <Swiften/Base/Log.h>

#include <Swift/QtUI/QtTabbable.h>

QList<QWidget*> windows = qApp->topLevelWidgets();

QList<QtTabbable*> tabbables;

QtTabbable* tabbable = dynamic_cast<QtTabbable*>(topLevelWidget);

if (tabbable) {

tabbables << tabbable;

int i = 0;

int defaultIndex = 0;

labelsWidget_->setModel(labelModel_);

if (label.getIsDefault()) {

defaultIndex = i;

break;

}

else {

if (impromptu_) {

// hide options we don't need in impromptu chats

if (availableAction == ChatWindow::ChangeSubject ||

groupsArea->setWidget(groups);

QVBoxLayout* scrollLayout = new QVBoxLayout(groups);

QString groupName = doubleAmpersand(group);

QCheckBox* check = new QCheckBox(groups);

check->setText(groupName);

std::string QtContactEditWidget::getName() const {

std::string name = Q2PSTRING(name_->text());

QList<QRadioButton*> buttons = findChildren<QRadioButton*>();

if (button->isChecked()) {

if (button == nameRadioButton_) {

name = Q2PSTRING(name_->text());

}

void QtContactEditWidget::setSelectedGroups(const std::vector<std::string>& groups) {

checkBoxes_[group]->setCheckState(Qt::Checked);

}

}

std::set<std::string> QtContactEditWidget::getSelectedGroups() const {

std::set<std::string> groups;

if (group.second->checkState() == Qt::Checked) {

groups.insert(group.first);

}

}

// populate new suggestions

suggestionsLayout_->insertWidget(nameLayout_->count() - 2, new QRadioButton(doubleAmpersand(name), this));

}

QRadioButton* suggestedRadioButton = nullptr;

QList<QRadioButton*> radioButtons = findChildren<QRadioButton*>();

if (candidate->text() == name_->text()) {

suggestedRadioButton = candidate;

break;

private:

QString doubleAmpersand(const std::string& name) const;

std::string singleAmpersand(const QString& name) const;

private:

QHBoxLayout* nameLayout_;

QHBoxLayout* suggestionsLayout_;

QRadioButton* nameRadioButton_;

#include <set>

#include <Swift/QtUI/QtSwiftUtil.h>

namespace Swift {

QtEmoticonsGrid::QtEmoticonsGrid(const std::map<std::string, std::string>& emoticons, QWidget* parent) : QGridLayout(parent) {

makeUniqueEmoticonsMap(emoticons);

int row = 0;

int column = 0;

QtEmoticonCell* newCell = new QtEmoticonCell(P2QSTRING(emoticon.first), P2QSTRING(emoticon.second));

addWidget(newCell, row, column);

connect(newCell, SIGNAL(emoticonClicked(QString)), this, SLOT(emoticonClickedSlot(QString)));

void QtEmoticonsGrid::makeUniqueEmoticonsMap(const std::map<std::string, std::string>& emoticons) {

std::set<std::string> paths;

if (paths.find(emoticon.second) == paths.end()) {

uniqueEmoticons_.insert(emoticon);

paths.insert(emoticon.second);

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

#include <Swift/QtUI/QtSwiftUtil.h>

namespace Swift {

// determine field name

std::string name = formResult_->getReportedFields().at(column)->getName();

if (field->getName() == name) {

std::string delimiter = "";

if (field->getType() == FormField::TextMultiType) {

#include <qdebug.h>

#include <Swift/QtUI/QtSwiftUtil.h>

namespace Swift {

QGridLayout* layout = new QGridLayout(scroll);

const std::vector<Form::FormItem> items = form->getItems();

if (items.empty()) { /* single item forms */

QWidget* widget = createWidget(field, field->getType(), 0);

if (widget) {

layout->addWidget(new QLabel(field->getLabel().c_str(), this), row, 0);

std::vector<bool> selected;

/* if this is an editable form, use the 'options' list, otherwise use the 'values' list */

if (form_->getType() != Form::FormType) {

listWidget->addItem(P2QSTRING(value));

selected.push_back(false);

}

} else {

listWidget->addItem(option.label.c_str());

if (field->getType() == FormField::ListSingleType) {

selected.push_back(!field->getValues().empty() && option.value == field->getValues()[0]);

Form::ref QtFormWidget::getCompletedForm() {

Form::ref result(new Form(Form::SubmitType));

std::shared_ptr<FormField> resultField = std::make_shared<FormField>(field->getType());

if (field->getType() == FormField::BooleanType) {

resultField->setBoolValue(qobject_cast<QCheckBox*>(fields_[field->getName()])->checkState() == Qt::Checked);

QString string = widget->toPlainText();

if (!string.isEmpty()) {

QStringList lines = string.split("\n");

resultField->addValue(Q2PSTRING(line));

}

}

}

if (field->getType() == FormField::ListMultiType) {

QListWidget* listWidget = qobject_cast<QListWidget*>(fields_[field->getName()]);

resultField->addValue(field->getOptions()[listWidget->row(item)].value);

}

}

if (!form_) {

return;

}

QWidget* widget = nullptr;

if (field) {

widget = fields_[field->getName()];

}

QDate currentDate;

int snippetPosition = conversation_->getSnippetPositionByDate(date);

if (snippetPosition <= pos) {

currentDate = date;

setInitialMenus();

std::vector<QMenu*> mainWindowMenus = qtMainWindow->getMenus();

viewMenu_ = mainWindowMenus[0];

menuBar_->addMenu(menu);

}

setFocus();

#include <QVBoxLayout>

#include <Swiften/Base/FileSize.h>

#include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>

#include <Swift/Controllers/UIEvents/UIEventStream.h>

QString chatMessageToString(const ChatWindow::ChatMessage& message) {

QString result;

std::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;

std::shared_ptr<ChatWindow::ChatURIMessagePart> uriPart;

std::shared_ptr<ChatWindow::ChatEmoticonMessagePart> emoticonPart;

// Force recaluclation of all layout geometry in children widgets.

// This is required on Windows to have the correct size even on first show.

QList<QWidget *> children = findChildren<QWidget*>();

child->updateGeometry();

}

std::vector<std::string> QtSettingsProvider::getAvailableProfiles() {

std::vector<std::string> profiles;

QVariant profilesVariant = settings_.value("profileList");

profiles.push_back(std::string(profileQString.toUtf8()));

}

return profiles;

void QtSettingsProvider::removeProfile(const std::string& profile) {

QString profileStart(QString(profile.c_str()) + ":");

if (key.startsWith(profileStart)) {

settings_.remove(key);

}

#include <Swift/QtUI/QtSingleWindow.h>

#include <Swift/QtUI/QtChatTabs.h>

#include <Swift/QtUI/QtSettingsProvider.h>

void QtSingleWindow::handleSplitterMoved(int, int) {

QList<QVariant> variantValues;

QList<int> intValues = sizes();

variantValues.append(QVariant(value));

}

settings_->getQSettings()->setValue(SINGLE_WINDOW_SPLITS, QVariant(variantValues));

void QtSingleWindow::restoreSplitters() {

QList<QVariant> variantValues = settings_->getQSettings()->value(SINGLE_WINDOW_SPLITS).toList();

QList<int> intValues;

intValues.append(value.toInt());

}

setSizes(intValues);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

spellingErrorFormat.setUnderlineColor(QColor(Qt::red));

spellingErrorFormat.setUnderlineStyle(QTextCharFormat::SpellCheckUnderline);

setFormat(boost::get<0>(position), boost::get<1>(position) - boost::get<0>(position), spellingErrorFormat);

};

}

QString text = statusEdit_->text();

newStatusText_ = text;

menu_->clear();

QListWidgetItem* item = new QListWidgetItem(text == "" ? getNoMessage() : text, menu_);

item->setIcon(icons_[type]);

item->setToolTip(P2QSTRING(statusShowTypeToFriendlyName(type)) + ": " + item->text());

item->setData(Qt::UserRole, QVariant(type));

}

std::vector<StatusCache::PreviousStatus> previousStatuses = statusCache_->getMatches(Q2PSTRING(text), 8);

if (savedStatus.first.empty() || std::find_if(allTypes_.begin(), allTypes_.end(),

savedStatus.second == lambda::_1 && savedStatus.first == lambda::bind(&statusShowTypeToFriendlyName, lambda::_1)) != allTypes_.end()) {

continue;

item->setStatusTip(item->toolTip());

item->setData(Qt::UserRole, QVariant(savedStatus.second));

}

if (Q2PSTRING(text) == statusShowTypeToFriendlyName(type)) {

continue;

}

if (x + width > screenWidth) {

x = screenWidth - width;

}

// if (statusEdit_->text() == P2QSTRING(statusShowTypeToFriendlyName(type))) {

statusEdit_->setText("");

// }

}

QtSubscriptionRequestWindow* QtSubscriptionRequestWindow::getWindow(std::shared_ptr<SubscriptionRequestEvent> event, QWidget* parent) {

if (window->getEvent() == event) {

return window;

}

#include <QShortcut>

#include <Swiften/Base/Platform.h>

#include <Swift/QtUI/QtChatTabs.h>

#include <Swift/QtUI/QtUtilities.h>

void QtTagComboBox::setTag(const QString &id, bool value) {

QList<QAction*> tagActions = editMenu->actions();

if (action->data() == id) {

action->setChecked(value);

updateDisplayItem();

bool QtTagComboBox::isTagSet(const QString &id) const {

QList<QAction*> tagActions = editMenu->actions();

if (action->data() == id) {

return action->isChecked();

}

void QtTagComboBox::updateDisplayItem() {

QList<QAction*> tagActions = editMenu->actions();

QString text = "";

if (action->isChecked()) {

if (text != "") {

text += ", ";

}

void QtVCardAddressField::customCleanup() {

widget->hide();

textFieldGridLayout->removeWidget(widget);

}

domesticRadioButton->setVisible(isEditable);

internationalRadioButton->setVisible(isEditable);

QtResizableLineEdit* lineEdit;

if ((lineEdit = dynamic_cast<QtResizableLineEdit*>(widget))) {

lineEdit->setVisible(isEditable ? true : !lineEdit->text().isEmpty());

void QtVCardGeneralField::handleCloseButtonClicked() {

customCleanup();

widget->hide();

layout->removeWidget(widget);

}

void QtVCardOrganizationField::setOrganization(const VCard::Organization& organization) {

organizationLineEdit->setText(P2QSTRING(organization.name));

unitsTreeWidget->clear();

QTreeWidgetItem* item = new QTreeWidgetItem(QStringList(P2QSTRING(unit)) << "");

item->setFlags(item->flags() | Qt::ItemIsEditable);

unitsTreeWidget->addTopLevelItem(item);

void QtVCardOrganizationField::guaranteeEmptyRow() {

bool hasEmptyRow = false;

QList<QTreeWidgetItem*> rows = unitsTreeWidget->findItems("", Qt::MatchFixedString);

if (row->text(0).isEmpty()) {

hasEmptyRow = true;

}

QString QtWebKitChatView::chatMessageToHTML(const ChatWindow::ChatMessage& message) {

QString result;

std::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;

std::shared_ptr<ChatWindow::ChatURIMessagePart> uriPart;

std::shared_ptr<ChatWindow::ChatEmoticonMessagePart> emoticonPart;

void QtFilterWidget::popAllFilters() {

std::vector<RosterFilter*> filters = treeView_->getRoster()->getFilters();

filters_.push_back(filter);

treeView_->getRoster()->removeFilter(filter);

}

void QtFilterWidget::pushAllFilters() {

treeView_->getRoster()->onFilterAdded.disconnect(boost::bind(&QtFilterWidget::handleFilterAdded, this, _1));

treeView_->getRoster()->onFilterRemoved.disconnect(boost::bind(&QtFilterWidget::handleFilterRemoved, this, _1));

treeView_->getRoster()->addFilter(filter);

}

filters_.clear();

}

else {

std::map<QAction*, ChatWindow::OccupantAction> actions;

QString text = "Error: missing string";

switch (availableAction) {

case ChatWindow::Kick: text = tr("Kick user"); break;

if (!roster_) {

return;

}

GroupRosterItem* child = dynamic_cast<GroupRosterItem*>(item);

if (!child) continue;

emit itemExpanded(index(child), child->isExpanded());

// star | name | content

QString currentBlock;

QString type = tel.isFax ? QObject::tr("Fax") : QObject::tr("Telephone");

QString field = buildVCardField(tel.isPreferred, type, htmlEscape(P2QSTRING(tel.number)));

if (tel.isPreferred) {

summary += currentBlock;

currentBlock = "";

QString field = buildVCardField(mail.isPreferred, QObject::tr("E-Mail"), htmlEscape(P2QSTRING(mail.address)));

if (mail.isPreferred) {

currentBlock = field;

summary += currentBlock;

currentBlock = "";

QString field = buildVCardField(false, QObject::tr("Organization"), htmlEscape(P2QSTRING(org.name)));

currentBlock += field;

}

summary += currentBlock;

currentBlock = "";

QString field = buildVCardField(false, QObject::tr("Title"), htmlEscape(P2QSTRING(title)));

currentBlock += field;

}

#include <QMimeData>

#include <Swiften/Base/Path.h>

#include <Swiften/Elements/StatusShow.h>

#include <Swift/QtUI/QtResourceHelper.h>

void QtContactListWidget::updateContacts(const std::vector<Contact::ref>& contactUpdates) {

std::vector<Contact::ref> contacts = contactListModel_->getList();

if (contactUpdate->jid == contact->jid) {

contact = contactUpdate;

break;

#include <memory>

namespace Swift {

void WinUIHelpers::displayCertificateChainAsSheet(QWidget* parent, const std::vector<Certificate::ref>& chain) {

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Chat/ChatStateNotifier.h>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Disco/DummyEntityCapsProvider.h>

int getComposingCount() const {

int result = 0;

if (stanza->getPayload<ChatState>() && stanza->getPayload<ChatState>()->getChatState() == ChatState::Composing) {

result++;

}

int getActiveCount() const {

int result = 0;

if (stanza->getPayload<ChatState>() && stanza->getPayload<ChatState>()->getChatState() == ChatState::Active) {

result++;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <algorithm>

using namespace Swift;

BlockListImpl::BlockListImpl() : state(Init) {

void BlockListImpl::setItems(const std::vector<JID>& newItems) {

// JIDs which are in the current list but not in the new list, are removed.

if (std::find(newItems.begin(), newItems.end(), jid) == newItems.end()) {

onItemRemoved(jid);

}

}

// JIDs which are in the new list but not in the current list, are added.

if (std::find(items.begin(), items.end(), jid) == items.end()) {

onItemAdded(jid);

}

}

void BlockListImpl::addItems(const std::vector<JID>& items) {

addItem(item);

}

}

void BlockListImpl::removeItems(const std::vector<JID>& items) {

std::vector<JID> itemsToRemove = items;

removeItem(item);

}

}

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Client/ClientSession.h>

#include <Swiften/Client/ClientSessionStanzaChannel.h>

#include <Swiften/Network/ChainedConnector.h>

void CoreClient::resetConnector() {

connector_->onConnectFinished.disconnect(boost::bind(&CoreClient::handleConnectorFinished, this, _1, _2));

connector_.reset();

delete f;

}

proxyConnectionFactories.clear();

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Client/StanzaChannel.h>

// build IQ response

std::shared_ptr<BlockListPayload> responsePayload = std::make_shared<BlockListPayload>();

responsePayload->addItem(jid);

}

#include <stack>

#include <Swiften/Base/Log.h>

#include <Swiften/Parser/PlatformXMLParserFactory.h>

namespace Swift {

buffer << "\"" << (doColoring ? styleNamespace(ns) : ns) << "\"";

}

if (!attributes.getEntries().empty()) {

buffer << " ";

buffer << (doColoring ? styleAttribute(entry.getAttribute().getName()) : entry.getAttribute().getName());

buffer << "=";

#include <algorithm>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/FormField.h>

std::vector<DiscoInfo::Identity> identities(discoInfo.getIdentities());

std::sort(identities.begin(), identities.end());

serializedCaps += identity.getCategory() + "/" + identity.getType() + "/" + identity.getLanguage() + "/" + identity.getName() + "<";

}

std::vector<std::string> features(discoInfo.getFeatures());

std::sort(features.begin(), features.end());

serializedCaps += feature + "<";

}

serializedCaps += extension->getFormType() + "<";

std::vector<FormField::ref> fields(extension->getFields());

std::sort(fields.begin(), fields.end(), &compareFields);

if (field->getName() == "FORM_TYPE") {

continue;

}

serializedCaps += field->getName() + "<";

std::vector<std::string> values(field->getValues());

std::sort(values.begin(), values.end());

serializedCaps += value + "<";

}

}

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

namespace Swift {

void DiscoServiceWalker::endWalk() {

if (active_) {

SWIFT_LOG(debug) << "Ending walk to " << service_ << std::endl;

request->onResponse.disconnect(boost::bind(&DiscoServiceWalker::handleDiscoInfoResponse, this, _1, _2, request));

}

request->onResponse.disconnect(boost::bind(&DiscoServiceWalker::handleDiscoItemsResponse, this, _1, _2, request));

}

active_ = false;

}

bool couldContainServices = false;

if (identity.getCategory() == "server") {

couldContainServices = true;

}

handleDiscoError(request->getReceiver(), error);

return;

}

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

/* Don't look at noded items. It's possible that this will exclude some services,

* but I've never seen one in the wild, and it's an easy fix for not looping.

#include <Swiften/Elements/Form.h>

namespace Swift {

std::string Form::getFormType() const {

}

FormField::ref Form::getField(const std::string& name) const {

if (field->getName() == name) {

return field;

}

void Form::clearEmptyTextFields() {

std::vector<FormField::ref> populatedFields;

if (field->getType() == FormField::TextSingleType) {

if (!field->getTextSingleValue().empty()) {

populatedFields.push_back(field);

#include <Swiften/Elements/RosterItemExchangePayload.h>

namespace Swift {

RosterItemExchangePayload::Item::Item(Action action) : action(action) {

#include <Swiften/Elements/RosterPayload.h>

namespace Swift {

boost::optional<RosterItemPayload> RosterPayload::getItem(const JID& jid) const {

// FIXME: MSVC rejects this. Find out why.

//if (item.getJID() == jid) {

if (item.getJID().equals(jid, JID::WithResource)) {

#include <boost/bind.hpp>

#include <Swiften/Elements/Delay.h>

namespace Swift {

}

void Stanza::updatePayload(std::shared_ptr<Payload> payload) {

if (typeid(*i.get()) == typeid(*payload.get())) {

i = payload;

return;

}

std::shared_ptr<Payload> Stanza::getPayloadOfSameType(std::shared_ptr<Payload> payload) const {

if (typeid(*i.get()) == typeid(*payload.get())) {

return i;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Elements/VCard.h>

namespace Swift {

VCard::EMailAddress VCard::getPreferredEMailAddress() const {

if (address.isPreferred) {

return address;

}

#include <boost/optional.hpp>

#include <Swiften/Base/Log.h>

namespace lambda = boost::lambda;

callEventPosted = !events_.empty();

}

if (!nextEvents.empty()) {

invokeCallback(event);

}

}

#include <boost/bind.hpp>

namespace Swift {

SimpleEventLoop::SimpleEventLoop() : isRunning_(true), eventAvailable_(false) {

#include <boost/bind.hpp>

namespace Swift {

SingleThreadedEventLoop::SingleThreadedEventLoop()

eventAvailableCondition_.wait(lock);

}

throw EventLoopCanceledException();

}

void SingleThreadedEventLoop::handleEvents() {

#include <boost/optional.hpp>

#include <Swiften/Client/Client.h>

#include <Swiften/Client/ClientXMLTracer.h>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

int roomCount = 0;

cout << "List of rooms at " << mucJID.toString() << endl;

roomCount++;

cout << "\t" << roomCount << ". " << item.getJID().getNode() << " - " << item.getName() << std::endl;

if (roomCount == 1) {

#include <boost/filesystem.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Client/Client.h>

#include <Swiften/Client/ClientXMLTracer.h>

#include <Swiften/Disco/ClientDiscoManager.h>

}

void stop() {

//transfer->stop();

}

client->disconnect();

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/FileTransfer/FailingTransportSession.h>

#include <Swiften/FileTransfer/FileTransferOptions.h>

s5bRegistry->setHasBytestream(getSOCKS5DstAddr(), false);

if (s5bServerManager->getServer()) {

std::vector<std::shared_ptr<SOCKS5BytestreamServerSession> > serverSessions = s5bServerManager->getServer()->getSessions(getSOCKS5DstAddr());

session->stop();

}

}

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Elements/JingleFileTransferDescription.h>

#include <Swiften/Elements/JingleFileTransferHash.h>

#include <Swiften/Elements/JingleIBBTransportPayload.h>

transport->setSessionID(s5bSessionID);

transport->setMode(JingleS5BTransportPayload::TCPMode);

transport->setDstAddr(dstAddr);

transport->addCandidate(candidate);

}

session->sendAccept(getContentID(), initialContent->getDescriptions()[0], transport);

if (receivedBytes == getFileSizeInBytes()) {

SWIFT_LOG(debug) << "All data received." << std::endl;

bool hashInfoAvailable = false;

hashInfoAvailable |= !hashElement.second.empty();

}

#include <boost/typeof/typeof.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/FileTransfer/FileTransferTransporter.h>

#include <Swiften/JID/JID.h>

void JingleFileTransfer::fillCandidateMap(CandidateMap& map, const std::vector<JingleS5BTransportPayload::Candidate>& candidates) {

map.clear();

map[candidate.cid] = candidate;

}

}

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Elements/JingleFileTransferDescription.h>

#include <Swiften/Elements/JingleFileTransferHash.h>

s5bTransport->setSessionID(s5bSessionID);

s5bTransport->setMode(JingleS5BTransportPayload::TCPMode);

s5bTransport->setDstAddr(dstAddr);

s5bTransport->addCandidate(candidate);

SWIFT_LOG(debug) << "\t" << "S5B candidate: " << candidate.hostPort.toString() << std::endl;

}

#include <boost/signals2.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

#include <Swiften/Network/ConnectionFactory.h>

void RemoteJingleTransportCandidateSelector::addCandidates(

const std::vector<JingleS5BTransportPayload::Candidate>& candidates) {

this->candidates.push(c);

}

}

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Elements/S5BProxyRequest.h>

#include <Swiften/Queries/GenericRequest.h>

#include <Swiften/Queries/IQRouter.h>

}

void SOCKS5BytestreamProxyFinder::stop() {

requester->onResponse.disconnect(boost::bind(&SOCKS5BytestreamProxyFinder::handleProxyResponse, this, requester, _1, _2));

}

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Base/Log.h>

namespace Swift {

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamServerSession.h>

void SOCKS5BytestreamServer::stop() {

connectionServer->onNewConnection.disconnect(boost::bind(&SOCKS5BytestreamServer::handleNewConnection, this, _1));

session->onFinished.disconnect(boost::bind(&SOCKS5BytestreamServer::handleSessionFinished, this, session));

session->stop();

}

std::vector< std::shared_ptr<SOCKS5BytestreamServerSession> > SOCKS5BytestreamServer::getSessions(

const std::string& streamID) const {

std::vector< std::shared_ptr<SOCKS5BytestreamServerSession> > result;

if (session->getStreamID() == streamID) {

result.push_back(session);

}

#include <Swiften/Jingle/JingleSession.h>

#include <algorithm>

#include <memory>

#include <boost/function.hpp>

using namespace Swift;

JingleSession::JingleSession(const JID& initiator, const std::string& id) : initiator(initiator), id(id) {

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Jingle/IncomingJingleSessionHandler.h>

#include <Swiften/Jingle/JingleResponder.h>

void JingleSessionManager::handleIncomingSession(const JID& initiator, const JID& recipient, JingleSessionImpl::ref session, const std::vector<JingleContentPayload::ref>& contents) {

sessions.insert(std::make_pair(JIDSession(initiator, session->getID()), session));

if (handler->handleIncomingJingleSession(session, contents, recipient)) {

return;

}

#include <unistd.h>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/LinkLocal/DNSSD/Bonjour/BonjourBrowseQuery.h>

#include <Swiften/LinkLocal/DNSSD/Bonjour/BonjourRegisterQuery.h>

#include <Swiften/LinkLocal/DNSSD/Bonjour/BonjourResolveHostnameQuery.h>

maxSocket = interruptSelectReadSocket;

FD_SET(interruptSelectReadSocket, &fdSet);

int socketID = query->getSocketID();

maxSocket = std::max(maxSocket, socketID);

FD_SET(socketID, &fdSet);

{

std::lock_guard<std::mutex> lock(runningQueriesMutex);

if (FD_ISSET(query->getSocketID(), &fdSet)) {

query->processResult();

}

#include <boost/bind.hpp>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/EventLoop/EventLoop.h>

#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDBrowseQuery.h>

#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h>

runningQueries.push_back(query);

allQueriesEverRun.push_back(query);

if (std::shared_ptr<FakeDNSSDBrowseQuery> browseQuery = std::dynamic_pointer_cast<FakeDNSSDBrowseQuery>(query)) {

eventLoop->postEvent(boost::bind(boost::ref(browseQuery->onServiceAdded), service), shared_from_this());

}

}

else if (std::shared_ptr<FakeDNSSDResolveServiceQuery> resolveQuery = std::dynamic_pointer_cast<FakeDNSSDResolveServiceQuery>(query)) {

}

}

}

void FakeDNSSDQuerier::addService(const DNSSDServiceID& id) {

services.insert(id);

eventLoop->postEvent(boost::bind(boost::ref(query->onServiceAdded), id), shared_from_this());

}

}

void FakeDNSSDQuerier::removeService(const DNSSDServiceID& id) {

services.erase(id);

serviceInfo.erase(id);

eventLoop->postEvent(boost::bind(boost::ref(query->onServiceRemoved), id), shared_from_this());

}

}

if (!r.second) {

r.first->second = info;

}

if (query->service == id) {

eventLoop->postEvent(boost::bind(boost::ref(query->onServiceResolved), info), shared_from_this());

}

}

bool FakeDNSSDQuerier::isServiceRegistered(const std::string& name, int port, const ByteArray& info) {

if (query->name == name && query->port == port && query->info == info) {

return true;

}

}

void FakeDNSSDQuerier::setBrowseError() {

eventLoop->postEvent(boost::ref(query->onError), shared_from_this());

}

}

void FakeDNSSDQuerier::setRegisterError() {

eventLoop->postEvent(boost::bind(boost::ref(query->onRegisterFinished), boost::optional<DNSSDServiceID>()), shared_from_this());

}

}

void FakeDNSSDQuerier::setAddress(const std::string& hostname, boost::optional<HostAddress> address) {

addresses[hostname] = address;

if (query->hostname == hostname) {

eventLoop->postEvent(boost::bind(

boost::ref(query->onHostnameResolved), address), shared_from_this());

#include <boost/bind.hpp>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/ProtocolHeader.h>

#include <Swiften/Elements/StreamFeatures.h>

}

void OutgoingLinkLocalSession::handleStreamStart(const ProtocolHeader&) {

sendElement(stanza);

}

queuedElements_.clear();

#include <boost/bind.hpp>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Queries/Requests/GetPrivateStorageRequest.h>

#include <Swiften/Queries/Requests/SetPrivateStorageRequest.h>

storage = payload;

std::vector<MUCBookmark> receivedBookmarks;

receivedBookmarks.push_back(MUCBookmark(room));

}

std::vector<MUCBookmark> newBookmarks;

if (containsEquivalent(receivedBookmarks, oldBookmark)) {

newBookmarks.push_back(oldBookmark);

} else {

}

}

if (!containsEquivalent(bookmarks_, newBookmark)) {

newBookmarks.push_back(newBookmark);

onBookmarkAdded(newBookmark);

}

// Update the storage element

storage->clearRooms();

storage->addRoom(bookmark.toStorage());

}

#include <Swiften/Base/Log.h>

#include <Swiften/Base/SafeString.h>

#include <Swiften/Network/CachingDomainNameResolver.h>

#include <Swiften/Network/HTTPConnectProxiedConnectionFactory.h>

BOSHConnectionPool::~BOSHConnectionPool() {

/* Don't do a normal close here. Instead kill things forcibly, as close() or writeFooter() will already have been called */

std::vector<BOSHConnection::ref> connectionCopies = connections;

if (connection) {

destroyConnection(connection);

connection->disconnect();

}

}

delete factory;

}

delete resolver;

else {

pendingTerminate = true;

std::vector<BOSHConnection::ref> connectionCopies = connections;

if (connection) {

connection->disconnect();

}

BOSHConnection::ref BOSHConnectionPool::getSuitableConnection() {

BOSHConnection::ref suitableConnection;

if (connection->isReadyToSend()) {

suitableConnection = connection;

break;

rid++;

suitableConnection->setRID(rid);

SafeByteArray data;

data.insert(data.end(), datum.begin(), datum.end());

}

suitableConnection->write(data);

if (!pendingTerminate) {

/* Ensure there's always a session waiting to read data for us */

bool pending = false;

if (connection && !connection->isReadyToSend()) {

pending = true;

}

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Network/ConnectionFactory.h>

#include <Swiften/Network/Connector.h>

#include <algorithm>

#include <Swiften/Network/Timer.h>

namespace Swift {

void DummyTimerFactory::setTime(int time) {

assert(time > currentTime);

if (timer->getAlarmTime() > currentTime && timer->getAlarmTime() <= time && timer->isRunning) {

timer->onTick();

}

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/String.h>

#include <Swiften/Network/ConnectionFactory.h>

#include <Swiften/Network/HTTPTrafficFilter.h>

#include <Swiften/Network/HostAddressPort.h>

append(data, createSafeByteArray("\r\n"));

}

else if (!nextHTTPRequestHeaders_.empty()) {

append(data, createSafeByteArray(headerField.first));

append(data, createSafeByteArray(": "));

append(data, createSafeByteArray(headerField.second));

}

void HTTPConnectProxiedConnection::sendHTTPRequest(const std::string& statusLine, const std::vector<std::pair<std::string, std::string> >& headerFields) {

std::stringstream request;

request << statusLine << "\r\n";

request << field.first << ":" << field.second << "\r\n";

}

request << "\r\n";

#include <Swiften/Network/NetworkEnvironment.h>

#include <Swiften/Network/HostAddress.h>

#include <Swiften/Network/NetworkInterface.h>

HostAddress NetworkEnvironment::getLocalAddress() const {

std::vector<NetworkInterface> networkInterfaces = getNetworkInterfaces();

if (!iface.isLoopback()) {

if (address.getRawAddress().is_v4()) {

return address;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Base/ByteArray.h>

#include <Swiften/EventLoop/EventLoop.h>

#include <Swiften/Base/BoostRandomGenerator.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Network/PlatformDomainNameResolver.h>

#include <Swiften/Network/UnixProxyProvider.h>

#if defined(HAVE_GCONF)

# include "Swiften/Network/GConfProxyProvider.h"

#endif

#include <winsock2.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Network/HostAddress.h>

#include <Swiften/Network/NetworkInterface.h>

}

}

}

return result;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/lexical_cast.hpp>

namespace Swift {

BytestreamsParser::BytestreamsParser() : level(TopLevel) {

#include <map>

namespace Swift {

FormParser::FormParser() : level_(TopLevel), parsingItem_(false), parsingReported_(false), parsingOption_(false), hasReportedRef_(false){

}

else {

if (currentPages_.size() > 0) {

if (pageRef == currentField_->getName()) {

page->addField(currentField_);

}

}

}

if (sectionRef == currentField_->getName()) {

section->addField(currentField_);

}

#include <Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h>

#include <Swiften/Elements/BlockListPayload.h>

#include <Swiften/Elements/BlockPayload.h>

#include <Swiften/Elements/UnblockPayload.h>

factories_.push_back(std::make_shared<GenericPayloadParserFactory2<CarbonsSentParser> >("sent", "urn:xmpp:carbons:2", this));

factories_.push_back(std::make_shared<GenericPayloadParserFactory<CarbonsPrivateParser> >("private", "urn:xmpp:carbons:2"));

addFactory(factory.get());

}

defaultFactory_ = new RawXMLPayloadParserFactory();

FullPayloadParserFactoryCollection::~FullPayloadParserFactoryCollection() {

setDefaultFactory(nullptr);

delete defaultFactory_;

removeFactory(factory.get());

}

}

#include <boost/lexical_cast.hpp>

#include <Swiften/StringCodecs/Base64.h>

namespace Swift {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/lexical_cast.hpp>

#include <Swiften/Elements/MUCOccupant.h>

namespace Swift {

void MUCAdminPayloadParser::handleTree(ParserElement::ref root) {

MUCItem item = MUCItemParser::itemFromTree(itemElement);

getPayloadInternal()->addItem(item);

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Parser/PayloadParsers/MUCDestroyPayloadParser.h>

namespace Swift {

void MUCDestroyPayloadParser::handleTree(ParserElement::ref root) {

#include <boost/lexical_cast.hpp>

#include <Swiften/Elements/MUCOccupant.h>

#include <Swiften/Parser/PayloadParserFactory.h>

#include <Swiften/Parser/PayloadParserFactoryCollection.h>

namespace Swift {

void MUCUserPayloadParser::handleTree(ParserElement::ref root) {

if (child->getName() == "item" && child->getNamespace() == root->getNamespace()) {

MUCItem item = MUCItemParser::itemFromTree(child);

getPayloadInternal()->addItem(item);

#include <Swiften/Parser/PayloadParsers/FormParserFactory.h>

#include <Swiften/Parser/PayloadParsers/FormParser.h>

#define FILE_TRANSFER_NS "http://jabber.org/protocol/si/profile/file-transfer"

#define FEATURE_NEG_NS "http://jabber.org/protocol/feature-neg"

FormField::ref field = std::dynamic_pointer_cast<FormField>(form->getField("stream-method"));

if (field) {

if (form->getType() == Form::FormType) {

getPayloadInternal()->addProvidedMethod(option.value);

}

}

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Elements/MUCDestroyPayload.h>

#include <Swiften/Parser/PayloadParsers/MUCUserPayloadParser.h>

#include <Swiften/Parser/PayloadParsers/UnitTest/PayloadsParserTester.h>

MUCUserPayload::ref payload = std::dynamic_pointer_cast<MUCUserPayload>(parser.getPayload());

if (status.code == 110) found110 = true;

if (status.code == 210) found210 = true;

}

#include <cassert>

#include <Swiften/Base/DateTime.h>

#include <Swiften/Parser/SerializingParser.h>

#include <Swiften/StringCodecs/Base64.h>

std::string VCardParser::getElementHierarchy() const {

std::string result;

result += "/" + element;

}

return result;

#include <cassert>

#include <memory>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

void SerializingParser::handleStartElement(const std::string& tag, const std::string& ns, const AttributeMap& attributes) {

std::shared_ptr<XMLElement> element = std::make_shared<XMLElement>(tag, ns);

// FIXME: Ignoring attribute namespace

element->setAttribute(e.getAttribute().getName(), e.getValue());

}

#include <boost/lexical_cast.hpp>

#include <Swiften/Elements/MUCOccupant.h>

#include <Swiften/Parser/PayloadParser.h>

#include <Swiften/Parser/PayloadParserFactory.h>

if (current.second) {

stack.push_back(ElementState(current.first, false));

parser->handleStartElement(current.first->getName(), current.first->getNamespace(), current.first->getAttributes());

stack.push_back(ElementState(child, true));

}

} else {

#include <Swiften/Presence/DirectedPresenceSender.h>

namespace Swift {

DirectedPresenceSender::DirectedPresenceSender(PresenceSender* sender) : sender(sender) {

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

std::shared_ptr<Presence> presenceCopy(new Presence(*presence));

presenceCopy->setTo(jid);

sender->sendPresence(presenceCopy);

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/bind.hpp>

#include <Swiften/Client/StanzaChannel.h>

namespace Swift {

#include <Swiften/Base/BoostRandomGenerator.h>

#include <Swiften/Base/Debug.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/sleep.h>

#include <Swiften/Client/Client.h>

#include <Swiften/Client/ClientXMLTracer.h>

#include <Swiften/Base/BoostRandomGenerator.h>

#include <Swiften/Base/Debug.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/sleep.h>

#include <Swiften/Client/Client.h>

#include <Swiften/Client/ClientXMLTracer.h>

std::vector<std::string> configurations;

std::string configs_env = std::string(getenv("SWIFT_FILETRANSFERTEST_CONFIG"));

boost::split(configurations, configs_env, boost::is_any_of("|"));

std::vector<std::string> split_config;

boost::split(split_config, config, boost::is_any_of(":"));

assert(split_config.size() == 2);

}

}

std::cout << "Failed test: " << "( " << failedTest.first << ", " << failedTest.second << ") " << std::endl;

}

}

}

}

std::cout << "Failed test: " << "( " << failedTest.first << ", " << failedTest.second << ") " << std::endl;

}

}

#include <iostream>

#include <Swiften/Network/PlatformProxyProvider.h>

using namespace Swift;

#include <boost/bind.hpp>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Queries/IQChannel.h>

#include <Swiften/Queries/IQHandler.h>

}

void IQRouter::processPendingRemoves() {

erase(handlers_, handler);

}

queuedRemoves_.clear();

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Elements/RosterItemPayload.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Roster/GetRosterRequest.h>

void XMPPRosterController::handleRosterReceived(std::shared_ptr<RosterPayload> rosterPayload, bool initial, std::shared_ptr<RosterPayload> previousRoster) {

if (rosterPayload) {

//Don't worry about the updated case, the XMPPRoster sorts that out.

if (item.getSubscription() == RosterItemPayload::Remove) {

xmppRoster_->removeContact(item.getJID());

}

else if (previousRoster) {

// The cached version hasn't changed; emit all items

if (item.getSubscription() != RosterItemPayload::Remove) {

xmppRoster_->addContact(item.getJID(), item.getName(), item.getGroups(), item.getSubscription());

}

std::vector<XMPPRosterItem> items = xmppRoster_->getItems();

std::shared_ptr<RosterPayload> roster(new RosterPayload());

roster->setVersion(version);

roster->addItem(RosterItemPayload(item.getJID(), item.getName(), item.getSubscription(), item.getGroups()));

}

rosterStorage_->setRoster(roster);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Roster/XMPPRosterImpl.h>

namespace Swift {

XMPPRosterImpl::XMPPRosterImpl() {

std::vector<XMPPRosterItem> XMPPRosterImpl::getItems() const {

std::vector<XMPPRosterItem> result;

result.push_back(entry.second);

}

return result;

std::set<std::string> XMPPRosterImpl::getGroups() const {

std::set<std::string> result;

std::vector<std::string> groups = entry.second.getGroups();

result.insert(groups.begin(), groups.end());

}

#include <boost/lexical_cast.hpp>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/XML/XMLElement.h>

std::string BytestreamsSerializer::serializePayload(std::shared_ptr<Bytestreams> bytestreams) const {

XMLElement queryElement("query", "http://jabber.org/protocol/bytestreams");

queryElement.setAttribute("sid", bytestreams->getStreamID());

std::shared_ptr<XMLElement> streamHostElement(new XMLElement("streamhost"));

streamHostElement->setAttribute("host", streamHost.host);

streamHostElement->setAttribute("jid", streamHost.jid.toString());

#include <memory>

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

actions += " execute='" + executeAction + "'";

}

actions += ">";

actions += "<" + actionToString(action) + "/>";

}

actions += "</actions>";

commandElement.addNode(std::make_shared<XMLRawTextNode>(actions));

}

std::shared_ptr<XMLElement> noteElement(new XMLElement("note"));

std::string type;

switch (note.type) {

#include <memory>

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

if (!discoInfo->getNode().empty()) {

queryElement.setAttribute("node", discoInfo->getNode());

}

std::shared_ptr<XMLElement> identityElement(new XMLElement("identity"));

if (!identity.getLanguage().empty()) {

identityElement->setAttribute("xml:lang", identity.getLanguage());

identityElement->setAttribute("type", identity.getType());

queryElement.addNode(identityElement);

}

std::shared_ptr<XMLElement> featureElement(new XMLElement("feature"));

featureElement->setAttribute("var", feature);

queryElement.addNode(featureElement);

}

queryElement.addNode(std::make_shared<XMLRawTextNode>(FormSerializer().serialize(extension)));

}

return queryElement.serialize();

#include <memory>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

if (!discoItems->getNode().empty()) {

queryElement.setAttribute("node", discoItems->getNode());

}

std::shared_ptr<XMLElement> itemElement(new XMLElement("item"));

itemElement->setAttribute("name", item.getName());

itemElement->setAttribute("jid", item.getJID());

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Base/String.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

if (!form->getInstructions().empty()) {

multiLineify(form->getInstructions(), "instructions", formElement);

}

formElement->addNode(pageToXML(page));

}

formElement->addNode(fieldToXML(field, true));

}

if (!form->getReportedFields().empty()) {

std::shared_ptr<XMLElement> reportedElement(new XMLElement("reported"));

reportedElement->addNode(fieldToXML(field, true));

}

formElement->addNode(reportedElement);

}

std::shared_ptr<XMLElement> itemElement(new XMLElement("item"));

itemElement->addNode(fieldToXML(field, false));

}

formElement->addNode(itemElement);

}

formElement->addNode(textToXML(text));

}

formElement->addNode(fieldToXML(field,true));

}

if (!page->getLabel().empty()) {

pageElement->setAttribute("label", page->getLabel());

}

pageElement->addNode(textToXML(text));

}

pageElement->addNode(fieldRefToXML(field->getName()));

fields_.push_back(field);

}

pageElement->addNode(std::make_shared<XMLElement>("reportedref"));

}

pageElement->addNode(sectionToXML(section));

}

return pageElement;

if (!section->getLabel().empty()) {

sectionElement->setAttribute("label", section->getLabel());

}

sectionElement->addNode(textToXML(text));

}

sectionElement->addNode(fieldRefToXML(field->getName()));

fields_.push_back(field);

}

sectionElement->addNode(std::make_shared<XMLElement>("reportedref"));

}

sectionElement->addNode(sectionToXML(childSection));

}

return sectionElement;

if (!fieldType.empty() && withTypeAttribute) {

fieldElement->setAttribute("type", fieldType);

}

std::shared_ptr<XMLElement> valueElement = std::make_shared<XMLElement>("value");

valueElement->addNode(std::make_shared<XMLTextNode>(value));

fieldElement->addNode(valueElement);

}

std::shared_ptr<XMLElement> optionElement(new XMLElement("option"));

if (!option.label.empty()) {

optionElement->setAttribute("label", option.label);

std::string unRdText(text);

erase(unRdText, '\r');

std::vector<std::string> lines = String::split(unRdText, '\n');

std::shared_ptr<XMLElement> lineElement(new XMLElement(elementName));

lineElement->addNode(std::make_shared<XMLTextNode>(line));

element->addNode(lineElement);

#include <Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h>

#include <Swiften/Elements/BlockListPayload.h>

#include <Swiften/Elements/BlockPayload.h>

#include <Swiften/Elements/UnblockPayload.h>

serializers_.push_back(new IsodeIQDelegationSerializer(this));

addSerializer(serializer);

}

}

FullPayloadSerializerCollection::~FullPayloadSerializerCollection() {