-#pragma once

-

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h"

-#include "Swiften/LinkLocal/DNSSD/DNSSDBrowseQuery.h"

-

-namespace Swift {

- class FakeDNSSDQuerier;

-

- class FakeDNSSDBrowseQuery : public DNSSDBrowseQuery, public FakeDNSSDQuery {

- public:

- FakeDNSSDBrowseQuery(boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier) {

- }

-

- void startBrowsing() {

- run();

- }

-

- void stopBrowsing() {

- finish();

- }

- };

-}

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h"

-

-#include <boost/bind.hpp>

-

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDBrowseQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveHostnameQuery.h"

-#include "Swiften/EventLoop/MainEventLoop.h"

-

-namespace Swift {

-

-FakeDNSSDQuerier::FakeDNSSDQuerier(const String& domain) : domain(domain) {

-}

-

-FakeDNSSDQuerier::~FakeDNSSDQuerier() {

- if (!runningQueries.empty()) {

- std::cerr << "FakeDNSSDQuerier: Running queries not empty at destruction time" << std::endl;

- }

-}

-

-boost::shared_ptr<DNSSDBrowseQuery> FakeDNSSDQuerier::createBrowseQuery() {

- return boost::shared_ptr<DNSSDBrowseQuery>(new FakeDNSSDBrowseQuery(shared_from_this()));

-}

-

-boost::shared_ptr<DNSSDRegisterQuery> FakeDNSSDQuerier::createRegisterQuery(const String& name, int port, const ByteArray& info) {

- return boost::shared_ptr<DNSSDRegisterQuery>(new FakeDNSSDRegisterQuery(name, port, info, shared_from_this()));

-}

-

-boost::shared_ptr<DNSSDResolveServiceQuery> FakeDNSSDQuerier::createResolveServiceQuery(const DNSSDServiceID& service) {

- return boost::shared_ptr<DNSSDResolveServiceQuery>(new FakeDNSSDResolveServiceQuery(service, shared_from_this()));

-}

-

-boost::shared_ptr<DNSSDResolveHostnameQuery> FakeDNSSDQuerier::createResolveHostnameQuery(const String& hostname, int interfaceIndex) {

- return boost::shared_ptr<DNSSDResolveHostnameQuery>(new FakeDNSSDResolveHostnameQuery(hostname, interfaceIndex, shared_from_this()));

-}

-

-void FakeDNSSDQuerier::addRunningQuery(boost::shared_ptr<FakeDNSSDQuery> query) {

- runningQueries.push_back(query);

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

- foreach(const DNSSDServiceID& service, services) {

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

- }

- }

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

- for(ServiceInfoMap::const_iterator i = serviceInfo.begin(); i != serviceInfo.end(); ++i) {

- if (i->first == resolveQuery->service) {

- MainEventLoop::postEvent(boost::bind(boost::ref(resolveQuery->onServiceResolved), i->second), shared_from_this());

- }

- }

- }

- else if (boost::shared_ptr<FakeDNSSDRegisterQuery> registerQuery = boost::dynamic_pointer_cast<FakeDNSSDRegisterQuery>(query)) {

- DNSSDServiceID service(registerQuery->name, domain);

- MainEventLoop::postEvent(boost::bind(boost::ref(registerQuery->onRegisterFinished), service), shared_from_this());

- }

- else if (boost::shared_ptr<FakeDNSSDResolveHostnameQuery> resolveHostnameQuery = boost::dynamic_pointer_cast<FakeDNSSDResolveHostnameQuery>(query)) {

- std::map<String,boost::optional<HostAddress> >::const_iterator i = addresses.find(resolveHostnameQuery->hostname);

- if (i != addresses.end()) {

- MainEventLoop::postEvent(

- boost::bind(

- boost::ref(resolveHostnameQuery->onHostnameResolved), i->second),

- shared_from_this());

- }

- }

-}

-

