AuthChallengeSerializer::AuthChallengeSerializer() {

}

boost::shared_ptr<AuthChallenge> authChallenge(boost::dynamic_pointer_cast<AuthChallenge>(element));

std::string value;

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

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

}

}

}

}

public:

AuthChallengeSerializer();

};

}

AuthFailureSerializer() : GenericElementSerializer<AuthFailure>() {

}

}

};

}

#include <Swiften/Elements/AuthRequest.h>

#include <Swiften/StringCodecs/Base64.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Base/Concat.h>

namespace Swift {

AuthRequestSerializer::AuthRequestSerializer() {

}

boost::shared_ptr<AuthRequest> authRequest(boost::dynamic_pointer_cast<AuthRequest>(element));

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

if (message) {

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

}

else {

value = Base64::encode(*message);

}

}

}

}

public:

AuthRequestSerializer();

};

}

#include <Swiften/Elements/AuthResponse.h>

#include <Swiften/StringCodecs/Base64.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Base/Concat.h>

namespace Swift {

AuthResponseSerializer::AuthResponseSerializer() {

}

boost::shared_ptr<AuthResponse> authResponse(boost::dynamic_pointer_cast<AuthResponse>(element));

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

if (message) {

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

}

else {

value = Base64::encode(*message);

}

}

}

}

public:

AuthResponseSerializer();

};

}

AuthSuccessSerializer::AuthSuccessSerializer() {

}

boost::shared_ptr<AuthSuccess> authSuccess(boost::dynamic_pointer_cast<AuthSuccess>(element));

std::string value;

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

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

}

}

}

}

public:

AuthSuccessSerializer();

};

}

ComponentHandshakeSerializer::ComponentHandshakeSerializer() {

}

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

}

}

public:

ComponentHandshakeSerializer();

};

}

CompressFailureSerializer() : GenericElementSerializer<CompressFailure>() {

}

}

};

}

CompressRequestSerializer::CompressRequestSerializer() {

}

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

}

bool CompressRequestSerializer::canSerialize(boost::shared_ptr<Element> element) const {

public:

CompressRequestSerializer();

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

};

}

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/Element.h>

namespace Swift {

class ElementSerializer {

public:

virtual ~ElementSerializer();

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

};

}

EnableStreamManagementSerializer() : GenericElementSerializer<EnableStreamManagement>() {

}

}

};

}

template<typename T>

class GenericElementSerializer : public ElementSerializer {

public:

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

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

StanzaAckRequestSerializer() : GenericElementSerializer<StanzaAckRequest>() {

}

}

};

}

StanzaAckSerializer() : GenericElementSerializer<StanzaAck>() {

}

StanzaAck::ref stanzaAck(boost::dynamic_pointer_cast<StanzaAck>(element));

assert(stanzaAck->isValid());

XMLElement result("a", "urn:xmpp:sm:2");

result.setAttribute("h", std::string(boost::lexical_cast<std::string>(stanzaAck->getHandledStanzasCount())));

}

};

}

StanzaSerializer::StanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers) : tag_(tag), payloadSerializers_(payloadSerializers) {

}

boost::shared_ptr<Stanza> stanza(boost::dynamic_pointer_cast<Stanza>(element));

XMLElement stanzaElement(tag_);

stanzaElement.addNode(boost::shared_ptr<XMLNode>(new XMLRawTextNode(serializedPayloads)));

}

}

}

public:

StanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers);

virtual void setStanzaSpecificAttributes(boost::shared_ptr<Element>, XMLElement&) const = 0;

private:

StartTLSFailureSerializer() : GenericElementSerializer<StartTLSFailure>() {

}

}

};

}

StartTLSRequestSerializer() : GenericElementSerializer<StartTLSRequest>() {

}

}

};

}

StreamErrorSerializer::StreamErrorSerializer() : GenericElementSerializer<StreamError>() {

}

StreamError::ref error = boost::dynamic_pointer_cast<StreamError>(element);

XMLElement errorElement("error", "http://etherx.jabber.org/streams");

errorElement.addNode(boost::make_shared<XMLElement>("text", "urn:ietf:params:xml:ns:xmpp-streams", error->getText()));

}

}

}

public:

StreamErrorSerializer();

};

}

StreamFeaturesSerializer::StreamFeaturesSerializer() {

}

boost::shared_ptr<StreamFeatures> streamFeatures(boost::dynamic_pointer_cast<StreamFeatures>(element));

XMLElement streamFeaturesElement("stream:features");

if (streamFeatures->hasRosterVersioning()) {

streamFeaturesElement.addNode(boost::make_shared<XMLElement>("ver", "urn:xmpp:features:rosterver"));

}

}

}

public:

StreamFeaturesSerializer();

};

}

StreamManagementEnabledSerializer::StreamManagementEnabledSerializer() : GenericElementSerializer<StreamManagementEnabled>() {

}

boost::shared_ptr<StreamManagementEnabled> e(boost::dynamic_pointer_cast<StreamManagementEnabled>(el));

XMLElement element("enabled", "urn:xmpp:sm:2");

if (!e->getResumeID().empty()) {

if (e->getResumeSupported()) {

element.setAttribute("resume", "true");

}

}

public:

StreamManagementEnabledSerializer();

};

}

StreamManagementFailedSerializer() : GenericElementSerializer<StreamManagementFailed>() {

}

}

};

}

StreamResumeSerializer::StreamResumeSerializer() : GenericElementSerializer<StreamResume>() {

}

boost::shared_ptr<StreamResume> e(boost::dynamic_pointer_cast<StreamResume>(el));

XMLElement element("resume", "urn:xmpp:sm:2");

element.setAttribute("previd", e->getResumeID());

if (e->getHandledStanzasCount()) {

element.setAttribute("h", boost::lexical_cast<std::string>(e->getHandledStanzasCount()));

}

}

public:

StreamResumeSerializer();

};

}

StreamResumedSerializer::StreamResumedSerializer() : GenericElementSerializer<StreamResumed>() {

}

boost::shared_ptr<StreamResumed> e(boost::dynamic_pointer_cast<StreamResumed>(el));

XMLElement element("resumed", "urn:xmpp:sm:2");

element.setAttribute("previd", e->getResumeID());

if (e->getHandledStanzasCount()) {

element.setAttribute("h", boost::lexical_cast<std::string>(e->getHandledStanzasCount()));

}

}

public:

StreamResumedSerializer();

};

}

TLSProceedSerializer() : GenericElementSerializer<TLSProceed>() {

}

}

};

}

boost::shared_ptr<AuthChallenge> authChallenge(new AuthChallenge());

authChallenge->setValue(createByteArray("foo"));

"<challenge xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"

"Zm9v"

"</challenge>"), testling.serialize(authChallenge));

AuthChallengeSerializer testling;

boost::shared_ptr<AuthChallenge> authChallenge(new AuthChallenge());

"<challenge xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"

"</challenge>"), testling.serialize(authChallenge));

}

boost::shared_ptr<AuthChallenge> authChallenge(new AuthChallenge());

authChallenge->setValue(std::vector<unsigned char>());

"<challenge xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"

"="

"</challenge>"), testling.serialize(authChallenge));

boost::shared_ptr<AuthRequest> authRequest(new AuthRequest("PLAIN"));

authRequest->setMessage(createSafeByteArray("foo"));

"<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" mechanism=\"PLAIN\">"

"Zm9v"

"</auth>"), testling.serialize(authRequest));

AuthRequestSerializer testling;

boost::shared_ptr<AuthRequest> authRequest(new AuthRequest("PLAIN"));

"<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" mechanism=\"PLAIN\">"

"</auth>"), testling.serialize(authRequest));

}

boost::shared_ptr<AuthRequest> authRequest(new AuthRequest("PLAIN"));

authRequest->setMessage(SafeByteArray());

"<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" mechanism=\"PLAIN\">"

"="

"</auth>"), testling.serialize(authRequest));

boost::shared_ptr<AuthResponse> authResponse(new AuthResponse());

authResponse->setValue(createSafeByteArray("foo"));

"<response xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"

"Zm9v"

"</response>"), testling.serialize(authResponse));

AuthResponseSerializer testling;

boost::shared_ptr<AuthResponse> authResponse(new AuthResponse());

"<response xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"

"</response>"), testling.serialize(authResponse));

}

boost::shared_ptr<AuthResponse> authResponse(new AuthResponse());

authResponse->setValue(SafeByteArray());

"<response xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"

"="

"</response>"), testling.serialize(authResponse));

boost::shared_ptr<AuthSuccess> authSuccess(new AuthSuccess());

authSuccess->setValue(createByteArray("foo"));

"<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"

"Zm9v"

"</success>"), testling.serialize(authSuccess));

AuthSuccessSerializer testling;

boost::shared_ptr<AuthSuccess> authSuccess(new AuthSuccess());

"<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"

"</success>"), testling.serialize(authSuccess));

}

boost::shared_ptr<AuthSuccess> authSuccess(new AuthSuccess());

authSuccess->setValue(std::vector<unsigned char>());

"<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"

"="

"</success>"), testling.serialize(authSuccess));

streamFeatures->setHasStreamManagement();

streamFeatures->setHasRosterVersioning();

"<stream:features>"

"<starttls xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\"/>"

"<compression xmlns=\"http://jabber.org/features/compress\">"

return result;

}

std::vector< boost::shared_ptr<ElementSerializer> >::const_iterator i = std::find_if(serializers_.begin(), serializers_.end(), boost::bind(&ElementSerializer::canSerialize, _1, element));

if (i != serializers_.end()) {

return (*i)->serialize(element);

}

else {

std::cerr << "Could not find serializer for " << typeid(*(element.get())).name() << std::endl;

}

}

XMPPSerializer(PayloadSerializerCollection*, StreamType type);

std::string serializeHeader(const ProtocolHeader&) const;

std::string serializeFooter() const;

private: