if env["warnings"] :

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

env.Append(CCFLAGS = ["/Wall"])

else :

env.Append(CCFLAGS = ["-W", "-Wall"])

#env.Append(CCFLAGS = ["-W", "-Wall", "-Wredundant-decls", "-pedantic", "-Wno-long-long", "-Woverloaded-virtual", "-Wundef", "-Wfloat-equal", "-Wold-style-cast"])

if env.get("coverage", 0) :

assert(env["PLATFORM"] != "win32")

env.Append(CCFLAGS = ["-fprofile-arcs", "-ftest-coverage"])

env.Append(LINKFLAGS = ["-fprofile-arcs", "-ftest-coverage"])

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

env.Append(LIBS = ["dnsapi", "ws2_32", "wsock32"])

env.Append(CCFLAGS = "/EHsc")

env["LINKCOM"] = [env["LINKCOM"], 'mt.exe -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;1']

env["SHLINKCOM"] = [env["SHLINKCOM"], 'mt.exe -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;2']

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

env.Append(FRAMEWORKS = "AppKit")

# Testing

env["TEST_TYPE"] = env["test"]

env.Alias("check", ".")

if "check" in ARGUMENTS or "check" in COMMAND_LINE_TARGETS :

env["TEST_TYPE"] = "unit"

env["TEST"] = (env["TEST_TYPE"] != "none") or env.GetOption("clean")

if env.get("valgrind", 0) :

env["TEST_RUNNER"] = "valgrind --suppressions=QA/valgrind.supp -q --leak-check=full --track-origins=yes "

# Packaging

if ARGUMENTS.get("SWIFT_INSTALLDIR", "") :

env["SWIFT_INSTALLDIR"] = Dir(ARGUMENTS["SWIFT_INSTALLDIR"]).abspath

conf_env = env.Clone()

Export("env")

Export("conf_env")

################################################################################

# Extend the default build environment (not affecting the configure env)

#

# Keeping both environments separated mostly because of SCons Issue 2391,

# although it doesn't hurt to separate them (e.g. not have pretty printed

# strings in config.log)

################################################################################

# Pretty output

def colorize(command, target, color) :

colors = { "red": "31", "green": "32", "yellow": "33", "blue": "34" }

prefix = ""

suffix = ""

if sys.stdout.isatty() and env["PLATFORM"] != "win32":

prefix = "\033[0;" + colors[color] + ";140m"

suffix = "\033[0m"

return " " + prefix + command + suffix + " " + target

if int(ARGUMENTS.get("V", 0)) == 0:

env["CCCOMSTR"] = colorize("CC", "$TARGET", "green")

env["CXXCOMSTR"] = colorize("CXX", "$TARGET", "green")

env["LINKCOMSTR"] = colorize("LINK", "$TARGET", "red")

env["ARCOMSTR"] = colorize("AR", "$TARGET", "red")

env["RANLIBCOMSTR"] = colorize("RANLIB", "$TARGET", "red")

env["QT4_RCCCOMSTR"] = colorize("RCC", "$TARGET", "blue")

env["QT4_UICCOMSTR"] = colorize("UIC", "$TARGET", "blue")

env["QT4_MOCFROMHCOMSTR"] = colorize("MOC", "$TARGET", "blue")

env["QT4_MOCFROMCXXCOMSTR"] = colorize("MOC", "$TARGET", "blue")

env["GENCOMSTR"] = colorize("GEN", "$TARGET", "blue")

env["RCCOMSTR"] = colorize("RC", "$TARGET", "blue")

env["BUNDLECOMSTR"] = colorize("BUNDLE", "$TARGET", "blue")

env["NIBCOMSTR"] = colorize("NIB", "$TARGET", "blue")

env["NSISCOMSTR"] = colorize("NSIS", "$TARGET", "blue")

env["TESTCOMSTR"] = colorize("TEST", "$SOURCE", "yellow")

#Progress(colorize("DEP", "$TARGET", "red")

################################################################################

# Platform configuration

################################################################################

conf = Configure(conf_env)

if conf.CheckLib("z") :

env.Append(LIBS = "z")

env["ZLIB_FLAGS"] = ""

else :

SConscript("3rdParty/ZLib/SConscript")

if conf.CheckLib("dl") :

env.Append(LIBS = ["dl"])

if conf.CheckLib("c") :

env.Append(LIBS = ["c"])

if conf.CheckLib("resolv") :

#pragma once

#include <deque>

#include <boost/signal.hpp>

#include <boost/shared_ptr.hpp>

#include "Swiften/Network/Connection.h"

#include "Swiften/Base/String.h"

namespace Swift {

class DomainNameResolver;

class ConnectionFactory;

class Connector : public boost::bsignals::trackable {

public:

Connector(const String& hostname, DomainNameResolver*, ConnectionFactory*);

void start();

boost::signal<void (boost::shared_ptr<Connection>)> onConnectFinished;

private:

void tryNextHostname();

void handleConnectionConnectFinished(bool error);

private:

String hostname;

DomainNameResolver* resolver;

ConnectionFactory* connectionFactory;

std::deque<HostAddressPort> resolvedHosts;

boost::shared_ptr<Connection> currentConnection;

};

};