env.Append(CXXFLAGS = ["/wd4503"]) # Disable 'decorated name length exceeded, name was truncated' warning

if not env.get("allow_warnings", "False") :

env.Append(CXXFLAGS = ["/WX"])

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

# HP-UX gives a flood of minor warnings if this is enabled

#env.Append(CXXFLAGS = ["+w"])

pass

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

#env.Append(CXXFLAGS = ["-z verbose"])

pass

else :

if os.path.basename(env["CXX"]).startswith(("clang", "clang++")) :

env.Append(CXXFLAGS = [

"-Weverything",

"-Wno-unknown-warning-option", # To stay compatible between CLang versions

"-Wno-unknown-pragmas", # To stay compatible between CLang versions

"-Wno-weak-vtables", # Virtually none of our elements have outlined methods. This also seems to affect classes in .cpp files, which in turn affects all our tests, which may need fixing in CLang

"-Wno-shadow", # Also warns for shadowing on constructor arguments, which we do a lot

"-Wno-documentation", # We don't care about documentation warnings

"-Wno-documentation-unknown-command", # We don't care about documentation warnings

"-Wno-exit-time-destructors", # Used a lot in e.g. CPPUnit

"-Wno-c++98-compat-pedantic", # We do different things that violate this, but they could be fixed

"-Wno-global-constructors", # We depend on this for e.g. string constants

"-Wno-disabled-macro-expansion", # Caused due to system headers

"-Wno-long-long", # We use long long

"-Wno-padded",

"-Wno-missing-variable-declarations", # Getting rid of CPPUnit warnings

"-Wno-direct-ivar-access", # Obj-C code warning

"-Wno-potentially-evaluated-expression", # Caused due to calling shared_ptr::get() inside typeid()

"-Wno-shadow-field", # FIXME: fix source code issues regarding this warning later

"-Wno-unused-template", # FIXME: fix source code issues regarding this warning later

])

else :

env.Append(CXXFLAGS = ["-Wextra", "-Wall", "-Wnon-virtual-dtor", "-Wundef", "-Wold-style-cast", "-Wno-long-long", "-Woverloaded-virtual", "-Wfloat-equal", "-Wredundant-decls", "-Wno-unknown-pragmas"])

gccVersion = env.get("CCVERSION", "0.0.0").split(".")

if gccVersion >= ["4", "5", "0"] and not "clang" in env["CC"] :

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

if not env.get("allow_warnings", False) :

env.Append(CXXFLAGS = ["-Werror"])

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 = ["user32", "crypt32", "dnsapi", "iphlpapi", "ws2_32", "wsock32", "Advapi32", "ntdsapi"])

env.Append(CCFLAGS = ["/EHsc", "/nologo", "/Zm256"])

env.Append(LINKFLAGS = ["/INCREMENTAL:no", "/NOLOGO"])

if int(env["MSVS_VERSION"].split(".")[0]) < 10 :

mt = env.get('mt')

if not mt:

mt = 'mt.exe'

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

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

if env["PLATFORM"] == "darwin" and not env["target"] in ["iphone-device", "iphone-simulator", "xcode", "android"] :

env["PLATFORM_FLAGS"]["FRAMEWORKS"] += ["IOKit", "AppKit", "SystemConfiguration", "Security", "SecurityInterface"]

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <string>

#include <boost/optional/optional.hpp>

#include <Swiften/Base/Override.h>

#include <Sluift/Completer.h>

struct lua_State;

