return *this;

}

friend bool operator>(const String& a, const String& b) {

return a.data_ > b.data_;

}

#include <boost/bind.hpp>

#include "Swiften/Network/ConnectionFactory.h"

#include "Swiften/StreamStack/StreamStack.h"

#include "Swiften/StreamStack/ConnectionLayer.h"

#include "Swiften/StreamStack/XMPPLayer.h"

}

void Session::sendStreamHeader() {

}

void Session::initializeStreamStack() {

#include "Swiften/StreamStack/TLSLayer.h"

#include "Swiften/StreamStack/StreamStack.h"

#include "Swiften/StreamStack/WhitespacePingLayer.h"

#include "Swiften/Elements/StreamFeatures.h"

#include "Swiften/Elements/Element.h"

#include "Swiften/Elements/Error.h"

assert(false);

}

void connect(const String& domain) {

if (fail_) {

MainEventLoop::postEvent(boost::bind(boost::ref(onDisconnected), Connection::ConnectionError));

parser_ = new XMPPParser(this, &payloadParserFactories_);

}

handleEvent(Event::StreamStartEvent);

}

String serializeEvent(const Event& event) {

switch (event.type) {

case Event::StreamStartEvent:

case Event::ElementEvent:

return serializer_.serializeElement(event.element);

case Event::StreamEndEvent:

void AppleDNSSDService::resolveHostname(const String& hostname, int interfaceIndex) {

boost::lock_guard<boost::mutex> lock(sdRefsMutex);

DNSServiceRef hostnameResolveSDRef;

DNSServiceErrorType result = DNSServiceGetAddrInfo(&hostnameResolveSDRef, 0, interfaceIndex, kDNSServiceProtocol_IPv4, hostname.getUTF8Data(), &AppleDNSSDService::handleHostnameResolvedGlobal, this);

// Hostname resolving

for (HostnameSDRefs::const_iterator i = hostnameResolveSDRefs.begin(); i != hostnameResolveSDRefs.end(); ++i) {

int hostnameResolveSocket = DNSServiceRefSockFD(*i);

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

FD_SET(hostnameResolveSocket, &fdSet);

for (HostnameSDRefs::const_iterator i = hostnameResolveSDRefs.begin(); i != hostnameResolveSDRefs.end(); ++i) {

if (FD_ISSET(DNSServiceRefSockFD(*i), &fdSet)) {

DNSServiceProcessResult(*i);

hostnameResolveSDRefs.erase(std::remove(hostnameResolveSDRefs.begin(), hostnameResolveSDRefs.end(), *i), hostnameResolveSDRefs.end());

DNSServiceRefDeallocate(*i);

break; // Stop the loop, because we removed an element

resolveSDRefs.clear();

for (HostnameSDRefs::const_iterator i = hostnameResolveSDRefs.begin(); i != hostnameResolveSDRefs.end(); ++i) {

DNSServiceRefDeallocate(*i);

}

hostnameResolveSDRefs.clear();

if (selfService && *selfService == service) {

return;

}

dnsSDService->startResolvingService(service);

}

void LinkLocalRoster::handleServiceResolved(const DNSSDService::Service& service, const DNSSDService::ResolveResult& result) {

services.insert(std::make_pair(service, result));

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

roster->addItem(getRosterItem(service, result));

std::cout << "DNSSDService stopped: " << error << std::endl;

}

}

boost::signal<void (boost::shared_ptr<RosterPayload>)> onRosterChanged;

boost::signal<void (boost::shared_ptr<Presence>)> onPresenceChanged;

private:

RosterItemPayload getRosterItem(const DNSSDService::Service& service, const DNSSDService::ResolveResult& info) const;

String getRosterName(const DNSSDService::Service& service, const DNSSDService::ResolveResult& info) const;

SWIFTEN_SOURCES += \

Swiften/LinkLocal/DNSSDService.cpp \

Swiften/LinkLocal/LinkLocalRoster.cpp \

ifeq ($(MACOSX),1)

void BoostConnection::connect(const String& domain) {

DomainNameResolver resolver;

try {

}

catch (const DomainNameResolveException& e) {

onDisconnected(DomainNameResolveError);

}

}

void BoostConnection::disconnect() {

//MainEventLoop::removeEventsFromOwner(shared_from_this());

socket_.close();

virtual void listen();

virtual void connect(const String& domain);

virtual void disconnect();

virtual void write(const ByteArray& data);

#include <boost/signals.hpp>

#include "Swiften/Base/String.h"

namespace Swift {

class Connection {

public:

enum Error {

virtual ~Connection() {}

virtual void listen() = 0;

virtual void connect(const String& domain) = 0;

virtual void disconnect() = 0;

virtual void write(const ByteArray& data) = 0;

boost::signal<void (const ByteArray&)> onDataRead;

};

}

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <vector>

#include "Swiften/Base/String.h"

#include "Swiften/Parser/XMPPParser.h"

#include "Swiften/Parser/ElementParser.h"

Client() {}

}

void handleElement(boost::shared_ptr<Element> element) {

#include <iostream>

#include <cassert>

#include "Swiften/Base/String.h"

#include "Swiften/Parser/XMLParser.h"

#include "Swiften/Parser/PlatformXMLParserFactory.h"

void XMPPParser::handleStartElement(const String& element, const String& ns, const AttributeMap& attributes) {

if (!inStream()) {

if (element == "stream" && ns == "http://etherx.jabber.org/streams") {

}

else {

parseErrorOccurred_ = true;

#include <boost/shared_ptr.hpp>

namespace Swift {

class String;

class XMPPParserClient {

public:

virtual ~XMPPParserClient();

virtual void handleElement(boost::shared_ptr<Element>) = 0;

virtual void handleStreamEnd() = 0;

};

}

#include <boost/bind.hpp>

#include <iostream>

#include "Swiften/Base/foreach.h"

#include "Swiften/Serializer/CompressRequestSerializer.h"

#include "Swiften/Serializer/CompressFailureSerializer.h"

serializers_.push_back(boost::shared_ptr<ElementSerializer>(new StreamFeaturesSerializer()));

}

}

}

}

result += ">";

return result;

#include <boost/shared_ptr.hpp>

#include <vector>

namespace Swift {

class PayloadSerializerCollection;

class CompressRequestSerializer;

class XMPPSerializer {

public:

XMPPSerializer(PayloadSerializerCollection*);

String serializeElement(boost::shared_ptr<Element> stanza) const;

String serializeFooter() const;

std::vector< boost::shared_ptr<ElementSerializer> > serializers_;

};

}

#include <boost/bind.hpp>

#include "Swiften/Server/UserRegistry.h"

#include "Swiften/Network/Connection.h"

#include "Swiften/StreamStack/StreamStack.h"

void ServerFromClientSession::start() {

xmppLayer_->onStreamStart.connect(

xmppLayer_->onElement.connect(

boost::bind(&ServerFromClientSession::handleElement, this, _1));

//xmppLayer_->onError.connect(

}

}

boost::shared_ptr<StreamFeatures> features(new StreamFeatures());

if (!authenticated_) {

#include "Swiften/Network/Connection.h"

namespace Swift {

class Element;

class Stanza;

class PayloadParserFactoryCollection;

private:

void handleDisconnected(const boost::optional<Connection::Error>& error);

void handleElement(boost::shared_ptr<Element>);

private:

String id_;

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include "Swiften/Elements/Presence.h"

#include "Swiften/Base/ByteArray.h"

#include "Swiften/StreamStack/XMPPLayer.h"

void testWriteHeader() {

testling_->onWriteData.connect(boost::bind(&XMPPLayerTest::handleWriteData, this, _1));

}

void testWriteElement() {

#include "Swiften/StreamStack/XMPPLayer.h"

#include "Swiften/Parser/XMPPParser.h"

#include "Swiften/Serializer/XMPPSerializer.h"

namespace Swift {

delete xmppParser_;

}

}

void XMPPLayer::writeFooter() {

resetParserAfterParse_ = false;

}

}

void XMPPLayer::handleElement(boost::shared_ptr<Element> stanza) {

#include <boost/shared_ptr.hpp>

#include <boost/signal.hpp>

#include "Swiften/Parser/XMPPParserClient.h"

namespace Swift {

class XMPPParser;

class PayloadParserFactoryCollection;

class XMPPSerializer;

PayloadSerializerCollection* payloadSerializers);

~XMPPLayer();

void writeFooter();

void writeElement(boost::shared_ptr<Element>);

void writeData(const String& data);

void resetParser();

public:

boost::signal<void (boost::shared_ptr<Element>)> onElement;

boost::signal<void (const ByteArray&)> onWriteData;

boost::signal<void (const ByteArray&)> onDataRead;

boost::signal<void ()> onError;

private:

void handleElement(boost::shared_ptr<Element>);

void handleStreamEnd();

bool inParser_;

};

}