/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ToplevelElement.h>

namespace Swift {

class SWIFTEN_API AuthFailure : public ToplevelElement {

public:

AuthFailure() {}

};

#pragma once

#include <string>

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SWIFTEN_API Bytestreams : public Payload {

public:

struct StreamHost {

StreamHost(const std::string& host = "", const JID& jid = JID(), int port = -1) : host(host), jid(jid), port(port) {}

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SWIFTEN_API CapsInfo : public Payload {

public:

CapsInfo(const std::string& node = "", const std::string& version = "", const std::string& hash = "sha-1") : node_(node), version_(version), hash_(hash) {}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SWIFTEN_API CarbonsDisable : public Payload {

public:

public:

virtual ~CarbonsDisable();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SWIFTEN_API CarbonsEnable : public Payload {

public:

public:

virtual ~CarbonsEnable();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SWIFTEN_API CarbonsPrivate : public Payload {

public:

public:

virtual ~CarbonsPrivate();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

forwarded_ = forwarded;

}

return forwarded_;

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Forwarded.h>

namespace Swift {

class SWIFTEN_API CarbonsReceived : public Payload {

public:

public:

virtual ~CarbonsReceived();

private:

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

forwarded_ = forwarded;

}

return forwarded_;

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Forwarded.h>

namespace Swift {

class SWIFTEN_API CarbonsSent : public Payload {

public:

public:

virtual ~CarbonsSent();

private:

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

namespace Swift {

class SWIFTEN_API ChatState : public Payload {

public:

public:

enum ChatStateType {Active, Composing, Paused, Inactive, Gone};

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Form.h>

#include <Swiften/Elements/Payload.h>

*/

class SWIFTEN_API Command : public Payload {

public:

enum Status {Executing, Completed, Canceled, NoStatus};

enum Action {Cancel, Execute, Complete, Prev, Next, NoAction};

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ToplevelElement.h>

namespace Swift {

class SWIFTEN_API ComponentHandshake : public ToplevelElement {

public:

ComponentHandshake(const std::string& data = "") : data(data) {

}

#pragma once

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Payload.h>

class SWIFTEN_API ContainerPayload : public Payload {

public:

ContainerPayload() {}

this->payload = payload;

}

return payload;

}

private:

};

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

class SWIFTEN_API DeliveryReceipt : public Payload {

public:

public:

DeliveryReceipt() {}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

class SWIFTEN_API DeliveryReceiptRequest : public Payload {

public:

public:

DeliveryReceiptRequest() {}

*/

class SWIFTEN_API DiscoInfo : public Payload {

public:

static const std::string ChatStatesFeature;

static const std::string SecurityLabelsFeature;

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SWIFTEN_API ErrorPayload : public Payload {

public:

enum Type { Cancel, Continue, Modify, Auth, Wait };

return text_;

}

payload_ = payload;

}

return payload_;

}

Type type_;

Condition condition_;

std::string text_;

};

}

*/

class SWIFTEN_API Form : public Payload {

public:

typedef std::vector<FormField::ref> FormItem;

enum Type { FormType, SubmitType, CancelType, ResultType };

public:

Form(Type type = FormType) : type_(type) {}

assert(page);

pages_.push_back(page);

}

return pages_;

}

assert(field);

fields_.push_back(field);

}

return fields_;

}

fields_.clear();

}

assert(text);

textElements_.push_back(text);

}

return textElements_;

}

assert(reportedRef);

reportedRefs_.push_back(reportedRef);

}

return reportedRefs_;

}

void clearReportedFields() { reportedFields_.clear(); }

private:

std::vector<FormItem> items_;

std::string title_;

std::string instructions_;

Type type_;

#pragma once

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class SWIFTEN_API FormField {

public:

enum Type {

UnknownType,

/*

* All rights reserved.

* See the COPYING file for more information.

*/

return label_;

}

childSections_.push_back(section);

}

return childSections_;

}

textElements_.push_back(textElement);

}

return textElements_;

}

