namespace Swift {

memoryStorages = new MemoryStorages();

softwareVersionResponder = new SoftwareVersionResponder(getIQRouter());

return roster;

}

softwareVersionResponder->setVersion(name, version);

}

* this is NULL,

* all data will be stored in memory (and be lost on shutdown)

*/

~Client();

*

* This will be used to respond to version queries from other entities.

*/

/**

* Returns a representation of the roster.

if (needResourceBind) {

state = BindingResource;

boost::shared_ptr<ResourceBind> resourceBind(new ResourceBind());

resourceBind->setResource(localJID.getResource());

}

sendStanza(IQ::createRequest(IQ::Set, JID(), "session-bind", resourceBind));

return true;

}

assert(WaitingForCredentials);

state = Authenticating;

authenticator->setCredentials(localJID.getNode(), password);

#include "Swiften/Base/Error.h"

#include "Swiften/Session/SessionStream.h"

#include "Swiften/JID/JID.h"

#include "Swiften/Elements/Element.h"

#include "Swiften/StreamManagement/StanzaAckRequester.h"

return getState() == Finished;

}

void sendStanza(boost::shared_ptr<Stanza>);

void setCertificateTrustChecker(CertificateTrustChecker* checker) {

send(presence);

}

return idGenerator.generateID();

}

}

private:

void send(boost::shared_ptr<Stanza> stanza);

void handleSessionFinished(boost::shared_ptr<Error> error);

void handleStanza(boost::shared_ptr<Stanza> stanza);

}

private:

printLine(direction);

std::cerr << data << std::endl;

}

namespace Swift {

stanzaChannel_ = new ClientSessionStanzaChannel();

stanzaChannel_->onMessageReceived.connect(boost::bind(&CoreClient::handleMessageReceived, this, _1));

stanzaChannel_->onPresenceReceived.connect(boost::bind(&CoreClient::handlePresenceReceived, this, _1));

connect(jid_.getDomain());

}

SWIFT_LOG(debug) << "Connecting to host " << host << std::endl;

disconnectRequested_ = false;

assert(!connector_);

assert(!sessionStream_);

sessionStream_ = boost::shared_ptr<BasicSessionStream>(new BasicSessionStream(ClientStreamType, connection_, getPayloadParserFactories(), getPayloadSerializers(), tlsFactories->getTLSContextFactory(), networkFactories->getTimerFactory()));

sessionStream_->setTLSCertificate(PKCS12Certificate(certificate_, password_));

}

sessionStream_->onDataRead.connect(boost::bind(&CoreClient::handleDataRead, this, _1));

}

}

certificate_ = certificate;

}

session_->sendCredentials(password_);

}

onDataRead(data);

}

onDataWritten(data);

}

#include "Swiften/Elements/Presence.h"

#include "Swiften/Elements/Message.h"

#include "Swiften/JID/JID.h"

#include "Swiften/Client/StanzaChannel.h"

#include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"

#include "Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h"

* Constructs a client for the given JID with the given password.

* The given eventLoop will be used to post events to.

*/

~CoreClient();

/**

* Connects the client to the server.

*/

void disconnect();

/**

* Sends a message.

* This signal is emitted before the XML data is parsed,

* so this data is unformatted.

*/

/**

* Emitted when the client sends data.

* This signal is emitted after the XML was serialized, and

* is unformatted.

*/