namespace Swift {

class Terminal;

class Console : public Completer {

public:

Console(lua_State* L, Terminal* terminal);

void run();

static int call(lua_State* L, int numberOfArguments, bool keepResult);

private:

std::string getPrompt(bool firstLine) const;

std::string getErrorMessage() const;

bool readCommand();

int tryLoadCommand(const std::string& command);

virtual std::vector<std::string> getCompletions(const std::string&, int start, int end) SWIFTEN_OVERRIDE;

private:

lua_State* L;

Terminal* terminal;

int previousNumberOfReturnArguments;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Sluift/Terminal.h>

namespace Swift {

class EditlineTerminal : public Terminal {

public:

static EditlineTerminal& getInstance();

private:

EditlineTerminal();

virtual boost::optional<std::string> readLine(const std::string& prompt) SWIFTEN_OVERRIDE;

virtual void printError(const std::string& message) SWIFTEN_OVERRIDE;

virtual void addToHistory(const std::string& command) SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Body.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class BodyConvertor : public GenericLuaElementConvertor<Body> {

public:

BodyConvertor();

virtual std::shared_ptr<Body> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<Body>) SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/CarbonsReceived.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class CarbonsReceivedConvertor : public GenericLuaElementConvertor<CarbonsReceived> {

public:

CarbonsReceivedConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<CarbonsReceived> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<CarbonsReceived>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/CarbonsSent.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class CarbonsSentConvertor : public GenericLuaElementConvertor<CarbonsSent> {

public:

CarbonsSentConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<CarbonsSent> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<CarbonsSent>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Command.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class CommandConvertor : public GenericLuaElementConvertor<Command> {

public:

CommandConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<Command> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<Command>) SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Parser/PlatformXMLParserFactory.h>

#include <Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h>

#include <Sluift/LuaElementConvertor.h>

namespace Swift {

class DOMElementConvertor : public LuaElementConvertor {

public:

DOMElementConvertor();

virtual std::shared_ptr<Element> convertFromLua(lua_State*, int index, const std::string& type) SWIFTEN_OVERRIDE;

virtual boost::optional<std::string> convertToLua(lua_State*, std::shared_ptr<Element>) SWIFTEN_OVERRIDE;

private:

PlatformXMLParserFactory parsers;

FullPayloadSerializerCollection serializers;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Sluift/LuaElementConvertor.h>

namespace Swift {

class DefaultElementConvertor : public LuaElementConvertor {

public:

DefaultElementConvertor();

virtual std::shared_ptr<Element> convertFromLua(lua_State*, int index, const std::string& type) SWIFTEN_OVERRIDE;

virtual boost::optional<std::string> convertToLua(lua_State*, std::shared_ptr<Element>) SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Delay.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class DelayConvertor : public GenericLuaElementConvertor<Delay> {

public:

DelayConvertor();

virtual std::shared_ptr<Delay> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<Delay>) SWIFTEN_OVERRIDE;

};

}

/*

* Copyright (c) 2013-2017 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class DiscoInfoConvertor : public GenericLuaElementConvertor<DiscoInfo> {

public:

DiscoInfoConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<DiscoInfo> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<DiscoInfo>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/DiscoItems.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class DiscoItemsConvertor : public GenericLuaElementConvertor<DiscoItems> {

public:

DiscoItemsConvertor();

virtual std::shared_ptr<DiscoItems> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<DiscoItems>) SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Form.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class FormConvertor : public GenericLuaElementConvertor<Form> {

public:

FormConvertor();

virtual std::shared_ptr<Form> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<Form>) SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Forwarded.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class ForwardedConvertor : public GenericLuaElementConvertor<Forwarded> {

public:

ForwardedConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<Forwarded> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<Forwarded>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/IQ.h>

#include <Sluift/ElementConvertors/StanzaConvertor.h>

namespace Swift {

class LuaElementConvertors;

class IQConvertor : public StanzaConvertor<IQ> {

public:

IQConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<IQ> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<IQ>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

static std::string convertIQTypeToString(IQ::Type type);

static IQ::Type convertIQTypeFromString(const std::string& type);

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/IsodeIQDelegation.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class IsodeIQDelegationConvertor : public GenericLuaElementConvertor<IsodeIQDelegation> {

public:

IsodeIQDelegationConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<IsodeIQDelegation> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<IsodeIQDelegation>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/MAMFin.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class MAMFinConvertor : public GenericLuaElementConvertor<MAMFin> {

public:

MAMFinConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<MAMFin> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<MAMFin>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/MAMQuery.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class MAMQueryConvertor : public GenericLuaElementConvertor<MAMQuery> {

public:

MAMQueryConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<MAMQuery> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<MAMQuery>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/MAMResult.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class MAMResultConvertor : public GenericLuaElementConvertor<MAMResult> {

public:

MAMResultConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<MAMResult> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<MAMResult>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Message.h>

#include <Sluift/ElementConvertors/StanzaConvertor.h>

namespace Swift {

class LuaElementConvertors;

class MessageConvertor : public StanzaConvertor<Message> {

public:

MessageConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<Message> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<Message>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

static std::string convertMessageTypeToString(Message::Type type);

static Message::Type convertMessageTypeFromString(const std::string& type);

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Presence.h>

#include <Sluift/ElementConvertors/StanzaConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PresenceConvertor : public StanzaConvertor<Presence> {

public:

PresenceConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<Presence> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<Presence>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

static std::string convertPresenceTypeToString(Presence::Type type);

static Presence::Type convertPresenceTypeFromString(const std::string& type);

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubAffiliation.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubAffiliationConvertor : public GenericLuaElementConvertor<PubSubAffiliation> {

public:

PubSubAffiliationConvertor();

virtual std::shared_ptr<PubSubAffiliation> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubAffiliation>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubAffiliations.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubAffiliationsConvertor : public GenericLuaElementConvertor<PubSubAffiliations> {

public:

PubSubAffiliationsConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubAffiliations> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubAffiliations>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubConfigure.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubConfigureConvertor : public GenericLuaElementConvertor<PubSubConfigure> {

public:

PubSubConfigureConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubConfigure> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubConfigure>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubCreate.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubCreateConvertor : public GenericLuaElementConvertor<PubSubCreate> {

public:

PubSubCreateConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubCreate> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubCreate>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubDefault.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubDefaultConvertor : public GenericLuaElementConvertor<PubSubDefault> {

public:

PubSubDefaultConvertor();

virtual std::shared_ptr<PubSubDefault> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubDefault>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventAssociate.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubEventAssociateConvertor : public GenericLuaElementConvertor<PubSubEventAssociate> {

public:

PubSubEventAssociateConvertor();

virtual std::shared_ptr<PubSubEventAssociate> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubEventAssociate>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventCollection.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubEventCollectionConvertor : public GenericLuaElementConvertor<PubSubEventCollection> {

public:

PubSubEventCollectionConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubEventCollection> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubEventCollection>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventConfiguration.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubEventConfigurationConvertor : public GenericLuaElementConvertor<PubSubEventConfiguration> {

public:

PubSubEventConfigurationConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubEventConfiguration> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubEventConfiguration>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEvent.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubEventConvertor : public GenericLuaElementConvertor<PubSubEvent> {

public:

PubSubEventConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubEvent> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubEvent>) SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventDelete.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubEventDeleteConvertor : public GenericLuaElementConvertor<PubSubEventDelete> {

public:

PubSubEventDeleteConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubEventDelete> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubEventDelete>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventDisassociate.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubEventDisassociateConvertor : public GenericLuaElementConvertor<PubSubEventDisassociate> {

public:

PubSubEventDisassociateConvertor();

virtual std::shared_ptr<PubSubEventDisassociate> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubEventDisassociate>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventItem.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubEventItemConvertor : public GenericLuaElementConvertor<PubSubEventItem> {

public:

PubSubEventItemConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubEventItem> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubEventItem>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventItems.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubEventItemsConvertor : public GenericLuaElementConvertor<PubSubEventItems> {

public:

PubSubEventItemsConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubEventItems> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubEventItems>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventPurge.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubEventPurgeConvertor : public GenericLuaElementConvertor<PubSubEventPurge> {

public:

PubSubEventPurgeConvertor();

virtual std::shared_ptr<PubSubEventPurge> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubEventPurge>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventRedirect.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubEventRedirectConvertor : public GenericLuaElementConvertor<PubSubEventRedirect> {

public:

PubSubEventRedirectConvertor();

virtual std::shared_ptr<PubSubEventRedirect> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubEventRedirect>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventRetract.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubEventRetractConvertor : public GenericLuaElementConvertor<PubSubEventRetract> {

public:

PubSubEventRetractConvertor();

virtual std::shared_ptr<PubSubEventRetract> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubEventRetract>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventSubscription.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubEventSubscriptionConvertor : public GenericLuaElementConvertor<PubSubEventSubscription> {

public:

PubSubEventSubscriptionConvertor();

virtual std::shared_ptr<PubSubEventSubscription> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubEventSubscription>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubItem.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubItemConvertor : public GenericLuaElementConvertor<PubSubItem> {

public:

PubSubItemConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubItem> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubItem>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubItems.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubItemsConvertor : public GenericLuaElementConvertor<PubSubItems> {

public:

PubSubItemsConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubItems> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubItems>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOptions.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubOptionsConvertor : public GenericLuaElementConvertor<PubSubOptions> {

public:

PubSubOptionsConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubOptions> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubOptions>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerAffiliation.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubOwnerAffiliationConvertor : public GenericLuaElementConvertor<PubSubOwnerAffiliation> {

public:

PubSubOwnerAffiliationConvertor();

virtual std::shared_ptr<PubSubOwnerAffiliation> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubOwnerAffiliation>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerAffiliations.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubOwnerAffiliationsConvertor : public GenericLuaElementConvertor<PubSubOwnerAffiliations> {

public:

PubSubOwnerAffiliationsConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubOwnerAffiliations> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubOwnerAffiliations>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerConfigure.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubOwnerConfigureConvertor : public GenericLuaElementConvertor<PubSubOwnerConfigure> {

public:

PubSubOwnerConfigureConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubOwnerConfigure> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubOwnerConfigure>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerDefault.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubOwnerDefaultConvertor : public GenericLuaElementConvertor<PubSubOwnerDefault> {

public:

PubSubOwnerDefaultConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubOwnerDefault> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubOwnerDefault>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerDelete.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubOwnerDeleteConvertor : public GenericLuaElementConvertor<PubSubOwnerDelete> {

public:

PubSubOwnerDeleteConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubOwnerDelete> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubOwnerDelete>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerPurge.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubOwnerPurgeConvertor : public GenericLuaElementConvertor<PubSubOwnerPurge> {

public:

PubSubOwnerPurgeConvertor();

virtual std::shared_ptr<PubSubOwnerPurge> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubOwnerPurge>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerRedirect.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubOwnerRedirectConvertor : public GenericLuaElementConvertor<PubSubOwnerRedirect> {

public:

PubSubOwnerRedirectConvertor();

virtual std::shared_ptr<PubSubOwnerRedirect> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubOwnerRedirect>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerSubscription.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubOwnerSubscriptionConvertor : public GenericLuaElementConvertor<PubSubOwnerSubscription> {

public:

PubSubOwnerSubscriptionConvertor();

virtual std::shared_ptr<PubSubOwnerSubscription> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubOwnerSubscription>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerSubscriptions.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubOwnerSubscriptionsConvertor : public GenericLuaElementConvertor<PubSubOwnerSubscriptions> {

public:

PubSubOwnerSubscriptionsConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubOwnerSubscriptions> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubOwnerSubscriptions>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubPublish.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubPublishConvertor : public GenericLuaElementConvertor<PubSubPublish> {

public:

PubSubPublishConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubPublish> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubPublish>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubRetract.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubRetractConvertor : public GenericLuaElementConvertor<PubSubRetract> {

public:

PubSubRetractConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubRetract> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubRetract>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubSubscribe.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubSubscribeConvertor : public GenericLuaElementConvertor<PubSubSubscribe> {

public:

PubSubSubscribeConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubSubscribe> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubSubscribe>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubSubscribeOptions.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubSubscribeOptionsConvertor : public GenericLuaElementConvertor<PubSubSubscribeOptions> {

public:

PubSubSubscribeOptionsConvertor();

virtual std::shared_ptr<PubSubSubscribeOptions> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubSubscribeOptions>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubSubscription.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubSubscriptionConvertor : public GenericLuaElementConvertor<PubSubSubscription> {

public:

PubSubSubscriptionConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubSubscription> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubSubscription>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubSubscriptions.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubSubscriptionsConvertor : public GenericLuaElementConvertor<PubSubSubscriptions> {

public:

PubSubSubscriptionsConvertor(LuaElementConvertors* convertors);

virtual std::shared_ptr<PubSubSubscriptions> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubSubscriptions>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

private:

LuaElementConvertors* convertors;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubUnsubscribe.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class PubSubUnsubscribeConvertor : public GenericLuaElementConvertor<PubSubUnsubscribe> {

public:

PubSubUnsubscribeConvertor();

virtual std::shared_ptr<PubSubUnsubscribe> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<PubSubUnsubscribe>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h>

#include <Sluift/LuaElementConvertor.h>

namespace Swift {

class RawXMLElementConvertor : public LuaElementConvertor {

public:

RawXMLElementConvertor();

virtual std::shared_ptr<Element> convertFromLua(lua_State*, int index, const std::string& type) SWIFTEN_OVERRIDE;

virtual boost::optional<std::string> convertToLua(lua_State*, std::shared_ptr<Element>) SWIFTEN_OVERRIDE;

private:

FullPayloadSerializerCollection serializers;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/ResultSet.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class ResultSetConvertor : public GenericLuaElementConvertor<ResultSet> {

public:

ResultSetConvertor();

virtual std::shared_ptr<ResultSet> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<ResultSet>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/SecurityLabel.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class SecurityLabelConvertor : public GenericLuaElementConvertor<SecurityLabel> {

public:

SecurityLabelConvertor();

virtual std::shared_ptr<SecurityLabel> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<SecurityLabel>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/SoftwareVersion.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class SoftwareVersionConvertor : public GenericLuaElementConvertor<SoftwareVersion> {

public:

SoftwareVersionConvertor();

virtual std::shared_ptr<SoftwareVersion> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<SoftwareVersion>) SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Status.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class StatusConvertor : public GenericLuaElementConvertor<Status> {

public:

StatusConvertor();

virtual std::shared_ptr<Status> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<Status>) SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/StatusShow.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class StatusShowConvertor : public GenericLuaElementConvertor<StatusShow> {

public:

StatusShowConvertor();

virtual std::shared_ptr<StatusShow> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<StatusShow>) SWIFTEN_OVERRIDE;

static std::string convertStatusShowTypeToString(const StatusShow::Type &show);

static StatusShow::Type convertStatusShowTypeFromString(const std::string& show);

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Subject.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class SubjectConvertor : public GenericLuaElementConvertor<Subject> {

public:

SubjectConvertor();

virtual std::shared_ptr<Subject> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<Subject>) SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/UserLocation.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class UserLocationConvertor : public GenericLuaElementConvertor<UserLocation> {

public:

UserLocationConvertor();

virtual std::shared_ptr<UserLocation> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<UserLocation>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/UserTune.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class LuaElementConvertors;

class UserTuneConvertor : public GenericLuaElementConvertor<UserTune> {

public:

UserTuneConvertor();

virtual std::shared_ptr<UserTune> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<UserTune>) SWIFTEN_OVERRIDE;

virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/VCard.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class VCardConvertor : public GenericLuaElementConvertor<VCard> {

public:

VCardConvertor();

virtual std::shared_ptr<VCard> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<VCard>) SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/VCardUpdate.h>

#include <Sluift/GenericLuaElementConvertor.h>

namespace Swift {

class VCardUpdateConvertor : public GenericLuaElementConvertor<VCardUpdate> {

public:

VCardUpdateConvertor();

virtual std::shared_ptr<VCardUpdate> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;

virtual void doConvertToLua(lua_State*, std::shared_ptr<VCardUpdate>) SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <string>

#include <lua.hpp>

#include <Swiften/Base/Override.h>

#include <Sluift/Lua/Check.h>

#include <Sluift/Lua/LuaUtils.h>

#include <Sluift/LuaElementConvertor.h>

namespace Swift {

template<typename T>

class GenericLuaElementConvertor : public LuaElementConvertor {

public:

GenericLuaElementConvertor(const std::string& type) : type(type) {

}

virtual std::shared_ptr<Element> convertFromLua(lua_State* L, int index, const std::string& payloadType) SWIFTEN_OVERRIDE {

if (payloadType == type) {

Lua::checkType(L, index, LUA_TTABLE);

lua_pushvalue(L, index);

std::shared_ptr<Element> result = doConvertFromLua(L);

lua_pop(L, 1);

return result;

}

return std::shared_ptr<Element>();

}

virtual boost::optional<std::string> convertToLua(

lua_State* L, std::shared_ptr<Element> payload) SWIFTEN_OVERRIDE {

if (std::shared_ptr<T> actualPayload = std::dynamic_pointer_cast<T>(payload)) {

doConvertToLua(L, actualPayload);

assert(lua_type(L, -1) == LUA_TTABLE);

return type;

}

return NO_RESULT;

}

protected:

virtual std::shared_ptr<T> doConvertFromLua(lua_State*) = 0;

virtual void doConvertToLua(lua_State*, std::shared_ptr<T>) = 0;

private:

std::string type;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Sluift/Terminal.h>

namespace Swift {

class StandardTerminal : public Terminal {

public:

StandardTerminal();

virtual boost::optional<std::string> readLine(const std::string& prompt) SWIFTEN_OVERRIDE;

virtual void printError(const std::string& message) SWIFTEN_OVERRIDE;

virtual void addToHistory(const std::string& command) SWIFTEN_OVERRIDE;

};

}

*/

#pragma once

#include <map>

#include <string>

#include <Swiften/Base/Override.h>

#include <Swiften/Base/Tristate.h>

#include <Swift/Controllers/Chat/ChatControllerBase.h>

#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

namespace Swift {

class AvatarManager;

class ChatStateNotifier;

class ChatStateTracker;

class ClientBlockListManager;

class EntityCapsProvider;

class FileTransferController;

class HighlightManager;

class HistoryController;

class NickResolver;

class SettingsProvider;

class TimerFactory;

class UIEvent;

class ChatController : public ChatControllerBase {

public:

ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);

virtual void setToJID(const JID& jid) SWIFTEN_OVERRIDE;

virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) SWIFTEN_OVERRIDE;

virtual void setOnline(bool online) SWIFTEN_OVERRIDE;

virtual void handleNewFileTransferController(FileTransferController* ftc);

virtual void handleWhiteboardSessionRequest(bool senderIsSelf);

virtual void handleWhiteboardStateChange(const ChatWindow::WhiteboardSessionState state);

virtual void setContactIsReceivingPresence(bool /*isReceivingPresence*/) SWIFTEN_OVERRIDE;

virtual ChatWindow* detachChatWindow() SWIFTEN_OVERRIDE;

virtual void handleIncomingOwnMessage(std::shared_ptr<Message> message) SWIFTEN_OVERRIDE;

protected:

virtual void cancelReplaces() SWIFTEN_OVERRIDE;

virtual JID getBaseJID() SWIFTEN_OVERRIDE;

virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) SWIFTEN_OVERRIDE;

virtual bool shouldIgnoreMessage(std::shared_ptr<Message> message) SWIFTEN_OVERRIDE;

virtual JID messageCorrectionJID(const JID& fromJID) SWIFTEN_OVERRIDE;

private:

void handlePresenceChange(std::shared_ptr<Presence> newPresence);

std::string getStatusChangeString(std::shared_ptr<Presence> presence);

virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) SWIFTEN_OVERRIDE;

virtual void postSendMessage(const std::string &body, std::shared_ptr<Stanza> sentStanza) SWIFTEN_OVERRIDE;

virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) SWIFTEN_OVERRIDE;

virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) SWIFTEN_OVERRIDE;

virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) SWIFTEN_OVERRIDE;

virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) SWIFTEN_OVERRIDE;

virtual void preSendMessageRequest(std::shared_ptr<Message>) SWIFTEN_OVERRIDE;

virtual std::string senderHighlightNameFromMessage(const JID& from) SWIFTEN_OVERRIDE;

virtual std::string senderDisplayNameFromMessage(const JID& from) SWIFTEN_OVERRIDE;

virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message>) const SWIFTEN_OVERRIDE;

namespace Swift {

class StanzaChannel;

class IQRouter;

class ChatWindowFactory;

class Roster;

class AvatarManager;

class UIEventStream;

class TimerFactory;

class TabComplete;

class XMPPRoster;

class HighlightManager;

class UIEvent;

class VCardManager;

class RosterVCardProvider;

class ClientBlockListManager;

class MUCBookmarkManager;

class MUCBookmark;

enum JoinPart {Join, Part, JoinThenPart, PartThenJoin};

struct NickJoinPart {

NickJoinPart(const std::string& nick, JoinPart type) : nick(nick), type(type) {}

std::string nick;

JoinPart type;

};

class MUCController : public ChatControllerBase {

public:

MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* xmppRoster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager, MUCBookmarkManager* mucBookmarkManager);

boost::signals2::signal<void ()> onUserLeft;

boost::signals2::signal<void ()> onUserJoined;

boost::signals2::signal<void ()> onImpromptuConfigCompleted;

boost::signals2::signal<void (const std::string&, const std::string& )> onUserNicknameChanged;

virtual void setOnline(bool online) SWIFTEN_OVERRIDE;

virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) SWIFTEN_OVERRIDE;

void rejoin();

static void appendToJoinParts(std::vector<NickJoinPart>& joinParts, const NickJoinPart& newEvent);

static std::string generateJoinPartString(const std::vector<NickJoinPart>& joinParts, bool isImpromptu);

static std::string concatenateListOfNames(const std::vector<NickJoinPart>& joinParts);

static std::string generateNicknameChangeString(const std::string& oldNickname, const std::string& newNickname);

bool isJoined();

const std::string& getNick();

const boost::optional<std::string> getPassword() const;

bool isImpromptu() const;

std::map<std::string, JID> getParticipantJIDs() const;

void sendInvites(const std::vector<JID>& jids, const std::string& reason) const;

void setChatWindowTitle(const std::string& title);

protected:

virtual void preSendMessageRequest(std::shared_ptr<Message> message) SWIFTEN_OVERRIDE;

virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) SWIFTEN_OVERRIDE;

