roster = new XMPPRosterImpl();

rosterController = new XMPPRosterController(getIQRouter(), roster, getStorages()->getRosterStorage());

subscriptionManager = new SubscriptionManager(getStanzaChannel());

presenceOracle->onPresenceChange.connect(boost::ref(onPresenceChange));

stanzaChannelPresenceSender = new StanzaChannelPresenceSender(getStanzaChannel());

directedPresenceSender = new DirectedPresenceSender(stanzaChannelPresenceSender);

discoManager = new ClientDiscoManager(getIQRouter(), directedPresenceSender, networkFactories->getCryptoProvider());

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/bind.hpp>

#include <Swiften/Client/StanzaChannel.h>

namespace Swift {

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

stanzaChannel_->onAvailableChanged.connect(boost::bind(&PresenceOracle::handleStanzaChannelAvailableChanged, this, _1));

}

PresenceOracle::~PresenceOracle() {

stanzaChannel_->onPresenceReceived.disconnect(boost::bind(&PresenceOracle::handleIncomingPresence, this, _1));

stanzaChannel_->onAvailableChanged.disconnect(boost::bind(&PresenceOracle::handleStanzaChannelAvailableChanged, this, _1));

}

void PresenceOracle::handleStanzaChannelAvailableChanged(bool available) {

if (available) {

entries_.clear();

}

}

void PresenceOracle::handleIncomingPresence(Presence::ref presence) {

JID bareJID(presence->getFrom().toBare());

if (presence->getType() == Presence::Subscribe) {

}

else {

Presence::ref passedPresence = presence;

/* 3921bis says that we don't follow up with an unavailable, so simulate this ourselves */

passedPresence = Presence::ref(new Presence());

passedPresence->setType(Presence::Unavailable);

passedPresence->setFrom(bareJID);

passedPresence->setStatus(presence->getStatus());

}

if (passedPresence->getFrom().isBare() && presence->getType() == Presence::Unavailable) {

/* Have a bare-JID only presence of offline */

jidMap.clear();

} else if (passedPresence->getType() == Presence::Available) {

/* Don't have a bare-JID only offline presence once there are available presences */

jidMap.erase(bareJID);

}

entries_[bareJID] = jidMap;

onPresenceChange(passedPresence);

}

}

Presence::ref PresenceOracle::getLastPresence(const JID& jid) const {

PresencesMap::const_iterator i = entries_.find(jid.toBare());

if (i == entries_.end()) {

return Presence::ref();

}

PresenceMap presenceMap = i->second;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <map>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

class StanzaChannel;

class SWIFTEN_API PresenceOracle {

public:

~PresenceOracle();

Presence::ref getLastPresence(const JID&) const;

Presence::ref getHighestPriorityPresence(const JID& bareJID) const;

std::vector<Presence::ref> getAllPresence(const JID& bareJID) const;

public:

boost::signal<void (Presence::ref)> onPresenceChange;

private:

void handleIncomingPresence(Presence::ref presence);

void handleStanzaChannelAvailableChanged(bool);

private:

typedef std::map<JID, Presence::ref> PresenceMap;

typedef std::map<JID, PresenceMap> PresencesMap;

PresencesMap entries_;

StanzaChannel* stanzaChannel_;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Presence/SubscriptionManager.h>

using namespace Swift;

class PresenceOracleTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(PresenceOracleTest);

CPPUNIT_TEST(testReceivePresence);

CPPUNIT_TEST(testHighestPresenceChangePriority);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

stanzaChannel_ = new DummyStanzaChannel();

oracle_->onPresenceChange.connect(boost::bind(&PresenceOracleTest::handlePresenceChange, this, _1));

subscriptionManager_ = new SubscriptionManager(stanzaChannel_);

subscriptionManager_->onPresenceSubscriptionRequest.connect(boost::bind(&PresenceOracleTest::handlePresenceSubscriptionRequest, this, _1, _2));

user1 = JID("user1@foo.com/Foo");

user1alt = JID("user1@foo.com/Bar");

user2 = JID("user2@bar.com/Bar");

}

void tearDown() {

delete subscriptionManager_;

delete oracle_;

delete stanzaChannel_;

}

void testHighestPresenceSingle() {

JID bareJID("alice@wonderland.lit");

Presence::ref fiveOn = makeOnline("blah", 5);

JID jid;

std::string reason;

};

PresenceOracle* oracle_;

SubscriptionManager* subscriptionManager_;

DummyStanzaChannel* stanzaChannel_;

std::vector<Presence::ref> changes;

std::vector<SubscriptionRequestInfo> subscriptionRequests;

JID user1;

JID user1alt;

JID user2;

};

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Roster/XMPPRosterImpl.h>

#include <Swiften/Base/foreach.h>

namespace Swift {

XMPPRosterImpl::XMPPRosterImpl() {

}

void XMPPRosterImpl::addContact(const JID& jid, const std::string& name, const std::vector<std::string>& groups, RosterItemPayload::Subscription subscription) {

JID bareJID(jid.toBare());

std::map<JID, XMPPRosterItem>::iterator i = entries_.find(bareJID);

if (i != entries_.end()) {

std::string oldName = i->second.getName();

std::vector<std::string> oldGroups = i->second.getGroups();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Roster/XMPPRoster.h>

namespace Swift {

class SWIFTEN_API XMPPRosterImpl : public XMPPRoster {

public:

XMPPRosterImpl();

void addContact(const JID& jid, const std::string& name, const std::vector<std::string>& groups, RosterItemPayload::Subscription subscription);

void removeContact(const JID& jid);

void clear();

bool containsJID(const JID& jid);