+CLangDiagnosticsFlags

+CLangDiagnosticsFlagsTool.sh

+CLangDiagnosticsFlagsTool

+clang-diagnostics-overview.*

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <iostream>

+#include <set>

+#include <vector>

+#include <cassert>

+#include <boost/algorithm/string/predicate.hpp>

+#include <boost/graph/graph_traits.hpp>

+#include <boost/graph/adjacency_list.hpp>

+#include <boost/graph/topological_sort.hpp>

+#include <boost/graph/topological_sort.hpp>

+#include <boost/graph/graphviz.hpp>

+

+// -----------------------------------------------------------------------------

+// Include diagnostics data from CLang

+// -----------------------------------------------------------------------------

+

+#define DIAG(name, a, b, c, d, e, f, g) name,

+

+namespace diag {

+ enum LexKinds {

+#include <clang/Basic/DiagnosticLexKinds.inc>

+#include <clang/Basic/DiagnosticParseKinds.inc>

+#include <clang/Basic/DiagnosticCommonKinds.inc>

+#include <clang/Basic/DiagnosticDriverKinds.inc>

+#include <clang/Basic/DiagnosticFrontendKinds.inc>

+#include <clang/Basic/DiagnosticSemaKinds.inc>

+ };

+}

+

+#define GET_DIAG_ARRAYS

+#include <clang/Basic/DiagnosticGroups.inc>

+#undef GET_DIAG_ARRAYS

+

+struct DiagTableEntry {

+ const char* name;

+ const short* array;

+ const short* group;

+};

+

+static const DiagTableEntry diagnostics[] = {

+#define GET_DIAG_TABLE

+#include <clang/Basic/DiagnosticGroups.inc>

+#undef GET_DIAG_TABLE

+};

+static const size_t diagnostics_count = sizeof(diagnostics) / sizeof(diagnostics[0]);

+

+// -----------------------------------------------------------------------------

+

+using namespace boost;

+

+struct Properties {

+ Properties() : missing(false), redundant(false) {

+ }

+

+ std::string name;

+ bool have;

+ bool implicitHave;

+ bool dontWant;

+ bool implicitDontWant;

+ bool ignored;

+ bool available;

+ bool missing;

+ bool redundant;

+ bool alreadyCovered;

+};

+

+class GraphVizLabelWriter {

+ public:

+ GraphVizLabelWriter(const std::vector<Properties>& properties) : properties(properties) {

+ }

+

+ template <class VertexOrEdge>

+ void operator()(std::ostream& out, const VertexOrEdge& v) const {

+ std::string color;

+ if (properties[v].missing) {

+ color = "orange";

+ }

+ else if (properties[v].redundant) {

+ color = "lightblue";

+ }

+ else if (properties[v].have) {

+ color = "darkgreen";

+ }

+ else if (properties[v].implicitHave) {

+ color = "green";

+ }

+ else if (properties[v].dontWant) {

+ color = "red";

+ }

+ else if (properties[v].implicitDontWant) {

+ color = "pink";

+ }

+ else if (properties[v].ignored) {

+ color = "white";

+ }

+ else if (properties[v].available) {

+ color = "yellow";

+ }

+ else {

+ assert(false);

+ }

+ out << "[label=" << escape_dot_string(properties[v].name) << " fillcolor=\"" << color << "\" style=filled]";

+ }

+

+ private:

+ const std::vector<Properties> properties;

+};

+

+int main(int argc, char* argv[]) {

+ // Parse command-line arguments

+ std::set<std::string> have;

+ std::set<std::string> dontWant;

+ std::string outputDir;

+ for (int i = 1; i < argc; ++i) {

+ std::string arg(argv[i]);

+ if (starts_with(arg, "-W")) {

+ have.insert(arg.substr(2, arg.npos));

+ }

+ else if (starts_with(arg, "-w")) {

+ dontWant.insert(arg.substr(2, arg.npos));

+ }

+ else if (starts_with(arg, "-O")) {

+ outputDir = arg.substr(2, arg.npos) + "/";

+ }

+ }

+

+ // Build the graph and initialize properties

+ typedef adjacency_list<vecS, vecS, bidirectionalS> Graph;

+ typedef graph_traits<Graph>::vertex_descriptor Vertex;

+ Graph g(diagnostics_count);

+ std::vector<Properties> properties(num_vertices(g));

+ for (size_t i = 0; i < diagnostics_count; ++i) {

+ std::string name(diagnostics[i].name);

+ properties[i].name = name;

+ properties[i].implicitHave = properties[i].have = have.find(name) != have.end();

+ properties[i].implicitDontWant = properties[i].dontWant = dontWant.find(name) != dontWant.end();

+ properties[i].ignored = diagnostics[i].group == 0 && diagnostics[i].array == 0;

+ properties[i].alreadyCovered = false;

+ properties[i].available = true;

+ for (const short* j = diagnostics[i].group; j && *j != -1; ++j) {

+ add_edge(i, *j, g);

+ }

+ }

+

+ // Sort the diagnostics

+ std::list<Vertex> sortedDiagnostics;

+ boost::topological_sort(g, std::front_inserter(sortedDiagnostics));

+

+ // Propagate dontWant and have properties down

+ for(std::list<Vertex>::const_iterator i = sortedDiagnostics.begin(); i != sortedDiagnostics.end(); ++i) {

+ graph_traits<Graph>::adjacency_iterator adjacentIt, adjacentEnd;

+ for (tie(adjacentIt, adjacentEnd) = adjacent_vertices(*i, g); adjacentIt != adjacentEnd; ++adjacentIt) {

+ properties[*adjacentIt].implicitDontWant = properties[*i].implicitDontWant || properties[*adjacentIt].implicitDontWant;

+ properties[*adjacentIt].implicitHave = properties[*i].implicitHave || properties[*adjacentIt].implicitHave;

+ }

+ }

+

+ // Propagate 'available' property upwards

+ for(std::list<Vertex>::const_reverse_iterator i = sortedDiagnostics.rbegin(); i != sortedDiagnostics.rend(); ++i) {

+ properties[*i].available = properties[*i].available && !properties[*i].implicitDontWant;

+ graph_traits<Graph>::in_edge_iterator edgesIt, edgesEnd;

+ graph_traits<Graph>::edge_descriptor edge;

+ for (tie(edgesIt, edgesEnd) = in_edges(*i, g); edgesIt != edgesEnd; ++edgesIt) {

+ properties[source(*edgesIt, g)].available = properties[source(*edgesIt, g)].available && properties[*i].available;

+ }

+ }

+

+ // Collect missing & redundant flags

+ std::set<std::string> missing;

+ std::set<std::string> redundant;

+ for(std::list<Vertex>::const_iterator i = sortedDiagnostics.begin(); i != sortedDiagnostics.end(); ++i) {

+ bool markChildrenCovered = true;

+ if (properties[*i].alreadyCovered) {

+ if (properties[*i].have) {

+ properties[*i].redundant = true;

+ redundant.insert(properties[*i].name);

+ }

+ }

+ else {

+ if (properties[*i].available) {

+ if (!properties[*i].implicitHave && !properties[*i].ignored) {

+ properties[*i].missing = true;

+ missing.insert(properties[*i].name);

+ }

+ }

+ else {

+ markChildrenCovered = false;

+ }

+ }

+ if (markChildrenCovered) {

+ graph_traits<Graph>::adjacency_iterator adjacentIt, adjacentEnd;

+ for (tie(adjacentIt, adjacentEnd) = adjacent_vertices(*i, g); adjacentIt != adjacentEnd; ++adjacentIt) {

+ properties[*adjacentIt].alreadyCovered = true;

+ }

+ }

+ }

+

+ // Write information

+ if (!missing.empty()) {

+ std::cout << "Missing diagnostic flags: ";

+ for(std::set<std::string>::const_iterator i = missing.begin(); i != missing.end(); ++i) {

+ std::cout << "-W" << *i << " ";

+ }

+ std::cout<< std::endl;

+ }

+

+ if (!redundant.empty()) {

+ std::cout << "Redundant diagnostic flags: ";

+ for(std::set<std::string>::const_iterator i = redundant.begin(); i != redundant.end(); ++i) {

+ std::cout << "-W" << *i << " ";

+ }

+ std::cout<< std::endl;

+ }

+

+ // Write graphviz file

+ if (!outputDir.empty()) {

+ std::ofstream f((outputDir + "clang-diagnostics-overview.dot").c_str());

+ write_graphviz(f, g, GraphVizLabelWriter(properties));

+ f.close();

+ }

+

+ return 0;

+}

+Import("env")

+

+#myenv = Environment()

+#myenv.Append(CPPPATH = ["."])

+#myenv.Program("CLangDiagnosticsFlagsTool", ["CLangDiagnosticsFlagsTool.cpp"])

+#

+#disabledDiagnostics = ["-wunreachable-code", "-wunused-macros", "-wmissing-noreturn", "-wlong-long", "-wcast-align", "-wglobal-constructors", "-wmissing-prototypes", "-wpadded", "-wshadow"]

+#clangDiagnosticsFlagsToolCommand = "BuildTools/CLang/CLangDiagnosticsFlagsTool -O" + env.Dir(".").abspath + " " + " ".join(disabledDiagnostics) + " "

+#clangDiagnosticsFlagsToolCommand += " ".join([flag for flag in env["CXXFLAGS"] if flag.startswith("-W")])

+#clangDiagnosticsFlagsToolCommand += "\n"

+#clangDiagnosticsFlagsToolCommand += "dot -Tpng " + env.Dir(".").abspath + "/clang-diagnostics-overview.dot > " + env.Dir(".").abspath + "/clang-diagnostics-overview.png\n"

+#v = env.WriteVal("#/BuildTools/CLang/CLangDiagnosticsFlagsTool.sh", env.Value(clangDiagnosticsFlagsToolCommand))

+#env.AddPostAction(v, Chmod(v[0], 0755))

+#

+#

+#!/usr/bin/env python

+

+import os, sys

+

+foundBadHeaders = False

+

+for (path, dirs, files) in os.walk(".") :

+ if "3rdParty" in path or ".sconf" in path or ".framework" in path :

+ continue

+ if not "Swiften" in path :

+ continue

+

+ for filename in [os.path.join(path, file) for file in files if file.endswith(".h")] :

+ file = open(filename, "r")

+ for line in file.readlines() :

+ for include in ["iostream", "algorithm", "cassert", "boost/bind.hpp", "boost/filesystem.hpp", "Base/foreach.h", "Base/Log.h", "boost/date_time/date_time.hpp", "boost/filesystem/filesystem.hpp"] :

+ if "#include" in line and include in line and not "Base/Log" in filename :

+ print "Found " + include + " include in " + filename

+ foundBadHeaders = True

+

+sys.exit(foundBadHeaders)

+ env.Append(CXXFLAGS = ["-Wlogical-op"])

+ if "clang" in env["CC"] :

+ env.Append(CXXFLAGS = ["-W#warnings", "-W-Wc++0x-compat", "-Wc++0x-compat", "-Waddress-of-temporary", "-Wambiguous-member-template", "-Warray-bounds", "-Watomic-properties", "-Wbind-to-temporary-copy", "-Wbuiltin-macro-redefined", "-Wc++-compat", "-Wc++0x-extensions", "-Wcomments", "-Wconditional-uninitialized", "-Wconstant-logical-operand", "-Wdeclaration-after-statement", "-Wdeprecated", "-Wdeprecated-implementations", "-Wdeprecated-writable-strings", "-Wduplicate-method-arg", "-Wempty-body", "-Wendif-labels", "-Wenum-compare", "-Wformat=2", "-Wfour-char-constants", "-Wgnu", "-Wincomplete-implementation", "-Winvalid-noreturn", "-Winvalid-offsetof", "-Winvalid-token-paste", "-Wlocal-type-template-args", "-Wmethod-signatures", "-Wmicrosoft", "-Wmissing-declarations", "-Wnon-pod-varargs", "-Wnonfragile-abi2", "-Wnull-dereference", "-Wout-of-line-declaration", "-Woverlength-strings", "-Wpacked", "-Wpointer-arith", "-Wpointer-sign", "-Wprotocol", "-Wreadonly-setter-attrs", "-Wselector", "-Wshift-overflow", "-Wshift-sign-overflow", "-Wstrict-selector-match", "-Wsuper-class-method-mismatch", "-Wtautological-compare", "-Wtypedef-redefinition", "-Wundeclared-selector", "-Wunknown-attributes", "-Wunknown-warning-option", "-Wunnamed-type-template-args", "-Wunused-exception-parameter", "-Wunused-member-function", "-Wused-but-marked-unused", "-Wvariadic-macros"])

+# To enable:

+# "-Wheader-hygiene"

+# "-Wnon-gcc",

+# "-Wweak-vtables",

+# "-Wlarge-by-value-copy",

+# Build tools

+env.SConscript(dirs = ["#/BuildTools/CLang"])

+

+class EchoPayload : public Swift::Payload {

+class EchoPayloadParser : public Swift::GenericPayloadParser<EchoPayload> {

+class EchoPayloadParserFactory : public Swift::GenericPayloadParserFactory<EchoPayloadParser> {

+class EchoPayloadSerializer : public Swift::GenericPayloadSerializer<EchoPayload> {

+#include <iostream>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>

+

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>

+#include <boost/filesystem.hpp>

+ file.write(reinterpret_cast<const char*>(avatar.getData()), static_cast<std::streamsize>(avatar.getSize()));

+#include <boost/filesystem/path.hpp>

+#include <boost/filesystem/path.hpp>

+#include <Swiften/Base/boost_bsignals.h>

+

+#include <boost/filesystem/path.hpp>

+#include <cstring> // for memcpy

+ data_.push_back(static_cast<unsigned char>(*c));

+ return data_.resize(size, static_cast<unsigned char>(c));

+ x[0] = static_cast<unsigned char>(b);

+ data_.push_back(static_cast<unsigned char>(c));

+#pragma once

+#include <boost/filesystem/path.hpp>

+#pragma once

+#pragma once

+#pragma once

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Client/CoreClient.h>

+ boost::shared_ptr<Presence> getLastPresence(const JID& jid) const;

+ boost::shared_ptr<Presence> getHighestPriorityPresence(const JID& bareJID) const;

+ boost::signal<void (boost::shared_ptr<Presence>)> onPresenceChange;

+#include <iostream>

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/Client/ClientXMLTracer.h>

+

+#include <iostream>

+#include <boost/bind.hpp>

+

+namespace Swift {

+

+ClientXMLTracer::ClientXMLTracer(CoreClient* client) {

+ client->onDataRead.connect(boost::bind(&ClientXMLTracer::printData, '<', _1));

+ client->onDataWritten.connect(boost::bind(&ClientXMLTracer::printData, '>', _1));

+}

+

+void ClientXMLTracer::printData(char direction, const std::string& data) {

+ printLine(direction);

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

+}

+

+void ClientXMLTracer::printLine(char c) {

+ for (unsigned int i = 0; i < 80; ++i) {

+ std::cerr << c;

+ }

+ std::cerr << std::endl;

+}

+

+}

+ ClientXMLTracer(CoreClient* client);

+ static void printData(char direction, const std::string& data);

+ static void printLine(char c);

+bool CoreClient::isAvailable() const {

+ return stanzaChannel_->isAvailable();

+}

+

+bool CoreClient::getStreamManagementEnabled() const {

+ return stanzaChannel_->getStreamManagementEnabled();

+}

+

+StanzaChannel* CoreClient::getStanzaChannel() const {

+ return stanzaChannel_;

+}

+

+const JID& CoreClient::getJID() const {

+ if (session_) {

+ return session_->getLocalJID();

+ }

+ else {

+ return jid_;

+ }

+}

+#include <string>

+#include <Swiften/Base/boost_bsignals.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/Client/ClientError.h>

+ class Connector;

+ class Message;

+ class Presence;

+ class Error;

+ class Connection;

+ class StanzaChannel;

+ class Stanza;

+ class ClientSessionStanzaChannel;

+ void sendMessage(boost::shared_ptr<Message>);

+ void sendPresence(boost::shared_ptr<Presence>);

+ bool isAvailable() const;

+ const JID& getJID() const;

+ bool getStreamManagementEnabled() const;

+ StanzaChannel* getStanzaChannel() const;

+ boost::signal<void (boost::shared_ptr<Message>)> onMessageReceived;

+ boost::signal<void (boost::shared_ptr<Presence>) > onPresenceReceived;

+ boost::signal<void (boost::shared_ptr<Stanza>)> onStanzaAcked;

+ void handlePresenceReceived(boost::shared_ptr<Presence>);

+ void handleMessageReceived(boost::shared_ptr<Message>);

+ void handleStanzaAcked(boost::shared_ptr<Stanza>);

+ boost::shared_ptr<Connector> connector_;

+#include <boost/filesystem/path.hpp>

+#include <Swiften/Base/boost_bsignals.h>

+#include <iostream>

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/Component/ComponentXMLTracer.h>

+

+#include <iostream>

+#include <boost/bind.hpp>

+

+namespace Swift {

+

+ComponentXMLTracer::ComponentXMLTracer(CoreComponent* client) {

+ client->onDataRead.connect(boost::bind(&ComponentXMLTracer::printData, '<', _1));

+ client->onDataWritten.connect(boost::bind(&ComponentXMLTracer::printData, '>', _1));

+}

+

+void ComponentXMLTracer::printData(char direction, const std::string& data) {

+ printLine(direction);

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

+}

+

+void ComponentXMLTracer::printLine(char c) {

+ for (unsigned int i = 0; i < 80; ++i) {

+ std::cerr << c;

+ }

+ std::cerr << std::endl;

+}

+

+}

+ ComponentXMLTracer(CoreComponent* component);

+ static void printData(char direction, const std::string& data);

+ static void printLine(char c);

+#include <iostream>

+ "ComponentXMLTracer.cpp",

+#include <cassert>

+

+#include <cassert>

+

+#include <boost/filesystem.hpp>

+#include <boost/filesystem.hpp>

+#include <boost/filesystem/path.hpp>

+#include <iostream>

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/Disco/DummyEntityCapsProvider.h>

+

+#include <iostream>

+

+namespace Swift {

+

+DiscoInfo::ref DummyEntityCapsProvider::getCaps(const JID& jid) const {

+ std::map<JID, DiscoInfo::ref>::const_iterator i = caps.find(jid);

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

+ return i->second;

+ }

+ return DiscoInfo::ref();

+}

+

+}

+

+ DiscoInfo::ref getCaps(const JID& jid) const;

+ "DummyEntityCapsProvider.cpp",

+#include <Swiften/Elements/Payload.h>

+

+#include <string>

+

+

+

+#include <string>

+#include <boost/date_time/posix_time/posix_time_types.hpp>

+#include <algorithm>

+

+bool DiscoInfo::hasFeature(const std::string& feature) const {

+ return std::find(features_.begin(), features_.end(), feature) != features_.end();

+}

+

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

+ bool hasFeature(const std::string& feature) const;

+#include <string>

+#pragma once

+#include <string>

+#include <string>

+

+

+#include <string>

+

+ const std::vector<boost::shared_ptr<JingleTransportPayload> >& getTransports() const {

+ void addTransport(boost::shared_ptr<JingleTransportPayload> transport) {

+ for (size_t i = 0; i < descriptions.size(); ++i) {

+ boost::shared_ptr<T> result(boost::dynamic_pointer_cast<T>(descriptions[i]));

+ for (size_t i = 0; i < transports.size(); ++i) {

+ boost::shared_ptr<T> result(boost::dynamic_pointer_cast<T>(transports[i]));

+<<<<<<< HEAD:Swiften/Elements/JingleContent.h

+=======

+ std::vector<boost::shared_ptr<JingleTransportPayload> > transports;

+>>>>>>> 7c05f3f... Cleaned up headers.:Swiften/Elements/JingleContentPayload.h

+#include <boost/shared_ptr.hpp>

+

+ class JingleTransportPayload : public Payload {

+ public:

+ typedef boost::shared_ptr<JingleTransportPayload> ref;

+#include <boost/date_time/posix_time/posix_time_types.hpp>

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/Elements/Presence.h>

+

+#include <Swiften/Elements/Priority.h>

+#include <Swiften/Elements/Status.h>

+

+namespace Swift {

+

+Presence::Presence() : type_(Available) /*, showType_(Online)*/ {

+}

+

+Presence::Presence(const std::string& status) : type_(Available) {

+ setStatus(status);

+}

+

+Presence::~Presence() {

+}

+

+int Presence::getPriority() const {

+ boost::shared_ptr<Priority> priority(getPayload<Priority>());

+ return (priority ? priority->getPriority() : 0);

+}

+

+void Presence::setPriority(int priority) {

+ updatePayload(boost::shared_ptr<Priority>(new Priority(priority)));

+}

+

+std::string Presence::getStatus() const {

+ boost::shared_ptr<Status> status(getPayload<Status>());

+ if (status) {

+ return status->getText();

+ }

+ return "";

+}

+

+void Presence::setStatus(const std::string& status) {

+ updatePayload(boost::shared_ptr<Status>(new Status(status)));

+}

+

+

+}

+#include <Swiften/Elements/Stanza.h>

+#include <Swiften/Elements/StatusShow.h>

+ Presence();

+ Presence(const std::string& status);

+ virtual ~Presence();

+ std::string getStatus() const;

+ void setStatus(const std::string& status);

+ int getPriority() const;

+ void setPriority(int priority);

+#include <Swiften/Elements/Payload.h>

+#pragma once

+#include <string>

+#include <boost/shared_ptr.hpp>

+#include <boost/shared_ptr.hpp>

+

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

+#include <Swiften/Base/foreach.h>

+

+Stanza::Stanza() {

+}

+

+#include <string>

+#include <boost/optional/optional_fwd.hpp>

+#include <boost/date_time/posix_time/ptime.hpp>

+#include <Swiften/Elements/Element.h>

+#include <Swiften/JID/JID.h>

+ class Payload;

+

+ Stanza();

+ for (size_t i = 0; i < payloads_.size(); ++i) {

+ boost::shared_ptr<T> result(boost::dynamic_pointer_cast<T>(payloads_[i]));

+ for (size_t i = 0; i < payloads_.size(); ++i) {

+ boost::shared_ptr<T> result(boost::dynamic_pointer_cast<T>(payloads_[i]));

+ std::vector< boost::shared_ptr<Payload> > payloads_;

+#pragma once

+#pragma once

+#include <Swiften/Elements/Payload.h>

+ case Online: return 4;

+ case FFC: return 5;

+ case Away: return 2;

+ case XA: return 1;

+ case DND: return 3;

+ case None: return 0;

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/Elements/StreamFeatures.h>

+

+#include <algorithm>

+

+namespace Swift {

+

+bool StreamFeatures::hasCompressionMethod(const std::string& mechanism) const {

+ return std::find(compressionMethods_.begin(), compressionMethods_.end(), mechanism) != compressionMethods_.end();

+}

+

+bool StreamFeatures::hasAuthenticationMechanism(const std::string& mechanism) const {

+ return std::find(authenticationMechanisms_.begin(), authenticationMechanisms_.end(), mechanism) != authenticationMechanisms_.end();

+}

+

+}

+#include <boost/shared_ptr.hpp>

+

+ bool hasCompressionMethod(const std::string& mechanism) const;

+ bool hasAuthenticationMechanism(const std::string& mechanism) const;

+#include <boost/date_time/posix_time/posix_time.hpp>

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

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

+

+

+Entity::Entity() {

+ payloadParserFactories = new FullPayloadParserFactoryCollection();

+ payloadSerializers = new FullPayloadSerializerCollection();

+}

+

+ delete payloadSerializers;

+ delete payloadParserFactories;

+ payloadParserFactories->addFactory(payloadParserFactory);

+ payloadParserFactories->removeFactory(payloadParserFactory);

+ payloadSerializers->addSerializer(payloadSerializer);

+ payloadSerializers->removeSerializer(payloadSerializer);

+}

+

+PayloadParserFactoryCollection* Entity::getPayloadParserFactories() {

+ return payloadParserFactories;

+}

+

+PayloadSerializerCollection* Entity::getPayloadSerializers() {

+ return payloadSerializers;

+ class FullPayloadParserFactoryCollection;

+ class FullPayloadSerializerCollection;

+ class PayloadParserFactoryCollection;

+ class PayloadSerializerCollection;

+ Entity();

+ PayloadParserFactoryCollection* getPayloadParserFactories();

+ PayloadSerializerCollection* getPayloadSerializers();

+ FullPayloadParserFactoryCollection* payloadParserFactories;

+ FullPayloadSerializerCollection* payloadSerializers;

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/EventLoop/DummyEventLoop.h>

+

+#include <iostream>

+

+namespace Swift {

+

+DummyEventLoop::DummyEventLoop() {

+}

+

+DummyEventLoop::~DummyEventLoop() {

+ if (!events_.empty()) {

+ std::cerr << "DummyEventLoop: Unhandled events at destruction time" << std::endl;

+ }

+ events_.clear();

+}

+

+

+}

+ DummyEventLoop();

+ ~DummyEventLoop();

+ "DummyEventLoop.cpp",

+#include <iostream>

+#include <iostream>

+#include <iostream>

+#include <Swiften/Elements/Presence.h>

+#include <Swiften/Base/foreach.h>

+#include <iostream>

+#include <Swiften/Elements/Presence.h>

+#include <iostream>

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

+#include <boost/filesystem/path.hpp>

+#include <boost/filesystem/path.hpp>

+#include <iostream>

+ catch (const BytestreamException&) {

+#include <iostream>

+ catch (const BytestreamException&) {

+#include <iosfwd>

+ for (size_t i = 0; i < contents.size(); ++i) {

+ if (contents[i]->getDescription<T>()) {

+ return contents[i];

+#include <Swiften/Base/foreach.h>

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/LinkLocal/DNSSD/Avahi/AvahiBrowseQuery.h>

+

+#include <boost/bind.hpp>

+#include <iostream>

+

+#include <Swiften/LinkLocal/DNSSD/Avahi/AvahiQuerier.h>

+

+namespace Swift {

+

+void AvahiBrowseQuery::startBrowsing() {

+ std::cout << "Start browsing" << std::endl;

+ assert(!browser);

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ browser = avahi_service_browser_new(querier->getClient(), AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_presence._tcp", NULL, static_cast<AvahiLookupFlags>(0), &handleServiceDiscoveredStatic, this);

+ if (!browser) {

+ std::cout << "Error" << std::endl;

+ eventLoop->postEvent(boost::bind(boost::ref(onError)), shared_from_this());

+ }

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+}

+

+void AvahiBrowseQuery::stopBrowsing() {

+ std::cout << "Stop browsing" << std::endl;

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ avahi_service_browser_free(browser);

+ browser = NULL;

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+}

+

+void AvahiBrowseQuery::handleServiceDiscovered(AvahiServiceBrowser *, AvahiIfIndex interfaceIndex, AvahiProtocol, AvahiBrowserEvent event, const char *name, const char *type, const char *domain, AvahiLookupResultFlags) {

+ switch (event) {

+ case AVAHI_BROWSER_FAILURE:

+ std::cout << "Service browse error" << std::endl;

+ eventLoop->postEvent(boost::bind(boost::ref(onError)), shared_from_this());

+ break;

+ case AVAHI_BROWSER_NEW: {

+ DNSSDServiceID service(name, domain, type, interfaceIndex);

+ std::cout << "Service discovered " << name << " " << domain << " " << type << " " << interfaceIndex << std::endl;

+ eventLoop->postEvent(boost::bind(boost::ref(onServiceAdded), service), shared_from_this());

+ break;

+ }

+ case AVAHI_BROWSER_REMOVE: {

+ std::cout << "Service went away " << name << " " << domain << " " << type << " " << interfaceIndex << std::endl;

+ DNSSDServiceID service(name, domain, type, interfaceIndex);

+ eventLoop->postEvent(boost::bind(boost::ref(onServiceRemoved), service), shared_from_this());

+ break;

+ }

+ case AVAHI_BROWSER_ALL_FOR_NOW:

+ case AVAHI_BROWSER_CACHE_EXHAUSTED:

+ break;

+ }

+}

+

+}

+#include <avahi-client/lookup.h>

+ void startBrowsing();

+ void stopBrowsing();

+ void handleServiceDiscovered(AvahiServiceBrowser *, AvahiIfIndex interfaceIndex, AvahiProtocol, AvahiBrowserEvent event, const char *name, const char *type, const char *domain, AvahiLookupResultFlags);

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/LinkLocal/DNSSD/Avahi/AvahiRegisterQuery.h>

+

+#include <iostream>

+#include <boost/bind.hpp>

+

+#include <Swiften/LinkLocal/DNSSD/Avahi/AvahiQuerier.h>

+

+namespace Swift {

+

+void AvahiRegisterQuery::registerService() {

+ std::cout << "Registering service " << name << ":" << port << std::endl;

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ if (!group) {

+ std::cout << "Creating entry group" << std::endl;

+ group = avahi_entry_group_new(querier->getClient(), handleEntryGroupChange, this);

+ if (!group) {

+ std::cout << "Error ceating entry group" << std::endl;

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

+ }

+ }

+

+ doRegisterService();

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+}

+

+void AvahiRegisterQuery::unregisterService() {

+ if (group) {

+ avahi_entry_group_free(group);

+ group = NULL;

+ }

+}

+

+void AvahiRegisterQuery::updateServiceInfo(const ByteArray& txtRecord) {

+ this->txtRecord = txtRecord;

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ assert(group);

+ avahi_entry_group_reset(group);

+ doRegisterService();

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+}

+

+void AvahiRegisterQuery::doRegisterService() {

+ AvahiStringList* txtList;

+ avahi_string_list_parse(txtRecord.getData(), txtRecord.getSize(), &txtList);

+

+ int result = avahi_entry_group_add_service_strlst(group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, static_cast<AvahiPublishFlags>(0), name.c_str(), "_presence._tcp", NULL, NULL, port, txtList);

+ if (result < 0) {

+ std::cout << "Error registering service: " << avahi_strerror(result) << std::endl;

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

+ }

+ result = avahi_entry_group_commit(group);

+ if (result < 0) {

+ std::cout << "Error registering service: " << avahi_strerror(result) << std::endl;

+ }

+}

+

+void AvahiRegisterQuery::handleEntryGroupChange(AvahiEntryGroup* g, AvahiEntryGroupState state) {

+ std::cout << "ENtry group callback: " << state << std::endl;

+ switch (state) {

+ case AVAHI_ENTRY_GROUP_ESTABLISHED :

+ // Domain is a hack!

+ eventLoop->postEvent(boost::bind(boost::ref(onRegisterFinished), boost::optional<DNSSDServiceID>(DNSSDServiceID(name, "local", "_presence._tcp", 0))), shared_from_this());

+ std::cout << "Entry group established" << std::endl;

+ break;

+ case AVAHI_ENTRY_GROUP_COLLISION : {

+ std::cout << "Entry group collision" << std::endl;

+ /*char *n;

+ n = avahi_alternative_service_name(name);

+ avahi_free(name);

+ name = n;*/

+ break;

+ }

+

+ case AVAHI_ENTRY_GROUP_FAILURE :

+ std::cout << "Entry group failure " << avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(g))) << std::endl;

+ break;

+

+ case AVAHI_ENTRY_GROUP_UNCOMMITED:

+ case AVAHI_ENTRY_GROUP_REGISTERING:

+ ;

+

+ /*

+ DNSServiceErrorType result = DNSServiceRegister(

+ &sdRef, 0, 0, name.c_str(), "_presence._tcp", NULL, NULL, port,

+ txtRecord.getSize(), txtRecord.getData(),

+ &AvahiRegisterQuery::handleServiceRegisteredStatic, this);

+ if (result != kDNSServiceErr_NoError) {

+ sdRef = NULL;

+ }*/

+ //eventLoop->postEvent(boost::bind(boost::ref(onRegisterFinished), boost::optional<DNSSDServiceID>()), shared_from_this());

+ }

+}

+

+

+}

+ void registerService();

+ void unregisterService();

+ void updateServiceInfo(const ByteArray& txtRecord);

+ void doRegisterService();

+ void handleEntryGroupChange(AvahiEntryGroup* g, AvahiEntryGroupState state);

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/LinkLocal/DNSSD/Avahi/AvahiResolveHostnameQuery.h>

+

+#include <iostream>

+#include <boost/bind.hpp>

+

+namespace Swift {

+

+AvahiResolveHostnameQuery::AvahiResolveHostnameQuery(const std::string& hostname, int, boost::shared_ptr<AvahiQuerier> querier, EventLoop* eventLoop) : AvahiQuery(querier, eventLoop), hostname(hostname) {

+ std::cout << "Resolving hostname " << hostname << std::endl;

+}

+

+void AvahiResolveHostnameQuery::run() {

+ eventLoop->postEvent(boost::bind(boost::ref(onHostnameResolved), boost::optional<HostAddress>(HostAddress(hostname))), shared_from_this());

+}

+

+}

+ AvahiResolveHostnameQuery(const std::string& hostname, int, boost::shared_ptr<AvahiQuerier> querier, EventLoop* eventLoop);

+ void run();

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/LinkLocal/DNSSD/Avahi/AvahiResolveServiceQuery.h>

+

+#include <boost/bind.hpp>

+#include <iostream>

+

+#include <Swiften/LinkLocal/DNSSD/Avahi/AvahiQuerier.h>

+

+namespace Swift {

+

+void AvahiResolveServiceQuery::start() {

+ std::cout << "Start resolving " << service.getName() << " " << service.getType() << " " << service.getDomain() << std::endl;

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ assert(!resolver);

+ resolver = avahi_service_resolver_new(querier->getClient(), service.getNetworkInterfaceID(), AVAHI_PROTO_UNSPEC, service.getName().c_str(), service.getType().c_str(), service.getDomain().c_str(), AVAHI_PROTO_UNSPEC, static_cast<AvahiLookupFlags>(0), handleServiceResolvedStatic, this);

+ if (!resolver) {

+ std::cout << "Error starting resolver" << std::endl;

+ eventLoop->postEvent(boost::bind(boost::ref(onServiceResolved), boost::optional<Result>()), shared_from_this());

+ }

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+}

+

+void AvahiResolveServiceQuery::stop() {

+ std::cout << "Stop resolving" << std::endl;

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ avahi_service_resolver_free(resolver);

+ resolver = NULL;

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+}

+

+void AvahiResolveServiceQuery::handleServiceResolved(AvahiServiceResolver* resolver, AvahiIfIndex, AvahiProtocol, AvahiResolverEvent event, const char *name, const char * type, const char* domain, const char * /*host_name*/, const AvahiAddress *address, uint16_t port, AvahiStringList *txt, AvahiLookupResultFlags) {

+ std::cout << "Resolve finished" << std::endl;

+ switch(event) {

+ case AVAHI_RESOLVER_FAILURE:

+ std::cout << "Resolve error " << avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(resolver))) << std::endl;

+ eventLoop->postEvent(boost::bind(boost::ref(onServiceResolved), boost::optional<Result>()), shared_from_this());

+ break;

+ case AVAHI_RESOLVER_FOUND: {

+ std::cout << "Success" << std::endl;

+ char a[AVAHI_ADDRESS_STR_MAX];

+ avahi_address_snprint(a, sizeof(a), address);

+

+ ByteArray txtRecord;

+ txtRecord.resize(1024);

+ avahi_string_list_serialize(txt, txtRecord.getData(), txtRecord.getSize());

+

+ // FIXME: Probably not accurate

+ std::string fullname = std::string(name) + "." + std::string(type) + "." + std::string(domain) + ".";

+ std::cout << "Result: " << fullname << "->" << std::string(a) << ":" << port << std::endl;

+ eventLoop->postEvent(

+ boost::bind(

+ boost::ref(onServiceResolved),

+ Result(fullname, std::string(a), port, txtRecord)),

+ shared_from_this());

+ break;

+ }

+ }

+}

+

+}

+#include <avahi-client/lookup.h>

+

+ void start();

+ void stop();

+ void handleServiceResolved(AvahiServiceResolver* resolver, AvahiIfIndex, AvahiProtocol, AvahiResolverEvent event, const char *name, const char * type, const char* domain, const char * /*host_name*/, const AvahiAddress *address, uint16_t port, AvahiStringList *txt, AvahiLookupResultFlags);

+#include <boost/thread/thread.hpp>

+#include <iostream>

+#include <Swiften/Base/foreach.h>

+ for (QueryList::const_iterator i = allQueriesEverRun.begin(); i != allQueriesEverRun.end(); ++i) {

+ if (boost::shared_ptr<T> resultQuery = boost::dynamic_pointer_cast<T>(*i)) {

+ for (QueryList::const_iterator i = runningQueries.begin(); i != runningQueries.end(); ++i) {

+ if (boost::shared_ptr<T> resultQuery = boost::dynamic_pointer_cast<T>(*i)) {

+ typedef std::list< boost::shared_ptr<FakeDNSSDQuery> > QueryList;

+ QueryList runningQueries;

+ QueryList allQueriesEverRun;

+#include <Swiften/Base/foreach.h>

+ "DNSSD/Avahi/AvahiQuery.cpp",

+ "DNSSD/Avahi/AvahiResolveHostnameQuery.cpp",

+ "DNSSD/Avahi/AvahiResolveServiceQuery.cpp",

+ "DNSSD/Avahi/AvahiRegisterQuery.cpp",

+ "DNSSD/Avahi/AvahiBrowseQuery.cpp",

+#include <boost/bind.hpp>

+

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>

+#include <boost/asio/placeholders.hpp>

+#include <boost/asio/write.hpp>

+#include <boost/asio/io_service.hpp>

+#include <boost/asio/ip/tcp.hpp>

+#include <boost/asio/io_service.hpp>

+#include <boost/asio/placeholders.hpp>

+#include <boost/asio/io_service.hpp>

+#include <boost/asio/ip/tcp.hpp>

+#include <boost/asio/io_service.hpp>

+#include <boost/thread/thread.hpp>

+#include <boost/bind.hpp>

+#include <boost/asio/io_service.hpp>

+#include <boost/asio/deadline_timer.hpp>

+#include <boost/asio/io_service.hpp>

+#include <boost/thread/thread.hpp>

+#include <Swiften/Base/boost_bsignals.h>

+#include <Swiften/Base/ByteArray.h>

+ class HostAddressPort;

+

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/Network/DummyConnection.h>

+

+#include <boost/bind.hpp>

+#include <cassert>

+

+namespace Swift {

+

+DummyConnection::DummyConnection(EventLoop* eventLoop) : eventLoop(eventLoop) {

+}

+

+void DummyConnection::receive(const ByteArray& data) {

+ eventLoop->postEvent(boost::bind(boost::ref(onDataRead), ByteArray(data)), shared_from_this());

+}

+

+void DummyConnection::listen() {

+ assert(false);

+}

+

+void DummyConnection::connect(const HostAddressPort&) {

+ assert(false);

+}

+

+

+}

+#include "Swiften/Network/HostAddressPort.h"

+ DummyConnection(EventLoop* eventLoop);

+ void listen();

+ void connect(const HostAddressPort&);

+ void receive(const ByteArray& data);

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/Network/FakeConnection.h>

+

+#include <boost/bind.hpp>

+

+namespace Swift {

+

+FakeConnection::FakeConnection(EventLoop* eventLoop) : eventLoop(eventLoop), state(Initial), delayConnect(false) {

+}

+

+FakeConnection::~FakeConnection() {

+}

+

+void FakeConnection::listen() {

+ assert(false);

+}

+

+void FakeConnection::setError(const Error& e) {

+ error = boost::optional<Error>(e);

+ state = DisconnectedWithError;

+ if (connectedTo) {

+ eventLoop->postEvent(

+ boost::bind(boost::ref(onDisconnected), error),

+ shared_from_this());

+ }

+}

+

+void FakeConnection::connect(const HostAddressPort& address) {

+ if (delayConnect) {

+ state = Connecting;

+ }

+ else {

+ if (!error) {

+ connectedTo = address;

+ state = Connected;

+ }

+ else {

+ state = DisconnectedWithError;

+ }

+ eventLoop->postEvent(

+ boost::bind(boost::ref(onConnectFinished), error),

+ shared_from_this());

+ }

+}

+

+void FakeConnection::disconnect() {

+ if (!error) {

+ state = Disconnected;

+ }

+ else {

+ state = DisconnectedWithError;

+ }

+ connectedTo.reset();

+ eventLoop->postEvent(

+ boost::bind(boost::ref(onDisconnected), error),

+ shared_from_this());

+}

+

+}

+ FakeConnection(EventLoop* eventLoop);

+ ~FakeConnection();

+ virtual void listen();

+ void setError(const Error& e);

+ virtual void connect(const HostAddressPort& address);

+ virtual void disconnect();

+ catch (const std::exception&) {

+#include <boost/asio/ip/address.hpp>

+#include <boost/asio/ip/tcp.hpp>

+#include <boost/asio/ip/tcp.hpp>

+

+#include <boost/asio/io_service.hpp>

+#include <boost/thread/thread.hpp>

+ "DummyConnection.cpp",

+ "FakeConnection.cpp",

+ virtual boost::shared_ptr<Payload> getPayload() const = 0;

+ catch (boost::bad_lexical_cast&) {

+#include <boost/date_time/posix_time/posix_time.hpp>

+#include <boost/date_time/posix_time/posix_time.hpp>

+ catch (boost::bad_lexical_cast&) {

+ catch (boost::bad_lexical_cast&) {

+ catch (boost::bad_lexical_cast&) {

+ catch (boost::bad_lexical_cast&) {

+ boost::shared_ptr<Priority> payload = boost::dynamic_pointer_cast<Priority>(parser.getPayload());

+ boost::shared_ptr<Priority> payload = boost::dynamic_pointer_cast<Priority>(parser.getPayload());

+void PayloadAddingPresenceSender::setPayload(boost::shared_ptr<Payload> payload) {

+ void sendPresence(boost::shared_ptr<Presence>);

+ void setPayload(boost::shared_ptr<Payload>);

+ boost::shared_ptr<Presence> lastSentPresence;

+ boost::shared_ptr<Payload> payload;

+#include <iostream>

+ virtual void handleResponse(boost::shared_ptr<Payload> payload, ErrorPayload::ref error) {

+#pragma once

+ virtual void setPayload(boost::shared_ptr<Payload> payload) {

+ boost::shared_ptr<Payload> getPayload() const {

+ virtual void handleResponse(boost::shared_ptr<Payload>, boost::shared_ptr<ErrorPayload>) = 0;

+ virtual void handleResponse(boost::shared_ptr<Payload> payload, ErrorPayload::ref error) {

+ boost::signal<void (boost::shared_ptr<Payload>, ErrorPayload::ref)> onResponse;

+/*

+ * Copyright (c) 2010-2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/Roster/UnitTest/XMPPRosterSignalHandler.h>

+

+#include <boost/bind.hpp>

+#include <cassert>

+

+using namespace Swift;

+

+XMPPRosterSignalHandler::XMPPRosterSignalHandler(Swift::XMPPRoster* roster) {

+ lastEvent_ = None;

+ roster->onJIDAdded.connect(boost::bind(&XMPPRosterSignalHandler::handleJIDAdded, this, _1));

+ roster->onJIDRemoved.connect(boost::bind(&XMPPRosterSignalHandler::handleJIDRemoved, this, _1));

+ roster->onJIDUpdated.connect(boost::bind(&XMPPRosterSignalHandler::handleJIDUpdated, this, _1, _2, _3));

+}

+

+void XMPPRosterSignalHandler::handleJIDUpdated(const Swift::JID& jid, const std::string& oldName, const std::vector<std::string>& oldGroups) {

+ assert(lastEvent_ == None);

+ lastJID_ = jid;

+ lastOldName_ = oldName;

+ lastOldGroups_ = oldGroups;

+ lastEvent_ = Update;

+}

+

+#include <boost/shared_ptr.hpp>

+ XMPPRosterSignalHandler(Swift::XMPPRoster* roster);

+ Swift::JID getLastJID() {

+ void handleJIDAdded(const Swift::JID& jid) {

+ void handleJIDRemoved(const Swift::JID& jid) {

+ void handleJIDUpdated(const Swift::JID& jid, const std::string& oldName, const std::vector<std::string>& oldGroups);

+ Swift::JID lastJID_;

+ "Client/ClientXMLTracer.cpp",

+ "Elements/Presence.cpp",

+ "Elements/StreamFeatures.cpp",

+ "Session/SessionTracer.cpp",

+ File("Roster/UnitTest/XMPPRosterSignalHandler.cpp"),

+ if file.startswith("CAres") or file.startswith("LibXML") or file.startswith("Expat") or file.startswith("foreach") or file.startswith("Log.h") or file.startswith("format.h") :

+#pragma once

+#include <boost/shared_ptr.hpp>

+ class Payload;

+

+#include <boost/date_time/posix_time/posix_time.hpp>

+#include <boost/lexical_cast.hpp>

+#include <boost/date_time/posix_time/posix_time.hpp>

+

+ boost::shared_ptr<XMLElement> featureElement(new XMLElement("feature", FEATURE_NEG_NS));

+#include <Swiften/Base/foreach.h>

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/Session/SessionTracer.h>

+

+#include <iostream>

+#include <boost/bind.hpp>

+

+namespace Swift {

+

+SessionTracer::SessionTracer(boost::shared_ptr<Session> session) : session(session) {

+ session->onDataRead.connect(boost::bind(&SessionTracer::printData, this, '<', _1));

+ session->onDataWritten.connect(boost::bind(&SessionTracer::printData, this, '>', _1));

+}

+

+void SessionTracer::printData(char direction, const ByteArray& data) {

+ std::cerr << direction << direction << " " << session->getLocalJID() << " ";

+ for (unsigned int i = 0; i < 72 - session->getLocalJID().toString().size() - session->getRemoteJID().toString().size(); ++i) {

+ std::cerr << direction;

+ }

+ std::cerr << " " << session->getRemoteJID()<< " " << direction << direction << std::endl;

+ std::cerr << data.toString() << std::endl;

+}

+

+}

+#include <string>

+ SessionTracer(boost::shared_ptr<Session> session);

+ void printData(char direction, const ByteArray& data);

+#include <iostream>

+ catch (const ZLibException&) {

+ catch (const ZLibException&) {

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/StreamStack/ConnectionLayer.h>

+#include <boost/bind.hpp>

+

+namespace Swift {

+

+ConnectionLayer::ConnectionLayer(boost::shared_ptr<Connection> connection) : connection(connection) {

+ connection->onDataRead.connect(boost::bind(&ConnectionLayer::writeDataToParentLayer, this, _1));

+}

+

+ConnectionLayer::~ConnectionLayer() {

+ connection->onDataRead.disconnect(boost::bind(&ConnectionLayer::writeDataToParentLayer, this, _1));

+}

+

+

+}

+ ConnectionLayer(boost::shared_ptr<Connection> connection);

+ ~ConnectionLayer();

+ "ConnectionLayer.cpp",

+ for (size_t i = 0; i < layers_.size(); ++i) {

+ T* layer = dynamic_cast<T*>(layers_[i]);

+#include <boost/filesystem.hpp>

+#include <iostream>

+#include <boost/filesystem/path.hpp>

+#include <Swiften/Base/foreach.h>

+#include <iostream>

+#include <Swiften/Base/foreach.h>

+#include <boost/bind.hpp>

+#include <boost/date_time/posix_time/posix_time.hpp>

+

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>