reportedRefs_.push_back(reportedRef);

}

return reportedRefs_;

}

fields_.push_back(field);

}

return fields_;

}

*/

#pragma once

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/FormField.h>

#include <Swiften/Elements/FormReportedRef.h>

class SWIFTEN_API FormPage {

public:

FormPage ();

~FormPage();

void setLabel(const std::string& label);

const std::string& getLabel() const;

void addFieldRef(std::string ref);

const std::vector<std::string> getFieldRefs() const;

private:

std::string label_;

std::vector<std::string> fieldRefs_;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

class SWIFTEN_API FormReportedRef {

public:

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

return label_;

}

textElements_.push_back(textElement);

}

return textElements_;

}

reportedRefs_.push_back(reportedRef);

}

return reportedRefs_;

}

childSections_.push_back(childSection);

}

return childSections_;

}

fields_.push_back(field);

}

return fields_;

}

*/

#pragma once

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/FormField.h>

#include <Swiften/Elements/FormReportedRef.h>

class SWIFTEN_API FormSection {

public:

FormSection();

~FormSection();

void setLabel(const std::string& label);

const std::string& getLabel() const;

void addFieldRef(std::string ref);

const std::vector<std::string> getFieldRefs() const;

private:

std::string label_;

std::vector<std::string> fieldRefs_;

};

}

*/

#pragma once

#include <string>

#include <Swiften/Base/API.h>

namespace Swift {

class SWIFTEN_API FormText{

public:

FormText();

virtual ~FormText();

void setTextString(const std::string& text);

public:

virtual ~Forwarded();

private:

};

}

#pragma once

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SWIFTEN_API IBB : public Payload {

public:

enum Action {

Open,

}

static IBB::ref createIBBOpen(const std::string& streamID, int blockSize) {

result->setBlockSize(blockSize);

return result;

}

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

result->setSequenceNumber(sequenceNumber);

result->setData(data);

return result;

}

static IBB::ref createIBBClose(const std::string& streamID) {

}

void setAction(Action action) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Elements/IQ.h>

namespace Swift {

if (to.isValid()) {

iq->setTo(to);

}

return iq;

}

iq->setTo(to);

iq->setID(id);

if (payload) {

return iq;

}

iq->setTo(to);

iq->setFrom(from);

iq->setID(id);

return iq;

}

iq->setTo(to);

iq->setID(id);

errorPayload->setPayload(payload);

iq->addPayload(errorPayload);

return iq;

}

iq->setTo(to);

iq->setFrom(from);

iq->setID(id);

errorPayload->setPayload(payload);

iq->addPayload(errorPayload);

return iq;

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ErrorPayload.h>

namespace Swift {

class SWIFTEN_API IQ : public Stanza {

public:

enum Type { Get, Set, Result, Error };

Type getType() const { return type_; }

void setType(Type type) { type_ = type; }

Type type,

const JID& to,

const std::string& id,

const JID& to,

const std::string& id,

const JID& to,

const JID& from,

const std::string& id,

const JID& to,

const std::string& id,

ErrorPayload::Condition condition = ErrorPayload::BadRequest,

ErrorPayload::Type type = ErrorPayload::Cancel,

const JID& to,

const JID& from,

const std::string& id,

ErrorPayload::Condition condition = ErrorPayload::BadRequest,

ErrorPayload::Type type = ErrorPayload::Cancel,

private:

Type type_;

#pragma once

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

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

class SWIFTEN_API Idle : public Payload {

public:

public:

Idle() {}

#pragma once

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Form.h>

namespace Swift {

class SWIFTEN_API InBandRegistrationPayload : public Payload {

public:

InBandRegistrationPayload() : registered(false), remove(false) {}

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

virtual ~IsodeIQDelegation();

return forward;

}

this->forward = value ;

}

private:

};

}

namespace Swift {

class SWIFTEN_API JingleContentPayload : public Payload {

public:

enum Creator {

UnknownCreator,

descriptions.push_back(description);

}

return transports;

}

transports.push_back(transport);

}

template<typename T>

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

if (result) {

return result;

}

}

}

template<typename T>

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

if (result) {

return result;

}

}

}

private:

std::string name;

//Senders senders;

std::vector<JingleDescription::ref> descriptions;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SWIFTEN_API JingleDescription : public Payload {

public:

};

}

#pragma once

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/JingleDescription.h>

#include <Swiften/Elements/JingleFileTransferFileInfo.h>

namespace Swift {

class SWIFTEN_API JingleFileTransferDescription : public JingleDescription {

public:

void setFileInfo(const JingleFileTransferFileInfo& fileInfo) {

fileInfo_ = fileInfo;

#pragma once

#include <map>

#include <string>

#include <vector>

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

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/HashElement.h>

* @brief This class represents the file info used in XEP-0234.

*/

class SWIFTEN_API JingleFileTransferFileInfo : public Payload {

public:

JingleFileTransferFileInfo(const std::string& name = "", const std::string& description = "", unsigned long long size = 0, const boost::posix_time::ptime &date = boost::posix_time::ptime()) :

#pragma once

#include <map>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/JingleDescription.h>

#include <Swiften/Elements/JingleFileTransferFileInfo.h>

class SWIFTEN_API JingleFileTransferHash : public Payload {

public:

void setFileInfo(const JingleFileTransferFileInfo& fileInfo) {

fileInfo_ = fileInfo;

#pragma once

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/JingleTransportPayload.h>

namespace Swift {

class SWIFTEN_API JingleIBBTransportPayload : public JingleTransportPayload {

public:

enum StanzaType {

IQStanza,

#pragma once

#include <string>

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/JingleContentPayload.h>

namespace Swift {

class SWIFTEN_API JinglePayload : public Payload {

public:

struct Reason : public Payload {

enum Type {

UnknownType,

this->payloads.push_back(content);

}

this->payloads.push_back(payload);

}

return getPayloads<JingleContentPayload>();

}

return payloads;

}

template<typename T>

if (result) {

matched_payloads.push_back(result);

}

}

template<typename T>

if (result) {

return result;

}

JID initiator;

JID responder;

std::string sessionID;

boost::optional<Reason> reason;

};

}

#pragma once

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Bytestreams.h>

#include <Swiften/Elements/JingleTransportPayload.h>

return proxyError;

}

public:

private:

Mode mode;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

}

public:

private:

std::string sessionID;

#pragma once

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

return isStable_;

}

resultSet_ = resultSet;

}

return resultSet_;

}

private:

bool isComplete_;

bool isStable_;

boost::optional<std::string> queryID_;

};

}

#pragma once

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Form.h>

void setNode(const boost::optional<std::string>& node) { node_ = node; }

const boost::optional<std::string>& getNode() const { return node_; }

private:

boost::optional<std::string> queryID_;

boost::optional<std::string> node_;

};

}

#pragma once

#include <string>

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/MUCItem.h>