-void FakeDNSSDQuerier::removeRunningQuery(boost::shared_ptr<FakeDNSSDQuery> query) {

- runningQueries.erase(std::remove(

- runningQueries.begin(), runningQueries.end(), query), runningQueries.end());

-}

-

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

- services.insert(id);

- foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {

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

- }

-}

-

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

- services.erase(id);

- serviceInfo.erase(id);

- foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {

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

- }

-}

-

-void FakeDNSSDQuerier::setServiceInfo(const DNSSDServiceID& id, const DNSSDResolveServiceQuery::Result& info) {

- std::pair<ServiceInfoMap::iterator, bool> r = serviceInfo.insert(std::make_pair(id, info));

- if (!r.second) {

- r.first->second = info;

- }

- foreach(const boost::shared_ptr<FakeDNSSDResolveServiceQuery>& query, getQueries<FakeDNSSDResolveServiceQuery>()) {

- if (query->service == id) {

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

- }

- }

-}

-

-bool FakeDNSSDQuerier::isServiceRegistered(const String& name, int port, const ByteArray& info) {

- foreach(const boost::shared_ptr<FakeDNSSDRegisterQuery>& query, getQueries<FakeDNSSDRegisterQuery>()) {

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

- return true;

- }

- }

- return false;

-}

-

-void FakeDNSSDQuerier::setBrowseError() {

- foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {

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

- }

-}

-

-void FakeDNSSDQuerier::setRegisterError() {

- foreach(const boost::shared_ptr<FakeDNSSDRegisterQuery>& query, getQueries<FakeDNSSDRegisterQuery>()) {

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

- }

-}

-

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

- addresses[hostname] = address;

