+ <extension id="be.el_tramo.ecppunit.CPPUnitErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>

+ <configuration artifactName="${ProjName}" buildProperties="" description="" errorParsers="org.eclipse.cdt.core.VCErrorParser;org.eclipse.cdt.core.GmakeErrorParser;org.eclipse.cdt.core.CWDLocator;org.eclipse.cdt.core.GCCErrorParser;org.eclipse.cdt.core.GASErrorParser;org.eclipse.cdt.core.GLDErrorParser;be.el_tramo.ecppunit.CPPUnitErrorParser" id="0.980756260.1834106966" name="Unit tests" parent="org.eclipse.cdt.build.core.prefbase.cfg">

+ <toolChain errorParsers="" id="org.eclipse.cdt.build.core.prefbase.toolchain.1171413969" name="No ToolChain" resourceTypeBasedDiscovery="false" superClass="org.eclipse.cdt.build.core.prefbase.toolchain">

+ <builder arguments="${ProjDirPath}/3rdParty/SCons/scons.py" autoBuildTarget="check=1 QA" buildPath="" cleanBuildTarget="-c" command="python" enableAutoBuild="true" errorParsers="org.eclipse.cdt.core.GmakeErrorParser;org.eclipse.cdt.core.CWDLocator" id="org.eclipse.cdt.build.core.settings.default.builder.1417638948" incrementalBuildTarget="check=1 QA" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" superClass="org.eclipse.cdt.build.core.settings.default.builder"/>

+ <tool errorParsers="org.eclipse.cdt.core.VCErrorParser;org.eclipse.cdt.core.GCCErrorParser;org.eclipse.cdt.core.GASErrorParser;org.eclipse.cdt.core.GLDErrorParser" id="org.eclipse.cdt.build.core.settings.holder.libs.358970395" name="holder for library settings" superClass="org.eclipse.cdt.build.core.settings.holder.libs"/>

+ <tool errorParsers="org.eclipse.cdt.core.VCErrorParser;org.eclipse.cdt.core.GCCErrorParser;org.eclipse.cdt.core.GASErrorParser;org.eclipse.cdt.core.GLDErrorParser" id="org.eclipse.cdt.build.core.settings.holder.655623884" name="Assembly" superClass="org.eclipse.cdt.build.core.settings.holder">

+ <tool errorParsers="org.eclipse.cdt.core.VCErrorParser;org.eclipse.cdt.core.GCCErrorParser;org.eclipse.cdt.core.GASErrorParser;org.eclipse.cdt.core.GLDErrorParser" id="org.eclipse.cdt.build.core.settings.holder.1108727159" name="GNU C++" superClass="org.eclipse.cdt.build.core.settings.holder">

+ <tool errorParsers="org.eclipse.cdt.core.VCErrorParser;org.eclipse.cdt.core.GCCErrorParser;org.eclipse.cdt.core.GASErrorParser;org.eclipse.cdt.core.GLDErrorParser" id="org.eclipse.cdt.build.core.settings.holder.569111652" name="GNU C" superClass="org.eclipse.cdt.build.core.settings.holder">

+ <value>check=1 QA</value>

+ <value>check=1 QA</value>

+#include "Swiften/Avatars/AvatarManager.h"

+#include "Swiften/Avatars/AvatarMemoryStorage.h"

+#include "Swiften/VCards/VCardManager.h"

+#include "Swiften/VCards/VCardMemoryStorage.h"

+

+ vcardStorage_ = new VCardMemoryStorage();

+ vcardManager_ = new VCardManager(jid_, iqRouter_, vcardStorage_);

+ avatarStorage_ = new AvatarMemoryStorage();

+ avatarManager_ = new AvatarManager(vcardManager_, stanzaChannel_, avatarStorage_, NULL);

+ delete avatarStorage_;

+ delete vcardManager_;

+ delete vcardStorage_;

+ VCardStorage* vcardStorage_;

+ VCardManager* vcardManager_;

+ AvatarStorage* avatarStorage_;

+#include "Swiften/VCards/VCardManager.h"

+#include "Swiften/VCards/VCardStorage.h"

+ loginWindow_(NULL) ,

