+ boost::shared_ptr<AuthChallenge> authChallenge(boost::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>");

+ class SWIFTEN_API AuthChallengeSerializer : public GenericElementSerializer<AuthChallenge> {

+ public:

+ AuthChallengeSerializer();

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

+ };

+ class SWIFTEN_API AuthFailureSerializer : public GenericElementSerializer<AuthFailure> {

+ public:

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

+ }

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

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

+ }

+ };

+ boost::shared_ptr<AuthRequest> authRequest(boost::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>"));

+ class SWIFTEN_API AuthRequestSerializer : public GenericElementSerializer<AuthRequest> {

+ public:

+ AuthRequestSerializer();

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

+ };

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

+ boost::shared_ptr<AuthResponse> authResponse(boost::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>"));

+ class SWIFTEN_API AuthResponseSerializer : public GenericElementSerializer<AuthResponse> {

+ public:

+ AuthResponseSerializer();

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

+ };

+ boost::shared_ptr<AuthSuccess> authSuccess(boost::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>");

+ class SWIFTEN_API AuthSuccessSerializer : public GenericElementSerializer<AuthSuccess> {

+ public:

+ AuthSuccessSerializer();

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

+ };

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

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

+ class SWIFTEN_API ComponentHandshakeSerializer : public GenericElementSerializer<ComponentHandshake> {

+ public:

+ ComponentHandshakeSerializer();

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

+ };

+ class SWIFTEN_API CompressFailureSerializer : public GenericElementSerializer<CompressFailure> {

+ public:

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

+ }

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

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

+ }

+ };

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

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

+ return boost::dynamic_pointer_cast<CompressRequest>(element) != 0;

+ class SWIFTEN_API CompressRequestSerializer : public ElementSerializer {

+ public:

+ CompressRequestSerializer();

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

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

+ };

+ class ElementSerializer {

+ public:

+ virtual ~ElementSerializer();

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

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

+ };

+ class SWIFTEN_API EnableStreamManagementSerializer : public GenericElementSerializer<EnableStreamManagement> {

+ public:

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

+ }

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

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

+ }

+ };

+ template<typename T>

+ class SWIFTEN_API GenericElementSerializer : public ElementSerializer {

+ public:

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

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

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

+ }

+ };

+ template<typename PAYLOAD_TYPE>

+ class GenericPayloadSerializer : public PayloadSerializer {

+ public:

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

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

+ }

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

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

+ }

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

+ };

+ 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(boost::shared_ptr<ToplevelElement> element) const {

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

+ }

+ virtual void setStanzaSpecificAttributes(

+ boost::shared_ptr<ToplevelElement> stanza,

+ XMLElement& element) const {

+ setStanzaSpecificAttributesGeneric(

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

+ }

+ virtual void setStanzaSpecificAttributesGeneric(

+ boost::shared_ptr<STANZA_TYPE>,

+ XMLElement&) const = 0;

+ };

+ 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(

+ boost::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;

+ }

+ }

+ };

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

+ boost::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");

+ }

+ 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(

+ boost::shared_ptr<Message> message,

+ XMLElement& element) const;

+ };

+ class Payload;

+ class SWIFTEN_API PayloadSerializer {

+ public:

+ virtual ~PayloadSerializer();

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

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

+ };

+ serializers_.push_back(serializer);

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

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

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

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

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

+ class PayloadSerializer;

+ class SWIFTEN_API PayloadSerializerCollection {

+ public:

+ PayloadSerializerCollection();

+ void addSerializer(PayloadSerializer* factory);

+ void removeSerializer(PayloadSerializer* factory);

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

+

+ private:

+ std::vector<PayloadSerializer*> serializers_;

+ };

+ 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(boost::shared_ptr<BLOCK_ELEMENT> payload) const {

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

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

+ for (std::vector<JID>::const_iterator i = items.begin(); i != items.end(); ++i) {

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

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

+ element.addNode(item);

+ }

+ return element.serialize();

+ }

+ private:

+ std::string tag;

+ };

+ class SWIFTEN_API BodySerializer : public GenericPayloadSerializer<Body> {

+ public:

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

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

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

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

+ }

+ };

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

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

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

+ foreach(const Bytestreams::StreamHost& streamHost, bytestreams->getStreamHosts()) {

+ boost::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()) {

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

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

+ queryElement.addNode(streamHostElement);

+ }

+ return queryElement.serialize();

+ class PayloadSerializerCollection;

+ class SWIFTEN_API BytestreamsSerializer : public GenericPayloadSerializer<Bytestreams> {

+ public:

+ BytestreamsSerializer();

+ virtual std::string serializePayload(boost::shared_ptr<Bytestreams>) 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();

+ class SWIFTEN_API CapsInfoSerializer : public GenericPayloadSerializer<CapsInfo> {

+ public:

+ CapsInfoSerializer();

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

+ };

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

+ }

+ CarbonsDisableSerializer::~CarbonsDisableSerializer() {

+ }

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

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

+ return element.serialize();

+ }

+ class SWIFTEN_API CarbonsDisableSerializer : public GenericPayloadSerializer<CarbonsDisable> {

+ public:

+ CarbonsDisableSerializer();

+ virtual ~CarbonsDisableSerializer();

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

+ };

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

+ }

+ CarbonsEnableSerializer::~CarbonsEnableSerializer() {

+ }

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

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

+ return element.serialize();

+ }

+ class SWIFTEN_API CarbonsEnableSerializer : public GenericPayloadSerializer<CarbonsEnable> {

+ public:

+ CarbonsEnableSerializer();

+ virtual ~CarbonsEnableSerializer();

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

+ };

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

+ }

+ CarbonsPrivateSerializer::~CarbonsPrivateSerializer() {

+ }

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

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

+ return element.serialize();

+ }

+ class SWIFTEN_API CarbonsPrivateSerializer : public GenericPayloadSerializer<CarbonsPrivate> {

+ public:

+ CarbonsPrivateSerializer();

+ virtual ~CarbonsPrivateSerializer();

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

+ };

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

+ }

+ CarbonsReceivedSerializer::~CarbonsReceivedSerializer() {

+ }

+

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

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

+ if (received->getForwarded()) {

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

+ }

+ return element.serialize();

+ }

+ class SWIFTEN_API CarbonsReceivedSerializer : public GenericPayloadSerializer<CarbonsReceived> {

+ public:

+ CarbonsReceivedSerializer(PayloadSerializerCollection* serializers);

+ virtual ~CarbonsReceivedSerializer();

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

+ private:

+ PayloadSerializerCollection* serializers_;

+ };

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

+ }

+ CarbonsSentSerializer::~CarbonsSentSerializer() {

+ }

+

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

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

+ if (sent->getForwarded()) {

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

+ }

+ return element.serialize();

+ }

+ class SWIFTEN_API CarbonsSentSerializer : public GenericPayloadSerializer<CarbonsSent> {

+ public:

+ CarbonsSentSerializer(PayloadSerializerCollection* serializers);

+ virtual ~CarbonsSentSerializer();

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

+ private:

+ PayloadSerializerCollection* serializers_;

+ };

+ 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;

+ class SWIFTEN_API ChatStateSerializer : public GenericPayloadSerializer<ChatState> {

+ public:

+ ChatStateSerializer();

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

+ };

+std::string CommandSerializer::serializePayload(boost::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 += ">";

+ foreach (Command::Action action, command->getAvailableActions()) {

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

+ }

+ actions += "</actions>";

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

+ }

+ foreach (Command::Note note, command->getNotes()) {

+ boost::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(boost::make_shared<XMLTextNode>(note.note));

+ commandElement.addNode(noteElement);

+ }

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

+ if (form) {

+ commandElement.addNode(boost::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;

+ class SWIFTEN_API CommandSerializer : public GenericPayloadSerializer<Command> {

+ public:

+ CommandSerializer();

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

+ private:

+ std::string actionToString(Command::Action action) 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();

+ class SWIFTEN_API DelaySerializer : public GenericPayloadSerializer<Delay> {

+ public:

+ DelaySerializer();

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

+ };

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

+ return requestXML.serialize();

+ class SWIFTEN_API DeliveryReceiptRequestSerializer : public GenericPayloadSerializer<DeliveryReceiptRequest> {

+ public:

+ DeliveryReceiptRequestSerializer();

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

+ };

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

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

+ return received.serialize();

+ class SWIFTEN_API DeliveryReceiptSerializer : public GenericPayloadSerializer<DeliveryReceipt> {

+ public:

+ DeliveryReceiptSerializer();

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

+ };

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

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

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

+ }

+ foreach(const DiscoInfo::Identity& identity, discoInfo->getIdentities()) {

+ boost::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);

+ }

+ foreach(const std::string& feature, discoInfo->getFeatures()) {

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

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

+ queryElement.addNode(featureElement);

+ }

+ foreach(const Form::ref extension, discoInfo->getExtensions()) {

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

+ }

+ return queryElement.serialize();

+ class SWIFTEN_API DiscoInfoSerializer : public GenericPayloadSerializer<DiscoInfo> {

+ public:

+ DiscoInfoSerializer();

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

+ };

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

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

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

+ }

+ foreach(const DiscoItems::Item& item, discoItems->getItems()) {

+ boost::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();

+ class SWIFTEN_API DiscoItemsSerializer : public GenericPayloadSerializer<DiscoItems> {

+ public:

+ DiscoItemsSerializer();

+ virtual std::string serializePayload(boost::shared_ptr<DiscoItems>) 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;

+ class PayloadSerializerCollection;

+ class SWIFTEN_API ErrorSerializer : public GenericPayloadSerializer<ErrorPayload> {

+ public:

+ ErrorSerializer(PayloadSerializerCollection* serializers);

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

+ private:

+ PayloadSerializerCollection* serializers;

+ };

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

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

+ if (!value.empty()) {

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

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

+ parent->addNode(valueElement);

+ }

+ }

+ if (!form) {

+ return "";

+ }

+

+ boost::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);

+ }

+ foreach(boost::shared_ptr<FormPage> page, form->getPages()) {

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

+ }

+ foreach(boost::shared_ptr<FormField> field, form->getFields()) {

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

+ }

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

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

+ foreach(FormField::ref field, form->getReportedFields()) {

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

+ }

+ formElement->addNode(reportedElement);

+ }

+

+ foreach(Form::FormItem item, form->getItems()) {

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

+ foreach(FormField::ref field, item) {

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

+ }

+ formElement->addNode(itemElement);

+ }

+

+ foreach(const FormText::text text, form->getTextElements()) {

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

+ }

+

+ foreach (boost::shared_ptr<FormField> field, fields_) {

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

+ }

+

+ return formElement->serialize();

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

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

+ return textElement;

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

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

+ return fieldRefElement;

+ boost::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());

+ }

+ foreach(const FormText::text text, page->getTextElements()) {

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

+ }

+ foreach (const boost::shared_ptr<FormField> field, page->getFields()) {

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

+ fields_.push_back(field);

+ }

+ foreach(const FormReportedRef::ref reportedRef, page->getReportedRefs()) {

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

+ }

+ foreach(const FormSection::section section, page->getChildSections()) {

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

+ }

+ return pageElement;

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

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

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

+ }

+ foreach(const FormText::text text, section->getTextElements()) {

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

+ }

+ foreach(const boost::shared_ptr<FormField> field, section->getFields()) {

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

+ fields_.push_back(field);

+ }

+ foreach(const FormReportedRef::ref reportedRef, section->getReportedRefs()) {

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

+ }

+ foreach(const FormSection::section childSection, section->getChildSections()) {

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

+ }

+ return sectionElement;

+ boost::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(boost::make_shared<XMLElement>("required"));

+ }

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

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

+ descriptionElement->addNode(boost::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);

+ }

+ foreach (const std::string& value, field->getValues()) {

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

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

+ fieldElement->addNode(valueElement);

+ }

+

+ foreach (const FormField::Option& option, field->getOptions()) {

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

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

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

+ }

+

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

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

+ optionElement->addNode(valueElement);

+ fieldElement->addNode(optionElement);

+ }

+ return fieldElement;

+ std::string unRdText(text);

+ erase(unRdText, '\r');

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

+ foreach (std::string line, lines) {

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

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

+ element->addNode(lineElement);

+ }

+ class SWIFTEN_API FormSerializer : public GenericPayloadSerializer<Form> {

+ public:

+ FormSerializer();

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

+ private:

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

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

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

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

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

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

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

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

+ };