- foreach(const boost::shared_ptr<FakeDNSSDResolveHostnameQuery>& query, getQueries<FakeDNSSDResolveHostnameQuery>()) {

- if (query->hostname == hostname) {

- MainEventLoop::postEvent(boost::bind(

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

- }

- }

-}

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/enable_shared_from_this.hpp>

-#include <list>

-#include <set>

-

-#include "Swiften/Base/foreach.h"

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

-#include "Swiften/EventLoop/EventOwner.h"

-#include "Swiften/LinkLocal/DNSSD/DNSSDQuerier.h"

-#include "Swiften/LinkLocal/DNSSD/DNSSDResolveServiceQuery.h"

-#include "Swiften/Network/HostAddress.h"

-

-namespace Swift {

- class ByteArray;

- class FakeDNSSDQuery;

- class FakeDNSSDBrowseQuery;

-

- class FakeDNSSDQuerier :

- public DNSSDQuerier,

- public EventOwner,

- public boost::enable_shared_from_this<FakeDNSSDQuerier> {

- public:

- FakeDNSSDQuerier(const String& domain);

- ~FakeDNSSDQuerier();

-

- void start() {}

- void stop() {}

-

- boost::shared_ptr<DNSSDBrowseQuery> createBrowseQuery();

- boost::shared_ptr<DNSSDRegisterQuery> createRegisterQuery(

- const String& name, int port, const ByteArray& info);

- boost::shared_ptr<DNSSDResolveServiceQuery> createResolveServiceQuery(

- const DNSSDServiceID&);

- boost::shared_ptr<DNSSDResolveHostnameQuery> createResolveHostnameQuery(

- const String& hostname, int interfaceIndex);

-

- void addRunningQuery(boost::shared_ptr<FakeDNSSDQuery>);

- void removeRunningQuery(boost::shared_ptr<FakeDNSSDQuery>);

-

- void addService(const DNSSDServiceID& id);

- void removeService(const DNSSDServiceID& id);

- void setServiceInfo(const DNSSDServiceID& id, const DNSSDResolveServiceQuery::Result& info);

- bool isServiceRegistered(const String& name, int port, const ByteArray& info);

- void setAddress(const String& hostname, boost::optional<HostAddress> address);

-

- void setBrowseError();

- void setRegisterError();

-

- private:

- template<typename T>

- std::vector< boost::shared_ptr<T> > getQueries() const {

- std::vector< boost::shared_ptr<T> > result;

- foreach(const boost::shared_ptr<FakeDNSSDQuery>& query, runningQueries) {

- if (boost::shared_ptr<T> resultQuery = boost::dynamic_pointer_cast<T>(query)) {

- result.push_back(resultQuery);

- }

- }

- return result;

- }

-

- private:

- String domain;

- std::list< boost::shared_ptr<FakeDNSSDQuery> > runningQueries;

- std::set<DNSSDServiceID> services;

- typedef std::map<DNSSDServiceID,DNSSDResolveServiceQuery::Result> ServiceInfoMap;

- ServiceInfoMap serviceInfo;

- std::map<String, boost::optional<HostAddress> > addresses;

- };

-}

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h"

-

-namespace Swift {

-

-FakeDNSSDQuery::FakeDNSSDQuery(boost::shared_ptr<FakeDNSSDQuerier> querier) : querier(querier) {

-}

-

-FakeDNSSDQuery::~FakeDNSSDQuery() {

-}

-

-void FakeDNSSDQuery::run() {

- querier->addRunningQuery(shared_from_this());

-}

-

-void FakeDNSSDQuery::finish() {

- querier->removeRunningQuery(shared_from_this());

-}

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/enable_shared_from_this.hpp>

-

-#include "Swiften/EventLoop/EventOwner.h"

-

-namespace Swift {

- class FakeDNSSDQuerier;

-

- class FakeDNSSDQuery :

- public EventOwner,

- public boost::enable_shared_from_this<FakeDNSSDQuery> {

- public:

- FakeDNSSDQuery(boost::shared_ptr<FakeDNSSDQuerier>);

- virtual ~FakeDNSSDQuery();

-

- protected:

- void run();

- void finish();

-

- protected:

- boost::shared_ptr<FakeDNSSDQuerier> querier;

- };

-}

-#pragma once

-

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h"

-#include "Swiften/LinkLocal/DNSSD/DNSSDRegisterQuery.h"

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

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

-

-namespace Swift {

- class FakeDNSSDQuerier;

-

- class FakeDNSSDRegisterQuery : public DNSSDRegisterQuery, public FakeDNSSDQuery {

- public:

- FakeDNSSDRegisterQuery(const String& name, int port, const ByteArray& info, boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), name(name), port(port), info(info) {

- }

-

- void registerService() {

- run();

- }

-

- void updateServiceInfo(const ByteArray& i) {

- info = i;

- }

-

- void unregisterService() {

- finish();

- }

-

- String name;

- int port;

- ByteArray info;

- };

-}

-#pragma once

-

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

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h"

-#include "Swiften/LinkLocal/DNSSD/DNSSDResolveHostnameQuery.h"

-#include "Swiften/Network/HostAddress.h"

-

-namespace Swift {

- class FakeDNSSDQuerier;

-

- class FakeDNSSDResolveHostnameQuery : public DNSSDResolveHostnameQuery, public FakeDNSSDQuery {

- public:

- FakeDNSSDResolveHostnameQuery(const String& hostname, int interfaceIndex, boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), hostname(hostname), interfaceIndex(interfaceIndex) {

- }

-

- void run() {

- FakeDNSSDQuery::run();

- }

-

- void finish() {

- FakeDNSSDQuery::finish();

- }

-

- String hostname;

- int interfaceIndex;

- };

-}

-#pragma once

-

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h"

-#include "Swiften/LinkLocal/DNSSD/DNSSDResolveServiceQuery.h"

-#include "Swiften/LinkLocal/LinkLocalServiceInfo.h"

-

-namespace Swift {

- class FakeDNSSDQuerier;

-

- class FakeDNSSDResolveServiceQuery : public DNSSDResolveServiceQuery, public FakeDNSSDQuery {

- public:

- FakeDNSSDResolveServiceQuery(const DNSSDServiceID& service, boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), service(service) {

- }

-

- void start() {

- run();

- }

-

- void stop() {

- finish();

- }

-

- DNSSDServiceID service;

- };

-}