/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

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

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

public:

AuthChallengeSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

AuthFailureSerializer() : GenericElementSerializer<AuthFailure>() {

}

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

}

};

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

AuthRequestSerializer::AuthRequestSerializer() {

}

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

SafeByteArray value;

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

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

public:

AuthRequestSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

AuthResponseSerializer::AuthResponseSerializer() {

}

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

SafeByteArray value;

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

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

public:

AuthResponseSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

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

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

public:

AuthSuccessSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

ComponentHandshakeSerializer::ComponentHandshakeSerializer() {

}

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

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

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

public:

ComponentHandshakeSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

CompressFailureSerializer() : GenericElementSerializer<CompressFailure>() {

}

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

}

};

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

CompressRequestSerializer::CompressRequestSerializer() {

}

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;

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

public:

CompressRequestSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

virtual ~ElementSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

EnableStreamManagementSerializer() : GenericElementSerializer<EnableStreamManagement>() {

}

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

}

};

template<typename T>

class GenericElementSerializer : public ElementSerializer {

public:

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

}

};

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

public:

GenericStanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers) : StanzaSerializer(tag, payloadSerializers) {}

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

}

virtual void setStanzaSpecificAttributes(

XMLElement& element) const {

setStanzaSpecificAttributesGeneric(

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

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

StanzaAckRequestSerializer() : GenericElementSerializer<StanzaAckRequest>() {

}

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

}

};

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

StanzaAckSerializer() : GenericElementSerializer<StanzaAck>() {

}

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

assert(stanzaAck->isValid());

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

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

}

return serialize(element, "");

}

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

XMLElement stanzaElement(tag_, xmlns);

public:

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

private:

std::string tag_;

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

StartTLSFailureSerializer() : GenericElementSerializer<StartTLSFailure>() {

}

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

}

};

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

StartTLSRequestSerializer() : GenericElementSerializer<StartTLSRequest>() {

}

return createSafeByteArray(XMLElement("starttls", "urn:ietf:params:xml:ns:xmpp-tls").serialize());

}

};

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

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

}

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

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

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

public:

StreamErrorSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

StreamFeaturesSerializer::StreamFeaturesSerializer() {

}

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

XMLElement streamFeaturesElement("stream:features");

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

public:

StreamFeaturesSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

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()) {

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

public:

StreamManagementEnabledSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

StreamManagementFailedSerializer() : GenericElementSerializer<StreamManagementFailed>() {

}

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

}

};

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

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

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

public:

StreamResumeSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

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

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

public:

StreamResumedSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

TLSProceedSerializer() : GenericElementSerializer<TLSProceed>() {

}

return createSafeByteArray(XMLElement("proceed", "urn:ietf:params:xml:ns:xmpp-tls").serialize());

}

};

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

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

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/StreamType.h>

#include <string>

#include <Swiften/Serializer/ElementSerializer.h>

XMPPSerializer(PayloadSerializerCollection*, StreamType type);

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

std::string serializeFooter() const;

private: