vars.Add(BoolVariable("max_jobs", "Build with maximum number of parallel jobs", "no"))

vars.Add(EnumVariable("target", "Choose a target platform for compilation", "native", ["native", "iphone-simulator", "iphone-device", "xcode"]))

vars.Add(BoolVariable("swift_mobile", "Build mobile Swift", "no"))

if os.name != "nt" :

vars.Add(BoolVariable("coverage", "Compile with coverage information", "no"))

if os.name == "posix" :

import SCons.Util, os

def generate(env) :

def exists(env) :

myenv.Program("checker", lib)

else :

checker = myenv.Program("checker", env["UNITTEST_SOURCES"] + env["UNITTEST_OBJECTS"])

myenv.Test(checker, is_checker = True)

import Version

def generateDefaultTheme(dir) :

myenv["SWIFT_VERSION_MINOR"] = int(version_match.group(2)) if version_match else 0

if env["PLATFORM"] == "win32" :

# For some reason, SCons isn't picking up the dependency correctly

# Adding it explicitly until i figure out why

"WinUIHelpers.cpp",

"CAPICertificateSelector.cpp",

"WindowsNotifier.cpp",

"#/Swift/resources/images",

]

if env["SWIFTEN_DLL"] :

qtimageformats = ["gif", "ico", "jpeg", "mng", "svg", "tiff"]

qtlibs = ["QtCore4", "QtGui4", "QtNetwork4", "QtWebKit4", "QtXMLPatterns4", "phonon4"]

myenv.WindowsBundle("Swift",

#include "Swift/Controllers/BuildVersion.h"

1 VERSIONINFO

// PRODUCTVERSION 1.0

FILEFLAGSMASK 0x3fL

#ifdef _DEBUG

VALUE "FileDescription", "Swift\0"

VALUE "FileVersion", SWIFT_VERSION_STRING

VALUE "InternalName", "Swift\0"

VALUE "OriginalFilename", "Swift.exe\0"

VALUE "ProductName", "Swift\0"

VALUE "ProductVersion", SWIFT_VERSION_STRING

#include <boost/filesystem/path.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

class JID;

public:

virtual ~AvatarManager();

#include <string>

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

class JID;

public:

virtual ~AvatarProvider();

#include <vector>

#include <map>

#include <Swiften/Avatars/AvatarProvider.h>

#include <Swiften/JID/JID.h>

namespace Swift {

public:

virtual std::string getAvatarHash(const JID&) const;

#pragma once

#include <Swiften/Avatars/AvatarProvider.h>

#include <Swiften/JID/JID.h>

class AvatarStorage;

class VCardManager;

public:

VCardAvatarManager(VCardManager*, AvatarStorage*, MUCRegistry* = NULL);

#include <boost/shared_ptr.hpp>

#include <map>

#include <Swiften/Avatars/AvatarProvider.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/Presence.h>

class StanzaChannel;

class VCardManager;

public:

VCardUpdateAvatarManager(VCardManager*, StanzaChannel*, AvatarStorage*, MUCRegistry* = NULL);

#pragma once

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

namespace Swift {

* Converts a date formatted according to XEP-0082 into a ptime

* object (in UTC).

*/

/**

* Converts a UTC ptime object to a XEP-0082 formatted string.

*/

}

#pragma once

#include <vector>

namespace Swift {

public:

virtual ~RandomGenerator();

#include <string>

namespace Swift {

public:

SimpleIDGenerator();

#include <string>

#include <boost/lexical_cast.hpp>

#include <boost/optional.hpp>

namespace Swift {

public:

URL() : scheme(""), user(""), password(""), host(""), path(""), empty(true) {

#include <boost/shared_ptr.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <Swiften/Base/Error.h>

#include <Swiften/Session/SessionStream.h>

#include <string>

class ClientAuthenticator;

class CertificateTrustChecker;

public:

enum State {

Initial,

#pragma once

#include <Swiften/Base/boost_bsignals.h>

#include <string>

namespace Swift {

public:

virtual ~NickManager();

#include <Swiften/Base/boost_bsignals.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/Timer.h>

#include <Swiften/Network/HostAddressPort.h>

class ConnectionFactory;

class TimerFactory;

public:

typedef boost::shared_ptr<ComponentConnector> ref;

#include <string>

namespace Swift {

public:

static std::string getHandshake(const std::string& streamID, const std::string& secret);

};

#include <boost/shared_ptr.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <Swiften/JID/JID.h>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Base/Error.h>

namespace Swift {

class ComponentAuthenticator;

public:

enum State {

Initial,

#pragma once

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

ZLibCodecompressor();

virtual ~ZLibCodecompressor();

#pragma once

#include <Swiften/Compress/ZLibCodecompressor.h>

namespace Swift {

public:

ZLibCompressor();

~ZLibCompressor();

#pragma once

#include <Swiften/Compress/ZLibCodecompressor.h>

namespace Swift {

public:

ZLibDecompressor();

~ZLibDecompressor();

#pragma once

#include <string>

#include <Swiften/Elements/CapsInfo.h>

namespace Swift {

class DiscoInfo;

public:

CapsInfoGenerator(const std::string& node);

#include <set>

#include <map>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/DiscoInfo.h>

class JID;

class CapsStorage;

public:

CapsManager(CapsStorage*, StanzaChannel*, IQRouter*);

#include <map>

#include <Swiften/Queries/GetResponder.h>

#include <Swiften/Elements/DiscoInfo.h>

namespace Swift {

class IQRouter;

public:

DiscoInfoResponder(IQRouter* router);

#include <map>

#include <Swiften/Disco/EntityCapsProvider.h>

namespace Swift {

public:

DummyEntityCapsProvider() {

}

#include <map>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/DiscoInfo.h>

* This information is provided in the form of service discovery

* information.

*/

public:

EntityCapsManager(CapsProvider*, StanzaChannel*);

#pragma once

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/DiscoInfo.h>

* This information is provided in the form of service discovery

* information.

*/

public:

virtual ~EntityCapsProvider();

#include <map>

#include <Swiften/Queries/GetResponder.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class IQRouter;

public:

JIDDiscoInfoResponder(IQRouter* router);

#include <string>

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/Payload.h>

#include <Swiften/JID/JID.h>

namespace Swift {

public:

typedef boost::shared_ptr<RosterItemExchangePayload> ref;

public:

enum Action { Add, Modify, Delete };

#include <boost/optional.hpp>

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/RosterItemPayload.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

public:

typedef boost::shared_ptr<RosterPayload> ref;

typedef std::vector<RosterItemPayload> RosterItemPayloads;

#pragma once

#include <Swiften/Elements/Payload.h>

namespace Swift {

public:

enum Type { Online, Away, FFC, XA, DND, None };

#include <string>

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/Element.h>

namespace Swift {

public:

typedef boost::shared_ptr<StreamFeatures> ref;

#include <string>

#include <Swiften/Elements/Element.h>

namespace Swift {

public:

StreamManagementEnabled();

~StreamManagementEnabled();

#include <string>

namespace Swift {

public:

WhiteboardColor();

WhiteboardColor(int red, int green, int blue, int alpha = 255);

#include <boost/filesystem.hpp>

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

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/JID/JID.h>

#include <Swiften/FileTransfer/OutgoingFileTransfer.h>

class ReadBytestream;

class S5BProxyRequest;

public:

virtual ~FileTransferManager();

#include <boost/shared_ptr.hpp>

#include <boost/optional/optional_fwd.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/FileTransfer/WriteBytestream.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class IQRouter;

public:

IBBReceiveSession(

const std::string& id,

#include <boost/shared_ptr.hpp>

#include <boost/optional.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/FileTransfer/ReadBytestream.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class IQRouter;

public:

IBBSendSession(const std::string& id, const JID& from, const JID& to, boost::shared_ptr<ReadBytestream> bytestream, IQRouter* router);

~IBBSendSession();

#include <boost/shared_ptr.hpp>

#include <boost/cstdint.hpp>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Network/Timer.h>

#include <Swiften/Jingle/JingleSession.h>

class SOCKS5BytestreamProxy;

class IncrementalBytestreamHashCalculator;

public:

typedef boost::shared_ptr<IncomingJingleFileTransfer> ref;

enum State {

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Elements/JingleTransportPayload.h>

#include <Swiften/FileTransfer/JingleTransport.h>

namespace Swift {

public:

virtual ~LocalJingleTransportCandidateGenerator();

/**

#pragma once

namespace Swift {

class LocalJingleTransportCandidateGenerator;

public:

virtual ~LocalJingleTransportCandidateGeneratorFactory();

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/JingleContentPayload.h>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

#include <Swiften/Elements/StreamInitiationFileInfo.h>

class SOCKS5BytestreamRegistry;

class SOCKS5BytestreamProxy;

public:

OutgoingJingleFileTransfer(JingleSession::ref,

RemoteJingleTransportCandidateSelectorFactory*,

#include <boost/shared_ptr.hpp>

#include <vector>

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

public:

virtual ~ReadBytestream();

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/JingleTransportPayload.h>

#include <Swiften/FileTransfer/JingleTransport.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>

namespace Swift {

public:

virtual ~RemoteJingleTransportCandidateSelector();

#pragma once

namespace Swift {

class RemoteJingleTransportCandidateSelector;

public:

virtual ~RemoteJingleTransportCandidateSelectorFactory();

#include <boost/shared_ptr.hpp>

#include <boost/optional.hpp>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/FileTransfer/FileTransferError.h>

#include <Swiften/FileTransfer/WriteBytestream.h>

* A session which has been connected to a SOCKS5 server (requester).

*

*/

public:

enum State {

Initial,

#include <string>

#include <vector>

#include <Swiften/Elements/S5BProxyRequest.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>

#include <Swiften/JID/JID.h>

* - manages list of working S5B proxies

* - creates initial connections (for the candidates you provide)

*/

public:

SOCKS5BytestreamProxy(ConnectionFactory*, TimerFactory*);

#include <vector>

#include <set>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/S5BProxyRequest.h>

#include <Swiften/Network/HostAddressPort.h>

namespace Swift {

public:

SOCKS5BytestreamRegistry();

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/FileTransfer/ReadBytestream.h>

namespace Swift {

class SOCKS5BytestreamRegistry;

public:

typedef boost::shared_ptr<SOCKS5BytestreamServerSession> ref;

#include <boost/shared_ptr.hpp>

#include <vector>

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

public:

typedef boost::shared_ptr<WriteBytestream> ref;

#include <string>

namespace Swift {

public:

static std::string getEncoded(const std::string& s);

};

#pragma once

#include <string>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

enum Profile {

NamePrep,

#include <vector>

#include <boost/variant.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/JinglePayload.h>

namespace Swift {

class JingleContentID;

public:

struct InitiateCall {

InitiateCall(JingleContentID contentId, JingleDescription::ref desc, JingleTransportPayload::ref payL) : id(contentId), description(desc), payload(payL) {}

#include <boost/shared_ptr.hpp>

#include <map>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Jingle/JingleSessionImpl.h>

class JingleResponder;

class IncomingJingleSessionHandler;

friend class JingleResponder;

public:

JingleSessionManager(IQRouter* router);

#pragma once

#include <string>

namespace Swift {

public:

static const char* PresenceServiceType;

#include <set>

#include <string>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/EventLoop/EventOwner.h>

#include <Swiften/LinkLocal/DNSSD/DNSSDQuerier.h>

class FakeDNSSDBrowseQuery;

class EventLoop;

public DNSSDQuerier,

public EventOwner,

public boost::enable_shared_from_this<FakeDNSSDQuerier> {

#include <boost/enable_shared_from_this.hpp>

#include <vector>

#include <Swiften/Network/Connection.h>

#include <Swiften/LinkLocal/LinkLocalService.h>

class DNSSDQuerier;

class DNSSDResolveHostnameQuery;

public:

LinkLocalConnector(

const LinkLocalService& service,

#pragma once

#include <string>

#include <Swiften/JID/JID.h>

#include <Swiften/LinkLocal/DNSSD/DNSSDServiceID.h>

#include <Swiften/LinkLocal/DNSSD/DNSSDResolveServiceQuery.h>

#include <Swiften/LinkLocal/LinkLocalServiceInfo.h>

namespace Swift {

public:

LinkLocalService(

const DNSSDServiceID& id,

#include <vector>

#include <string>

#include <Swiften/LinkLocal/DNSSD/DNSSDQuerier.h>

#include <Swiften/LinkLocal/DNSSD/DNSSDResolveServiceQuery.h>

#include <Swiften/LinkLocal/DNSSD/DNSSDRegisterQuery.h>

#include <Swiften/LinkLocal/LinkLocalServiceInfo.h>

namespace Swift {

public:

LinkLocalServiceBrowser(boost::shared_ptr<DNSSDQuerier> querier);

~LinkLocalServiceBrowser();

#include <boost/optional.hpp>

#include <Swiften/Base/ByteArray.h>

#include <string>

#include <Swiften/JID/JID.h>

namespace Swift {

public:

enum Status { Available, Away, DND };

#include <boost/enable_shared_from_this.hpp>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/Connector.h>

#include <Swiften/Network/HostAddressPort.h>

class XMLParserFactory;

class TLSContextFactory;

public:

enum Type {BadRequest, HostGone, HostUnknown, ImproperAddressing,

InternalServerError, ItemNotFound, OtherRequest, PolicyViolation,

};

public:

typedef boost::shared_ptr<BOSHConnection> ref;

static ref create(const URL& boshURL, Connector::ref connector, XMLParserFactory* parserFactory) {

#include <vector>

#include <Swiften/Base/SafeString.h>

#include <Swiften/Network/BOSHConnection.h>

class CachingDomainNameResolver;

class EventLoop;

public:

BOSHConnectionPool(const URL& boshURL, DomainNameResolver* resolver, ConnectionFactory* connectionFactory, XMLParserFactory* parserFactory, TLSContextFactory* tlsFactory, TimerFactory* timerFactory, EventLoop* eventLoop, const std::string& to, unsigned long long initialRID, const URL& boshHTTPConnectProxyURL, const SafeString& boshHTTPConnectProxyAuthID, const SafeString& boshHTTPConnectProxyAuthPassword);

~BOSHConnectionPool();

#include <deque>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Base/Error.h>

class TimerFactory;

class DomainNameResolver;

public:

ChainedConnector(const std::string& hostname, int port, bool doServiceLookups, DomainNameResolver*, const std::vector<ConnectionFactory*>&, TimerFactory*);

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

class HostAddressPort;

public:

typedef boost::shared_ptr<Connection> ref;

#include <boost/shared_ptr.hpp>

namespace Swift {

class Connection;

public:

virtual ~ConnectionFactory();

#include <Swiften/Base/boost_bsignals.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Network/DomainNameServiceQuery.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/Timer.h>

class ConnectionFactory;

class TimerFactory;

public:

typedef boost::shared_ptr<Connector> ref;

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swiften/Network/DomainNameResolveError.h>

namespace Swift {

class RandomGenerator;

public:

typedef boost::shared_ptr<DomainNameServiceQuery> ref;

#include <boost/enable_shared_from_this.hpp>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/EventLoop/EventLoop.h>

#include <Swiften/EventLoop/EventOwner.h>

namespace Swift {

public:

DummyConnection(EventLoop* eventLoop);

#include <list>

#include <Swiften/Network/TimerFactory.h>

namespace Swift {

public:

class DummyTimer;

#include <boost/enable_shared_from_this.hpp>

#include <vector>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/EventLoop/EventOwner.h>

#include <Swiften/EventLoop/EventLoop.h>

namespace Swift {

public Connection,

public EventOwner,

public boost::enable_shared_from_this<FakeConnection> {

#pragma once

#include <Swiften/Network/ProxiedConnection.h>

namespace Swift {

class EventLoop;

class TimerFactory;

public:

typedef boost::shared_ptr<HTTPConnectProxiedConnection> ref;

#include <vector>

#include <map>

#include <Swiften/Network/HostAddress.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Network/DomainNameResolver.h>

#include <Swiften/EventLoop/EventLoop.h>

namespace Swift {

public:

typedef std::map<std::string, std::vector<HostAddress> > AddressesMap;

typedef std::vector< std::pair<std::string, DomainNameServiceQuery::Result> > ServicesCollection;

#pragma once

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

/**

* A class for triggering an event after a given period.

*/

public:

typedef boost::shared_ptr<Timer> ref;

#include <boost/shared_ptr.hpp>

#include <Swiften/Network/Timer.h>

namespace Swift {

public:

virtual ~TimerFactory();

*/

#pragma once

#include <Swiften/Network/ProxyProvider.h>

namespace Swift {

public:

WindowsProxyProvider();

virtual HostAddressPort getHTTPConnectProxy() const;

#include <boost/optional.hpp>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Parser/XMLParserClient.h>

namespace Swift {

class XMLParserFactory;

friend class BOSHBodyParserClient;

public:

struct BOSHBody {

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swiften/Elements/Element.h>

#include <Swiften/Parser/AttributeMap.h>

namespace Swift {

public:

virtual ~ElementParser();

#include <boost/noncopyable.hpp>

#include <boost/shared_ptr.hpp>

#include <Swiften/Parser/XMLParser.h>

namespace Swift {

public:

ExpatParser(XMLParserClient* client);

~ExpatParser();

#pragma once

#include <Swiften/Parser/GenericStanzaParser.h>

#include <Swiften/Elements/IQ.h>

namespace Swift {

public:

IQParser(PayloadParserFactoryCollection* factories);

#pragma once

#include <Swiften/Parser/GenericStanzaParser.h>

#include <Swiften/Elements/Message.h>

namespace Swift {

public:

MessageParser(PayloadParserFactoryCollection* factories);

#pragma once

#include <Swiften/Elements/RawXMLPayload.h>

#include <Swiften/Parser/GenericPayloadParser.h>

#include <Swiften/Parser/SerializingParser.h>

namespace Swift {

class SerializingParser;

public:

RawXMLPayloadParser();

#pragma once

#include <Swiften/Parser/GenericStanzaParser.h>

#include <Swiften/Elements/Presence.h>

namespace Swift {

public:

PresenceParser(PayloadParserFactoryCollection* factories);

#pragma once

#include <string>

#include <Swiften/Parser/AttributeMap.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

public:

SerializingParser();

#pragma once

#include <Swiften/Parser/GenericElementParser.h>

#include <Swiften/Elements/StanzaAck.h>

namespace Swift {

public:

StanzaAckParser();

#include <boost/noncopyable.hpp>

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swiften/Elements/Stanza.h>

#include <Swiften/Parser/ElementParser.h>

class PayloadParser;

class PayloadParserFactoryCollection;

public:

StanzaParser(PayloadParserFactoryCollection* factories);

~StanzaParser();

#pragma once

#include <string>

#include <Swiften/Parser/GenericElementParser.h>

#include <Swiften/Elements/StreamFeatures.h>

namespace Swift {

public:

StreamFeaturesParser();

#include <Swiften/Parser/GenericElementParser.h>

#include <Swiften/Elements/StreamManagementEnabled.h>

namespace Swift {

public:

StreamManagementEnabledParser();

~StreamManagementEnabledParser();

#include <string>

#include <vector>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Parser/AttributeMap.h>

#include <boost/shared_ptr.hpp>

#include <boost/smart_ptr/make_shared.hpp>

namespace Swift {

public:

typedef boost::shared_ptr<ParserElement> ref;

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Parser/GenericPayloadTreeParser.h>

#include <Swiften/Parser/PayloadParsers/UnitTest/PayloadParserTester.h>

#include <Swiften/Elements/RawXMLPayload.h>

using namespace Swift;

class GenericPayloadTreeParserTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(GenericPayloadTreeParserTest);

CPPUNIT_TEST(testTree);

#include <Swiften/Elements/Presence.h>

#include <Swiften/Presence/PresenceSender.h>

namespace Swift {

public:

enum SendPresence {AndSendPresence, DontSendPresence};

DirectedPresenceSender(PresenceSender*);

#pragma once

#include <Swiften/Presence/PresenceSender.h>

#include <Swiften/Elements/Payload.h>

*

* This class isn't meant to be used with directed presence.

*/

public:

PayloadAddingPresenceSender(PresenceSender*);

#pragma once

#include <Swiften/Presence/PresenceSender.h>

namespace Swift {

class StanzaChannel;

public:

StanzaChannelPresenceSender(StanzaChannel*);

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swiften/Elements/IQ.h>

namespace Swift {

public:

virtual ~IQChannel();

#pragma once

#include <Swiften/Roster/RosterStorage.h>

namespace Swift {

public:

RosterMemoryStorage();

#include <boost/shared_ptr.hpp>

#include <Swiften/JID/JID.h>

#include <string>

#include <Swiften/Elements/IQ.h>

class XMPPRosterImpl;

class RosterStorage;

public:

XMPPRosterController(IQRouter *iqRouter, XMPPRosterImpl* xmppRoster, RosterStorage* storage);

~XMPPRosterController();

#include <map>

#include <set>

#include <Swiften/Roster/XMPPRoster.h>

namespace Swift {

public:

XMPPRosterImpl();

#include <string>

#include <vector>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

public:

ClientAuthenticator(const std::string& name);

virtual ~ClientAuthenticator();

#include <string>

#include <vector>

#include <Swiften/SASL/ClientAuthenticator.h>

#include <Swiften/SASL/DIGESTMD5Properties.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

DIGESTMD5ClientAuthenticator(const std::string& host, const std::string& nonce);

#include <boost/optional.hpp>

#include <string>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

public:

DIGESTMD5Properties();

#pragma once

#include <Swiften/SASL/ClientAuthenticator.h>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

public:

PLAINClientAuthenticator();

#include <string>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/SASL/ClientAuthenticator.h>

namespace Swift {

public:

SCRAMSHA1ClientAuthenticator(const std::string& nonce, bool useChannelBinding = false);

Import("env")

external_swiften_dep_modules = ["BOOST"]

if env["SCONS_STAGE"] == "flags" :

env["SWIFTEN_VERSION"] = Version.getBuildVersion(env.Dir("#").abspath, "swift")

version_match = re.match("(\d+)\.(\d+).*", env["SWIFTEN_VERSION"])

if version_match :

if env["SWIFTEN_DLL"] :

if env["PLATFORM"] == "win32" :

elif env["PLATFORM"] == "darwin" :

env["SWIFTEN_LIBRARY_FILE"] = env.subst("Swiften.${SWIFTEN_VERSION_MAJOR}.${SWIFTEN_VERSION_MINOR}")

env["SWIFTEN_LIBRARY_ALIASES"] = ["libSwiften.dylib", env.subst("libSwiften.${SWIFTEN_VERSION_MAJOR}.dylib")]

swiften_env = env.Clone()

swiften_env["LIBPATH"] = [Dir(".")]

swiften_env["LIBS"] = [swiften_env["SWIFTEN_LIBRARY"]]

if not env["SWIFTEN_DLL"] :

swiften_env.Append(CPPDEFINES = ["SWIFTEN_STATIC"])

"CPPPATH": e.get("CPPPATH", []),

"CPPFLAGS": e.get("CPPFLAGS", []),

"LIBPATH": e.get("LIBPATH", []),

"LIBS": e.get("LIBS", []),

"FRAMEWORKS": e.get("FRAMEWORKS", []),

}

if myenv["PLATFORM"] != "darwin" and myenv["PLATFORM"] != "win32" and myenv.get("HAVE_GCONF", 0) :

env.MergeFlags(env["GCONF_FLAGS"])

if myenv["SWIFTEN_DLL"] :

if myenv["PLATFORM"] == "posix" :

myenv.Append(LINKFLAGS = ["-Wl,-soname,libSwiften.so.$SWIFTEN_VERSION_MAJOR"])

myenv["SHLIBSUFFIX"] = ""

elif myenv["PLATFORM"] == "darwin" :

myenv.Append(LINKFLAGS = ["-Wl,-install_name,libSwiften.so.$SWIFTEN_VERSION_MAJOR", "-Wl,-compatibility_version,${SWIFTEN_VERSION_MAJOR}.${SWIFTEN_VERSION_MINOR}", "-Wl,-current_version,${SWIFTEN_VERSION_MAJOR}.${SWIFTEN_VERSION_MINOR}"])

swiften_lib = myenv.SwiftenLibrary(swiften_env["SWIFTEN_LIBRARY_FILE"], sources + swiften_env["SWIFTEN_OBJECTS"])

def symlink(env, target, source) :

if os.path.exists(str(target[0])) :

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/AuthChallenge.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

public:

AuthChallengeSerializer();

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/AuthRequest.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

public:

AuthRequestSerializer();

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/AuthResponse.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

public:

AuthResponseSerializer();

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/AuthSuccess.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

public:

AuthSuccessSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/CapsInfo.h>

namespace Swift {

public:

CapsInfoSerializer();

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/DeliveryReceiptRequest.h>

namespace Swift {

public:

DeliveryReceiptRequestSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/DeliveryReceipt.h>

namespace Swift {

public:

DeliveryReceiptSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/Form.h>

#include <Swiften/Elements/FormField.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

public:

FormSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/InBandRegistrationPayload.h>

namespace Swift {

public:

InBandRegistrationPayloadSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/JingleFileTransferDescription.h>

namespace Swift {

class PayloadSerializerCollection;

class XMLElement;

public:

JingleFileTransferDescriptionSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/JinglePayload.h>

class PayloadSerializerCollection;

class XMLElement;

public:

JinglePayloadSerializer(PayloadSerializerCollection*);

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/MUCAdminPayload.h>

namespace Swift {

public:

MUCAdminPayloadSerializer();

std::string affiliationToString(MUCOccupant::Affiliation affiliation) const;

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/ResourceBind.h>

namespace Swift {

public:

ResourceBindSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/RosterItemExchangePayload.h>

namespace Swift {

public:

RosterItemExchangeSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/SearchPayload.h>

namespace Swift {

class PayloadSerializerCollection;

public:

SearchPayloadSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/SecurityLabel.h>

namespace Swift {

public:

SecurityLabelSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/SecurityLabelsCatalog.h>

namespace Swift {

public:

SecurityLabelsCatalogSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/SoftwareVersion.h>

namespace Swift {

public:

SoftwareVersionSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/StreamInitiationFileInfo.h>

namespace Swift {

class PayloadSerializerCollection;

public:

StreamInitiationFileInfoSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/StreamInitiation.h>

namespace Swift {

public:

StreamInitiationSerializer();

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/VCardUpdate.h>

namespace Swift {

public:

VCardUpdateSerializer();

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/StreamFeatures.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

public:

StreamFeaturesSerializer();

#include <boost/shared_ptr.hpp>

#include <vector>

#include <Swiften/Elements/Element.h>

#include <Swiften/Elements/StreamType.h>

#include <string>

class CompressRequestSerializer;

class ProtocolHeader;

public:

XMPPSerializer(PayloadSerializerCollection*, StreamType type);

#include <boost/shared_ptr.hpp>

#include <boost/optional.hpp>

#include <Swiften/Elements/ProtocolHeader.h>

#include <Swiften/Elements/Element.h>

#include <Swiften/Base/Error.h>

#include <Swiften/TLS/CertificateVerificationError.h>

namespace Swift {

public:

class SessionStreamError : public Swift::Error {

public:

#include <boost/shared_ptr.hpp>

#include <deque>

#include <Swiften/Elements/Stanza.h>

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

public:

StanzaAckRequester();

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/Stanza.h>

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

public:

StanzaAckResponder();

#pragma once

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

class LowLayer;

friend class StreamStack;

public:

#pragma once

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

class HighLayer;

friend class StreamStack;

public:

#include <Swiften/Base/boost_bsignals.h>

#include <vector>

#include <Swiften/Elements/Stanza.h>

namespace Swift {

class LowLayer;

class StreamLayer;

public:

StreamStack(XMPPLayer* xmppLayer, LowLayer* physicalLayer);

~StreamStack();

#pragma once

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

struct md5_state_s;

public:

MD5();

~MD5();

#include <vector>

#include <boost/cstdint.hpp>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

SHA256();

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

public:

typedef boost::shared_ptr<Certificate> ref;

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swiften/JID/JID.h>

#include <Swiften/TLS/Certificate.h>

namespace Swift {

public:

ServerIdentityVerifier(const JID& jid);

#pragma once

#include <Swiften/Whiteboard/WhiteboardSession.h>

#include <Swiften/Whiteboard/WhiteboardClient.h>

#include <boost/shared_ptr.hpp>

namespace Swift {

public:

typedef boost::shared_ptr<IncomingWhiteboardSession> ref;

#include <Swiften/Whiteboard/WhiteboardServer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Queries/GenericRequest.h>

namespace Swift {

public:

typedef boost::shared_ptr<OutgoingWhiteboardSession> ref;

#pragma once

#include <Swiften/Elements/Whiteboard/WhiteboardOperation.h>

#include <list>

#include <utility>

namespace Swift {

public:

struct Result {

WhiteboardOperation::ref client;

#pragma once

#include <Swiften/Elements/Whiteboard/WhiteboardInsertOperation.h>

#include <list>

namespace Swift {

public:

void handleLocalOperationReceived(WhiteboardOperation::ref operation);

WhiteboardOperation::ref handleClientOperationReceived(WhiteboardOperation::ref operation);

#include <boost/shared_ptr.hpp>

#include <Swiften/JID/JID.h>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Base/IDGenerator.h>

class ErrorPayload;

class WhiteboardPayload;

public:

typedef boost::shared_ptr<WhiteboardSession> ref;

#include <map>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Client/StanzaChannel.h>

class PresenceOracle;

class EntityCapsProvider;

friend class WhiteboardResponder;

public:

WhiteboardSessionManager(IQRouter* router, StanzaChannel* stanzaChannel, PresenceOracle* presenceOracle, EntityCapsProvider* capsProvider);