+ * Copyright (c) 2010-2016 Isode Limited.

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

+SafeByteArray AuthChallengeSerializer::serialize(std::shared_ptr<ToplevelElement> element) const {

+ std::shared_ptr<AuthChallenge> authChallenge(std::dynamic_pointer_cast<AuthChallenge>(element));

+ std::string value;

+ boost::optional<std::vector<unsigned char> > message = authChallenge->getValue();

+ if (message) {

+ if ((*message).empty()) {

+ value = "=";

+ }

+ else {

+ value = Base64::encode(ByteArray(*message));

+ }

+ }

+ return createSafeByteArray("<challenge xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">" + value + "</challenge>");

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class SWIFTEN_API AuthChallengeSerializer : public GenericElementSerializer<AuthChallenge> {

+ public:

+ AuthChallengeSerializer();

+ virtual SafeByteArray serialize(std::shared_ptr<ToplevelElement> element) const;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class SWIFTEN_API AuthFailureSerializer : public GenericElementSerializer<AuthFailure> {

+ public:

+ AuthFailureSerializer() : GenericElementSerializer<AuthFailure>() {

+ }

+ virtual SafeByteArray serialize(std::shared_ptr<ToplevelElement>) const {

+ return createSafeByteArray(XMLElement("failure", "urn:ietf:params:xml:ns:xmpp-sasl").serialize());

+ }

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

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

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

+SafeByteArray AuthRequestSerializer::serialize(std::shared_ptr<ToplevelElement> element) const {

+ std::shared_ptr<AuthRequest> authRequest(std::dynamic_pointer_cast<AuthRequest>(element));

+ SafeByteArray value;

+ boost::optional<SafeByteArray> message = authRequest->getMessage();

+ if (message) {

+ if ((*message).empty()) {

+ value = createSafeByteArray("=");

+ }

+ else {

+ value = Base64::encode(*message);

+ }

+ }

+ return concat(createSafeByteArray("<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" mechanism=\"" + authRequest->getMechanism() + "\">"), value, createSafeByteArray("</auth>"));

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class SWIFTEN_API AuthRequestSerializer : public GenericElementSerializer<AuthRequest> {

+ public:

+ AuthRequestSerializer();

+ virtual SafeByteArray serialize(std::shared_ptr<ToplevelElement> element) const;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

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

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

+SafeByteArray AuthResponseSerializer::serialize(std::shared_ptr<ToplevelElement> element) const {

+ std::shared_ptr<AuthResponse> authResponse(std::dynamic_pointer_cast<AuthResponse>(element));

+ SafeByteArray value;

+ boost::optional<SafeByteArray> message = authResponse->getValue();

+ if (message) {

+ if ((*message).empty()) {

+ value = createSafeByteArray("");

+ }

+ else {

+ value = Base64::encode(*message);

+ }

+ }

+ return concat(createSafeByteArray("<response xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"), value, createSafeByteArray("</response>"));

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class SWIFTEN_API AuthResponseSerializer : public GenericElementSerializer<AuthResponse> {

+ public:

+ AuthResponseSerializer();

+ virtual SafeByteArray serialize(std::shared_ptr<ToplevelElement> element) const;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

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

+SafeByteArray AuthSuccessSerializer::serialize(std::shared_ptr<ToplevelElement> element) const {

+ std::shared_ptr<AuthSuccess> authSuccess(std::dynamic_pointer_cast<AuthSuccess>(element));

+ std::string value;

+ boost::optional<std::vector<unsigned char> > message = authSuccess->getValue();

+ if (message) {

+ if ((*message).empty()) {

+ value = "=";

+ }

+ else {

+ value = Base64::encode(ByteArray(*message));

+ }

+ }

+ return createSafeByteArray("<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">" + value + "</success>");

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class SWIFTEN_API AuthSuccessSerializer : public GenericElementSerializer<AuthSuccess> {

+ public:

+ AuthSuccessSerializer();

+ virtual SafeByteArray serialize(std::shared_ptr<ToplevelElement> element) const;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+SafeByteArray ComponentHandshakeSerializer::serialize(std::shared_ptr<ToplevelElement> element) const {

+ std::shared_ptr<ComponentHandshake> handshake(std::dynamic_pointer_cast<ComponentHandshake>(element));

+ return createSafeByteArray("<handshake>" + handshake->getData() + "</handshake>");

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class SWIFTEN_API ComponentHandshakeSerializer : public GenericElementSerializer<ComponentHandshake> {

+ public:

+ ComponentHandshakeSerializer();

+ virtual SafeByteArray serialize(std::shared_ptr<ToplevelElement> element) const;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class SWIFTEN_API CompressFailureSerializer : public GenericElementSerializer<CompressFailure> {

+ public:

+ CompressFailureSerializer() : GenericElementSerializer<CompressFailure>() {

+ }

+ virtual SafeByteArray serialize(std::shared_ptr<ToplevelElement>) const {

+ return createSafeByteArray(XMLElement("failure", "http://jabber.org/protocol/compress").serialize());

+ }

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+SafeByteArray CompressRequestSerializer::serialize(std::shared_ptr<ToplevelElement> element) const {

+ std::shared_ptr<CompressRequest> compressRequest(std::dynamic_pointer_cast<CompressRequest>(element));

+ return createSafeByteArray("<compress xmlns='http://jabber.org/protocol/compress'><method>" + compressRequest->getMethod() + "</method></compress>");

+bool CompressRequestSerializer::canSerialize(std::shared_ptr<ToplevelElement> element) const {

+ return std::dynamic_pointer_cast<CompressRequest>(element) != nullptr;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class SWIFTEN_API CompressRequestSerializer : public ElementSerializer {

+ public:

+ CompressRequestSerializer();

+ virtual SafeByteArray serialize(std::shared_ptr<ToplevelElement> element) const;

+ virtual bool canSerialize(std::shared_ptr<ToplevelElement> element) const;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

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

+ class ElementSerializer {

+ public:

+ virtual ~ElementSerializer();

+ virtual SafeByteArray serialize(std::shared_ptr<ToplevelElement> element) const = 0;

+ virtual bool canSerialize(std::shared_ptr<ToplevelElement> element) const = 0;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class SWIFTEN_API EnableStreamManagementSerializer : public GenericElementSerializer<EnableStreamManagement> {

+ public:

+ EnableStreamManagementSerializer() : GenericElementSerializer<EnableStreamManagement>() {

+ }

+ virtual SafeByteArray serialize(std::shared_ptr<ToplevelElement>) const {

+ return createSafeByteArray(XMLElement("enable", "urn:xmpp:sm:2").serialize());

+ }

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ template<typename T>

+ class SWIFTEN_API GenericElementSerializer : public ElementSerializer {

+ public:

+ virtual SafeByteArray serialize(std::shared_ptr<ToplevelElement> element) const = 0;

+ virtual bool canSerialize(std::shared_ptr<ToplevelElement> element) const {

+ return !!std::dynamic_pointer_cast<T>(element);

+ }

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ template<typename PAYLOAD_TYPE>

+ class GenericPayloadSerializer : public PayloadSerializer {

+ public:

+ virtual std::string serialize(std::shared_ptr<Payload> element) const {

+ return serializePayload(std::dynamic_pointer_cast<PAYLOAD_TYPE>(element));

+ }

+ virtual bool canSerialize(std::shared_ptr<Payload> element) const {

+ return !!std::dynamic_pointer_cast<PAYLOAD_TYPE>(element);

+ }

+ virtual std::string serializePayload(std::shared_ptr<PAYLOAD_TYPE>) const = 0;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+ template<typename STANZA_TYPE>

+ class SWIFTEN_API GenericStanzaSerializer : public StanzaSerializer {

+ public:

+ GenericStanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers, const boost::optional<std::string>& explicitNS = boost::optional<std::string>()) : StanzaSerializer(tag, payloadSerializers, explicitNS) {}

+ virtual bool canSerialize(std::shared_ptr<ToplevelElement> element) const {

+ return dynamic_cast<STANZA_TYPE*>(element.get()) != nullptr;

+ }

+ virtual void setStanzaSpecificAttributes(

+ std::shared_ptr<ToplevelElement> stanza,

+ XMLElement& element) const {

+ setStanzaSpecificAttributesGeneric(

+ std::dynamic_pointer_cast<STANZA_TYPE>(stanza), element);

+ }

+ virtual void setStanzaSpecificAttributesGeneric(

+ std::shared_ptr<STANZA_TYPE>,

+ XMLElement&) const = 0;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <boost/optional.hpp>

+

+#include <Swiften/Serializer/GenericStanzaSerializer.h>

+ class SWIFTEN_API IQSerializer : public GenericStanzaSerializer<IQ> {

+ public:

+ IQSerializer(PayloadSerializerCollection* payloadSerializers, const boost::optional<std::string>& explicitNS = boost::optional<std::string>()) :

+ GenericStanzaSerializer<IQ>("iq", payloadSerializers, explicitNS) {

+ }

+ private:

+ virtual void setStanzaSpecificAttributesGeneric(

+ std::shared_ptr<IQ> iq,

+ XMLElement& element) const {

+ switch (iq->getType()) {

+ case IQ::Get: element.setAttribute("type","get"); break;

+ case IQ::Set: element.setAttribute("type","set"); break;

+ case IQ::Result: element.setAttribute("type","result"); break;

+ case IQ::Error: element.setAttribute("type","error"); break;

+ }

+ }

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+

+ GenericStanzaSerializer<Message>("message", payloadSerializers, explicitNS) {

+ std::shared_ptr<Message> message,

+ XMLElement& element) const {

+ if (message->getType() == Message::Chat) {

+ element.setAttribute("type", "chat");

+ }

+ else if (message->getType() == Message::Groupchat) {

+ element.setAttribute("type", "groupchat");

+ }

+ else if (message->getType() == Message::Headline) {

+ element.setAttribute("type", "headline");

+ }

+ else if (message->getType() == Message::Error) {

+ element.setAttribute("type", "error");

+ }

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <boost/optional.hpp>

+

+#include <Swiften/Serializer/GenericStanzaSerializer.h>

+ class XMLElement;

+ class SWIFTEN_API MessageSerializer : public GenericStanzaSerializer<Message> {

+ public:

+ MessageSerializer(PayloadSerializerCollection* payloadSerializers, const boost::optional<std::string>& explitNS = boost::optional<std::string>());

+ private:

+ void setStanzaSpecificAttributesGeneric(

+ std::shared_ptr<Message> message,

+ XMLElement& element) const;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class Payload;

+ class SWIFTEN_API PayloadSerializer {

+ public:

+ virtual ~PayloadSerializer();

+ virtual bool canSerialize(std::shared_ptr<Payload>) const = 0;

+ virtual std::string serialize(std::shared_ptr<Payload>) const = 0;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Serializer/PayloadSerializerCollection.h>

+

+#include <boost/bind.hpp>

+

+PayloadSerializerCollection::~PayloadSerializerCollection() {

+}

+

+ serializers_.push_back(serializer);

+ serializers_.erase(std::remove(serializers_.begin(), serializers_.end(), serializer), serializers_.end());

+PayloadSerializer* PayloadSerializerCollection::getPayloadSerializer(std::shared_ptr<Payload> payload) const {

+ std::vector<PayloadSerializer*>::const_iterator i = std::find_if(

+ serializers_.begin(), serializers_.end(),

+ boost::bind(&PayloadSerializer::canSerialize, _1, payload));

+ return (i != serializers_.end() ? *i : nullptr);

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class PayloadSerializer;

+ class SWIFTEN_API PayloadSerializerCollection {

+ public:

+ PayloadSerializerCollection();

+ virtual ~PayloadSerializerCollection();

+ void addSerializer(PayloadSerializer* factory);

+ void removeSerializer(PayloadSerializer* factory);

+ PayloadSerializer* getPayloadSerializer(std::shared_ptr<Payload>) const;

+ private:

+ std::vector<PayloadSerializer*> serializers_;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ template<typename BLOCK_ELEMENT>

+ class SWIFTEN_API BlockSerializer : public GenericPayloadSerializer<BLOCK_ELEMENT> {

+ public:

+ BlockSerializer(std::string tag) : GenericPayloadSerializer<BLOCK_ELEMENT>(), tag(tag) {

+ }

+ virtual std::string serializePayload(std::shared_ptr<BLOCK_ELEMENT> payload) const {

+ XMLElement element(tag, "urn:xmpp:blocking");

+ const std::vector<JID>& items = payload->getItems();

+ for (const auto& i : items) {

+ std::shared_ptr<XMLElement> item = std::make_shared<XMLElement>("item");

+ item->setAttribute("jid", i);

+ element.addNode(item);

+ }

+ return element.serialize();

+ }

+ private:

+ std::string tag;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

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

+ class SWIFTEN_API BodySerializer : public GenericPayloadSerializer<Body> {

+ public:

+ BodySerializer() : GenericPayloadSerializer<Body>() {}

+ virtual std::string serializePayload(std::shared_ptr<Body> body) const {

+ XMLTextNode textNode(body->getText());

+ return "<body>" + textNode.serialize() + "</body>";

+ }

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

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

+std::string BytestreamsSerializer::serializePayload(std::shared_ptr<Bytestreams> bytestreams) const {

+ XMLElement queryElement("query", "http://jabber.org/protocol/bytestreams");

+ queryElement.setAttribute("sid", bytestreams->getStreamID());

+ for (const auto& streamHost : bytestreams->getStreamHosts()) {

+ std::shared_ptr<XMLElement> streamHostElement(new XMLElement("streamhost"));

+ streamHostElement->setAttribute("host", streamHost.host);

+ streamHostElement->setAttribute("jid", streamHost.jid.toString());

+ streamHostElement->setAttribute("port", boost::lexical_cast<std::string>(streamHost.port));

+ queryElement.addNode(streamHostElement);

+ }

+

+ if (bytestreams->getUsedStreamHost()) {

+ std::shared_ptr<XMLElement> streamHostElement(new XMLElement("streamhost-used"));

+ streamHostElement->setAttribute("jid", *bytestreams->getUsedStreamHost());

+ queryElement.addNode(streamHostElement);

+ }

+ return queryElement.serialize();

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class PayloadSerializerCollection;

+ class SWIFTEN_API BytestreamsSerializer : public GenericPayloadSerializer<Bytestreams> {

+ public:

+ BytestreamsSerializer();

+ virtual std::string serializePayload(std::shared_ptr<Bytestreams>) const;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+std::string CapsInfoSerializer::serializePayload(std::shared_ptr<CapsInfo> capsInfo) const {

+ XMLElement capsElement("c", "http://jabber.org/protocol/caps");

+ capsElement.setAttribute("node", capsInfo->getNode());

+ capsElement.setAttribute("hash", capsInfo->getHash());

+ capsElement.setAttribute("ver", capsInfo->getVersion());

+ return capsElement.serialize();

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class SWIFTEN_API CapsInfoSerializer : public GenericPayloadSerializer<CapsInfo> {

+ public:

+ CapsInfoSerializer();

+ virtual std::string serializePayload(std::shared_ptr<CapsInfo>) const;

+ };

+ * Copyright (c) 2015-2016 Isode Limited.

+ CarbonsDisableSerializer::CarbonsDisableSerializer() : GenericPayloadSerializer<CarbonsDisable>() {

+ }

+ CarbonsDisableSerializer::~CarbonsDisableSerializer() {

+ }

+ std::string CarbonsDisableSerializer::serializePayload(std::shared_ptr<CarbonsDisable>) const {

+ XMLElement element("disable", "urn:xmpp:carbons:2");

+ return element.serialize();

+ }

+ * Copyright (c) 2015-2016 Isode Limited.

+ class SWIFTEN_API CarbonsDisableSerializer : public GenericPayloadSerializer<CarbonsDisable> {

+ public:

+ CarbonsDisableSerializer();

+ virtual ~CarbonsDisableSerializer();

+ virtual std::string serializePayload(std::shared_ptr<CarbonsDisable>) const;

+ };

+ * Copyright (c) 2015-2016 Isode Limited.

+ CarbonsEnableSerializer::CarbonsEnableSerializer() : GenericPayloadSerializer<CarbonsEnable>() {

+ }

+ CarbonsEnableSerializer::~CarbonsEnableSerializer() {

+ }

+ std::string CarbonsEnableSerializer::serializePayload(std::shared_ptr<CarbonsEnable>) const {

+ XMLElement element("enable", "urn:xmpp:carbons:2");

+ return element.serialize();

+ }

+ * Copyright (c) 2015-2016 Isode Limited.

+ class SWIFTEN_API CarbonsEnableSerializer : public GenericPayloadSerializer<CarbonsEnable> {

+ public:

+ CarbonsEnableSerializer();

+ virtual ~CarbonsEnableSerializer();

+ virtual std::string serializePayload(std::shared_ptr<CarbonsEnable>) const;

+ };

+ * Copyright (c) 2015-2016 Isode Limited.

+ CarbonsPrivateSerializer::CarbonsPrivateSerializer() : GenericPayloadSerializer<CarbonsPrivate>() {

+ }

+ CarbonsPrivateSerializer::~CarbonsPrivateSerializer() {

+ }

+ std::string CarbonsPrivateSerializer::serializePayload(std::shared_ptr<CarbonsPrivate>) const {

+ XMLElement element("private", "urn:xmpp:carbons:2");

+ return element.serialize();

+ }

+ * Copyright (c) 2015-2016 Isode Limited.

+ class SWIFTEN_API CarbonsPrivateSerializer : public GenericPayloadSerializer<CarbonsPrivate> {

+ public:

+ CarbonsPrivateSerializer();

+ virtual ~CarbonsPrivateSerializer();

+ virtual std::string serializePayload(std::shared_ptr<CarbonsPrivate>) const;

+ };

+ * Copyright (c) 2015-2016 Isode Limited.

+#include <memory>

+ CarbonsReceivedSerializer::CarbonsReceivedSerializer(PayloadSerializerCollection* serializers) : GenericPayloadSerializer<CarbonsReceived>(), serializers_(serializers) {

+ }

+ CarbonsReceivedSerializer::~CarbonsReceivedSerializer() {

+ }

+

+ std::string CarbonsReceivedSerializer::serializePayload(std::shared_ptr<CarbonsReceived> received) const {

+ XMLElement element("received", "urn:xmpp:carbons:2");

+ if (received->getForwarded()) {

+ element.addNode(std::make_shared<XMLRawTextNode>(ForwardedSerializer(serializers_).serialize(received->getForwarded())));

+ }

+ return element.serialize();

+ }

+ * Copyright (c) 2015-2016 Isode Limited.

+#include <Swiften/Serializer/PayloadSerializers/ForwardedSerializer.h>

+ class SWIFTEN_API CarbonsReceivedSerializer : public GenericPayloadSerializer<CarbonsReceived> {

+ public:

+ CarbonsReceivedSerializer(PayloadSerializerCollection* serializers);

+ virtual ~CarbonsReceivedSerializer();

+ virtual std::string serializePayload(std::shared_ptr<CarbonsReceived> received) const;

+ private:

+ PayloadSerializerCollection* serializers_;

+ };

+ * Copyright (c) 2015-2016 Isode Limited.

+ CarbonsSentSerializer::CarbonsSentSerializer(PayloadSerializerCollection* serializers) : GenericPayloadSerializer<CarbonsSent>(), serializers_(serializers) {

+ }

+ CarbonsSentSerializer::~CarbonsSentSerializer() {

+ }

+

+ std::string CarbonsSentSerializer::serializePayload(std::shared_ptr<CarbonsSent> sent) const {

+ XMLElement element("sent", "urn:xmpp:carbons:2");

+ if (sent->getForwarded()) {

+ element.addNode(std::make_shared<XMLRawTextNode>(ForwardedSerializer(serializers_).serialize(sent->getForwarded())));

+ }

+ return element.serialize();

+ }

+ * Copyright (c) 2015-2016 Isode Limited.

+#include <memory>

+#include <Swiften/Serializer/PayloadSerializers/ForwardedSerializer.h>

+ class SWIFTEN_API CarbonsSentSerializer : public GenericPayloadSerializer<CarbonsSent> {

+ public:

+ CarbonsSentSerializer(PayloadSerializerCollection* serializers);

+ virtual ~CarbonsSentSerializer();

+ virtual std::string serializePayload(std::shared_ptr<CarbonsSent> sent) const;

+ private:

+ PayloadSerializerCollection* serializers_;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+std::string ChatStateSerializer::serializePayload(std::shared_ptr<ChatState> chatState) const {

+ std::string result("<");

+ switch (chatState->getChatState()) {

+ case ChatState::Active: result += "active"; break;

+ case ChatState::Composing: result += "composing"; break;

+ case ChatState::Paused: result += "paused"; break;

+ case ChatState::Inactive: result += "inactive"; break;

+ case ChatState::Gone: result += "gone"; break;

+ }

+ result += " xmlns=\"http://jabber.org/protocol/chatstates\"/>";

+ return result;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class SWIFTEN_API ChatStateSerializer : public GenericPayloadSerializer<ChatState> {

+ public:

+ ChatStateSerializer();

+ virtual std::string serializePayload(std::shared_ptr<ChatState> error) const;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

+#include <Swiften/Serializer/XML/XMLTextNode.h>

+std::string CommandSerializer::serializePayload(std::shared_ptr<Command> command) const {

+ XMLElement commandElement("command", "http://jabber.org/protocol/commands");

+ commandElement.setAttribute("node", command->getNode());

+ if (!command->getSessionID().empty()) {

+ commandElement.setAttribute("sessionid", command->getSessionID());

+ }

+ std::string action = actionToString(command->getAction());

+ if (!action.empty()) {

+ commandElement.setAttribute("action", action);

+ }

+ std::string status;

+ switch (command->getStatus()) {

+ case Command::Executing: status = "executing";break;

+ case Command::Completed: status = "completed";break;

+ case Command::Canceled: status = "canceled";break;

+ case Command::NoStatus: break;

+ }

+ if (!status.empty()) {

+ commandElement.setAttribute("status", status);

+ }

+ if (command->getAvailableActions().size() > 0) {

+ std::string actions = "<actions";

+ std::string executeAction = actionToString(command->getExecuteAction());

+ if (!executeAction.empty()) {

+ actions += " execute='" + executeAction + "'";

+ }

+ actions += ">";

+ for (const auto& action : command->getAvailableActions()) {

+ actions += "<" + actionToString(action) + "/>";

+ }

+ actions += "</actions>";

+ commandElement.addNode(std::make_shared<XMLRawTextNode>(actions));

+ }

+ for (const auto& note : command->getNotes()) {

+ std::shared_ptr<XMLElement> noteElement(new XMLElement("note"));

+ std::string type;

+ switch (note.type) {

+ case Command::Note::Info: type = "info"; break;

+ case Command::Note::Warn: type = "warn"; break;

+ case Command::Note::Error: type = "error"; break;

+ }

+ if (!type.empty()) {

+ noteElement->setAttribute("type", type);

+ }

+ noteElement->addNode(std::make_shared<XMLTextNode>(note.note));

+ commandElement.addNode(noteElement);

+ }

+ Form::ref form = command->getForm();

+ if (form) {

+ commandElement.addNode(std::make_shared<XMLRawTextNode>(FormSerializer().serialize(form)));

+ }

+ return commandElement.serialize();

+ std::string string;

+ switch (action) {

+ case Command::Cancel: string = "cancel"; break;

+ case Command::Execute: string = "execute"; break;

+ case Command::Complete: string = "complete"; break;

+ case Command::Prev: string = "prev"; break;

+ case Command::Next: string = "next"; break;

+ case Command::NoAction: break;

+ }

+ return string;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class SWIFTEN_API CommandSerializer : public GenericPayloadSerializer<Command> {

+ public:

+ CommandSerializer();

+ virtual std::string serializePayload(std::shared_ptr<Command>) const;

+ private:

+ std::string actionToString(Command::Action action) const;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

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

+std::string DelaySerializer::serializePayload(std::shared_ptr<Delay> delay) const {

+ XMLElement delayElement("delay", "urn:xmpp:delay");

+ if (delay->getFrom() && delay->getFrom()->isValid()) {

+ delayElement.setAttribute("from", delay->getFrom()->toString());

+ }

+ delayElement.setAttribute("stamp", dateTimeToString(delay->getStamp()));

+ return delayElement.serialize();

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class SWIFTEN_API DelaySerializer : public GenericPayloadSerializer<Delay> {

+ public:

+ DelaySerializer();

+ virtual std::string serializePayload(std::shared_ptr<Delay>) const;

+ };

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

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

+std::string DeliveryReceiptRequestSerializer::serializePayload(std::shared_ptr<DeliveryReceiptRequest> /* request*/) const {

+ XMLElement requestXML("request", "urn:xmpp:receipts");

+ return requestXML.serialize();

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

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

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class SWIFTEN_API DeliveryReceiptRequestSerializer : public GenericPayloadSerializer<DeliveryReceiptRequest> {

+ public:

+ DeliveryReceiptRequestSerializer();

+ virtual std::string serializePayload(std::shared_ptr<DeliveryReceiptRequest> request) const;

+ };

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+

+std::string DeliveryReceiptSerializer::serializePayload(std::shared_ptr<DeliveryReceipt> receipt) const {

+ XMLElement received("received", "urn:xmpp:receipts");

+ received.setAttribute("id", receipt->getReceivedID());

+ return received.serialize();

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class SWIFTEN_API DeliveryReceiptSerializer : public GenericPayloadSerializer<DeliveryReceipt> {

+ public:

+ DeliveryReceiptSerializer();

+ virtual std::string serializePayload(std::shared_ptr<DeliveryReceipt> receipt) const;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

+std::string DiscoInfoSerializer::serializePayload(std::shared_ptr<DiscoInfo> discoInfo) const {

+ XMLElement queryElement("query", "http://jabber.org/protocol/disco#info");

+ if (!discoInfo->getNode().empty()) {

+ queryElement.setAttribute("node", discoInfo->getNode());

+ }

+ for (const auto& identity : discoInfo->getIdentities()) {

+ std::shared_ptr<XMLElement> identityElement(new XMLElement("identity"));

+ if (!identity.getLanguage().empty()) {

+ identityElement->setAttribute("xml:lang", identity.getLanguage());

+ }

+ identityElement->setAttribute("category", identity.getCategory());

+ identityElement->setAttribute("name", identity.getName());

+ identityElement->setAttribute("type", identity.getType());

+ queryElement.addNode(identityElement);

+ }

+ for (const auto& feature : discoInfo->getFeatures()) {

+ std::shared_ptr<XMLElement> featureElement(new XMLElement("feature"));

+ featureElement->setAttribute("var", feature);

+ queryElement.addNode(featureElement);

+ }

+ for (const auto& extension : discoInfo->getExtensions()) {

+ queryElement.addNode(std::make_shared<XMLRawTextNode>(FormSerializer().serialize(extension)));

+ }

+ return queryElement.serialize();

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class SWIFTEN_API DiscoInfoSerializer : public GenericPayloadSerializer<DiscoInfo> {

+ public:

+ DiscoInfoSerializer();

+ virtual std::string serializePayload(std::shared_ptr<DiscoInfo>) const;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+std::string DiscoItemsSerializer::serializePayload(std::shared_ptr<DiscoItems> discoItems) const {

+ XMLElement queryElement("query", "http://jabber.org/protocol/disco#items");

+ if (!discoItems->getNode().empty()) {

+ queryElement.setAttribute("node", discoItems->getNode());

+ }

+ for (const auto& item : discoItems->getItems()) {

+ std::shared_ptr<XMLElement> itemElement(new XMLElement("item"));

+ itemElement->setAttribute("name", item.getName());

+ itemElement->setAttribute("jid", item.getJID());

+ if (!item.getNode().empty()) {

+ itemElement->setAttribute("node", item.getNode());

+ }

+ queryElement.addNode(itemElement);

+ }

+ return queryElement.serialize();

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class SWIFTEN_API DiscoItemsSerializer : public GenericPayloadSerializer<DiscoItems> {

+ public:

+ DiscoItemsSerializer();

+ virtual std::string serializePayload(std::shared_ptr<DiscoItems>) const;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+

+#include <Swiften/Serializer/XML/XMLTextNode.h>

+std::string ErrorSerializer::serializePayload(std::shared_ptr<ErrorPayload> error) const {

+ std::string result("<error type=\"");

+ switch (error->getType()) {

+ case ErrorPayload::Continue: result += "continue"; break;

+ case ErrorPayload::Modify: result += "modify"; break;

+ case ErrorPayload::Auth: result += "auth"; break;

+ case ErrorPayload::Wait: result += "wait"; break;

+ case ErrorPayload::Cancel: result += "cancel"; break;

+ }

+ result += "\">";

+ std::string conditionElement;

+ switch (error->getCondition()) {

+ case ErrorPayload::BadRequest: conditionElement = "bad-request"; break;

+ case ErrorPayload::Conflict: conditionElement = "conflict"; break;

+ case ErrorPayload::FeatureNotImplemented: conditionElement = "feature-not-implemented"; break;

+ case ErrorPayload::Forbidden: conditionElement = "forbidden"; break;

+ case ErrorPayload::Gone: conditionElement = "gone"; break;

+ case ErrorPayload::InternalServerError: conditionElement = "internal-server-error"; break;

+ case ErrorPayload::ItemNotFound: conditionElement = "item-not-found"; break;

+ case ErrorPayload::JIDMalformed: conditionElement = "jid-malformed"; break;

+ case ErrorPayload::NotAcceptable: conditionElement = "not-acceptable"; break;

+ case ErrorPayload::NotAllowed: conditionElement = "not-allowed"; break;

+ case ErrorPayload::NotAuthorized: conditionElement = "not-authorized"; break;

+ case ErrorPayload::PaymentRequired: conditionElement = "payment-required"; break;

+ case ErrorPayload::RecipientUnavailable: conditionElement = "recipient-unavailable"; break;

+ case ErrorPayload::Redirect: conditionElement = "redirect"; break;

+ case ErrorPayload::RegistrationRequired: conditionElement = "registration-required"; break;

+ case ErrorPayload::RemoteServerNotFound: conditionElement = "remote-server-not-found"; break;

+ case ErrorPayload::RemoteServerTimeout: conditionElement = "remote-server-timeout"; break;

+ case ErrorPayload::ResourceConstraint: conditionElement = "resource-constraint"; break;

+ case ErrorPayload::ServiceUnavailable: conditionElement = "service-unavailable"; break;

+ case ErrorPayload::SubscriptionRequired: conditionElement = "subscription-required"; break;

+ case ErrorPayload::UnexpectedRequest: conditionElement = "unexpected-request"; break;

+ case ErrorPayload::UndefinedCondition: conditionElement = "undefined-condition"; break;

+ }

+ result += "<" + conditionElement + " xmlns=\"urn:ietf:params:xml:ns:xmpp-stanzas\"/>";

+ if (!error->getText().empty()) {

+ XMLTextNode textNode(error->getText());

+ result += "<text xmlns=\"urn:ietf:params:xml:ns:xmpp-stanzas\">" + textNode.serialize() + "</text>";

+ }

+ if (error->getPayload()) {

+ PayloadSerializer* serializer = serializers->getPayloadSerializer(error->getPayload());

+ if (serializer) {

+ result += serializer->serialize(error->getPayload());

+ }

+ }

+ result += "</error>";

+ return result;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class PayloadSerializerCollection;

+ class SWIFTEN_API ErrorSerializer : public GenericPayloadSerializer<ErrorPayload> {

+ public:

+ ErrorSerializer(PayloadSerializerCollection* serializers);

+ virtual std::string serializePayload(std::shared_ptr<ErrorPayload> error) const;

+ private:

+ PayloadSerializerCollection* serializers;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

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

+#include <Swiften/Serializer/XML/XMLTextNode.h>

+ template<typename T> void serializeValueAsString(std::shared_ptr<FormField> field, std::shared_ptr<XMLElement> parent) {

+ std::string value = std::dynamic_pointer_cast<T>(field)->getValue();

+ if (!value.empty()) {

+ std::shared_ptr<XMLElement> valueElement(new XMLElement("value"));

+ valueElement->addNode(XMLTextNode::create(value));

+ parent->addNode(valueElement);

+ }

+ }

+std::string FormSerializer::serializePayload(std::shared_ptr<Form> form) const {

+ if (!form) {

+ return "";

+ }

+

+ std::shared_ptr<XMLElement> formElement(new XMLElement("x", "jabber:x:data"));

+ std::string type;

+ switch (form->getType()) {

+ case Form::FormType: type = "form"; break;

+ case Form::SubmitType: type = "submit"; break;

+ case Form::CancelType: type = "cancel"; break;

+ case Form::ResultType: type = "result"; break;

+ }

+ formElement->setAttribute("type", type);

+ if (!form->getTitle().empty()) {

+ multiLineify(form->getTitle(), "title", formElement);

+ }

+ if (!form->getInstructions().empty()) {

+ multiLineify(form->getInstructions(), "instructions", formElement);

+ }

+ for (const auto& page : form->getPages()) {

+ formElement->addNode(pageToXML(page));

+ }

+ for (const auto& field : form->getFields()) {

+ formElement->addNode(fieldToXML(field, true));

+ }

+ if (!form->getReportedFields().empty()) {

+ std::shared_ptr<XMLElement> reportedElement(new XMLElement("reported"));

+ for (const auto& field : form->getReportedFields()) {

+ reportedElement->addNode(fieldToXML(field, true));

+ }

+ formElement->addNode(reportedElement);

+ }

+

+ for (const auto& item : form->getItems()) {

+ std::shared_ptr<XMLElement> itemElement(new XMLElement("item"));

+ for (const auto& field : item) {

+ itemElement->addNode(fieldToXML(field, false));

+ }

+ formElement->addNode(itemElement);

+ }

+

+ for (const auto& text : form->getTextElements()) {

+ formElement->addNode(textToXML(text));

+ }

+

+ for (const auto& field : fields_) {

+ formElement->addNode(fieldToXML(field,true));

+ }

+

+ return formElement->serialize();

+std::shared_ptr<XMLElement> FormSerializer::textToXML(std::shared_ptr<FormText> text) const {

+ std::shared_ptr<XMLElement> textElement (new XMLElement("text"));

+ textElement->addNode(std::make_shared<XMLTextNode>(text->getTextString()));

+ return textElement;

+std::shared_ptr<XMLElement> FormSerializer::fieldRefToXML(const std::string& ref) const {

+ std::shared_ptr<XMLElement> fieldRefElement(new XMLElement("fieldref"));

+ fieldRefElement->setAttribute("var", ref);

+ return fieldRefElement;

+std::shared_ptr<XMLElement> FormSerializer::pageToXML(std::shared_ptr<FormPage> page) const {

+ std::shared_ptr<XMLElement> pageElement(new XMLElement("page"));

+ pageElement->setAttribute("xmlns", "http://jabber.org/protocol/xdata-layout");

+ if (!page->getLabel().empty()) {

+ pageElement->setAttribute("label", page->getLabel());

+ }

+ for (const auto& text : page->getTextElements()) {

+ pageElement->addNode(textToXML(text));

+ }

+ for (const auto& field : page->getFields()) {

+ pageElement->addNode(fieldRefToXML(field->getName()));

+ fields_.push_back(field);

+ }

+ for (const auto& reportedRef: page->getReportedRefs()) {

+ (void)reportedRef;

+ pageElement->addNode(std::make_shared<XMLElement>("reportedref"));

+ }

+ for (const auto& section : page->getChildSections()) {

+ pageElement->addNode(sectionToXML(section));

+ }

+ return pageElement;

+std::shared_ptr<XMLElement> FormSerializer::sectionToXML(std::shared_ptr<FormSection> section) const {

+ std::shared_ptr<XMLElement> sectionElement(new XMLElement("section"));

+ if (!section->getLabel().empty()) {

+ sectionElement->setAttribute("label", section->getLabel());

+ }

+ for (const auto& text : section->getTextElements()) {

+ sectionElement->addNode(textToXML(text));

+ }

+ for (const auto& field : section->getFields()) {

+ sectionElement->addNode(fieldRefToXML(field->getName()));

+ fields_.push_back(field);

+ }

+ for (const auto& reportedRef : section->getReportedRefs()) {

+ (void)reportedRef;

+ sectionElement->addNode(std::make_shared<XMLElement>("reportedref"));

+ }

+ for (const auto& childSection : section->getChildSections()) {

+ sectionElement->addNode(sectionToXML(childSection));

+ }

+ return sectionElement;

+std::shared_ptr<XMLElement> FormSerializer::fieldToXML(std::shared_ptr<FormField> field, bool withTypeAttribute) const {

+ std::shared_ptr<XMLElement> fieldElement(new XMLElement("field"));

+ if (!field->getName().empty()) {

+ fieldElement->setAttribute("var", field->getName());

+ }

+ if (!field->getLabel().empty()) {

+ fieldElement->setAttribute("label", field->getLabel());

+ }

+ if (field->getRequired()) {

+ fieldElement->addNode(std::make_shared<XMLElement>("required"));

+ }

+ if (!field->getDescription().empty()) {

+ std::shared_ptr<XMLElement> descriptionElement(new XMLElement("desc"));

+ descriptionElement->addNode(std::make_shared<XMLTextNode>(field->getDescription()));

+ fieldElement->addNode(descriptionElement);

+ }

+

+ // Set the value and type

+ std::string fieldType;

+ switch (field->getType()) {

+ case FormField::UnknownType: fieldType = ""; break;

+ case FormField::BooleanType: fieldType = "boolean"; break;

+ case FormField::FixedType: fieldType = "fixed"; break;

+ case FormField::HiddenType: fieldType = "hidden"; break;

+ case FormField::ListSingleType: fieldType = "list-single"; break;

+ case FormField::TextMultiType: fieldType = "text-multi"; break;

+ case FormField::TextPrivateType: fieldType = "text-private"; break;

+ case FormField::TextSingleType: fieldType = "text-single"; break;

+ case FormField::JIDSingleType: fieldType = "jid-single"; break;

+ case FormField::JIDMultiType: fieldType = "jid-multi"; break;

+ case FormField::ListMultiType: fieldType = "list-multi"; break;

+ }

+ if (!fieldType.empty() && withTypeAttribute) {

+ fieldElement->setAttribute("type", fieldType);

+ }

+ for (const auto& value : field->getValues()) {

+ std::shared_ptr<XMLElement> valueElement = std::make_shared<XMLElement>("value");

+ valueElement->addNode(std::make_shared<XMLTextNode>(value));

+ fieldElement->addNode(valueElement);

+ }

+

+ for (const auto& option : field->getOptions()) {

+ std::shared_ptr<XMLElement> optionElement(new XMLElement("option"));

+ if (!option.label.empty()) {

+ optionElement->setAttribute("label", option.label);

+ }

+

+ std::shared_ptr<XMLElement> valueElement(new XMLElement("value"));

+ valueElement->addNode(XMLTextNode::create(option.value));

+ optionElement->addNode(valueElement);

+ fieldElement->addNode(optionElement);

+ }

+ return fieldElement;

+void FormSerializer::multiLineify(const std::string& text, const std::string& elementName, std::shared_ptr<XMLElement> element) const {

+ std::string unRdText(text);

+ erase(unRdText, '\r');

+ std::vector<std::string> lines = String::split(unRdText, '\n');

+ for (const auto& line : lines) {

+ std::shared_ptr<XMLElement> lineElement(new XMLElement(elementName));

+ lineElement->addNode(std::make_shared<XMLTextNode>(line));

+ element->addNode(lineElement);

+ }

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class SWIFTEN_API FormSerializer : public GenericPayloadSerializer<Form> {

+ public:

+ FormSerializer();

+ virtual std::string serializePayload(std::shared_ptr<Form>) const;

+ private:

+ std::shared_ptr<XMLElement> textToXML(std::shared_ptr<FormText> textElement) const;

+ std::shared_ptr<XMLElement> fieldRefToXML(const std::string& ref) const;

+ std::shared_ptr<XMLElement> reportedRefToXML(std::shared_ptr<FormReportedRef> reportedRef) const;

+ std::shared_ptr<XMLElement> pageToXML(std::shared_ptr<FormPage> page) const;

+ std::shared_ptr<XMLElement> sectionToXML(std::shared_ptr<FormSection> section) const;

+ std::shared_ptr<XMLElement> fieldToXML(std::shared_ptr<FormField> field, bool withTypeAttribute) const;

+ void multiLineify(const std::string& text, const std::string& elementName, std::shared_ptr<XMLElement> parent) const;

+ mutable std::vector<std::shared_ptr<FormField> > fields_;

+ };

+ * Copyright (c) 2014-2016 Isode Limited.

+#include <Swiften/Serializer/PayloadSerializers/ForwardedSerializer.h>

+

+#include <memory>

+

+

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

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

+#include <Swiften/Serializer/XML/XMLRawTextNode.h>

+std::string ForwardedSerializer::serializePayload(std::shared_ptr<Forwarded> payload) const {

+ if (!payload) {

+ return "";

+ }

+

+ XMLElement element("forwarded", "urn:xmpp:forward:0");

+

+ if (payload->getDelay()) {

+ element.addNode(std::make_shared<XMLRawTextNode>(DelaySerializer().serialize(payload->getDelay())));

+ }

+

+ if (payload->getStanza()) { /* find out what type of stanza we are dealing with and branch into the correct serializer*/

+ std::shared_ptr<IQ> iq;

+ std::shared_ptr<Message> message;

+ std::shared_ptr<Presence> presence;

+ const std::string ns = "jabber:client";

+ if ((iq = std::dynamic_pointer_cast<IQ>(payload->getStanza()))) {

+ element.addNode(std::make_shared<XMLRawTextNode>(safeByteArrayToString(IQSerializer(serializers_).serialize(iq, ns))));

+ } else if ((message = std::dynamic_pointer_cast<Message>(payload->getStanza()))) {

+ element.addNode(std::make_shared<XMLRawTextNode>(safeByteArrayToString(MessageSerializer(serializers_).serialize(message, ns))));

+ } else if ((presence = std::dynamic_pointer_cast<Presence>(payload->getStanza()))) {

+ element.addNode(std::make_shared<XMLRawTextNode>(safeByteArrayToString(PresenceSerializer(serializers_).serialize(presence, ns))));

+ }

+ }

+

+ return element.serialize();

+ * Copyright (c) 2014-2016 Isode Limited.

+#include <memory>

+

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

+ class PayloadSerializerCollection;

+ class SWIFTEN_API ForwardedSerializer : public GenericPayloadSerializer<Forwarded> {

+ public:

+ ForwardedSerializer(PayloadSerializerCollection* serializers);

+ virtual ~ForwardedSerializer();

+ virtual std::string serializePayload(std::shared_ptr<Forwarded>) const SWIFTEN_OVERRIDE;

+ private:

+ PayloadSerializerCollection* serializers_;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+

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

+ serializers_.push_back(new IBBSerializer());

+ serializers_.push_back(new BodySerializer());

+ serializers_.push_back(new SubjectSerializer());

+ serializers_.push_back(new ThreadSerializer());

+ serializers_.push_back(new ChatStateSerializer());

+ serializers_.push_back(new PrioritySerializer());

+ serializers_.push_back(new ErrorSerializer(this));

+ serializers_.push_back(new RosterSerializer());

+ serializers_.push_back(new RosterItemExchangeSerializer());

+ serializers_.push_back(new MUCPayloadSerializer());

+ serializers_.push_back(new MUCDestroyPayloadSerializer());

+ serializers_.push_back(new MUCAdminPayloadSerializer());

+ serializers_.push_back(new MUCInvitationPayloadSerializer());

+ serializers_.push_back(new MUCOwnerPayloadSerializer(this));

+ serializers_.push_back(new MUCUserPayloadSerializer(this));

+ serializers_.push_back(new SoftwareVersionSerializer());

+ serializers_.push_back(new StatusSerializer());

+ serializers_.push_back(new StatusShowSerializer());

+ serializers_.push_back(new DiscoInfoSerializer());

+ serializers_.push_back(new DiscoItemsSerializer());

+ serializers_.push_back(new CapsInfoSerializer());

+ serializers_.push_back(new BlockSerializer<BlockPayload>("block"));

+ serializers_.push_back(new BlockSerializer<UnblockPayload>("unblock"));

+ serializers_.push_back(new BlockSerializer<BlockListPayload>("blocklist"));

+ serializers_.push_back(new ResourceBindSerializer());

+ serializers_.push_back(new StartSessionSerializer());

+ serializers_.push_back(new SecurityLabelSerializer());

+ serializers_.push_back(new SecurityLabelsCatalogSerializer());

+ serializers_.push_back(new StreamInitiationSerializer());

+ serializers_.push_back(new BytestreamsSerializer());

+ serializers_.push_back(new VCardSerializer());

+ serializers_.push_back(new VCardUpdateSerializer());

+ serializers_.push_back(new RawXMLPayloadSerializer());

+ serializers_.push_back(new StorageSerializer());

+ serializers_.push_back(new DelaySerializer());

+ serializers_.push_back(new FormSerializer());

+ serializers_.push_back(new PrivateStorageSerializer(this));

+ serializers_.push_back(new CommandSerializer());

+ serializers_.push_back(new InBandRegistrationPayloadSerializer());

+ serializers_.push_back(new NicknameSerializer());

+ serializers_.push_back(new SearchPayloadSerializer());

+ serializers_.push_back(new ReplaceSerializer());

+ serializers_.push_back(new LastSerializer());

+ serializers_.push_back(new WhiteboardSerializer());

+ serializers_.push_back(new UserLocationSerializer(this));

+ serializers_.push_back(new UserTuneSerializer(this));

+ serializers_.push_back(new IdleSerializer());

+

+ serializers_.push_back(new StreamInitiationFileInfoSerializer());

+ serializers_.push_back(new JingleFileTransferFileInfoSerializer());

+ serializers_.push_back(new JingleContentPayloadSerializer());

+ serializers_.push_back(new JingleFileTransferDescriptionSerializer());

+ serializers_.push_back(new JingleFileTransferHashSerializer());

+ serializers_.push_back(new JingleIBBTransportPayloadSerializer());

+ serializers_.push_back(new JingleS5BTransportPayloadSerializer());

+ serializers_.push_back(new JinglePayloadSerializer(this));

+ serializers_.push_back(new S5BProxyRequestSerializer());

+ serializers_.push_back(new DeliveryReceiptSerializer());

+ serializers_.push_back(new DeliveryReceiptRequestSerializer());

+

+ serializers_.push_back(new PubSubSerializer(this));

+ serializers_.push_back(new PubSubEventSerializer(this));

+ serializers_.push_back(new PubSubOwnerPubSubSerializer(this));

+ serializers_.push_back(new PubSubErrorSerializer());

+ serializers_.push_back(new ResultSetSerializer());

+ serializers_.push_back(new ForwardedSerializer(this));

+ serializers_.push_back(new MAMResultSerializer(this));

+ serializers_.push_back(new MAMQuerySerializer());

+ serializers_.push_back(new MAMFinSerializer());

+ serializers_.push_back(new CarbonsDisableSerializer());

+ serializers_.push_back(new CarbonsEnableSerializer());

+ serializers_.push_back(new CarbonsPrivateSerializer());

+ serializers_.push_back(new CarbonsReceivedSerializer(this));

+ serializers_.push_back(new CarbonsSentSerializer(this));

+ serializers_.push_back(new IsodeIQDelegationSerializer(this));

+ for (auto serializer : serializers_) {

+ addSerializer(serializer);

+ }

+ for (auto serializer : serializers_) {

+ removeSerializer(serializer);

+ delete serializer;

+ }

+ serializers_.clear();

+ class SWIFTEN_API FullPayloadSerializerCollection : public PayloadSerializerCollection {

+ public:

+ FullPayloadSerializerCollection();

+ virtual ~FullPayloadSerializerCollection();

+ private:

+ std::vector<PayloadSerializer*> serializers_;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

+std::string IBBSerializer::serializePayload(std::shared_ptr<IBB> ibb) const {

+ switch(ibb->getAction()) {

+ case IBB::Data: {

+ XMLElement ibbElement("data", "http://jabber.org/protocol/ibb");

+ ibbElement.setAttribute("sid", ibb->getStreamID());

+ if (ibb->getSequenceNumber() >= 0) {

+ ibbElement.setAttribute("seq", boost::lexical_cast<std::string>(ibb->getSequenceNumber()));

+ }

+ ibbElement.addNode(std::make_shared<XMLTextNode>(Base64::encode(ibb->getData())));

+ return ibbElement.serialize();

+ }

+ case IBB::Open: {

+ XMLElement ibbElement("open", "http://jabber.org/protocol/ibb");

+ ibbElement.setAttribute("sid", ibb->getStreamID());

+ switch (ibb->getStanzaType()) {

+ case IBB::IQStanza: ibbElement.setAttribute("stanza", "iq"); break;

+ case IBB::MessageStanza: ibbElement.setAttribute("stanza", "message"); break;

+ }

+ assert(ibb->getBlockSize() > 0);

+ ibbElement.setAttribute("block-size", boost::lexical_cast<std::string>(ibb->getBlockSize()));

+ return ibbElement.serialize();

+ }

+ case IBB::Close: {

+ XMLElement ibbElement("close", "http://jabber.org/protocol/ibb");

+ ibbElement.setAttribute("sid", ibb->getStreamID());

+ return ibbElement.serialize();

+ }

+ }

+ assert(false);

+ return "";

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class SWIFTEN_API IBBSerializer : public GenericPayloadSerializer<IBB> {

+ public:

+ IBBSerializer();

+ virtual std::string serializePayload(std::shared_ptr<IBB>) const;

+ };

+ * Copyright (c) 2015-2016 Isode Limited.

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

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class SWIFTEN_API IdleSerializer : public GenericPayloadSerializer<Idle> {

+ public:

+ IdleSerializer() : GenericPayloadSerializer<Idle>() {}

+ virtual std::string serializePayload(std::shared_ptr<Idle> idle) const {

+ return "<idle xmlns='urn:xmpp:idle:1' since='" + dateTimeToString(idle->getSince()) + "'/>";

+ }

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

+std::string InBandRegistrationPayloadSerializer::serializePayload(std::shared_ptr<InBandRegistrationPayload> registration) const {

+ XMLElement registerElement("query", "jabber:iq:register");

+ if (registration->isRegistered()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("registered")));

+ }

+ if (registration->isRemove()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("remove")));

+ }

+ if (registration->getInstructions()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("instructions", "", *registration->getInstructions())));

+ }

+ if (registration->getUsername()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("username", "", *registration->getUsername())));

+ }

+ if (registration->getNick()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("nick", "", *registration->getNick())));

+ }

+ if (registration->getPassword()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("password", "", *registration->getPassword())));

+ }

+ if (registration->getName()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("name", "", *registration->getName())));

+ }

+ if (registration->getFirst()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("first", "", *registration->getFirst())));

+ }

+ if (registration->getLast()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("last", "", *registration->getLast())));

+ }

+ if (registration->getEMail()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("email", "", *registration->getEMail())));

+ }

+ if (registration->getAddress()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("address", "", *registration->getAddress())));

+ }

+ if (registration->getCity()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("city", "", *registration->getCity())));

+ }

+ if (registration->getState()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("state", "", *registration->getState())));

+ }

+ if (registration->getZip()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("zip", "", *registration->getZip())));

+ }

+ if (registration->getPhone()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("phone", "", *registration->getPhone())));

+ }

+ if (registration->getURL()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("url", "", *registration->getURL())));

+ }

+ if (registration->getDate()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("date", "", *registration->getDate())));

+ }

+ if (registration->getMisc()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("misc", "", *registration->getMisc())));

+ }

+ if (registration->getText()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("text", "", *registration->getText())));

+ }

+ if (registration->getKey()) {

+ registerElement.addNode(XMLElement::ref(new XMLElement("key", "", *registration->getKey())));

+ }

+ if (Form::ref form = registration->getForm()) {

+ registerElement.addNode(std::make_shared<XMLRawTextNode>(FormSerializer().serialize(form)));

+ }

+ return registerElement.serialize();

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class SWIFTEN_API InBandRegistrationPayloadSerializer : public GenericPayloadSerializer<InBandRegistrationPayload> {

+ public:

+ InBandRegistrationPayloadSerializer();

+ virtual std::string serializePayload(std::shared_ptr<InBandRegistrationPayload>) const;

+ };

+ * Copyright (c) 2014-2016 Isode Limited.

+

+

+#include <memory>

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

+std::string IsodeIQDelegationSerializer::serializePayload(std::shared_ptr<IsodeIQDelegation> payload) const {

+ if (!payload) {

+ return "";

+ }

+ XMLElement element("delegate", "http://isode.com/iq_delegation");

+ element.addNode(std::make_shared<XMLRawTextNode>(serializers->getPayloadSerializer(payload->getForward())->serialize(payload->getForward())));

+ return element.serialize();

+ * Copyright (c) 2014-2016 Isode Limited.

+#include <memory>

+

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

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class PayloadSerializerCollection;

+

+ class SWIFTEN_API IsodeIQDelegationSerializer : public GenericPayloadSerializer<IsodeIQDelegation> {

+ public:

+ IsodeIQDelegationSerializer(PayloadSerializerCollection* serializers);

+ virtual ~IsodeIQDelegationSerializer();

+ virtual std::string serializePayload(std::shared_ptr<IsodeIQDelegation>) const SWIFTEN_OVERRIDE;

+ private:

+ private:

+ PayloadSerializerCollection* serializers;

+ };

+ * Copyright (c) 2014-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+#include <memory>

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

+#include <Swiften/Serializer/XML/XMLNode.h>

+#include <Swiften/Serializer/XML/XMLRawTextNode.h>

+std::string JingleContentPayloadSerializer::serializePayload(std::shared_ptr<JingleContentPayload> payload) const {

+ XMLElement payloadXML("content");

+ payloadXML.setAttribute("creator", creatorToString(payload->getCreator()));

+ payloadXML.setAttribute("name", payload->getName());

+

+ if (!payload->getDescriptions().empty()) {

+ // JingleFileTransferDescription

+ JingleFileTransferDescriptionSerializer ftSerializer;

+ JingleFileTransferDescription::ref filetransfer;

+

+ for (auto&& desc : payload->getDescriptions()) {

+ if ((filetransfer = std::dynamic_pointer_cast<JingleFileTransferDescription>(desc))) {

+ payloadXML.addNode(std::make_shared<XMLRawTextNode>(ftSerializer.serializePayload(filetransfer)));

+ }

+ }

+ }

+

+ if (!payload->getTransports().empty()) {

+ // JingleIBBTransportPayload

+ JingleIBBTransportPayloadSerializer ibbSerializer;

+ JingleIBBTransportPayload::ref ibb;

+

+ // JingleS5BTransportPayload

+ JingleS5BTransportPayloadSerializer s5bSerializer;

+ JingleS5BTransportPayload::ref s5b;

+ for (auto&& transport : payload->getTransports()) {

+ if ((ibb = std::dynamic_pointer_cast<JingleIBBTransportPayload>(transport))) {

+ payloadXML.addNode(std::make_shared<XMLRawTextNode>(ibbSerializer.serializePayload(ibb)));

+ } else if ((s5b = std::dynamic_pointer_cast<JingleS5BTransportPayload>(transport))) {

+ payloadXML.addNode(std::make_shared<XMLRawTextNode>(s5bSerializer.serializePayload(s5b)));

+ }

+ }

+ }

+ return payloadXML.serialize();

+ switch(creator) {

+ case JingleContentPayload::InitiatorCreator:

+ return "initiator";

+ case JingleContentPayload::ResponderCreator:

+ return "responder";

+ case JingleContentPayload::UnknownCreator:

+ SWIFT_LOG(error) << "Serializing unknown creator value.";

+ return "ERROR ERROR ERROR";

+ }

+ assert(false);

+ return "";

+ * Copyright (c) 2015-2016 Isode Limited.

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

+ class PayloadSerializerCollection;

+

+ class SWIFTEN_API JingleContentPayloadSerializer : public GenericPayloadSerializer<JingleContentPayload> {

+ public:

+ JingleContentPayloadSerializer();

+

+ virtual std::string serializePayload(std::shared_ptr<JingleContentPayload>) const;

+

+ private:

+ std::string creatorToString(JingleContentPayload::Creator creator) const;

+ };

+ * Copyright (c) 2015-2016 Isode Limited.

+#include <memory>

+