virtual std::string senderHighlightNameFromMessage(const JID& from) SWIFTEN_OVERRIDE;

virtual std::string senderDisplayNameFromMessage(const JID& from) SWIFTEN_OVERRIDE;

virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message> message) const SWIFTEN_OVERRIDE;

virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent>) SWIFTEN_OVERRIDE;

virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time) SWIFTEN_OVERRIDE;

virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) SWIFTEN_OVERRIDE;

virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent>, const ChatWindow::ChatMessage& chatMessage) SWIFTEN_OVERRIDE;

virtual void cancelReplaces() SWIFTEN_OVERRIDE;

** from this software without specific prior written permission.

**

**

** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."

**

** $QT_END_LICENSE$

**

****************************************************************************/

#ifndef FLOWLAYOUT_H

#define FLOWLAYOUT_H

#include <QLayout>

#include <QRect>

#include <QStyle>

class FlowLayout : public QLayout

{

public:

explicit FlowLayout(QWidget *parent, int margin = -1, int hSpacing = -1, int vSpacing = -1);

explicit FlowLayout(int margin = -1, int hSpacing = -1, int vSpacing = -1);

void addItem(QLayoutItem *item) override;

int horizontalSpacing() const;

int verticalSpacing() const;

Qt::Orientations expandingDirections() const override;

bool hasHeightForWidth() const override;

int heightForWidth(int) const override;

int count() const override;

QLayoutItem *itemAt(int index) const override;

QSize minimumSize() const override;

void setGeometry(const QRect &rect) override;

QSize sizeHint() const override;

QLayoutItem *takeAt(int index) override;

private:

int doLayout(const QRect &rect, bool testOnly) const;

int smartSpacing(QStyle::PixelMetric pm) const;

QList<QLayoutItem *> itemList;

int m_hSpace;

int m_vSpace;

};