+ useDelayForLatency_(useDelayForLatency) {

+ vcardManager_ = NULL;

+ for(VCardStorageMap::iterator i = vcardStorages_.begin(); i != vcardStorages_.end(); ++i) {

+ delete i->second;

+ }

+ delete vcardManager_;

+ vcardManager_ = NULL;

+ vcardManager_ = new VCardManager(jid_, client_, getVCardStorageForProfile(jid_));

+ vcardManager_->onOwnVCardChanged.connect(boost::bind(&MainController::handleOwnVCardReceived, this, _1));

+ avatarManager_ = new AvatarManager(vcardManager_, client_, avatarStorage_);

+ vcardManager_->requestOwnVCard();

+void MainController::handleOwnVCardReceived(VCard::ref vCard) {

+ if (!vCard || vCard->getPhoto().isEmpty()) {

+ vCardPhotoHash_ = Hexify::hexify(SHA1::getHash(vCard->getPhoto()));

+ if (client_ && client_->isAvailable()) {

+ sendPresence(statusTracker_->getNextPresence());

+VCardStorage* MainController::getVCardStorageForProfile(const JID& jid) {

+ String profile = jid.toBare().toString();

+ std::pair<VCardStorageMap::iterator, bool> r = vcardStorages_.insert(std::make_pair<String, VCardStorage*>(profile, NULL));

+ if (r.second) {

+ r.first->second = vcardStorageFactory_->createVCardStorage(profile);

+ }

+ return r.first->second;

+}

+

+

+ class VCardStorage;

+ class VCardManager;

+ void handleOwnVCardReceived(VCard::ref vCard);

+ VCardStorage* getVCardStorageForProfile(const JID& jid);

+

+ private:

+ VCardManager* vcardManager_;

+

+ typedef std::map<String, VCardStorage*> VCardStorageMap;

+ VCardStorageMap vcardStorages_;

+ByteArray AvatarFileStorage::getAvatar(const String& hash) const {

+ ByteArray data;

+ data.readFromFile(getAvatarPath(hash).string());

+ return data;

+}

+

+

+ virtual ByteArray getAvatar(const String& hash) const;

+#include "Swiften/VCards/VCardManager.h"

+AvatarManager::AvatarManager(VCardManager* vcardManager, StanzaChannel* stanzaChannel, AvatarStorage* avatarStorage, MUCRegistry* mucRegistry) : vcardManager_(vcardManager), stanzaChannel_(stanzaChannel), avatarStorage_(avatarStorage), mucRegistry_(mucRegistry) {

+ vcardManager_->onVCardChanged.connect(boost::bind(&AvatarManager::handleVCardChanged, this, _1, _2));

+ if (!update || presence->getPayload<ErrorPayload>()) {

+ JID from = getAvatarJID(presence->getFrom());

+ if (getAvatarHash(from) == update->getPhotoHash()) {

+ if (avatarStorage_->hasAvatar(update->getPhotoHash())) {

+ setAvatarHash(from, update->getPhotoHash());

+ }

+ else {

+ vcardManager_->requestVCard(from);

+void AvatarManager::handleVCardChanged(const JID& from, VCard::ref vCard) {

+ String hash = Hexify::hexify(SHA1::getHash(vCard->getPhoto()));

+ avatarStorage_->addAvatar(hash, vCard->getPhoto());

+ setAvatarHash(from, hash);

+/*

+void AvatarManager::setAvatar(const JID& jid, const ByteArray& avatar) {

+ String hash = Hexify::hexify(SHA1::getHash(avatar));

+ avatarStorage_->addAvatar(hash, avatar);

+ setAvatarHash(getAvatarJID(jid), hash);

+}

+*/

+

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

+ class VCardManager;

+ AvatarManager(VCardManager*, StanzaChannel*, AvatarStorage*, MUCRegistry* = NULL);

+// virtual void setAvatar(const JID&, const ByteArray& avatar);*/

+ public:

+ boost::signal<void (const JID&, const String& /*hash*/)> onAvatarChanged;

+ void handleVCardChanged(const JID& from, VCard::ref);

+ String getAvatarHash(const JID&) const;

+ VCardManager* vcardManager_;

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <map>

+

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

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

+#include "Swiften/Avatars/AvatarStorage.h"

+

+namespace Swift {

+ class AvatarMemoryStorage : public AvatarStorage {

+ public:

+ virtual bool hasAvatar(const String& hash) const { return avatars.find(hash) != avatars.end(); }

+ virtual void addAvatar(const String& hash, const ByteArray& avatar) { avatars[hash] = avatar; }

+ virtual ByteArray getAvatar(const String& hash) const {

+ std::map<String, ByteArray>::const_iterator i = avatars.find(hash);

+ return i == avatars.end() ? ByteArray() : i->second;

+ }

+

+ virtual boost::filesystem::path getAvatarPath(const String& hash) const {

+ return boost::filesystem::path();

+ }

+

+ private:

+ std::map<String, ByteArray> avatars;

+ };

+}

+ virtual ByteArray getAvatar(const String& hash) const = 0;

+#include <boost/bind.hpp>

+#include "Swiften/Avatars/AvatarMemoryStorage.h"

+#include "Swiften/VCards/VCardMemoryStorage.h"

+#include "Swiften/VCards/VCardManager.h"

+#include "Swiften/StringCodecs/SHA1.h"

+#include "Swiften/StringCodecs/Hexify.h"

+ CPPUNIT_TEST(testUpdate_NewHashNewVCardRequestsVCard);

+ CPPUNIT_TEST(testUpdate_NewHashStoresAvatarAndEmitsNotificationOnVCardReceive);

+ CPPUNIT_TEST(testUpdate_KnownHash);

+ CPPUNIT_TEST(testUpdate_KnownHashFromDifferentUserDoesNotRequestVCardButTriggersNotification);

+ //CPPUNIT_TEST(testUpdate_UpdateWithError);

+ ownJID = JID("foo@fum.com/bum");

+ stanzaChannel = new DummyStanzaChannel();

+ iqRouter = new IQRouter(stanzaChannel);

+ mucRegistry = new DummyMUCRegistry();

+ avatarStorage = new AvatarMemoryStorage();

+ vcardStorage = new VCardMemoryStorage();

+ vcardManager = new VCardManager(ownJID, iqRouter, vcardStorage);

+ avatar1 = ByteArray("abcdefg");

+ avatar1Hash = Hexify::hexify(SHA1::getHash(avatar1));

+ user1 = JID("user1@bar.com/bla");

+ user2 = JID("user2@foo.com/baz");

+ delete vcardManager;

+ delete vcardStorage;

+ delete avatarStorage;

+ delete mucRegistry;

+ delete iqRouter;

+ delete stanzaChannel;

+ void testUpdate_NewHashNewVCardRequestsVCard() {

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<VCard>(0, user1.toBare(), IQ::Get));

+ void testUpdate_NewHashStoresAvatarAndEmitsNotificationOnVCardReceive() {

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

+ stanzaChannel->onIQReceived(createVCardResult(avatar1));

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

+ CPPUNIT_ASSERT_EQUAL(user1.toBare(), changes[0].first);

+ CPPUNIT_ASSERT_EQUAL(avatar1Hash, changes[0].second);

+ CPPUNIT_ASSERT(avatarStorage->hasAvatar(avatar1Hash));

+ CPPUNIT_ASSERT_EQUAL(avatar1, avatarStorage->getAvatar(avatar1Hash));

+ void testUpdate_KnownHash() {

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

+ stanzaChannel->onIQReceived(createVCardResult(avatar1));

+ changes.clear();

+ stanzaChannel->sentStanzas.clear();

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(changes.size()));

+ void testUpdate_KnownHashFromDifferentUserDoesNotRequestVCardButTriggersNotification() {

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

+ stanzaChannel->onIQReceived(createVCardResult(avatar1));

+ changes.clear();

+ stanzaChannel->sentStanzas.clear();

+

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user2, avatar1Hash));

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

+ CPPUNIT_ASSERT_EQUAL(user2.toBare(), changes[0].first);

+ CPPUNIT_ASSERT_EQUAL(avatar1Hash, changes[0].second);

+/*

+ void testUpdate_UpdateNewHashFromMUC() {

+

+ /*void testUpdate_UpdateWithError() {

+ }*/

+ std::auto_ptr<AvatarManager> result(new AvatarManager(vcardManager, stanzaChannel, avatarStorage, mucRegistry));

+ result->onAvatarChanged.connect(boost::bind(&AvatarManagerTest::handleAvatarChanged, this, _1, _2));

+ return result;

+ boost::shared_ptr<Presence> createPresenceWithPhotoHash(const JID& jid, const String& hash) {

+ presence->setFrom(jid);

+ presence->addPayload(boost::shared_ptr<VCardUpdate>(new VCardUpdate(hash)));

+ IQ::ref createVCardResult(const ByteArray& avatar) {

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

+ vcard->setPhoto(avatar);

+ return IQ::createResult(JID("baz@fum.com"), stanzaChannel->sentStanzas[0]->getID(), vcard);

+ }

+

+ void handleAvatarChanged(const JID& jid, const String& hash) {

+ changes.push_back(std::pair<JID,String>(jid, hash));

+ }

+

+

+ JID ownJID;

+ DummyStanzaChannel* stanzaChannel;

+ IQRouter* iqRouter;

+ DummyMUCRegistry* mucRegistry;

+ AvatarMemoryStorage* avatarStorage;

+ VCardManager* vcardManager;

+ VCardMemoryStorage* vcardStorage;

+ ByteArray avatar1;

+ String avatar1Hash;

+ std::vector<std::pair<JID,String> > changes;

+ JID user1;

+ JID user2;

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

+ class IQ : public Stanza, public Shared<IQ>

+ ErrorPayload::Condition condition = ErrorPayload::BadRequest,

+ ErrorPayload::Type type = ErrorPayload::Cancel);

+ myenv.MergeFlags(myenv.get("LIBXML_FLAGS", {}))

+ testling->setVCard(JID("alice@wonderland.lit/TeaRoom"), vcard);

+ boost::filesystem::path vcardFile(vcardsPath / "alice@wonderland.lit%2fTeaRoom.xml");

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

+ class GetVCardRequest : public GenericRequest<VCard>, public Shared<GetVCardRequest> {

+ File("VCards/UnitTest/VCardManagerTest.cpp"),

+#include "Swiften/StringCodecs/Hexify.h"

+ if (!vcard->getPhoto().isEmpty() || !vcard->getPhotoType().isEmpty()) {

+ XMLElement::ref photoElement(new XMLElement("PHOTO"));

+ if (!vcard->getPhotoType().isEmpty()) {

+ XMLElement::ref typeElement(new XMLElement("TYPE"));

+ typeElement->addNode(XMLTextNode::ref(new XMLTextNode(vcard->getPhotoType())));

+ photoElement->addNode(typeElement);

+ }

+ if (!vcard->getPhoto().isEmpty()) {

+ XMLElement::ref binvalElement(new XMLElement("BINVAL"));

+ binvalElement->addNode(XMLTextNode::ref(new XMLTextNode(Hexify::hexify(vcard->getPhoto()))));

+ photoElement->addNode(binvalElement);

+ }

+ queryElement.addNode(photoElement);

+ }

+#pragma once

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

+ class XMLElement : public XMLNode, public Shared<XMLElement> {

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

+ class XMLTextNode : public XMLNode, public Shared<XMLTextNode> {

+ "VCardManager.cpp",

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+#include <vector>

+#include <boost/bind.hpp>

+

+#include "Swiften/VCards/VCardManager.h"

+#include "Swiften/VCards/VCardMemoryStorage.h"

+#include "Swiften/Queries/IQRouter.h"

+#include "Swiften/Client/DummyStanzaChannel.h"

+

+using namespace Swift;

+

+class VCardManagerTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(VCardManagerTest);

+ CPPUNIT_TEST(testGet_NewVCardRequestsVCard);

+ CPPUNIT_TEST(testGet_ExistingVCard);

+ CPPUNIT_TEST(testRequest_RequestsVCard);

+ CPPUNIT_TEST(testRequest_ReceiveEmitsNotification);

+ CPPUNIT_TEST(testRequest_Error);

+ CPPUNIT_TEST(testRequest_VCardAlreadyRequested);

+ CPPUNIT_TEST(testRequest_AfterPreviousRequest);

+ CPPUNIT_TEST(testRequestOwnVCard);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ ownJID = JID("baz@fum.com/dum");

+ stanzaChannel = new DummyStanzaChannel();

+ iqRouter = new IQRouter(stanzaChannel);

+ vcardStorage = new VCardMemoryStorage();

+ }

+

+ void tearDown() {

+ delete vcardStorage;

+ delete iqRouter;

+ delete stanzaChannel;

+ }

+

+ void testGet_NewVCardRequestsVCard() {

+ std::auto_ptr<VCardManager> testling = createManager();

+ VCard::ref result = testling->getVCardAndRequestWhenNeeded(JID("foo@bar.com/baz"));

+

+ CPPUNIT_ASSERT(!result);

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<VCard>(0, JID("foo@bar.com/baz"), IQ::Get));

+ }

+

+ void testGet_ExistingVCard() {

+ std::auto_ptr<VCardManager> testling = createManager();

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

+ vcard->setFullName("Foo Bar");

+ vcardStorage->setVCard(JID("foo@bar.com/baz"), vcard);

+

+ VCard::ref result = testling->getVCardAndRequestWhenNeeded(JID("foo@bar.com/baz"));

+

+ CPPUNIT_ASSERT_EQUAL(String("Foo Bar"), result->getFullName());

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ }

+

+ void testRequest_RequestsVCard() {

+ std::auto_ptr<VCardManager> testling = createManager();

+ testling->requestVCard(JID("foo@bar.com/baz"));

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<VCard>(0, JID("foo@bar.com/baz"), IQ::Get));

+ }

+

+ void testRequest_ReceiveEmitsNotification() {

+ std::auto_ptr<VCardManager> testling = createManager();

+ testling->requestVCard(JID("foo@bar.com/baz"));

+ stanzaChannel->onIQReceived(createVCardResult());

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com/baz"), changes[0].first);

+ CPPUNIT_ASSERT_EQUAL(String("Foo Bar"), changes[0].second->getFullName());

+ CPPUNIT_ASSERT_EQUAL(String("Foo Bar"), vcardStorage->getVCard(JID("foo@bar.com/baz"))->getFullName());

+ }

+

+ void testRequest_Error() {

+ std::auto_ptr<VCardManager> testling = createManager();

+ testling->requestVCard(JID("foo@bar.com/baz"));

+ stanzaChannel->onIQReceived(IQ::createError(JID("baz@fum.com/foo"), stanzaChannel->sentStanzas[0]->getID()));

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com/baz"), changes[0].first);

+ CPPUNIT_ASSERT_EQUAL(String(""), changes[0].second->getFullName());

+ CPPUNIT_ASSERT_EQUAL(String(""), vcardStorage->getVCard(JID("foo@bar.com/baz"))->getFullName());

+ }

+

+ void testRequest_VCardAlreadyRequested() {

+ std::auto_ptr<VCardManager> testling = createManager();

+ testling->requestVCard(JID("foo@bar.com/baz"));

+ VCard::ref result = testling->getVCardAndRequestWhenNeeded(JID("foo@bar.com/baz"));

+

+ CPPUNIT_ASSERT(!result);

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ }

+

+ void testRequest_AfterPreviousRequest() {

+ std::auto_ptr<VCardManager> testling = createManager();

+ testling->requestVCard(JID("foo@bar.com/baz"));

+ stanzaChannel->onIQReceived(createVCardResult());

+ testling->requestVCard(JID("foo@bar.com/baz"));

+

+ CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<VCard>(1, JID("foo@bar.com/baz"), IQ::Get));

+ }

+

+ void testRequestOwnVCard() {

+ std::auto_ptr<VCardManager> testling = createManager();

+ testling->requestVCard(ownJID);

+ stanzaChannel->onIQReceived(createOwnVCardResult());

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<VCard>(0, JID(), IQ::Get));

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

+ CPPUNIT_ASSERT_EQUAL(ownJID.toBare(), changes[0].first);

+ CPPUNIT_ASSERT_EQUAL(String("Myself"), changes[0].second->getFullName());

+ CPPUNIT_ASSERT_EQUAL(String("Myself"), vcardStorage->getVCard(ownJID.toBare())->getFullName());

+ }

+

+ private:

+ std::auto_ptr<VCardManager> createManager() {

+ std::auto_ptr<VCardManager> manager(new VCardManager(ownJID, iqRouter, vcardStorage));

+ manager->onVCardChanged.connect(boost::bind(&VCardManagerTest::handleVCardChanged, this, _1, _2));

+ return manager;

+ }

+

+ void handleVCardChanged(const JID& jid, VCard::ref vcard) {

+ changes.push_back(std::pair<JID, VCard::ref>(jid, vcard));

+ }

+

+ IQ::ref createVCardResult() {

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

+ vcard->setFullName("Foo Bar");

+ return IQ::createResult(JID("baz@fum.com/dum"), stanzaChannel->sentStanzas[0]->getID(), vcard);

+ }

+

+ IQ::ref createOwnVCardResult() {

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

+ vcard->setFullName("Myself");

+ return IQ::createResult(JID(), stanzaChannel->sentStanzas[0]->getID(), vcard);

+ }

+

+ private:

+ JID ownJID;

+ DummyStanzaChannel* stanzaChannel;

+ IQRouter* iqRouter;

+ VCardMemoryStorage* vcardStorage;

+ std::vector< std::pair<JID, VCard::ref> > changes;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(VCardManagerTest);

+ String file(jid.toString());

+ file.replaceAll('/', "%2f");

+ return boost::filesystem::path(vcardsPath / (file.getUTF8String() + ".xml"));

+ virtual VCard::ref getVCard(const JID& jid) const;

+ virtual void setVCard(const JID& jid, VCard::ref v);

+ return new VCardFileStorage(base / profile.getUTF8String() / "vcards");

+#include <boost/bind.hpp>

+

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

+#include "Swiften/VCards/VCardStorage.h"

+#include "Swiften/Queries/Requests/GetVCardRequest.h"

+

+VCardManager::VCardManager(const JID& ownJID, IQRouter* iqRouter, VCardStorage* vcardStorage) : ownJID(ownJID), iqRouter(iqRouter), storage(vcardStorage) {

+VCard::ref VCardManager::getVCardAndRequestWhenNeeded(const JID& jid) {

+ VCard::ref vcard = storage->getVCard(jid);

+ requestVCard(jid);

+

+void VCardManager::requestVCard(const JID& requestedJID) {

+ JID jid = requestedJID.equals(ownJID, JID::WithoutResource) ? JID() : requestedJID;

+ if (requestedVCards.find(jid) != requestedVCards.end()) {

+ return;

+ }

+ GetVCardRequest::ref request(new GetVCardRequest(jid, iqRouter));

+ request->onResponse.connect(boost::bind(&VCardManager::handleVCardReceived, this, jid, _1, _2));

+ request->send();

+ requestedVCards.insert(jid);

+}

+

+void VCardManager::requestOwnVCard() {

+ requestVCard(JID());

+}

+

+

+void VCardManager::handleVCardReceived(const JID& actualJID, VCard::ref vcard, const boost::optional<ErrorPayload>& error) {

+ if (error) {

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

+ }

+ requestedVCards.erase(actualJID);

+ JID jid = actualJID.isValid() ? actualJID : ownJID.toBare();

+ storage->setVCard(jid, vcard);

+ onVCardChanged(jid, vcard);

+}

+

+#include <boost/signals.hpp>

+#include <set>

+

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

+#include "Swiften/Elements/ErrorPayload.h"

+ class IQRouter;

+ VCardManager(const JID& ownJID, IQRouter* iqRouter, VCardStorage* vcardStorage);

+ VCard::ref getVCardAndRequestWhenNeeded(const JID& jid);

+ void requestVCard(const JID& jid);

+ void requestOwnVCard();

+ /**

+ * The JID will always be bare.

+ */

+ boost::signal<void (const JID&, VCard::ref)> onVCardChanged;

+ boost::signal<void (VCard::ref)> onOwnVCardChanged;

+

+ private:

+ void handleVCardReceived(const JID& from, VCard::ref, const boost::optional<ErrorPayload>&);

+ JID ownJID;

+ std::set<JID> requestedVCards;

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <map>

+

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

+#include "Swiften/VCards/VCardStorage.h"

+

+namespace Swift {

+ class VCardMemoryStorage : public VCardStorage {

+ public:

+ VCardMemoryStorage() {}

+

+ virtual VCard::ref getVCard(const JID& jid) const {

+ VCardMap::const_iterator i = vcards.find(jid);

+ if (i != vcards.end()) {

+ return i->second;

+ }

+ else {

+ return VCard::ref();

+ }

+ }

+

+ virtual void setVCard(const JID& jid, VCard::ref v) {

+ vcards[jid] = v;

+ }

+

+ private:

+ typedef std::map<JID, VCard::ref> VCardMap;

+ VCardMap vcards;

+ };

+}

+ virtual VCard::ref getVCard(const JID& jid) const = 0;

+ virtual void setVCard(const JID&, VCard::ref) = 0;