+ if (!payload) {

+ return "";

+ }

+

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

+

+ if (payload->getDelay()) {

+ element.addNode(boost::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*/

+ boost::shared_ptr<IQ> iq;

+ boost::shared_ptr<Message> message;

+ boost::shared_ptr<Presence> presence;

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

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

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

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

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

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

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

+ }

+ }

+

+ return element.serialize();

+ class PayloadSerializerCollection;

+ class SWIFTEN_API ForwardedSerializer : public GenericPayloadSerializer<Forwarded> {

+ public:

+ ForwardedSerializer(PayloadSerializerCollection* serializers);

+ virtual ~ForwardedSerializer();

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

+ private:

+ PayloadSerializerCollection* serializers_;

+ };

+ 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));

+

+ foreach(PayloadSerializer* serializer, serializers_) {

+ addSerializer(serializer);

+ }

+ foreach(PayloadSerializer* serializer, serializers_) {

+ removeSerializer(serializer);

+ delete serializer;

+ }

+ serializers_.clear();

+ class SWIFTEN_API FullPayloadSerializerCollection : public PayloadSerializerCollection {

+ public:

+ FullPayloadSerializerCollection();

+ virtual ~FullPayloadSerializerCollection();

+ private:

+ std::vector<PayloadSerializer*> serializers_;

+ };

+ 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(boost::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 "";

+ class SWIFTEN_API IBBSerializer : public GenericPayloadSerializer<IBB> {

+ public:

+ IBBSerializer();

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

+ };

+ class SWIFTEN_API IdleSerializer : public GenericPayloadSerializer<Idle> {

+ public:

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

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

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

+ }

+ };

+std::string InBandRegistrationPayloadSerializer::serializePayload(boost::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(boost::make_shared<XMLRawTextNode>(FormSerializer().serialize(form)));

+ }

+ return registerElement.serialize();

+ class SWIFTEN_API InBandRegistrationPayloadSerializer : public GenericPayloadSerializer<InBandRegistrationPayload> {

+ public:

+ InBandRegistrationPayloadSerializer();

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

+ };

+ if (!payload) {

+ return "";

+ }

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

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

+ return element.serialize();

+ class PayloadSerializerCollection;

+ class SWIFTEN_API IsodeIQDelegationSerializer : public GenericPayloadSerializer<IsodeIQDelegation> {

+ public:

+ IsodeIQDelegationSerializer(PayloadSerializerCollection* serializers);

+ virtual ~IsodeIQDelegationSerializer();

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

+ private:

+

+ private:

+ PayloadSerializerCollection* serializers;

+ };

+ XMLElement payloadXML("content");

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

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

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

+ // JingleFileTransferDescription

+ JingleFileTransferDescriptionSerializer ftSerializer;

+ JingleFileTransferDescription::ref filetransfer;

+

+ foreach(JingleDescription::ref desc, payload->getDescriptions()) {

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

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

+ }

+ }

+ }

+

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

+ // JingleIBBTransportPayload

+ JingleIBBTransportPayloadSerializer ibbSerializer;

+ JingleIBBTransportPayload::ref ibb;

+

+ // JingleS5BTransportPayload

+ JingleS5BTransportPayloadSerializer s5bSerializer;

+ JingleS5BTransportPayload::ref s5b;

+

