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

+

+#include <string>

+

+

+

+#include <string>

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

+#include <algorithm>

+

+const std::string DiscoInfo::CommandsFeature = std::string("http://jabber.org/protocol/commands");

+bool DiscoInfo::hasFeature(const std::string& feature) const {

+ return std::find(features_.begin(), features_.end(), feature) != features_.end();

+}

+

+#include "Swiften/Elements/Payload.h"

+ static const std::string CommandsFeature;

+ bool hasFeature(const std::string& feature) const;

+#include <string>

+#pragma once

+#include <string>

+#include <string>

+

+#include <string>

+#include <vector>

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

+ static IBB::ref createIBBData(const std::string& streamID, int sequenceNumber, const std::vector<unsigned char>& data) {

+ const std::vector<unsigned char>& getData() const {

+ void setData(const std::vector<unsigned char>& data) {

+ std::vector<unsigned char> data;

+#include <string>

+

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

+ class JingleContentPayload : public Payload {

+ typedef boost::shared_ptr<JingleContentPayload> ref;

+ Creator getCreator() const {

+ return creator;

+ }

+

+ const std::string& getName() const {

+ return name;

+ }

+

+ const std::vector<boost::shared_ptr<JingleTransportPayload> >& getTransports() const {

+ void addTransport(boost::shared_ptr<JingleTransportPayload> transport) {

+ for (size_t i = 0; i < descriptions.size(); ++i) {

+ boost::shared_ptr<T> result(boost::dynamic_pointer_cast<T>(descriptions[i]));

+ for (size_t i = 0; i < transports.size(); ++i) {

+ boost::shared_ptr<T> result(boost::dynamic_pointer_cast<T>(transports[i]));

+ std::vector<boost::shared_ptr<JingleTransportPayload> > transports;

+#include <boost/shared_ptr.hpp>

+

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

+ class JingleIBBTransportPayload : public JingleTransportPayload {

+ typedef boost::shared_ptr<JingleIBBTransportPayload> ref;

+

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

+ void addContent(JingleContentPayload::ref content) {

+ const std::vector<JingleContentPayload::ref> getContents() const {

+ std::vector<JingleContentPayload::ref> contents;

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

+// FIXME: Remove Bytestreams, and replace by our own candidate

+

+ class JingleS5BTransportPayload : public JingleTransportPayload {

+#include <boost/shared_ptr.hpp>

+

+ class JingleTransportPayload : public Payload {

+ public:

+ typedef boost::shared_ptr<JingleTransportPayload> ref;

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

+#include "Swiften/Elements/Replace.h"

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

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

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

+

+namespace Swift {

+

+Presence::Presence() : type_(Available) /*, showType_(Online)*/ {

+}

+

+Presence::Presence(const std::string& status) : type_(Available) {

+ setStatus(status);

+}

+

+Presence::~Presence() {

+}

+

+int Presence::getPriority() const {

+ boost::shared_ptr<Priority> priority(getPayload<Priority>());

+ return (priority ? priority->getPriority() : 0);

+}

+

+void Presence::setPriority(int priority) {

+ updatePayload(boost::shared_ptr<Priority>(new Priority(priority)));

+}

+

+std::string Presence::getStatus() const {

+ boost::shared_ptr<Status> status(getPayload<Status>());

+ if (status) {

+ return status->getText();

+ }

+ return "";

+}

+

+void Presence::setStatus(const std::string& status) {

+ updatePayload(boost::shared_ptr<Status>(new Status(status)));

+}

+

+

+}

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

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

+ Presence();

+ Presence(const std::string& status);

+ virtual ~Presence();

+ std::string getStatus() const;

+ void setStatus(const std::string& status);

+ int getPriority() const;

+ void setPriority(int priority);

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

+/*

+ * Copyright (c) 2011 Vlad Voicu

+ * Licensed under the Simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

+#include "Swiften/Elements/Payload.h"

+

+namespace Swift {

+ class Replace : public Payload {

+ public:

+ typedef boost::shared_ptr<Replace> ref;

+ Replace(std::string id = "") : replaceID_(id) {};

+ std::string getId() {

+ return replaceID_;

+ }

+ void setId(std::string id) {

+ replaceID_ = id;

+ }

+ private:

+ std::string replaceID_;

+ };

+}

+/*

+ * Copyright (c) 2011 Jan Kaluza

+ * Licensed under the Simplified BSD license.

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

+ */

+

+#include "Swiften/Elements/RosterItemExchangePayload.h"

+#include "Swiften/Base/foreach.h"

+

+namespace Swift {

+

+RosterItemExchangePayload::Item::Item() {

+}

+

+RosterItemExchangePayload::RosterItemExchangePayload() {

+}

+

+}

+/*

+ * Copyright (c) 2011 Jan Kaluza

+ * Licensed under the Simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <vector>

+#include <string>

+#include <boost/shared_ptr.hpp>

+

+#include "Swiften/Elements/Payload.h"

+#include "Swiften/JID/JID.h"

+

+

+namespace Swift {

+ class RosterItemExchangePayload : public Payload {

+ public:

+ typedef boost::shared_ptr<RosterItemExchangePayload> ref;

+

+ class Item {

+ public:

+ enum Action { Add, Modify, Delete };

+

+ Item();

+

+ Action getAction() const {

+ return action;

+ }

+

+ void setAction(Action action) {

+ this->action = action;

+ }

+

+ const JID& getJID() const {

+ return jid;

+ }

+

+ void setJID(const JID& jid) {

+ this->jid = jid;

+ }

+

+ const std::string& getName() const {

+ return name;

+ }

+

+ void setName(const std::string& name) {

+ this->name = name;

+ }

+

+ const std::vector<std::string>& getGroups() const {

+ return groups;

+ }

+

+ void addGroup(const std::string& group) {

+ groups.push_back(group);

+ }

+

+ private:

+ Action action;

+ JID jid;

+ std::string name;

+ std::vector<std::string> groups;

+ };

+

+ typedef std::vector<RosterItemExchangePayload::Item> RosterItemExchangePayloadItems;

+

+ public:

+ RosterItemExchangePayload();

+

+ void addItem(const RosterItemExchangePayload::Item& item) {

+ items_.push_back(item);

+ }

+

+ const RosterItemExchangePayloadItems& getItems() const {

+ return items_;

+ }

+

+ private:

+ RosterItemExchangePayloadItems items_;

+ };

+}

+#pragma once

+#include <Swiften/JID/JID.h>

+

+ class RosterItemPayload {

+ RosterItemPayload(const JID& jid, const std::string& name, Subscription subscription, const std::vector<std::string>& groups = std::vector<std::string>()) : jid_(jid), name_(name), subscription_(subscription), groups_(groups), ask_(false) { }

+ const boost::optional<std::string>& getVersion() const {

+ return version_;

+ }

+

+ void setVersion(const std::string& version) {

+ version_ = version;

+ }

+

+ boost::optional<std::string> version_;

+#pragma once

+#include <string>

+#include <boost/shared_ptr.hpp>

+#include <boost/shared_ptr.hpp>

+

+#include "Swiften/Elements/Payload.h"

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

+

+Stanza::Stanza() {

+}

+

+#include <string>

+#include <boost/optional/optional_fwd.hpp>

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

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

+#include <Swiften/JID/JID.h>

+ class Payload;

+

+ Stanza();

+ for (size_t i = 0; i < payloads_.size(); ++i) {

+ boost::shared_ptr<T> result(boost::dynamic_pointer_cast<T>(payloads_[i]));

+ for (size_t i = 0; i < payloads_.size(); ++i) {

+ boost::shared_ptr<T> result(boost::dynamic_pointer_cast<T>(payloads_[i]));

+ std::vector< boost::shared_ptr<Payload> > payloads_;

+#pragma once

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+using namespace Swift;

+

+StatusShow::StatusShow(const Type& type) : type_(type) {

+}

+#pragma once

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

+ StatusShow(const Type& type = Online);

+ case Online: return 4;

+ case FFC: return 5;

+ case Away: return 2;

+ case XA: return 1;

+ case DND: return 3;

+ case None: return 0;

+ return 0;

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <algorithm>

+

+namespace Swift {

+

+bool StreamFeatures::hasCompressionMethod(const std::string& mechanism) const {

+ return std::find(compressionMethods_.begin(), compressionMethods_.end(), mechanism) != compressionMethods_.end();

+}

+

+bool StreamFeatures::hasAuthenticationMechanism(const std::string& mechanism) const {

+ return std::find(authenticationMechanisms_.begin(), authenticationMechanisms_.end(), mechanism) != authenticationMechanisms_.end();

+}

+

+}

+#include <boost/shared_ptr.hpp>

+

+ StreamFeatures() : hasStartTLS_(false), hasResourceBind_(false), hasSession_(false), hasStreamManagement_(false), hasRosterVersioning_(false) {}

+ bool hasCompressionMethod(const std::string& mechanism) const;

+ bool hasAuthenticationMechanism(const std::string& mechanism) const;

+ bool hasRosterVersioning() const {

+ return hasRosterVersioning_;

+ }

+

+ void setHasRosterVersioning() {

+ hasRosterVersioning_ = true;

+ }

+

+ bool hasRosterVersioning_;

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+using namespace Swift;

+

+StreamManagementEnabled::StreamManagementEnabled() {

+}

+

+StreamManagementEnabled::~StreamManagementEnabled() {

+}

+ * Copyright (c) 2010-2011 Remko Tronçon

+#include <string>

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

+ StreamManagementEnabled();

+ ~StreamManagementEnabled();

+

+ void setResumeSupported() {

+ resumeSupported = true;

+ }

+

+ bool getResumeSupported() const {

+ return resumeSupported;

+ }

+

+ void setResumeID(const std::string& id) {

+ resumeID = id;

+ }

+

+ const std::string& getResumeID() const {

+ return resumeID;

+ }

+

+ private:

+ bool resumeSupported;

+ std::string resumeID;

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+using namespace Swift;

+

+StreamResume::StreamResume() {

+}

+

+StreamResume::~StreamResume() {

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <string>

+#include <boost/optional.hpp>

+

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

+

+namespace Swift {

+ class StreamResume : public Element {

+ public:

+ StreamResume();

+ ~StreamResume();

+

+ void setResumeID(const std::string& id) {

+ resumeID = id;

+ }

+

+ const std::string& getResumeID() const {

+ return resumeID;

+ }

+

+ const boost::optional<int> getHandledStanzasCount() const {

+ return handledStanzasCount;

+ }

+

+ void setHandledStanzasCount(int i) {

+ handledStanzasCount = i;

+ }

+

+ private:

+ std::string resumeID;

+ boost::optional<int> handledStanzasCount;

+ };

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+using namespace Swift;

+

+StreamResumed::StreamResumed() {

+}

+

+StreamResumed::~StreamResumed() {

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <string>

+#include <boost/optional.hpp>

+

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

+

+namespace Swift {

+ class StreamResumed : public Element {

+ public:

+ StreamResumed();

+ ~StreamResumed();

+

+ void setResumeID(const std::string& id) {

+ resumeID = id;

+ }

+

+ const std::string& getResumeID() const {

+ return resumeID;

+ }

+

+ const boost::optional<int> getHandledStanzasCount() const {

+ return handledStanzasCount;

+ }

+

+ void setHandledStanzasCount(int i) {

+ handledStanzasCount = i;

+ }

+

+ private:

+ std::string resumeID;

+ boost::optional<int> handledStanzasCount;

+ };

+}

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