#endif // FLOWLAYOUT_H

#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

#include <Swift/QtUI/ChatSnippet.h>

#include <Swift/QtUI/QtChatView.h>

class QWebPage;

class QUrl;

class QDate;

namespace Swift {

class QtWebView;

class QtChatTheme;

class QtChatWindowJSBridge;

class UIEventStream;

class QtChatWindow;

class QtWebKitChatView : public QtChatView {

Q_OBJECT

public:

static const QString ButtonWhiteboardSessionCancel;

static const QString ButtonWhiteboardSessionAcceptRequest;

static const QString ButtonWhiteboardShowWindow;

static const QString ButtonFileTransferCancel;

static const QString ButtonFileTransferSetDescription;

static const QString ButtonFileTransferSendRequest;

static const QString ButtonFileTransferAcceptRequest;

static const QString ButtonFileTransferOpenFile;

static const QString ButtonMUCInvite;

public:

QtWebKitChatView(QtChatWindow* window, UIEventStream* eventStream, QtChatTheme* theme, QWidget* parent, bool disableAutoScroll = false);

/** Add message to window.

* @return id of added message (for acks).

*/

virtual std::string addMessage(const ChatWindow::ChatMessage& message, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time) SWIFTEN_OVERRIDE;

/** Adds action to window.

* @return id of added message (for acks);

*/

virtual std::string addAction(const ChatWindow::ChatMessage& message, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time) SWIFTEN_OVERRIDE;

virtual std::string addSystemMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) SWIFTEN_OVERRIDE;

virtual void addPresenceMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) SWIFTEN_OVERRIDE;

virtual void addErrorMessage(const ChatWindow::ChatMessage& message) SWIFTEN_OVERRIDE;

virtual void replaceMessage(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time) SWIFTEN_OVERRIDE;

virtual void replaceSystemMessage(const ChatWindow::ChatMessage& message, const std::string& id, ChatWindow::TimestampBehaviour timestampBehaviour) SWIFTEN_OVERRIDE;

virtual void replaceWithAction(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time) SWIFTEN_OVERRIDE;

virtual void replaceLastMessage(const ChatWindow::ChatMessage& message, const ChatWindow::TimestampBehaviour timestampBehaviour) SWIFTEN_OVERRIDE;

virtual void setAckState(const std::string& id, ChatWindow::AckState state) SWIFTEN_OVERRIDE;

virtual std::string addFileTransfer(const std::string& senderName, const std::string& avatarPath, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes, const std::string& description) SWIFTEN_OVERRIDE;

virtual void setFileTransferProgress(std::string, const int percentageDone) SWIFTEN_OVERRIDE;

virtual void setFileTransferStatus(std::string, const ChatWindow::FileTransferState state, const std::string& msg = "") SWIFTEN_OVERRIDE;

virtual void addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct, bool isImpromptu, bool isContinuation) SWIFTEN_OVERRIDE;

virtual std::string addWhiteboardRequest(const QString& contact, bool senderIsSelf) SWIFTEN_OVERRIDE;

virtual void setWhiteboardSessionStatus(const std::string& id, const ChatWindow::WhiteboardSessionState state) SWIFTEN_OVERRIDE;

virtual void setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state) SWIFTEN_OVERRIDE;

virtual void showEmoticons(bool show) SWIFTEN_OVERRIDE;

void addMessageTop(std::shared_ptr<ChatSnippet> snippet);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <set>

#include <QWizard>

#include <Swiften/Base/Override.h>

#include <Swift/Controllers/UIInterfaces/UserSearchWindow.h>

#include <Swift/QtUI/UserSearch/ui_QtUserSearchWizard.h>

namespace Swift {

class UserSearchModel;

class UserSearchDelegate;

class UserSearchResult;

class UIEventStream;

class QtUserSearchFirstPage;

class QtUserSearchFirstMultiJIDPage;

class QtUserSearchFieldsPage;

class QtUserSearchResultsPage;

class QtUserSearchDetailsPage;

class QtFormResultItemModel;

class SettingsProvider;

class QtUserSearchWindow : public QWizard, public UserSearchWindow, private Ui::QtUserSearchWizard {

Q_OBJECT

public:

QtUserSearchWindow(UIEventStream* eventStream, UserSearchWindow::Type type, const std::set<std::string>& groups, SettingsProvider* settingsProvider);

virtual void addSavedServices(const std::vector<JID>& services) SWIFTEN_OVERRIDE;

virtual void clear() SWIFTEN_OVERRIDE;

virtual void show() SWIFTEN_OVERRIDE;

virtual void setResults(const std::vector<UserSearchResult>& results) SWIFTEN_OVERRIDE;

virtual void setResultsForm(Form::ref results) SWIFTEN_OVERRIDE;

virtual void setSelectedService(const JID& jid) SWIFTEN_OVERRIDE;

virtual void setServerSupportsSearch(bool error) SWIFTEN_OVERRIDE;

virtual void setSearchError(bool error) SWIFTEN_OVERRIDE;

virtual void setSearchFields(std::shared_ptr<SearchPayload> fields) SWIFTEN_OVERRIDE;

virtual void setNameSuggestions(const std::vector<std::string>& suggestions) SWIFTEN_OVERRIDE;

virtual void prepopulateJIDAndName(const JID& jid, const std::string& name) SWIFTEN_OVERRIDE;

virtual void setContactSuggestions(const std::vector<Contact::ref>& suggestions) SWIFTEN_OVERRIDE;

virtual void setJIDs(const std::vector<JID> &jids) SWIFTEN_OVERRIDE;

virtual void setOriginator(const JID& originator) SWIFTEN_OVERRIDE;

virtual void setRoomJID(const JID &roomJID) SWIFTEN_OVERRIDE;

virtual std::string getReason() const SWIFTEN_OVERRIDE;

virtual std::vector<JID> getJIDs() const SWIFTEN_OVERRIDE;

virtual void setCanStartImpromptuChats(bool supportsImpromptu) SWIFTEN_OVERRIDE;

virtual void updateContacts(const std::vector<Contact::ref> &contacts) SWIFTEN_OVERRIDE;

virtual void addContacts(const std::vector<Contact::ref>& contacts) SWIFTEN_OVERRIDE;

virtual void setCanSupplyDescription(bool allowed) SWIFTEN_OVERRIDE;

virtual void setWarning(const boost::optional<std::string>& message) SWIFTEN_OVERRIDE;

protected:

virtual int nextId() const SWIFTEN_OVERRIDE;

private slots:

void handleFirstPageRadioChange();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/Override.h>

namespace Swift {

/**

* @brief The SimpleIDGenerator class implements a IDGenerator generating consecutive ID strings from

* the lower case latin alphabet.

*/

class SWIFTEN_API SimpleIDGenerator : public IDGenerator {

public:

SimpleIDGenerator();

std::string generateID() SWIFTEN_OVERRIDE;

private:

std::string currentID;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Crypto/CommonCryptoCryptoProvider.h>

#include <cassert>

#include <boost/numeric/conversion/cast.hpp>

#include <CommonCrypto/CommonDigest.h>

#include <CommonCrypto/CommonHMAC.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Crypto/Hash.h>

using namespace Swift;

namespace {

class SHA1Hash : public Hash {

public:

SHA1Hash() : finalized(false) {

if (!CC_SHA1_Init(&context)) {

assert(false);

}

}

}

virtual Hash& update(const ByteArray& data) SWIFTEN_OVERRIDE {

return updateInternal(data);

}

virtual Hash& update(const SafeByteArray& data) SWIFTEN_OVERRIDE {

return updateInternal(data);

}

virtual std::vector<unsigned char> getHash() SWIFTEN_OVERRIDE {

assert(!finalized);

std::vector<unsigned char> result(CC_SHA1_DIGEST_LENGTH);

CC_SHA1_Final(vecptr(result), &context);

return result;

}

private:

template<typename ContainerType>

Hash& updateInternal(const ContainerType& data) {

assert(!finalized);

if (!CC_SHA1_Update(&context, vecptr(data), boost::numeric_cast<CC_LONG>(data.size()))) {

assert(false);

}

return *this;

}

private:

CC_SHA1_CTX context;

bool finalized;

};

class MD5Hash : public Hash {

public:

MD5Hash() : finalized(false) {

if (!CC_MD5_Init(&context)) {

assert(false);

}

}

}

virtual Hash& update(const ByteArray& data) SWIFTEN_OVERRIDE {

return updateInternal(data);

}

virtual Hash& update(const SafeByteArray& data) SWIFTEN_OVERRIDE {

return updateInternal(data);

}

virtual std::vector<unsigned char> getHash() SWIFTEN_OVERRIDE {

assert(!finalized);

std::vector<unsigned char> result(CC_MD5_DIGEST_LENGTH);

CC_MD5_Final(vecptr(result), &context);

return result;

}

private:

template<typename ContainerType>

Hash& updateInternal(const ContainerType& data) {

assert(!finalized);

if (!CC_MD5_Update(&context, vecptr(data), boost::numeric_cast<CC_LONG>(data.size()))) {

assert(false);

}

return *this;

}

private:

CC_MD5_CTX context;

bool finalized;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Crypto/CryptoProvider.h>

namespace Swift {

class SWIFTEN_API CommonCryptoCryptoProvider : public CryptoProvider {

public:

CommonCryptoCryptoProvider();

virtual Hash* createSHA1() SWIFTEN_OVERRIDE;

virtual Hash* createMD5() SWIFTEN_OVERRIDE;

virtual ByteArray getHMACSHA1(const SafeByteArray& key, const ByteArray& data) SWIFTEN_OVERRIDE;

virtual ByteArray getHMACSHA1(const ByteArray& key, const ByteArray& data) SWIFTEN_OVERRIDE;

virtual bool isMD5AllowedForCrypto() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/Override.h>

#include <Swiften/Crypto/CryptoProvider.h>

namespace Swift {

class OpenSSLCryptoProvider : public CryptoProvider {

public:

OpenSSLCryptoProvider();

virtual Hash* createSHA1() SWIFTEN_OVERRIDE;

virtual Hash* createMD5() SWIFTEN_OVERRIDE;

virtual ByteArray getHMACSHA1(const SafeByteArray& key, const ByteArray& data) SWIFTEN_OVERRIDE;

virtual ByteArray getHMACSHA1(const ByteArray& key, const ByteArray& data) SWIFTEN_OVERRIDE;

virtual bool isMD5AllowedForCrypto() const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/FileTransfer/FileTransferTransporter.h>

namespace Swift {

class LocalJingleTransportCandidateGenerator;

class RemoteJingleTransportCandidateSelector;

class SOCKS5BytestreamRegistry;

class SOCKS5BytestreamServerManager;

class SOCKS5BytestreamProxiesManager;

class SOCKS5BytestreamClientSession;

class SOCKS5BytestreamServerSession;

class IDGenerator;

class IQRouter;

class ReadBytestream;

class WriteBytestream;

class ConnectionFactory;

class TimerFactory;

class CryptoProvider;

class FileTransferOptions;

class SWIFTEN_API DefaultFileTransferTransporter : public FileTransferTransporter {

public:

enum Role {

Initiator,

Responder

};

DefaultFileTransferTransporter(

const JID& initiator,

const JID& responder,

Role role,

SOCKS5BytestreamRegistry*,

SOCKS5BytestreamServerManager* s5bServerManager,

SOCKS5BytestreamProxiesManager* s5bProxy,

IDGenerator* idGenerator,

ConnectionFactory*,

TimerFactory*,

CryptoProvider*,

IQRouter*,

const FileTransferOptions&);

virtual void initialize();

virtual void initialize(const std::string& s5bSessionID);

virtual void startGeneratingLocalCandidates() SWIFTEN_OVERRIDE;

virtual void stopGeneratingLocalCandidates() SWIFTEN_OVERRIDE;

virtual void addRemoteCandidates(

const std::vector<JingleS5BTransportPayload::Candidate>&, const std::string&) SWIFTEN_OVERRIDE;

virtual void startTryingRemoteCandidates() SWIFTEN_OVERRIDE;

virtual void stopTryingRemoteCandidates() SWIFTEN_OVERRIDE;

virtual void startActivatingProxy(const JID& jid) SWIFTEN_OVERRIDE;

virtual void stopActivatingProxy() SWIFTEN_OVERRIDE;

virtual std::shared_ptr<TransportSession> createIBBSendSession(

const std::string& sessionID, unsigned int blockSize, std::shared_ptr<ReadBytestream>) SWIFTEN_OVERRIDE;

virtual std::shared_ptr<TransportSession> createIBBReceiveSession(

const std::string& sessionID, unsigned long long size, std::shared_ptr<WriteBytestream>) SWIFTEN_OVERRIDE;

virtual std::shared_ptr<TransportSession> createRemoteCandidateSession(

std::shared_ptr<ReadBytestream>, const JingleS5BTransportPayload::Candidate& candidate) SWIFTEN_OVERRIDE;

virtual std::shared_ptr<TransportSession> createRemoteCandidateSession(

std::shared_ptr<WriteBytestream>, const JingleS5BTransportPayload::Candidate& candidate) SWIFTEN_OVERRIDE;

virtual std::shared_ptr<TransportSession> createLocalCandidateSession(

std::shared_ptr<ReadBytestream>, const JingleS5BTransportPayload::Candidate& candidate) SWIFTEN_OVERRIDE;

virtual std::shared_ptr<TransportSession> createLocalCandidateSession(

std::shared_ptr<WriteBytestream>, const JingleS5BTransportPayload::Candidate& candidate) SWIFTEN_OVERRIDE;

private:

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/FileTransfer/FileTransferTransporterFactory.h>

namespace Swift {

class SOCKS5BytestreamRegistry;

class SOCKS5BytestreamServerManager;

class SOCKS5BytestreamProxiesManager;

class IDGenerator;

class ConnectionFactory;

class TimerFactory;

class CryptoProvider;

class IQRouter;

class SWIFTEN_API DefaultFileTransferTransporterFactory : public FileTransferTransporterFactory {

public:

DefaultFileTransferTransporterFactory(

SOCKS5BytestreamRegistry*,

SOCKS5BytestreamServerManager* s5bServerManager,

SOCKS5BytestreamProxiesManager* s5bProxy,

IDGenerator* idGenerator,

ConnectionFactory*,

TimerFactory*,

CryptoProvider*,

IQRouter*);

virtual FileTransferTransporter* createInitiatorTransporter(

const JID& initiator, const JID& responder, const FileTransferOptions&) SWIFTEN_OVERRIDE;

virtual FileTransferTransporter* createResponderTransporter(

const JID& initiator, const JID& responder, const std::string& s5bSessionID, const FileTransferOptions&) SWIFTEN_OVERRIDE;

private:

SOCKS5BytestreamRegistry* s5bRegistry;

SOCKS5BytestreamServerManager* s5bServerManager;

SOCKS5BytestreamProxiesManager* s5bProxiesManager;

IDGenerator* idGenerator;

ConnectionFactory* connectionFactory;

TimerFactory* timerFactory;

CryptoProvider* cryptoProvider;

IQRouter* iqRouter;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/TransportSession.h>

namespace Swift {

class SWIFTEN_API FailingTransportSession : public TransportSession {

public:

virtual void start() SWIFTEN_OVERRIDE;

virtual void stop() SWIFTEN_OVERRIDE;

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <string>

#include <vector>

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

#include <boost/filesystem/path.hpp>

#include <boost/optional.hpp>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/S5BProxyRequest.h>

#include <Swiften/FileTransfer/FileTransferManager.h>

#include <Swiften/FileTransfer/FileTransferOptions.h>

#include <Swiften/FileTransfer/IncomingFileTransfer.h>

#include <Swiften/FileTransfer/OutgoingFileTransfer.h>

namespace Swift {

class ConnectionFactory;

class ConnectionServerFactory;

class CryptoProvider;

class DomainNameResolver;

class EntityCapsProvider;

class FileTransferTransporterFactory;

class IQRouter;

class IncomingFileTransferManager;

class JID;

class JingleSessionManager;

class NATTraverser;

class NetworkEnvironment;

class OutgoingFileTransferManager;

class PresenceOracle;

class ReadBytestream;

class SOCKS5BytestreamProxiesManager;

class SOCKS5BytestreamRegistry;

class SOCKS5BytestreamServerManager;

class TimerFactory;

class SWIFTEN_API FileTransferManagerImpl : public FileTransferManager {

public:

FileTransferManagerImpl(

const JID& ownFullJID,

JingleSessionManager* jingleSessionManager,

IQRouter* router,

EntityCapsProvider* capsProvider,

PresenceOracle* presOracle,

ConnectionFactory* connectionFactory,

ConnectionServerFactory* connectionServerFactory,

TimerFactory* timerFactory,

DomainNameResolver* domainNameResolver,

NetworkEnvironment* networkEnvironment,

NATTraverser* natTraverser,

CryptoProvider* crypto);

OutgoingFileTransfer::ref createOutgoingFileTransfer(

const JID& to,

const boost::filesystem::path& filepath,

const std::string& description,

std::shared_ptr<ReadBytestream> bytestream,

const FileTransferOptions&) SWIFTEN_OVERRIDE;

OutgoingFileTransfer::ref createOutgoingFileTransfer(

const JID& to,

const std::string& filename,

const std::string& description,

const boost::uintmax_t sizeInBytes,

const boost::posix_time::ptime& lastModified,

std::shared_ptr<ReadBytestream> bytestream,

const FileTransferOptions&) SWIFTEN_OVERRIDE;

void start();

void stop();

private:

boost::optional<JID> highestPriorityJIDSupportingFileTransfer(const JID& bareJID);

private:

OutgoingFileTransferManager* outgoingFTManager;

IncomingFileTransferManager* incomingFTManager;

FileTransferTransporterFactory* transporterFactory;

IQRouter* iqRouter;

EntityCapsProvider* capsProvider;

PresenceOracle* presenceOracle;

IDGenerator idGenerator;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/IBBReceiveSession.h>

#include <Swiften/FileTransfer/TransportSession.h>

namespace Swift {

class SWIFTEN_API IBBReceiveTransportSession : public TransportSession {

public:

IBBReceiveTransportSession(std::shared_ptr<IBBReceiveSession> session);

virtual void start() SWIFTEN_OVERRIDE;

virtual void stop() SWIFTEN_OVERRIDE;

private:

std::shared_ptr<IBBReceiveSession> session;

boost::signals2::scoped_connection finishedConnection;

boost::signals2::scoped_connection bytesSentConnection;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/IBBSendSession.h>

#include <Swiften/FileTransfer/TransportSession.h>

namespace Swift {

class SWIFTEN_API IBBSendTransportSession : public TransportSession {

public:

IBBSendTransportSession(std::shared_ptr<IBBSendSession> session);

virtual void start() SWIFTEN_OVERRIDE;

virtual void stop() SWIFTEN_OVERRIDE;

private:

std::shared_ptr<IBBSendSession> session;

boost::signals2::scoped_connection finishedConnection;

boost::signals2::scoped_connection bytesSentConnection;

};

}

namespace Swift {

class CryptoProvider;

class FileTransferTransporterFactory;

class IncrementalBytestreamHashCalculator;

class JID;

class JingleContentPayload;

class JingleFileTransferDescription;

class JingleSession;

class Timer;

class TimerFactory;

/**

* @brief The IncomingJingleFileTransfer class contains the business logic for managing incoming

* Jingle file transfers.

*

* Calling IncomingJingleFileTransfer::accept will start to negotiate possible transfer

* methods and after a working method has been decided among peers the trasnfer is started.

*/

class SWIFTEN_API IncomingJingleFileTransfer : public IncomingFileTransfer, public JingleFileTransfer {

public:

typedef std::shared_ptr<IncomingJingleFileTransfer> ref;

IncomingJingleFileTransfer(

const JID& recipient,

std::shared_ptr<JingleSession>,

std::shared_ptr<JingleContentPayload> content,

FileTransferTransporterFactory*,

TimerFactory*,

CryptoProvider*);

virtual void accept(std::shared_ptr<WriteBytestream>, const FileTransferOptions& = FileTransferOptions()) SWIFTEN_OVERRIDE;

virtual void cancel() SWIFTEN_OVERRIDE;

private:

enum State {

Initial,

GeneratingInitialLocalCandidates,

TryingCandidates,

WaitingForPeerProxyActivate,

WaitingForLocalProxyActivate,

WaitingForFallbackOrTerminate,

Transferring,

WaitingForHash,

Finished

};

virtual void handleSessionTerminateReceived(

boost::optional<JinglePayload::Reason> reason) SWIFTEN_OVERRIDE;

virtual void handleSessionInfoReceived(std::shared_ptr<JinglePayload>) SWIFTEN_OVERRIDE;

virtual void handleTransportReplaceReceived(

const JingleContentID&, std::shared_ptr<JingleTransportPayload>) SWIFTEN_OVERRIDE;

virtual void handleLocalTransportCandidatesGenerated(

const std::string& s5bSessionID,

const std::vector<JingleS5BTransportPayload::Candidate>&,

const std::string& dstAddr) SWIFTEN_OVERRIDE;

void handleWriteStreamDataReceived(const std::vector<unsigned char>& data);

void stopActiveTransport();

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/JingleFileTransferFileInfo.h>

#include <Swiften/FileTransfer/FileTransferOptions.h>

#include <Swiften/FileTransfer/JingleFileTransfer.h>

#include <Swiften/FileTransfer/OutgoingFileTransfer.h>

#include <Swiften/Jingle/JingleContentID.h>

#include <Swiften/Network/Timer.h>

namespace Swift {

class CryptoProvider;

class FileTransferTransporterFactory;

class IDGenerator;

class IncrementalBytestreamHashCalculator;

class ReadBytestream;

class TimerFactory;

class TransportSession;

class SWIFTEN_API OutgoingJingleFileTransfer : public OutgoingFileTransfer, public JingleFileTransfer {

public:

OutgoingJingleFileTransfer(

const JID& to,

std::shared_ptr<JingleSession>,

std::shared_ptr<ReadBytestream>,

FileTransferTransporterFactory*,

TimerFactory*,

IDGenerator*,

const JingleFileTransferFileInfo&,

const FileTransferOptions&,

CryptoProvider*);

virtual void start() SWIFTEN_OVERRIDE;

virtual void cancel() SWIFTEN_OVERRIDE;

private:

enum State {

Initial,

GeneratingInitialLocalCandidates,

WaitingForAccept,

TryingCandidates,

WaitingForPeerProxyActivate,

WaitingForLocalProxyActivate,

WaitingForCandidateAcknowledge,

FallbackRequested,

Transferring,

WaitForTermination,

Finished

};

virtual void handleSessionAcceptReceived(const JingleContentID&, std::shared_ptr<JingleDescription>, std::shared_ptr<JingleTransportPayload>) SWIFTEN_OVERRIDE;

virtual void handleSessionTerminateReceived(boost::optional<JinglePayload::Reason> reason) SWIFTEN_OVERRIDE;

virtual void handleTransportAcceptReceived(const JingleContentID&, std::shared_ptr<JingleTransportPayload>) SWIFTEN_OVERRIDE;

virtual void handleTransportRejectReceived(const JingleContentID &, std::shared_ptr<JingleTransportPayload>) SWIFTEN_OVERRIDE;

virtual void startTransferViaRemoteCandidate() SWIFTEN_OVERRIDE;

virtual void startTransferViaLocalCandidate() SWIFTEN_OVERRIDE;

void startTransferringIfCandidateAcknowledged();

virtual void handleLocalTransportCandidatesGenerated(const std::string& s5bSessionID, const std::vector<JingleS5BTransportPayload::Candidate>&, const std::string& dstAddr) SWIFTEN_OVERRIDE;

virtual void handleTransportInfoAcknowledged(const std::string& id) SWIFTEN_OVERRIDE;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/bind.hpp>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/ReadBytestream.h>

#include <Swiften/FileTransfer/TransportSession.h>

#include <Swiften/FileTransfer/WriteBytestream.h>

namespace Swift {

template <typename T>

class SWIFTEN_API S5BTransportSession : public TransportSession {

public:

S5BTransportSession(

std::shared_ptr<T> session,

std::shared_ptr<ReadBytestream> readStream) :

session(session),

readStream(readStream) {

initialize();

}

S5BTransportSession(

std::shared_ptr<T> session,

std::shared_ptr<WriteBytestream> writeStream) :

session(session),

writeStream(writeStream) {

initialize();

}

}

virtual void start() SWIFTEN_OVERRIDE {

if (readStream) {

session->startSending(readStream);

}

else {

session->startReceiving(writeStream);

}

}

virtual void stop() SWIFTEN_OVERRIDE {

session->stop();

}

private:

void initialize() {

finishedConnection = session->onFinished.connect(boost::bind(boost::ref(onFinished), _1));

bytesSentConnection = session->onBytesSent.connect(boost::bind(boost::ref(onBytesSent), _1));

}

private:

std::shared_ptr<T> session;

std::shared_ptr<ReadBytestream> readStream;

std::shared_ptr<WriteBytestream> writeStream;

boost::signals2::scoped_connection finishedConnection;

boost::signals2::scoped_connection bytesSentConnection;

};

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <string>

#include <vector>

#include <boost/signals2.hpp>

#include <boost/variant.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Base/SimpleIDGenerator.h>

#include <Swiften/Elements/JinglePayload.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Jingle/JingleContentID.h>

#include <Swiften/Jingle/JingleSession.h>

namespace Swift {

class JingleContentID;

class SWIFTEN_API FakeJingleSession : public JingleSession {

public:

struct InitiateCall {

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

JingleContentID id;

JingleDescription::ref description;

struct InfoTransportCall {

InfoTransportCall(JingleContentID contentId, JingleTransportPayload::ref payL) : id(contentId), payload(payL) {}

JingleContentID id;

JingleTransportPayload::ref payload;

};

struct AcceptTransportCall {

AcceptTransportCall(JingleContentID contentId, JingleTransportPayload::ref payL) : id(contentId), payload(payL) {}

JingleContentID id;

JingleTransportPayload::ref payload;

};

struct RejectTransportCall {

RejectTransportCall(JingleContentID contentId, JingleTransportPayload::ref payL) : id(contentId), payload(payL) {}

JingleContentID id;

JingleTransportPayload::ref payload;

};

struct ReplaceTransportCall {

ReplaceTransportCall(JingleContentID contentId, JingleTransportPayload::ref payL) : id(contentId), payload(payL) {}

JingleContentID id;

JingleTransportPayload::ref payload;

};

typedef boost::variant<InitiateCall, TerminateCall, AcceptCall, InfoCall, InfoTransportCall, AcceptTransportCall, RejectTransportCall, ReplaceTransportCall> Command;

public:

typedef std::shared_ptr<FakeJingleSession> ref;

FakeJingleSession(const JID& initiator, const std::string& id);

virtual void sendInitiate(const JingleContentID&, JingleDescription::ref, JingleTransportPayload::ref) SWIFTEN_OVERRIDE;

virtual void sendTerminate(JinglePayload::Reason::Type reason) SWIFTEN_OVERRIDE;

virtual void sendInfo(std::shared_ptr<Payload>) SWIFTEN_OVERRIDE;

virtual void sendAccept(const JingleContentID&, JingleDescription::ref, JingleTransportPayload::ref = JingleTransportPayload::ref()) SWIFTEN_OVERRIDE;

virtual std::string sendTransportInfo(const JingleContentID&, JingleTransportPayload::ref) SWIFTEN_OVERRIDE;

virtual void sendTransportAccept(const JingleContentID&, JingleTransportPayload::ref) SWIFTEN_OVERRIDE;

virtual void sendTransportReject(const JingleContentID&, JingleTransportPayload::ref) SWIFTEN_OVERRIDE;

virtual void sendTransportReplace(const JingleContentID&, JingleTransportPayload::ref) SWIFTEN_OVERRIDE;

void handleSessionTerminateReceived(boost::optional<JinglePayload::Reason>);

void handleSessionAcceptReceived(const JingleContentID&, std::shared_ptr<JingleDescription>, std::shared_ptr<JingleTransportPayload>);

void handleSessionInfoReceived(std::shared_ptr<JinglePayload>);

void handleTransportReplaceReceived(const JingleContentID&, JingleTransportPayload::ref);

void handleTransportAcceptReceived(const JingleContentID&, std::shared_ptr<JingleTransportPayload>);

void handleTransportInfoReceived(const JingleContentID&, std::shared_ptr<JingleTransportPayload>);

void handleTransportRejectReceived(const JingleContentID&, std::shared_ptr<JingleTransportPayload>);

void handleTransportInfoAcknowledged(const std::string& id);

public:

std::vector<Command> calledCommands;

SimpleIDGenerator idGenerator;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Network/BoostIOServiceThread.h>

#include <Swiften/Network/NetworkFactories.h>

namespace Swift {

class EventLoop;

class NATTraverser;

class PlatformTLSFactories;

class SWIFTEN_API BoostNetworkFactories : public NetworkFactories {

public:

/**

* Construct the network factories, using the provided EventLoop.

* @param ioService If this optional parameter is provided, it will be

* used for the construction of the BoostIOServiceThread.

*/

BoostNetworkFactories(EventLoop* eventLoop, std::shared_ptr<boost::asio::io_service> ioService = std::shared_ptr<boost::asio::io_service>());

virtual TimerFactory* getTimerFactory() const SWIFTEN_OVERRIDE {

return timerFactory;

}

virtual ConnectionFactory* getConnectionFactory() const SWIFTEN_OVERRIDE {

return connectionFactory;

}

BoostIOServiceThread* getIOServiceThread() {

return &ioServiceThread;

}

DomainNameResolver* getDomainNameResolver() const SWIFTEN_OVERRIDE {

return domainNameResolver;

}

ConnectionServerFactory* getConnectionServerFactory() const SWIFTEN_OVERRIDE {

return connectionServerFactory;

}

NetworkEnvironment* getNetworkEnvironment() const SWIFTEN_OVERRIDE {

return networkEnvironment;

}

NATTraverser* getNATTraverser() const SWIFTEN_OVERRIDE {

return natTraverser;

}

virtual XMLParserFactory* getXMLParserFactory() const SWIFTEN_OVERRIDE {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/IsodeIQDelegation.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API IsodeIQDelegationParser : public GenericPayloadParser<IsodeIQDelegation> {

public:

IsodeIQDelegationParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

PayloadParserFactoryCollection* parsers;

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* Copyright (c) 2017 Tarun Gupta

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/MIXCreate.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParser;

class SWIFTEN_API MIXCreateParser : public GenericPayloadParser<MIXCreate> {

public:

MIXCreateParser();

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level_;

std::shared_ptr<PayloadParser> currentPayloadParser_;

};

}

/*

* Copyright (c) 2017 Tarun Gupta

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/MIXDestroy.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParser;

class SWIFTEN_API MIXDestroyParser : public GenericPayloadParser<MIXDestroy> {

public:

MIXDestroyParser();

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level_;

};

}

/*

* Copyright (c) 2017 Tarun Gupta

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/MIXJoin.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParser;

class SWIFTEN_API MIXJoinParser : public GenericPayloadParser<MIXJoin> {

public:

MIXJoinParser();

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level_;

std::shared_ptr<PayloadParser> currentPayloadParser_;

};

}

/*

* Copyright (c) 2017 Tarun Gupta

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/MIXLeave.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class SWIFTEN_API MIXLeaveParser : public GenericPayloadParser<MIXLeave> {

public:

MIXLeaveParser();

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level_;

};

}

/*

* Copyright (c) 2017 Tarun Gupta

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/MIXSubscribe.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API MIXSubscribeParser : public GenericPayloadParser<MIXSubscribe> {

public:

MIXSubscribeParser();

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level_;

};

}

/*

* Copyright (c) 2017 Tarun Gupta

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/MIXUserPreference.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParser;

class SWIFTEN_API MIXUserPreferenceParser : public GenericPayloadParser<MIXUserPreference> {

public:

MIXUserPreferenceParser();

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level_;

std::shared_ptr<PayloadParser> currentPayloadParser_;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubAffiliation.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubAffiliationParser : public GenericPayloadParser<PubSubAffiliation> {

public:

PubSubAffiliationParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubAffiliations.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubAffiliationsParser : public GenericPayloadParser<PubSubAffiliations> {

public:

PubSubAffiliationsParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

PayloadParserFactoryCollection* parsers;

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubConfigure.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubConfigureParser : public GenericPayloadParser<PubSubConfigure> {

public:

PubSubConfigureParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubCreate.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubCreateParser : public GenericPayloadParser<PubSubCreate> {

public:

PubSubCreateParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubDefault.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubDefaultParser : public GenericPayloadParser<PubSubDefault> {

public:

PubSubDefaultParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* Copyright (c) 2013-2017 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubError.h>

#include <Swiften/Parser/EnumParser.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class SWIFTEN_API PubSubErrorParser : public GenericPayloadParser<PubSubError> {

public:

PubSubErrorParser();

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

EnumParser<PubSubError::Type> typeParser;

EnumParser<PubSubError::UnsupportedFeatureType> unsupportedTypeParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventAssociate.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubEventAssociateParser : public GenericPayloadParser<PubSubEventAssociate> {

public:

PubSubEventAssociateParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventCollection.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubEventCollectionParser : public GenericPayloadParser<PubSubEventCollection> {

public:

PubSubEventCollectionParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

PayloadParserFactoryCollection* parsers;

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventConfiguration.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubEventConfigurationParser : public GenericPayloadParser<PubSubEventConfiguration> {

public:

PubSubEventConfigurationParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventDelete.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubEventDeleteParser : public GenericPayloadParser<PubSubEventDelete> {

public:

PubSubEventDeleteParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

PayloadParserFactoryCollection* parsers;

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventDisassociate.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubEventDisassociateParser : public GenericPayloadParser<PubSubEventDisassociate> {

public:

PubSubEventDisassociateParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventItem.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubEventItemParser : public GenericPayloadParser<PubSubEventItem> {

public:

PubSubEventItemParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

PayloadParserFactoryCollection* parsers;

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventItems.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubEventItemsParser : public GenericPayloadParser<PubSubEventItems> {

public:

PubSubEventItemsParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

PayloadParserFactoryCollection* parsers;

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEvent.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubEventParser : public GenericPayloadParser<PubSubEvent> {

public:

PubSubEventParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

PayloadParserFactoryCollection* parsers;

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventPurge.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubEventPurgeParser : public GenericPayloadParser<PubSubEventPurge> {

public:

PubSubEventPurgeParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventRedirect.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubEventRedirectParser : public GenericPayloadParser<PubSubEventRedirect> {

public:

PubSubEventRedirectParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventRetract.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubEventRetractParser : public GenericPayloadParser<PubSubEventRetract> {

public:

PubSubEventRetractParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubEventSubscription.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubEventSubscriptionParser : public GenericPayloadParser<PubSubEventSubscription> {

public:

PubSubEventSubscriptionParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubItem.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubItemParser : public GenericPayloadParser<PubSubItem> {

public:

PubSubItemParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

PayloadParserFactoryCollection* parsers;

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubItems.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubItemsParser : public GenericPayloadParser<PubSubItems> {

public:

PubSubItemsParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

PayloadParserFactoryCollection* parsers;

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOptions.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubOptionsParser : public GenericPayloadParser<PubSubOptions> {

public:

PubSubOptionsParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerAffiliation.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubOwnerAffiliationParser : public GenericPayloadParser<PubSubOwnerAffiliation> {

public:

PubSubOwnerAffiliationParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerAffiliations.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubOwnerAffiliationsParser : public GenericPayloadParser<PubSubOwnerAffiliations> {

public:

PubSubOwnerAffiliationsParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

PayloadParserFactoryCollection* parsers;

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerConfigure.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubOwnerConfigureParser : public GenericPayloadParser<PubSubOwnerConfigure> {

public:

PubSubOwnerConfigureParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerDefault.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubOwnerDefaultParser : public GenericPayloadParser<PubSubOwnerDefault> {

public:

PubSubOwnerDefaultParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerDelete.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubOwnerDeleteParser : public GenericPayloadParser<PubSubOwnerDelete> {

public:

PubSubOwnerDeleteParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

PayloadParserFactoryCollection* parsers;

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerPubSub.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubOwnerPubSubParser : public GenericPayloadParser<PubSubOwnerPubSub> {

public:

PubSubOwnerPubSubParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

PayloadParserFactoryCollection* parsers;

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerPurge.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubOwnerPurgeParser : public GenericPayloadParser<PubSubOwnerPurge> {

public:

PubSubOwnerPurgeParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerRedirect.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubOwnerRedirectParser : public GenericPayloadParser<PubSubOwnerRedirect> {

public:

PubSubOwnerRedirectParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerSubscription.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubOwnerSubscriptionParser : public GenericPayloadParser<PubSubOwnerSubscription> {

public:

PubSubOwnerSubscriptionParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubOwnerSubscriptions.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadParser;

class SWIFTEN_API PubSubOwnerSubscriptionsParser : public GenericPayloadParser<PubSubOwnerSubscriptions> {

public:

PubSubOwnerSubscriptionsParser(PayloadParserFactoryCollection* parsers);

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) SWIFTEN_OVERRIDE;

virtual void handleEndElement(const std::string& element, const std::string&) SWIFTEN_OVERRIDE;

virtual void handleCharacterData(const std::string& data) SWIFTEN_OVERRIDE;

private:

PayloadParserFactoryCollection* parsers;

int level;

std::shared_ptr<PayloadParser> currentPayloadParser;

};

}