+ foreach(JingleTransportPayload::ref transport, payload->getTransports()) {

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

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

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

+ payloadXML.addNode(boost::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 "";

+ class PayloadSerializerCollection;

+

+ class SWIFTEN_API JingleContentPayloadSerializer : public GenericPayloadSerializer<JingleContentPayload> {

+ public:

+ JingleContentPayloadSerializer();

+

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

+

+ private:

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

+ };

+ XMLElement description("description", "urn:xmpp:jingle:apps:file-transfer:4");

+ JingleFileTransferFileInfoSerializer fileInfoSerializer;

+ boost::shared_ptr<XMLRawTextNode> fileInfoXML = boost::make_shared<XMLRawTextNode>(fileInfoSerializer.serialize(boost::make_shared<JingleFileTransferFileInfo>(payload->getFileInfo())));

+ description.addNode(fileInfoXML);

+ return description.serialize();

+ class PayloadSerializerCollection;

+ class XMLElement;

+

+ class SWIFTEN_API JingleFileTransferDescriptionSerializer : public GenericPayloadSerializer<JingleFileTransferDescription> {

+ public:

+ JingleFileTransferDescriptionSerializer();

+

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

+ };

+ XMLElement fileElement("file", "");

+

+ if (fileInfo->getDate() != stringToDateTime("")) {

+ fileElement.addNode(boost::make_shared<XMLElement>("date", "", dateTimeToString(fileInfo->getDate())));

+ }

+

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

+ fileElement.addNode(boost::make_shared<XMLElement>("desc", "", fileInfo->getDescription()));

+ }

+

+ if (!fileInfo->getMediaType().empty()) {

+ fileElement.addNode(boost::make_shared<XMLElement>("media-type", "", fileInfo->getMediaType()));

+ }

+

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

+ fileElement.addNode(boost::make_shared<XMLElement>("name", "", fileInfo->getName()));

+ }

+

+ if (fileInfo->getSupportsRangeRequests()) {

+ boost::shared_ptr<XMLElement> range = boost::make_shared<XMLElement>("range");

+ if (fileInfo->getRangeOffset() != 0) {

+ range->setAttribute("offset", boost::lexical_cast<std::string>(fileInfo->getRangeOffset()));

+ }

+ fileElement.addNode(range);

+ }

+

+ if (fileInfo->getSize() > 0) {

+ fileElement.addNode(boost::make_shared<XMLElement>("size", "", boost::lexical_cast<std::string>(fileInfo->getSize())));

+ }

+

+ foreach (JingleFileTransferFileInfo::HashElementMap::value_type hashElement, fileInfo->getHashes()) {

+ boost::shared_ptr<XMLElement> hash = boost::make_shared<XMLElement>("hash", "urn:xmpp:hashes:1", Base64::encode(hashElement.second));

+ hash->setAttribute("algo", hashElement.first);

+ fileElement.addNode(hash);

+ }

+

+ return fileElement.serialize();

+ class PayloadSerializerCollection;

+ class SWIFTEN_API JingleFileTransferFileInfoSerializer : public GenericPayloadSerializer<JingleFileTransferFileInfo> {

+ public:

+ JingleFileTransferFileInfoSerializer();

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

+ };

+ // code for version urn:xmpp:jingle:apps:file-transfer:2

+ //XMLElement hash("hash", "urn:xmpp:jingle:apps:file-transfer:info:2", payload->getHash());

+ // code for version urn:xmpp:jingle:apps:file-transfer:4

+ XMLElement checksum("checksum", "urn:xmpp:jingle:apps:file-transfer:4");

+ JingleFileTransferFileInfoSerializer fileSerializer;

+ boost::shared_ptr<XMLRawTextNode> file = boost::make_shared<XMLRawTextNode>(fileSerializer.serialize(boost::make_shared<JingleFileTransferFileInfo>(payload->getFileInfo())));

+ checksum.addNode(file);

+ return checksum.serialize();

+ class PayloadSerializerCollection;

+ class XMLElement;

+

+ class SWIFTEN_API JingleFileTransferHashSerializer : public GenericPayloadSerializer<JingleFileTransferHash> {

+ public:

+ JingleFileTransferHashSerializer();

+

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

+ };

+ XMLElement payloadXML("transport", "urn:xmpp:jingle:transports:ibb:1");

+ if (payload->getBlockSize()) {

+ payloadXML.setAttribute("block-size", boost::lexical_cast<std::string>(*payload->getBlockSize()));

+ }

+ payloadXML.setAttribute("sid", payload->getSessionID());

+ return payloadXML.serialize();

+ class PayloadSerializerCollection;

+ class XMLElement;

+

+ class SWIFTEN_API JingleIBBTransportPayloadSerializer : public GenericPayloadSerializer<JingleIBBTransportPayload> {

+ public:

+ JingleIBBTransportPayloadSerializer();

+

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

+ };

+ XMLElement jinglePayload("jingle", "urn:xmpp:jingle:1");

+ jinglePayload.setAttribute("action", actionToString(payload->getAction()));

+ jinglePayload.setAttribute("initiator", payload->getInitiator());

+ jinglePayload.setAttribute("sid", payload->getSessionID());

+ std::vector<boost::shared_ptr<Payload> > payloads = payload->getPayloads();

+ if (!payloads.empty()) {

+ foreach(boost::shared_ptr<Payload> subPayload, payloads) {

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

+ if (serializer) {

+ jinglePayload.addNode(boost::make_shared<XMLRawTextNode>(serializer->serialize(subPayload)));

+ }

+ }

+ }

+

+ if (payload->getReason().is_initialized()) {

+ boost::shared_ptr<XMLElement> reason = boost::make_shared<XMLElement>("reason");

+ reason->addNode(boost::make_shared<XMLElement>(reasonTypeToString(payload->getReason()->type)));

+ if (!payload->getReason()->text.empty()) {

+ reason->addNode(boost::make_shared<XMLElement>("desc", "", payload->getReason()->text));

+ }

+ jinglePayload.addNode(reason);

+ }

+

+ return jinglePayload.serialize();

+ switch(action) {

+ case JinglePayload::ContentAccept:

+ return "content-accept";

+ case JinglePayload::ContentAdd:

+ return "content-add";

+ case JinglePayload::ContentModify:

+ return "content-modify";

+ case JinglePayload::ContentReject:

+ return "content-reject";

+ case JinglePayload::ContentRemove:

+ return "content-remove";

+ case JinglePayload::DescriptionInfo:

+ return "description-info";

+ case JinglePayload::SecurityInfo:

+ return "security-info";

+ case JinglePayload::SessionAccept:

+ return "session-accept";

+ case JinglePayload::SessionInfo:

+ return "session-info";

+ case JinglePayload::SessionInitiate:

+ return "session-initiate";

+ case JinglePayload::SessionTerminate:

+ return "session-terminate";

+ case JinglePayload::TransportAccept:

+ return "transport-accept";

+ case JinglePayload::TransportInfo:

+ return "transport-info";

+ case JinglePayload::TransportReject:

+ return "transport-reject";

+ case JinglePayload::TransportReplace:

+ return "transport-replace";

+ case JinglePayload::UnknownAction:

+ SWIFT_LOG(warning) << "Serializing unknown action value." << std::endl;

+ return "";

+ }

+ assert(false);

+ return "";

+ switch(type) {

+ case JinglePayload::Reason::UnknownType:

+ SWIFT_LOG(warning) << "Unknown jingle reason type!" << std::endl;

+ return "";

+ case JinglePayload::Reason::AlternativeSession:

+ return "alternative-session";

+ case JinglePayload::Reason::Busy:

+ return "busy";

+ case JinglePayload::Reason::Cancel:

+ return "cancel";

+ case JinglePayload::Reason::ConnectivityError:

+ return "connectivity-error";

+ case JinglePayload::Reason::Decline:

+ return "decline";

+ case JinglePayload::Reason::Expired:

+ return "expired";

+ case JinglePayload::Reason::FailedApplication:

+ return "failed-application";

+ case JinglePayload::Reason::FailedTransport:

+ return "failed-transport";

+ case JinglePayload::Reason::GeneralError:

+ return "general-error";

+ case JinglePayload::Reason::Gone:

+ return "gone";

+ case JinglePayload::Reason::IncompatibleParameters:

+ return "incompatible-parameters";

+ case JinglePayload::Reason::MediaError:

+ return "media-error";

+ case JinglePayload::Reason::SecurityError:

+ return "security-error";

+ case JinglePayload::Reason::Success:

+ return "success";

+ case JinglePayload::Reason::Timeout:

+ return "timeout";

+ case JinglePayload::Reason::UnsupportedApplications:

+ return "unsupported-applications";

+ case JinglePayload::Reason::UnsupportedTransports:

+ return "unsupported-transports";

+ }

+ assert(false);

+ return "";

+ class PayloadSerializerCollection;

+ class XMLElement;

+

+ class SWIFTEN_API JinglePayloadSerializer : public GenericPayloadSerializer<JinglePayload> {

+ public:

+ JinglePayloadSerializer(PayloadSerializerCollection*);

+

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

+

+ private:

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

+ std::string reasonTypeToString(JinglePayload::Reason::Type type) const;

+

+ private:

+ PayloadSerializerCollection* serializers;

+ };

+ XMLElement payloadXML("transport", "urn:xmpp:jingle:transports:s5b:1");

+ payloadXML.setAttribute("sid", payload->getSessionID());

+ payloadXML.setAttribute("mode", modeToString(payload->getMode()));

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

+ payloadXML.setAttribute("dstaddr", payload->getDstAddr());

+ }

+

+ foreach(JingleS5BTransportPayload::Candidate candidate, payload->getCandidates()) {

+ boost::shared_ptr<XMLElement> candidateXML = boost::make_shared<XMLElement>("candidate");

+ candidateXML->setAttribute("cid", candidate.cid);

+ candidateXML->setAttribute("host", candidate.hostPort.getAddress().toString());

+ candidateXML->setAttribute("jid", candidate.jid.toString());

+ candidateXML->setAttribute("port", boost::lexical_cast<std::string>(candidate.hostPort.getPort()));

+ candidateXML->setAttribute("priority", boost::lexical_cast<std::string>(candidate.priority));

+ candidateXML->setAttribute("type", typeToString(candidate.type));

+ payloadXML.addNode(candidateXML);

+ }

+

+ if (payload->hasCandidateError()) {

+ payloadXML.addNode(boost::make_shared<XMLElement>("candidate-error"));

+ }

+ if (payload->hasProxyError()) {

+ payloadXML.addNode(boost::make_shared<XMLElement>("proxy-error"));

+ }

+

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

+ boost::shared_ptr<XMLElement> activatedXML = boost::make_shared<XMLElement>("activated");

+ activatedXML->setAttribute("cid", payload->getActivated());

+ payloadXML.addNode(activatedXML);

+ }

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

+ boost::shared_ptr<XMLElement> candusedXML = boost::make_shared<XMLElement>("candidate-used");

+ candusedXML->setAttribute("cid", payload->getCandidateUsed());

+ payloadXML.addNode(candusedXML);

+ }

+

+ return payloadXML.serialize();

+ switch(mode) {

+ case JingleS5BTransportPayload::TCPMode:

+ return "tcp";

+ case JingleS5BTransportPayload::UDPMode:

+ return "udp";

+ }

+ assert(false);

+ return "";

+ switch(type) {

+ case JingleS5BTransportPayload::Candidate::AssistedType:

+ return "assisted";

+ case JingleS5BTransportPayload::Candidate::DirectType:

+ return "direct";

+ case JingleS5BTransportPayload::Candidate::ProxyType:

+ return "proxy";

+ case JingleS5BTransportPayload::Candidate::TunnelType:

+ return "tunnel";

+ }

+ assert(false);

+ return "";

+ class PayloadSerializerCollection;

+ class XMLElement;

+

+ class SWIFTEN_API JingleS5BTransportPayloadSerializer : public GenericPayloadSerializer<JingleS5BTransportPayload> {

+ public:

+ JingleS5BTransportPayloadSerializer();

+

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

+

+ private:

+ std::string modeToString(JingleS5BTransportPayload::Mode) const;

+ std::string typeToString(JingleS5BTransportPayload::Candidate::Type) const;

+ };

+ class SWIFTEN_API LastSerializer : public GenericPayloadSerializer<Last> {

+ public:

+ LastSerializer() : GenericPayloadSerializer<Last>() {}

+ virtual std::string serializePayload(boost::shared_ptr<Last> last) const {

+ return "<query xmlns='jabber:iq:last' seconds='" + boost::lexical_cast<std::string>(last->getSeconds()) + "'/>";

+ }

+ };

+ if (!payload) {

+ return "";

+ }

+ XMLElement element("fin", "urn:xmpp:mam:0");

+ if (payload->isComplete()) {

+ element.setAttribute("complete", "true");

+ }

+ if (!payload->isStable()) {

+ element.setAttribute("stable", "false");

+ }

+ if (payload->getQueryID()) {

+ element.setAttribute("queryid", *payload->getQueryID());

+ }

+ if (payload->getResultSet()) {

+ element.addNode(boost::make_shared<XMLRawTextNode>(ResultSetSerializer().serialize(payload->getResultSet())));

+ }

+ return element.serialize();

+ class PayloadSerializerCollection;

+ class SWIFTEN_API MAMFinSerializer : public GenericPayloadSerializer<MAMFin> {

+ public:

+ MAMFinSerializer();

+ virtual ~MAMFinSerializer();

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

+ };

+ if (!payload) {

+ return "";

+ }

+ XMLElement element("query", "urn:xmpp:mam:0");

+ if (payload->getQueryID()) {

+ element.setAttribute("queryid", *payload->getQueryID());

+ }

+ if (payload->getNode()) {

+ element.setAttribute("node", *payload->getNode());

+ }

+ if (payload->getForm()) {

+ element.addNode(boost::make_shared<XMLRawTextNode>(FormSerializer().serialize(payload->getForm())));

+ }

+ if (payload->getResultSet()) {

+ element.addNode(boost::make_shared<XMLRawTextNode>(ResultSetSerializer().serialize(payload->getResultSet())));

+ }

+ return element.serialize();

+ class PayloadSerializerCollection;

+ class SWIFTEN_API MAMQuerySerializer : public GenericPayloadSerializer<MAMQuery> {

+ public:

+ MAMQuerySerializer();

+ virtual ~MAMQuerySerializer();

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

+ };

+ if (!payload) {

+ return "";

+ }

+ XMLElement element("result", "urn:xmpp:mam:0");

+ element.setAttribute("id", payload->getID());

+ if (payload->getQueryID()) {

+ element.setAttribute("queryid", *payload->getQueryID());

+ }

+ element.addNode(boost::make_shared<XMLRawTextNode>(ForwardedSerializer(serializers_).serialize(payload->getPayload())));

+ return element.serialize();

+ class PayloadSerializerCollection;

+ class SWIFTEN_API MAMResultSerializer : public GenericPayloadSerializer<MAMResult> {

+ public:

+ MAMResultSerializer(PayloadSerializerCollection* serializers);

+ virtual ~MAMResultSerializer();

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

+ private:

+ PayloadSerializerCollection* serializers_;

+ };

+ XMLElement mucElement("query", "http://jabber.org/protocol/muc#admin");

+ foreach (const MUCItem& item, payload->getItems()) {

+ mucElement.addNode(MUCItemSerializer::itemToElement(item));

+ }

+ return mucElement.serialize();

+ class SWIFTEN_API MUCAdminPayloadSerializer : public GenericPayloadSerializer<MUCAdminPayload> {

+ public:

+ MUCAdminPayloadSerializer();

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

+ std::string roleToString(MUCOccupant::Role role) const;

+ virtual std::string serializePayload(boost::shared_ptr<MUCAdminPayload> version) const;

+ };

+ XMLElement mucElement("destroy", "");

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

+ XMLElement::ref reason = boost::make_shared<XMLElement>("reason", "");

+ reason->addNode(boost::make_shared<XMLTextNode>(payload->getReason()));

+ mucElement.addNode(reason);

+ }

+ if (payload->getNewVenue().isValid()) {

+ mucElement.setAttribute("jid", payload->getNewVenue().toString());

+ }

+ return mucElement.serialize();

+ class PayloadSerializerCollection;

+ class SWIFTEN_API MUCDestroyPayloadSerializer : public GenericPayloadSerializer<MUCDestroyPayload> {

+ public:

+ MUCDestroyPayloadSerializer();

+ virtual std::string serializePayload(boost::shared_ptr<MUCDestroyPayload> version) const;

+ };

+ XMLElement mucElement("x", "jabber:x:conference");

+ if (payload->getIsContinuation()) {

+ mucElement.setAttribute("continue", "true");

+ }

+ if (payload->getJID().isValid()) {

+ mucElement.setAttribute("jid", payload->getJID().toString());

+ }

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

+ mucElement.setAttribute("password", payload->getPassword());

+ }

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

+ mucElement.setAttribute("reason", payload->getReason());

+ }

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

+ mucElement.setAttribute("thread", payload->getThread());

+ }

+ if (payload->getIsImpromptu()) {

+ mucElement.addNode(boost::make_shared<XMLElement>("impromptu", "http://swift.im/impromptu"));

+ }

+ return mucElement.serialize();