namespace Swift {

class SWIFTEN_API MUCAdminPayload : public Payload {

public:

MUCAdminPayload() {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

namespace Swift {

class SWIFTEN_API MUCDestroyPayload : public Payload {

public:

MUCDestroyPayload() {

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

namespace Swift {

class SWIFTEN_API MUCInvitationPayload : public Payload {

public:

MUCInvitationPayload() : continuation_(false), impromptu_(false) {

}

namespace Swift {

class SWIFTEN_API MUCOwnerPayload : public Payload {

public:

MUCOwnerPayload() {

}

return payload;

}

payload = p;

}

Form::ref getForm() {

}

private:

};

}

namespace Swift {

class SWIFTEN_API MUCPayload : public Payload {

public:

MUCPayload() {

maxChars_ = -1;

#pragma once

#include <string>

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/MUCItem.h>

namespace Swift {

class SWIFTEN_API MUCUserPayload : public Payload {

public:

struct StatusCode {

StatusCode() : code(0) {}

const std::vector<StatusCode>& getStatusCodes() const {return statusCodes_;}

return payload_;

}

payload_ = p;

}

private:

std::vector<MUCItem> items_;

std::vector<StatusCode> statusCodes_;

boost::optional<std::string> password_;

boost::optional<Invite> invite_;

};

#pragma once

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Body.h>

namespace Swift {

class SWIFTEN_API Message : public Stanza {

public:

enum Type { Normal, Chat, Error, Groupchat, Headline };

Message() : type_(Chat) { }

std::string getSubject() const {

if (subject) {

return subject->getText();

}

}

void setSubject(const std::string& subject) {

}

// Explicitly convert to bool. In C++11, it would be cleaner to

}

boost::optional<std::string> getBody() const {

boost::optional<std::string> bodyData;

if (body) {

bodyData = body->getText();

void setBody(const boost::optional<std::string>& body) {

if (body) {

}

else {

}

}

bool isError() {

return getType() == Message::Error || error;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Element.h>

namespace Swift {

class SWIFTEN_API Payload : public Element {

public:

public:

Payload() {}

SWIFTEN_DEFAULT_COPY_CONSTRUCTOR(Payload)

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

int Presence::getPriority() const {

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

}

void Presence::setPriority(int priority) {

}

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

if (status) {

return status->getText();

}

}

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

}

}

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Stanza.h>

namespace Swift {

class SWIFTEN_API Presence : public Stanza {

public:

enum Type { Available, Error, Probe, Subscribe, Subscribed, Unavailable, Unsubscribe, Unsubscribed };

virtual ~Presence();

static ref create() {

}

static ref create(const std::string& status) {

}

static ref create(Presence::ref presence) {

}

Type getType() const { return type_; }

void setType(Type type) { type_ = type; }

StatusShow::Type getShow() const {

if (show) {

return show->getType();

}

}

void setShow(const StatusShow::Type &show) {

}

std::string getStatus() const;

int getPriority() const;

void setPriority(int priority);

}

bool isAvailable() const {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SWIFTEN_API PrivateStorage : public Payload {

public:

}

return payload;

}

payload = p;

}

private:

};

}

#pragma once

#include <string>

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

this->node = value ;

}

return affiliations;

}

this->affiliations = value ;

}

this->affiliations.push_back(value);

}

private:

boost::optional< std::string > node;

};

}

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

virtual ~PubSubConfigure();

return data;

}

this->data = value ;

}

private:

};

}

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Payload.h>

this->node = value ;

}

return configure;

}

this->configure = value ;

}

private:

std::string node;

};

}

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#pragma once

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

this->node = value ;

}

return disassociate;

}

this->disassociate = value ;

}

return associate;

}

this->associate = value ;

}

private:

boost::optional< std::string > node;

};

}

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Form.h>

this->node = value ;

}

return data;

}

this->data = value ;

}

private:

std::string node;

};

}

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Payload.h>

this->node = value ;

}

return redirects;

}

this->redirects = value ;

}

private:

std::string node;

};

}

#pragma once

#include <string>

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

this->publisher = value ;

}

return data;

}

this->data = value ;

}

this->data.push_back(value);

}

private:

boost::optional< std::string > node;

boost::optional< std::string > publisher;

boost::optional< std::string > id;

};

}

#pragma once

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Payload.h>

this->node = value ;

}

return items;

}

this->items = value ;

}

this->items.push_back(value);

}

return retracts;

}

this->retracts = value ;

}

this->retracts.push_back(value);

}

private:

std::string node;

};

}

#pragma once

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Payload.h>

virtual ~PubSubItem();

return data;

}

this->data = value ;

}

this->data.push_back(value);

}

private:

std::string id;

};

}

#pragma once

#include <string>

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

this->node = value ;

}

return items;

}

this->items = value ;

}

this->items.push_back(value);

}

private:

std::string node;

boost::optional< unsigned int > maximumItems;

boost::optional< std::string > subscriptionID;

};