/**

* Emitted when a message is received.

void handleStanzaChannelAvailableChanged(bool available);

void handleSessionFinished(boost::shared_ptr<Error>);

void handleNeedCredentials();

void handlePresenceReceived(Presence::ref);

void handleMessageReceived(Message::ref);

void handleStanzaAcked(Stanza::ref);

private:

JID jid_;

NetworkFactories* networkFactories;

ClientSessionStanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;

boost::shared_ptr<Connection> connection_;

boost::shared_ptr<BasicSessionStream> sessionStream_;

boost::shared_ptr<ClientSession> session_;

bool disconnectRequested_;

CertificateTrustChecker* certificateTrustChecker;

};

class DummyNickManager : public NickManager {

public:

return "";

}

}

};

}

sentStanzas.push_back(presence);

}

return "test-id";

}

namespace Swift {

FileStorages::FileStorages(const boost::filesystem::path& baseDir, const JID& jid) {

capsStorage = new CapsFileStorage(baseDir / "caps");

avatarStorage = new AvatarFileStorage(baseDir / "avatars");

}

#pragma once

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

class NickManager {

public:

virtual ~NickManager();

};

}

vcardManager->onVCardChanged.disconnect(boost::bind(&NickManagerImpl::handleVCardReceived, this, _1, _2));

}

return ownNick;

}

}

void NickManagerImpl::handleVCardReceived(const JID& jid, VCard::ref vcard) {

}

void NickManagerImpl::updateOwnNickFromVCard(VCard::ref vcard) {

nick = vcard->getNickname();

}

if (ownNick != nick) {

#include <Swiften/Client/NickManager.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class VCardManager;

NickManagerImpl(const JID& ownJID, VCardManager* vcardManager);

~NickManagerImpl();

private:

void handleVCardReceived(const JID& jid, VCard::ref vCard);

private:

JID ownJID;

VCardManager* vcardManager;

};

}

xmppRoster_->onJIDAdded.connect(boost::bind(&NickResolver::handleJIDAdded, this, _1));

}

onNickChanged(jid, previousNick);

}

void NickResolver::handleJIDAdded(const JID& jid) {

onNickChanged(jid, oldNick);

}

if (jid.toBare() == ownJID_) {

return ownNick_;

}

}

if (mucRegistry_ && mucRegistry_->isMUC(jid.toBare()) ) {

}

return xmppRoster_->getNameForJID(jid);

}

if (!jid.equals(ownJID_, JID::WithoutResource)) {

return;

}

ownNick_ = ownJID_.toString();

if (ownVCard) {

ownNick_ = ownVCard->getNickname();

ownNick_ = ownVCard->getGivenName();

ownNick_ = ownVCard->getFullName();

}

}

#include <boost/signals.hpp>

#include <boost/shared_ptr.hpp>

#include "Swiften/JID/JID.h"

#include "Swiften/Elements/VCard.h"

public:

NickResolver(const JID& ownJID, XMPPRoster* xmppRoster, VCardManager* vcardManager, MUCRegistry* mucRegistry);

private:

void handleVCardReceived(const JID& jid, VCard::ref vCard);

void handleJIDAdded(const JID& jid);

private:

JID ownJID_;

XMPPRoster* xmppRoster_;

MUCRegistry* mucRegistry_;

VCardManager* vcardManager_;

CPPUNIT_ASSERT(boost::dynamic_pointer_cast<StartTLSRequest>(event.element));

}

Event event = popEvent();

CPPUNIT_ASSERT(event.element);

boost::shared_ptr<AuthRequest> request(boost::dynamic_pointer_cast<AuthRequest>(event.element));

bool tlsEncrypted;

bool compressed;

bool whitespacePingEnabled;

int resetCount;

std::deque<Event> receivedEvents;

};

registry_->addMUC(JID("foo@bar"));

JID testJID("foo@bar/baz");

}

void testMUCNoNick() {

registry_->addMUC(JID("foo@bar"));

JID testJID("foo@bar");

}

void testNoMatch() {

JID testJID("foo@bar/baz");

}

void testZeroLengthMatch() {

JID testJID("foo@bar/baz");

xmppRoster_->addContact(testJID, "", groups_, RosterItemPayload::Both);

}

void testMatch() {

JID testJID("foo@bar/baz");

xmppRoster_->addContact(testJID, "Test", groups_, RosterItemPayload::Both);

}

void testOverwrittenMatch() {

xmppRoster_->addContact(testJID, "FailTest", groups_, RosterItemPayload::Both);

xmppRoster_->addContact(testJID, "Test", groups_, RosterItemPayload::Both);

}

void testRemovedMatch() {

JID testJID("foo@bar/baz");

xmppRoster_->addContact(testJID, "FailTest", groups_, RosterItemPayload::Both);

xmppRoster_->removeContact(testJID);

}

void testOwnNickFullOnly() {

populateOwnVCard("", "", "Kevin Smith");

}

void testOwnNickGivenAndFull() {

populateOwnVCard("", "Kevin", "Kevin Smith");

}

void testOwnNickNickEtAl() {

populateOwnVCard("Kev", "Kevin", "Kevin Smith");

}

VCard::ref vcard(new VCard());

vcard->setNickname(nick);

}

vcard->setGivenName(given);

}

vcard->setFullName(full);

}

vCardManager_->requestVCard(ownJID_);

}

private:

XMPPRosterImpl* xmppRoster_;

VCardStorage* vCardStorage_;

IQRouter* iqRouter_;