#pragma once

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

this->jid = value ;

}

return data;

}

this->data = value ;

}

private:

std::string node;

JID jid;

boost::optional< std::string > subscriptionID;

};

}

#pragma once

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Payload.h>

this->node = value ;

}

return affiliations;

}

this->affiliations = value ;

}

this->affiliations.push_back(value);

}

private:

std::string node;

};

}

#pragma once

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

this->node = value ;

}

return data;

}

this->data = value ;

}

private:

boost::optional< std::string > node;

};

}

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

virtual ~PubSubOwnerDefault();

return data;

}

this->data = value ;

}

private:

};

}

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Payload.h>

this->node = value ;

}

return redirect;

}

this->redirect = value ;

}

private:

std::string node;

};

}

#pragma once

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Payload.h>

this->node = value ;

}

return subscriptions;

}

this->subscriptions = value ;

}

this->subscriptions.push_back(value);

}

private:

std::string node;

};

}

#pragma once

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Payload.h>

this->node = value ;

}

return items;

}

this->items = value ;

}

this->items.push_back(value);

}

private:

std::string node;

};

}

#pragma once

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/Payload.h>

this->node = value ;

}

return items;

}

this->items = value ;

}

this->items.push_back(value);

}

private:

std::string node;

bool notify;

};

}

#pragma once

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

this->jid = value ;

}

return options;

}

this->options = value ;

}

private:

boost::optional< std::string > node;

JID jid;

};

}

#pragma once

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

this->jid = value ;

}

return options;

}

this->options = value ;

}

boost::optional< std::string > node;

boost::optional< std::string > subscriptionID;

JID jid;

SubscriptionType subscription;

};

}

#pragma once

#include <string>

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

this->node = value ;

}

return subscriptions;

}

this->subscriptions = value ;

}

this->subscriptions.push_back(value);

}

private:

boost::optional< std::string > node;

};

}

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SWIFTEN_API Replace : public Payload {

public:

Replace(const std::string& id = std::string()) : replaceID_(id) {}

const std::string& getID() const {

return replaceID_;

#pragma once

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#pragma once

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class SWIFTEN_API RosterItemExchangePayload : public Payload {

public:

class SWIFTEN_API Item {

public:

#pragma once

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SWIFTEN_API RosterPayload : public Payload {

public:

typedef std::vector<RosterItemPayload> RosterItemPayloads;

public:

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

class SWIFTEN_API S5BProxyRequest : public Payload {

public:

public:

struct StreamHost {

#pragma once

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Form.h>

*/

class SWIFTEN_API SearchPayload : public Payload {

public:

struct Item {

std::string first;

#pragma once

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

#include <Swiften/Elements/SecurityLabel.h>

namespace Swift {

class SWIFTEN_API SecurityLabelsCatalog : public Payload {

public:

class Item {

public:

Item() : default_(false) {}

return label_;

}

label_ = label;

}

default_ = isDefault;

}

private:

std::string selector_;

bool default_;

};

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SWIFTEN_API SoftwareVersion : public Payload {

public:

SoftwareVersion(

const std::string& name = "",

payloads_.clear();

}

if (typeid(*i.get()) == typeid(*payload.get())) {

i = payload;

return;

addPayload(payload);

}

return typeid(*a.get()) == typeid(*b.get());

}

payloads_.erase(std::remove_if(payloads_.begin(), payloads_.end(),

boost::bind<bool>(&sameType, payload, _1)),

payloads_.end());

}

if (typeid(*i.get()) == typeid(*payload.get())) {

return i;

}

}

}

boost::optional<boost::posix_time::ptime> Stanza::getTimestamp() const {

return delay ? delay->getStamp() : boost::optional<boost::posix_time::ptime>();

}

boost::optional<boost::posix_time::ptime> Stanza::getTimestampFrom(const JID& jid) const {

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

if (delays[i]->getFrom() == jid) {

return delays[i]->getStamp();

#pragma once

#include <string>

#include <vector>

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

#include <boost/optional/optional_fwd.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ToplevelElement.h>

class SWIFTEN_API Stanza : public ToplevelElement {

public:

protected:

Stanza();

SWIFTEN_DEFAULT_COPY_CONSTRUCTOR(Stanza)

template<typename T>

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

if (result) {

return result;

}

}

}

template<typename T>

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

if (result) {

results.push_back(result);

}

}

return payloads_;

}

payloads_.push_back(payload);

}

payloads_.insert(payloads_.end(), begin, end);

}

const JID& getFrom() const { return from_; }

void setFrom(const JID& from) { from_ = from; }

std::string id_;

JID from_;

JID to_;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ToplevelElement.h>

namespace Swift {

class SWIFTEN_API StanzaAck : public ToplevelElement {

public:

StanzaAck() : valid(false), handledStanzasCount(0) {}

StanzaAck(unsigned int handledStanzasCount) : valid(true), handledStanzasCount(handledStanzasCount) {}

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ToplevelElement.h>

namespace Swift {

class SWIFTEN_API StreamError : public ToplevelElement {

public:

enum Type {

BadFormat,

#pragma once

#include <string>

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ToplevelElement.h>

namespace Swift {

class SWIFTEN_API StreamFeatures : public ToplevelElement {

public:

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

#pragma once

#include <string>

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SWIFTEN_API StreamInitiation : public Payload {

public:

StreamInitiation() : isFileTransfer(true) {}

#pragma once

#include <string>

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

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

class SWIFTEN_API StreamInitiationFileInfo : public Payload {

public:

public:

StreamInitiationFileInfo(const std::string& name = "", const std::string& description = "", unsigned long long size = 0,

* See the COPYING file for more information.

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

void testGetFormType() {

Form form;

field->setName("FORM_TYPE");

form.addField(field);

CPPUNIT_ASSERT_EQUAL(std::string("jabber:bot"), form.getFormType());

}

void testGetFormType_InvalidFormType() {

Form form;

field->setName("FORM_TYPE");

form.addField(field);

void testGetFormType_NoFormType() {

Form form;

CPPUNIT_ASSERT_EQUAL(std::string(""), form.getFormType());

}

* See the COPYING file for more information.

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

IQTest() {}

void testCreateResult() {

CPPUNIT_ASSERT_EQUAL(JID("foo@bar/fum"), iq->getTo());

CPPUNIT_ASSERT_EQUAL(std::string("myid"), iq->getID());

}

void testCreateResult_WithoutPayload() {

CPPUNIT_ASSERT_EQUAL(JID("foo@bar/fum"), iq->getTo());

CPPUNIT_ASSERT_EQUAL(std::string("myid"), iq->getID());

}

void testCreateError() {

CPPUNIT_ASSERT_EQUAL(JID("foo@bar/fum"), iq->getTo());

CPPUNIT_ASSERT_EQUAL(std::string("myid"), iq->getID());

CPPUNIT_ASSERT(error);

CPPUNIT_ASSERT_EQUAL(ErrorPayload::BadRequest, error->getCondition());

CPPUNIT_ASSERT_EQUAL(ErrorPayload::Modify, error->getType());

* See the COPYING file for more information.

*/

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

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

void testConstructor_Copy() {

Message m;

Message copy(m);

CPPUNIT_ASSERT(copy.getPayload<MyPayload1>());

bool payloadAlive = true;

{

Message m;

}

CPPUNIT_ASSERT(!payloadAlive);

void testDestructor_Copy() {

bool payloadAlive = true;

Message* m1 = new Message();

Message* m2 = new Message(*m1);

delete m1;

void testGetPayload() {

Message m;

CPPUNIT_ASSERT(p);

}

void testGetPayload_NoSuchPayload() {

Message m;

CPPUNIT_ASSERT(!p);

}

void testGetPayloads() {

Message m;

m.addPayload(payload1);

m.addPayload(payload2);

CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(2), m.getPayloads<MyPayload2>().size());

void testUpdatePayload_ExistingPayload() {

Message m;

CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(3), m.getPayloads().size());

CPPUNIT_ASSERT_EQUAL(std::string("bar"), p->text_);

}

void testUpdatePayload_NewPayload() {

Message m;

CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(3), m.getPayloads().size());

CPPUNIT_ASSERT_EQUAL(std::string("bar"), p->text_);

}

void testGetPayloadOfSameType() {

Message m;

CPPUNIT_ASSERT(payload);

CPPUNIT_ASSERT_EQUAL(std::string("foo"), payload->text_);

}

void testGetPayloadOfSameType_NoSuchPayload() {

Message m;

}

void testGetTimestamp() {

Message m;

boost::optional<boost::posix_time::ptime> timestamp = m.getTimestamp();

void testGetTimestamp_TimestampWithFrom() {

Message m;

boost::optional<boost::posix_time::ptime> timestamp = m.getTimestamp();

void testGetTimestampFrom() {

Message m;

boost::optional<boost::posix_time::ptime> timestamp = m.getTimestampFrom(JID("foo2@bar.com"));

void testGetTimestampFrom_Fallsback() {

Message m;

boost::optional<boost::posix_time::ptime> timestamp = m.getTimestampFrom(JID("foo2@bar.com"));

#pragma once

#include <string>

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

#include <Swiften/Base/API.h>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

class SWIFTEN_API VCard : public Payload {

public:

struct EMailAddress {

EMailAddress() : isHome(false), isWork(false), isInternet(false), isPreferred(false), isX400(false) {

namespace Swift {

class SWIFTEN_API WhiteboardDeleteOperation : public WhiteboardOperation {

public:

public:

std::string getElementID() const {

return elementID_;

#pragma once

#include <Swiften/Elements/Whiteboard/WhiteboardElementVisitor.h>

namespace Swift {

class WhiteboardElement {

public:

public:

virtual ~WhiteboardElement() {}

namespace Swift {

class SWIFTEN_API WhiteboardEllipseElement : public WhiteboardElement {

public:

public:

WhiteboardEllipseElement(int cx, int cy, int rx, int ry) {

cx_ = cx;

class SWIFTEN_API WhiteboardFreehandPathElement : public WhiteboardElement {

typedef std::pair<int, int> Point;

public:

public:

WhiteboardFreehandPathElement() {

}

namespace Swift {

class SWIFTEN_API WhiteboardInsertOperation : public WhiteboardOperation {

public:

public:

WhiteboardElement::ref getElement() const {

return element_;

namespace Swift {

class SWIFTEN_API WhiteboardLineElement : public WhiteboardElement {

public:

public:

WhiteboardLineElement(int x1, int y1, int x2, int y2) : penWidth_(1) {

x1_ = x1;

namespace Swift {

class WhiteboardOperation {

public:

public:

WhiteboardOperation() {}

SWIFTEN_DEFAULT_COPY_CONSTRUCTOR(WhiteboardOperation)

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

class SWIFTEN_API WhiteboardPolygonElement : public WhiteboardElement {

typedef std::pair<int, int> Point;

public:

public:

WhiteboardPolygonElement() {

}

namespace Swift {

class SWIFTEN_API WhiteboardRectElement : public WhiteboardElement {

public:

public:

WhiteboardRectElement(int x, int y, int width, int height) : penWidth_(1) {

x_ = x;

namespace Swift {

class SWIFTEN_API WhiteboardTextElement : public WhiteboardElement {

public:

public:

WhiteboardTextElement(int x, int y) {

x_ = x;

namespace Swift {

class SWIFTEN_API WhiteboardUpdateOperation : public WhiteboardOperation {

public:

public:

WhiteboardElement::ref getElement() const {

return element_;

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

namespace Swift {

class SWIFTEN_API WhiteboardPayload : public Payload {

public:

public:

enum Type {UnknownType, Data, SessionRequest, SessionAccept, SessionTerminate};