+ class SWIFTEN_API AuthChallenge : public ToplevelElement {

+ public:

+ AuthChallenge() {

+ }

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

+ }

+ const boost::optional< std::vector<unsigned char> >& getValue() const {

+ return value;

+ }

+ void setValue(const std::vector<unsigned char>& value) {

+ this->value = boost::optional<std::vector<unsigned char> >(value);

+ }

+ private:

+ boost::optional< std::vector<unsigned char> > value;

+ };

+ class SWIFTEN_API AuthFailure : public ToplevelElement {

+ public:

+ typedef boost::shared_ptr<AuthFailure> ref;

+ AuthFailure() {}

+ };

+ class SWIFTEN_API AuthRequest : public ToplevelElement {

+ public:

+ AuthRequest(const std::string& mechanism = "") : mechanism_(mechanism) {

+ }

+

+ AuthRequest(const std::string& mechanism, const SafeByteArray& message) :

+ mechanism_(mechanism), message_(message) {

+ }

+

+ AuthRequest(const std::string& mechanism, const boost::optional<SafeByteArray>& message) :

+ mechanism_(mechanism), message_(message) {

+ }

+

+ const boost::optional<SafeByteArray>& getMessage() const {

+ return message_;

+ }

+

+ void setMessage(const SafeByteArray& message) {

+ message_ = boost::optional<SafeByteArray>(message);

+ }

+

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

+ return mechanism_;

+ }

+

+ void setMechanism(const std::string& mechanism) {

+ mechanism_ = mechanism;

+ }

+

+ private:

+ std::string mechanism_;

+ boost::optional<SafeByteArray> message_;

+ };

+ class SWIFTEN_API AuthResponse : public ToplevelElement {

+ public:

+ AuthResponse() {

+ }

+ AuthResponse(const SafeByteArray& value) : value(value) {

+ }

+ AuthResponse(const boost::optional<SafeByteArray>& value) : value(value) {

+ }

+ const boost::optional<SafeByteArray>& getValue() const {

+ return value;

+ }

+ void setValue(const SafeByteArray& value) {

+ this->value = boost::optional<SafeByteArray>(value);

+ }

+ private:

+ boost::optional<SafeByteArray> value;

+ };

+ class SWIFTEN_API AuthSuccess : public ToplevelElement {

+ public:

+ AuthSuccess() {}

+ const boost::optional<std::vector<unsigned char> >& getValue() const {

+ return value;

+ }

+ void setValue(const std::vector<unsigned char>& value) {

+ this->value = boost::optional<std::vector<unsigned char> >(value);

+ }

+ private:

+ boost::optional<std::vector<unsigned char> > value;

+ };

+ class SWIFTEN_API BlockListPayload : public Payload {

+ public:

+ BlockListPayload(const std::vector<JID>& items = std::vector<JID>()) : items(items) {

+ }

+ void addItem(const JID& item) {

+ items.push_back(item);

+ }

+ const std::vector<JID>& getItems() const {

+ return items;

+ }

+ private:

+ std::vector<JID> items;

+ };

+ class SWIFTEN_API BlockPayload : public Payload {

+ public:

+ BlockPayload(const std::vector<JID>& jids = std::vector<JID>()) : items(jids) {

+ }

+ void addItem(const JID& jid) {

+ items.push_back(jid);

+ }

+ const std::vector<JID>& getItems() const {

+ return items;

+ }

+ private:

+ std::vector<JID> items;

+ };

+ class SWIFTEN_API Body : public Payload {

+ public:

+ Body(const std::string& text = "") : text_(text) {

+ }

+ void setText(const std::string& text) {

+ text_ = text;

+ }

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

+ return text_;

+ }

+ private:

+ std::string text_;

+ };

+ class SWIFTEN_API Bytestreams : public Payload {

+ public:

+ typedef boost::shared_ptr<Bytestreams> ref;

+ struct StreamHost {

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

+ std::string host;

+ JID jid;

+ int port;

+ };

+ Bytestreams() {}

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

+ return id;

+ }

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

+ this->id = id;

+ }

+ const boost::optional<JID>& getUsedStreamHost() const {

+ return usedStreamHost;

+ }

+ void setUsedStreamHost(const JID& host) {

+ usedStreamHost = host;

+ }

+ const std::vector<StreamHost>& getStreamHosts() const {

+ return streamHosts;

+ }

+ void addStreamHost(const StreamHost& streamHost) {

+ streamHosts.push_back(streamHost);

+ }

+ private:

+ std::string id;

+ boost::optional<JID> usedStreamHost;

+ std::vector<StreamHost> streamHosts;

+ };

+ class SWIFTEN_API CapsInfo : public Payload {

+ public:

+ typedef boost::shared_ptr<CapsInfo> ref;

+

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

+

+ bool operator==(const CapsInfo& o) const {

+ return o.node_ == node_ && o.version_ == version_ && o.hash_ == hash_;

+ }

+

+ bool operator<(const CapsInfo& o) const {

+ if (o.node_ == node_) {

+ if (o.version_ == version_) {

+ return hash_ < o.hash_;

+ }

+ else {

+ return version_ < o.version_;

+ }

+ }

+ else {

+ return node_ < o.node_;

+ }

+ }

+

+ const std::string& getNode() const { return node_; }

+ void setNode(const std::string& node) {

+ node_ = node;

+ }

+

+ const std::string& getVersion() const { return version_; }

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

+ version_ = version;

+ }

+

+ const std::string& getHash() const { return hash_; }

+ void setHash(const std::string& hash) {

+ hash_ = hash;

+ }

+

+ private:

+ std::string node_;

+ std::string version_;

+ std::string hash_;

+ };

+ CarbonsDisable::~CarbonsDisable() {

+ }

+ class SWIFTEN_API CarbonsDisable : public Payload {

+ public:

+ typedef boost::shared_ptr<CarbonsDisable> ref;

+ public:

+ virtual ~CarbonsDisable();

+ };

+ CarbonsEnable::~CarbonsEnable() {

+ }

+ class SWIFTEN_API CarbonsEnable : public Payload {

+ public:

+ typedef boost::shared_ptr<CarbonsEnable> ref;

+ public:

+ virtual ~CarbonsEnable();

+ };

+ CarbonsPrivate::~CarbonsPrivate() {

+ }

+ class SWIFTEN_API CarbonsPrivate : public Payload {

+ public:

+ typedef boost::shared_ptr<CarbonsPrivate> ref;

+ public:

+ virtual ~CarbonsPrivate();

+ };

+ CarbonsReceived::~CarbonsReceived() {

+ }

+ void CarbonsReceived::setForwarded(boost::shared_ptr<Forwarded> forwarded) {

+ forwarded_ = forwarded;

+ }

+ boost::shared_ptr<Forwarded> CarbonsReceived::getForwarded() const {

+ return forwarded_;

+ }

+ class SWIFTEN_API CarbonsReceived : public Payload {

+ public:

+ typedef boost::shared_ptr<CarbonsReceived> ref;

+ public:

+ virtual ~CarbonsReceived();

+ void setForwarded(boost::shared_ptr<Forwarded> forwarded);

+ boost::shared_ptr<Forwarded> getForwarded() const;

+ private:

+ boost::shared_ptr<Forwarded> forwarded_;

+ };

+ CarbonsSent::~CarbonsSent() {

+ }

+ void CarbonsSent::setForwarded(boost::shared_ptr<Forwarded> forwarded) {

+ forwarded_ = forwarded;

+ }

+

+ boost::shared_ptr<Forwarded> CarbonsSent::getForwarded() const {

+ return forwarded_;

+ }

+ class SWIFTEN_API CarbonsSent : public Payload {

+ public:

+ typedef boost::shared_ptr<CarbonsSent> ref;

+ public:

+ virtual ~CarbonsSent();

+ void setForwarded(boost::shared_ptr<Forwarded> forwarded);

+ boost::shared_ptr<Forwarded> getForwarded() const;

+ private:

+ boost::shared_ptr<Forwarded> forwarded_;

+ };

+ class SWIFTEN_API ChatState : public Payload {

+ public:

+ typedef boost::shared_ptr<ChatState> ref;

+ public:

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

+ ChatState(ChatStateType state = Active) {

+ state_ = state;

+ }

+ ChatStateType getChatState() const { return state_; }

+ void setChatState(ChatStateType state) {state_ = state;}

+ private:

+ ChatStateType state_;

+ };

+ /**

+ * Ad-Hoc Command (XEP-0050).

+ */

+ class SWIFTEN_API Command : public Payload {

+ public:

+ typedef boost::shared_ptr<Command> ref;

+

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

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

+

+ struct Note {

+ enum Type {Info, Warn, Error};

+

+ Note(std::string note, Type type) : note(note), type(type) {}

+

+ std::string note;

+ Type type;

+ };

+

+ public:

+ Command(const std::string& node, const std::string& sessionID, Status status) { constructor(node, sessionID, NoAction, status);}

+ Command(const std::string& node = "", const std::string& sessionID = "", Action action = Execute) { constructor(node, sessionID, action, NoStatus); }

+

+ const std::string& getNode() const { return node_; }

+ void setNode(const std::string& node) { node_ = node; }

+

+ const std::string& getSessionID() const { return sessionID_; }

+ void setSessionID(const std::string& id) { sessionID_ = id; }

+

+ Action getAction() const { return action_; }

+ void setAction(Action action) { action_ = action; }

+

+ void setExecuteAction(Action action) { executeAction_ = action; }

+ Action getExecuteAction() const { return executeAction_; }

+

+ Status getStatus() const { return status_; }

+ void setStatus(Status status) { status_ = status; }

+

+ void addAvailableAction(Action action) { availableActions_.push_back(action); }

+ const std::vector<Action>& getAvailableActions() const { return availableActions_; }

+ void addNote(const Note& note) { notes_.push_back(note); }

+ const std::vector<Note>& getNotes() const { return notes_; }

+

+ Form::ref getForm() const { return form_; }

+ void setForm(Form::ref payload) { form_ = payload; }

+

+ private:

+ void constructor(const std::string& node, const std::string& sessionID, Action action, Status status) {

+ node_ = node;

+ sessionID_ = sessionID;

+ action_ = action;

+ status_ = status;

+ executeAction_ = NoAction;

+ }

+

+ private:

+ std::string node_;

+ std::string sessionID_;

+ Action action_;

+ Status status_;

+ Action executeAction_;

+ std::vector<Action> availableActions_;

+ std::vector<Note> notes_;

+ Form::ref form_;

+ };

+ class SWIFTEN_API ComponentHandshake : public ToplevelElement {

+ public:

+ typedef boost::shared_ptr<ComponentHandshake> ref;

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

+ }

+ void setData(const std::string& d) {

+ data = d;

+ }

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

+ return data;

+ }

+ private:

+ std::string data;

+ };

+ class SWIFTEN_API CompressFailure : public ToplevelElement {

+ public:

+ CompressFailure() {}

+ };

+ class SWIFTEN_API CompressRequest : public ToplevelElement

+ {

+ public:

+ CompressRequest(const std::string& method = "") : method_(method) {}

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

+ return method_;

+ }

+ void setMethod(const std::string& method) {

+ method_ = method;

+ }

+ private:

+ std::string method_;

+ };

+ class SWIFTEN_API Compressed : public ToplevelElement {

+ public:

+ Compressed() {}

+ };

+ template<typename T>

+ class SWIFTEN_API ContainerPayload : public Payload {

+ public:

+ ContainerPayload() {}

+ ContainerPayload(boost::shared_ptr<T> payload) : payload(payload) {}

+

+ void setPayload(boost::shared_ptr<T> payload) {

+ this->payload = payload;

+ }

+

+ boost::shared_ptr<T> getPayload() const {

+ return payload;

+ }

+

+ private:

+ boost::shared_ptr<T> payload;

+ };

+ class SWIFTEN_API Delay : public Payload {

+ public:

+ Delay() {}

+ Delay(const boost::posix_time::ptime& time, const JID& from = JID()) : time_(time), from_(from) {}

+ const boost::posix_time::ptime& getStamp() const {return time_;}

+ void setStamp(const boost::posix_time::ptime& time) {time_ = time;}

+ const boost::optional<JID>& getFrom() const {return from_;}

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

+ private:

+ boost::posix_time::ptime time_;

+ boost::optional<JID> from_;

+ };

+ public:

+ typedef boost::shared_ptr<DeliveryReceipt> ref;

+ public:

+ DeliveryReceipt() {}

+ DeliveryReceipt(const std::string& msgId) : receivedID_(msgId) {}

+ void setReceivedID(const std::string& msgId) {

+ receivedID_ = msgId;

+ }

+ std::string getReceivedID() const {

+ return receivedID_;

+ }

+ private:

+ std::string receivedID_;

+ public:

+ typedef boost::shared_ptr<DeliveryReceiptRequest> ref;

+ public:

+ DeliveryReceiptRequest() {}

+ if (category_ == other.category_) {

+ if (type_ == other.type_) {

+ if (lang_ == other.lang_) {

+ return name_ < other.name_;

+ }

+ else {

+ return lang_ < other.lang_;

+ }

+ }

+ else {

+ return type_ < other.type_;

+ }

+ }

+ else {

+ return category_ < other.category_;

+ }

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

+ /**

+ * disco#info from XEP-0030

+ */

+ class SWIFTEN_API DiscoInfo : public Payload {

+ public:

+ typedef boost::shared_ptr<DiscoInfo> ref;

+

+ static const std::string ChatStatesFeature;

+ static const std::string SecurityLabelsFeature;

+ static const std::string SecurityLabelsCatalogFeature;

+ static const std::string JabberSearchFeature;

+ static const std::string CommandsFeature;

+ static const std::string MessageCorrectionFeature;

+ static const std::string JingleFeature;

+ static const std::string JingleFTFeature;

+ static const std::string JingleTransportsIBBFeature;

+ static const std::string JingleTransportsS5BFeature;

+ static const std::string Bytestream;

+ static const std::string MessageDeliveryReceiptsFeature;

+ static const std::string WhiteboardFeature;

+ static const std::string BlockingCommandFeature;

+

+ class Identity {

+ public:

+ Identity(const std::string& name, const std::string& category = "client", const std::string& type = "pc", const std::string& lang = "") : name_(name), category_(category), type_(type), lang_(lang) {

+ }

+

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

+ return category_;

+ }

+

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

+ return type_;

+ }

+

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

+ return lang_;

+ }

+

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

+ return name_;

+ }

+

+ // Sorted according to XEP-115 rules

+ bool operator<(const Identity& other) const;

+

+ private:

+ std::string name_;

+ std::string category_;

+ std::string type_;

+ std::string lang_;

+ };

+

+ DiscoInfo() {

+ }

+

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

+ return node_;

+ }

+

+ void setNode(const std::string& node) {

+ node_ = node;

+ }

+

+ const std::vector<Identity>& getIdentities() const {

+ return identities_;

+ }

+

+ void addIdentity(const Identity& identity) {

+ identities_.push_back(identity);

+ }

+

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

+ return features_;

+ }

+

+ void addFeature(const std::string& feature) {

+ features_.push_back(feature);

+ }

+

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

+

+ void addExtension(Form::ref form) {

+ extensions_.push_back(form);

+ }

+

+ const std::vector<Form::ref>& getExtensions() const {

+ return extensions_;

+ }

+

+ private:

+ std::string node_;

+ std::vector<Identity> identities_;

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

+ std::vector<Form::ref> extensions_;

+ };

+ /**

+ * Service discovery disco#items from XEP-0030.

+ */

+ class SWIFTEN_API DiscoItems : public Payload {

+ public:

+ /**

+ * A single result item.

+ */

+ class Item {

+ public:

+ Item(const std::string& name, const JID& jid, const std::string& node="") : name_(name), jid_(jid), node_(node) {

+ }

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

+ return name_;

+ }

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

+ return node_;

+ }

+ const JID& getJID() const {

+ return jid_;

+ }

+ private:

+ std::string name_;

+ JID jid_;

+ std::string node_;

+ };

+ DiscoItems() {

+ }

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

+ return node_;

+ }

+ void setNode(const std::string& node) {

+ node_ = node;

+ }

+ const std::vector<Item>& getItems() const {

+ return items_;

+ }

+ void addItem(const Item& item) {

+ items_.push_back(item);

+ }

+ private:

+ std::string node_;

+ std::vector<Item> items_;

+ };

+ class SWIFTEN_API Element {

+ public:

+ Element() {}

+ SWIFTEN_DEFAULT_COPY_CONSTRUCTOR(Element)

+ virtual ~Element();

+ SWIFTEN_DEFAULT_COPY_ASSIGMNENT_OPERATOR(Element)

+ };

+ class SWIFTEN_API EnableStreamManagement : public ToplevelElement {

+ public:

+ EnableStreamManagement() {}

+ };

+ class SWIFTEN_API ErrorPayload : public Payload {

+ public:

+ typedef boost::shared_ptr<ErrorPayload> ref;

+

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

+

+ enum Condition {

+ BadRequest,

+ Conflict,

+ FeatureNotImplemented,

+ Forbidden,

+ Gone,

+ InternalServerError,

+ ItemNotFound,

+ JIDMalformed,

+ NotAcceptable,

+ NotAllowed,

+ NotAuthorized,

+ PaymentRequired,

+ RecipientUnavailable,

+ Redirect,

+ RegistrationRequired,

+ RemoteServerNotFound,

+ RemoteServerTimeout,

+ ResourceConstraint,

+ ServiceUnavailable,

+ SubscriptionRequired,

+ UndefinedCondition,

+ UnexpectedRequest

+ };

+

+ ErrorPayload(Condition condition = UndefinedCondition, Type type = Cancel, const std::string& text = std::string()) : type_(type), condition_(condition), text_(text) { }

+

+ Type getType() const {

+ return type_;

+ }

+

+ void setType(Type type) {

+ type_ = type;

+ }

+

+ Condition getCondition() const {

+ return condition_;

+ }

+

+ void setCondition(Condition condition) {

+ condition_ = condition;

+ }

+

+ void setText(const std::string& text) {

+ text_ = text;

+ }

+

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

+ return text_;

+ }

+

+ void setPayload(boost::shared_ptr<Payload> payload) {

+ payload_ = payload;

+ }

+

+ boost::shared_ptr<Payload> getPayload() const {

+ return payload_;

+ }

+

+ private:

+ Type type_;

+ Condition condition_;

+ std::string text_;

+ boost::shared_ptr<Payload> payload_;

+ };

+ FormField::ref field = getField("FORM_TYPE");

+ if (field && field->getType() == FormField::HiddenType) {

+ return field->getValues().empty() ? "" : field->getValues()[0];

+ }

+ return "";

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

+ if (field->getName() == name) {

+ return field;

+ }

+ }

+ return FormField::ref();

+ reportedFields_.push_back(field);

+ return reportedFields_;

+ items_.push_back(item);

+ return items_;

+ std::vector<FormField::ref> populatedFields;

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

+ if (field->getType() == FormField::TextSingleType) {

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

+ populatedFields.push_back(field);

+ }

+ }

+ else if (field->getType() == FormField::TextMultiType) {

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

+ populatedFields.push_back(field);

+ }

+ }

+ else {

+ populatedFields.push_back(field);

+ }

+ }

+ fields_ = populatedFields;

+ /**

+ * XEP-0004 Data form.

+ * For the relevant Fields, the parsers and serialisers protect the API user against

+ * the strange multi-value instead of newline thing by transforming them.

+ */

+ class SWIFTEN_API Form : public Payload {

+ public:

+ typedef boost::shared_ptr<Form> ref;

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

+

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

+

+ public:

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

+

+ void addPage(boost::shared_ptr<FormPage> page) {

+ assert(page);

+ pages_.push_back(page);

+ }

+

+ const std::vector<boost::shared_ptr<FormPage> >& getPages() const {

+ return pages_;

+ }

+

+ void addField(boost::shared_ptr<FormField> field) {

+ assert(field);

+ fields_.push_back(field);

+ }

+

+ const std::vector<boost::shared_ptr<FormField> >& getFields() const {

+ return fields_;

+ }

+

+ void clearFields() {

+ fields_.clear();

+ }

+

+ void addTextElement(boost::shared_ptr<FormText> text) {

+ assert(text);

+ textElements_.push_back(text);

+ }

+

+ const std::vector<boost::shared_ptr<FormText> >& getTextElements() const {

+ return textElements_;

+ }

+

+ void addReportedRef(boost::shared_ptr<FormReportedRef> reportedRef) {

+ assert(reportedRef);

+ reportedRefs_.push_back(reportedRef);

+ }

+

+ const std::vector<boost::shared_ptr<FormReportedRef> >& getReportedRefs() const {

+ return reportedRefs_;

+ }

+

+ void setTitle(const std::string& title) {

+ title_ = title;

+ }

+

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

+ return title_;

+ }

+

+ void setInstructions(const std::string& instructions) {

+ instructions_ = instructions;

+ }

+

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

+ return instructions_;

+ }

+

+ Type getType() const {

+ return type_;

+ }

+

+ void setType(Type type) {

+ type_ = type;

+ }

+

+ std::string getFormType() const;

+ FormField::ref getField(const std::string& name) const;

+ void addItem(const FormItem& item);

+ const std::vector<FormItem>& getItems() const;

+ void clearItems() { items_.clear(); }

+

+ void clearEmptyTextFields();

+

+ void addReportedField(FormField::ref field);

+ const std::vector<FormField::ref> & getReportedFields() const;

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

+

+ private:

+ std::vector<boost::shared_ptr<FormReportedRef> >reportedRefs_;

+ std::vector<boost::shared_ptr<FormText> > textElements_;

+ std::vector<boost::shared_ptr<FormPage> > pages_;

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

+ std::vector<boost::shared_ptr<FormField> > reportedFields_;

+ std::vector<FormItem> items_;

+ boost::shared_ptr<FormReportedRef> reportedRef_;

+ std::string title_;

+ std::string instructions_;

+ Type type_;

+ };

+ assert(type == TextMultiType || type == UnknownType);

+ return boost::algorithm::join(values, "\n");

+ assert(type == TextMultiType || type == UnknownType);

+ values.clear();

+ boost::split(values, value, boost::is_any_of("\n"));

+ values.clear();

+ values.push_back(b ? "1" : "0");

+ class SWIFTEN_API FormField {

+ public:

+ typedef boost::shared_ptr<FormField> ref;

+

+ enum Type {

+ UnknownType,

+ BooleanType,

+ FixedType,

+ HiddenType,

+ ListSingleType,

+ TextMultiType,

+ TextPrivateType,

+ TextSingleType,

+ JIDSingleType,

+ JIDMultiType,

+ ListMultiType

+ };

+

+ FormField(Type type = UnknownType) : type(type), required(false) {}

+ FormField(Type type, const std::string& value) : type(type), required(false) {

+ addValue(value);

+ }

+ virtual ~FormField();

+

+ struct Option {

+ Option(const std::string& label, const std::string& value) : label(label), value(value) {}

+ std::string label;

+ std::string value;

+ };

+

+ void setName(const std::string& name) { this->name = name; }

+ const std::string& getName() const { return name; }

+

+ void setLabel(const std::string& label) { this->label = label; }

+ const std::string& getLabel() const { return label; }

+

+ void setDescription(const std::string& description) { this->description = description; }

+ const std::string& getDescription() const { return description; }

+

+ void setRequired(bool required) { this->required = required; }

+ bool getRequired() const { return required; }

+

+ void addOption(const Option& option) {

+ options.push_back(option);

+ }

+

+ const std::vector<Option>& getOptions() const {

+ return options;

+ }

+

+ void clearOptions() {

+ options.clear();

+ }

+

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

+ return values;

+ }

+

+ void addValue(const std::string& value) {

+ values.push_back(value);

+ }

+

+ Type getType() const {

+ return type;

+ }

+

+ void setType(Type type) {

+ this->type = type;

+ }

+

+ // Type specific

+

+ bool getBoolValue() const {

+ assert(type == BooleanType || type == UnknownType);

+ if (values.empty()) {

+ return false;

+ }

+ return values[0] == "true" || values[0] == "1";

+ }

+

+ void setBoolValue(bool b);

+

+ JID getJIDSingleValue() const {

+ assert(type == JIDSingleType || type == UnknownType);

+ return values.empty() ? JID() : JID(values[0]);

+ }

+

+ JID getJIDMultiValue(size_t index) const {

+ assert(type == JIDMultiType || type == UnknownType);

+ return values.empty() ? JID() : JID(values[index]);

+ }

+

+ std::string getTextPrivateValue() const {

+ assert(type == TextPrivateType || type == UnknownType);

+ return values.empty() ? "" : values[0];

+ }

+

+ std::string getFixedValue() const {

+ assert(type == FixedType || type == UnknownType);

+ return values.empty() ? "" : values[0];

+ }

+

+ std::string getTextSingleValue() const {

+ assert(type == TextSingleType || type == UnknownType);

+ return values.empty() ? "" : values[0];

+ }

+

+ std::string getTextMultiValue() const;

+ void setTextMultiValue(const std::string& value);

+

+ protected:

+

+ private:

+ Type type;

+ std::string name;

+ std::string label;

+ std::string description;

+ bool required;

+ std::vector<Option> options;

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

+ };

+ label_ = label;

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

+ fieldRefs_.push_back(ref);

+ return fieldRefs_;

+ class SWIFTEN_API FormPage {

+ public:

+ typedef boost::shared_ptr<FormPage> page;

+ FormPage ();

+ ~FormPage();

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

+ const std::string& getLabel() const;

+ void addChildSection(boost::shared_ptr<FormSection> section);

+ const std::vector<boost::shared_ptr<FormSection> >& getChildSections() const;

+ void addTextElement(boost::shared_ptr<FormText> textElement);

+ const std::vector<boost::shared_ptr<FormText> >& getTextElements() const;

+ void addReportedRef(boost::shared_ptr<FormReportedRef> reportedRef);

+ const std::vector<boost::shared_ptr<FormReportedRef> >& getReportedRefs() const;

+ void addField(boost::shared_ptr<FormField> field);

+ const std::vector<boost::shared_ptr<FormField> >& getFields() const;

+ void addFieldRef(std::string ref);

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

+ private:

+ std::string label_;

+ std::vector<boost::shared_ptr<FormText> > textElements_;

+ std::vector<boost::shared_ptr<FormSection> > childSections_;

+ std::vector<boost::shared_ptr<FormReportedRef> > reportedRefs_;

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

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

+ };

+ class SWIFTEN_API FormReportedRef {

+ public:

+ typedef boost::shared_ptr<FormReportedRef> ref;

+ };

+ label_ = label;

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

+ fieldRefs_.push_back(ref);

+ return fieldRefs_;

+ class SWIFTEN_API FormSection {

+ public:

+ typedef boost::shared_ptr<FormSection> section;

+ FormSection();

+ ~FormSection();

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

+ const std::string& getLabel() const;

+ void addTextElement(boost::shared_ptr<FormText> textElement);

+ const std::vector<boost::shared_ptr<FormText> >& getTextElements() const;

+ void addReportedRef(boost::shared_ptr<FormReportedRef> reportedRef);

+ const std::vector<boost::shared_ptr<FormReportedRef> >& getReportedRefs() const;

+ void addChildSection(boost::shared_ptr<FormSection> childSection);

+ const std::vector<boost::shared_ptr<FormSection> >& getChildSections() const;

+ void addField(boost::shared_ptr<FormField> field);

+ const std::vector<boost::shared_ptr<FormField> >& getFields() const;

+ void addFieldRef(std::string ref);

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

+ private:

+ std::string label_;

+ std::vector<boost::shared_ptr<FormText> > textElements_;

+ std::vector<boost::shared_ptr<FormReportedRef> > reportedRefs_;

+ std::vector<boost::shared_ptr<FormSection> > childSections_;

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

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

+ };

+ text_ = text;

+ return text_;

+ class SWIFTEN_API FormText{

+ public:

+ typedef boost::shared_ptr<FormText> text;

+ FormText();

+ virtual ~FormText();

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

+ const std::string& getTextString() const;

+ private:

+ std::string text_;

+ };

+ class Delay;

+ class Stanza;

+ class SWIFTEN_API Forwarded : public Payload {

+ public:

+ virtual ~Forwarded();

+ void setDelay(boost::shared_ptr<Delay> delay) { delay_ = delay; }

+ const boost::shared_ptr<Delay>& getDelay() const { return delay_; }

+ void setStanza(boost::shared_ptr<Stanza> stanza) { stanza_ = stanza; }

+ const boost::shared_ptr<Stanza>& getStanza() const { return stanza_; }

+ private:

+ boost::shared_ptr<Delay> delay_;

+ boost::shared_ptr<Stanza> stanza_;

+ };

+ /*

+ * @brief This class represents a XEP-0300 <hash/> element.

+ */

+ class SWIFTEN_API HashElement {

+ public:

+ HashElement(const std::string& algorithm, const ByteArray& hash) : algorithm_(algorithm), hash_(hash) {

+ }

+

+ void setHashValue(const std::string& algorithm, const ByteArray& hash) {

+ algorithm_ = algorithm;

+ hash_ = hash;

+ }

+

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

+ return algorithm_;

+ }

+

+ const ByteArray& getHashValue() const {

+ return hash_;

+ }

+

+ bool operator==(const HashElement& rhs) const {

+ return (algorithm_ == rhs.algorithm_) && (hash_ == rhs.hash_);

+ }

+

+

+ private:

+ std::string algorithm_;

+ ByteArray hash_;

+ };

+ class SWIFTEN_API IBB : public Payload {

+ public:

+ typedef boost::shared_ptr<IBB> ref;

+

+ enum Action {

+ Open,

+ Close,

+ Data

+ };

+ enum StanzaType {

+ IQStanza,

+ MessageStanza

+ };

+

+ IBB(Action action = Open, const std::string& streamID = "") : action(action), streamID(streamID), stanzaType(IQStanza), blockSize(-1), sequenceNumber(-1) {

+ }

+

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

+ IBB::ref result = boost::make_shared<IBB>(Open, streamID);

+ result->setBlockSize(blockSize);

+ return result;

+ }

+

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

+ IBB::ref result = boost::make_shared<IBB>(Data, streamID);

+ result->setSequenceNumber(sequenceNumber);

+ result->setData(data);

+ return result;

+ }

+

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

+ return boost::make_shared<IBB>(Close, streamID);

+ }

+

+ void setAction(Action action) {

+ this->action = action;

+ }

+

+ Action getAction() const {

+ return action;

+ }

+

+ void setStanzaType(StanzaType stanzaType) {

+ this->stanzaType = stanzaType;

+ }

+

+ StanzaType getStanzaType() const {

+ return stanzaType;

+ }

+

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

+ streamID = id;

+ }

+

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

+ return streamID;

+ }

+

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

+ return data;

+ }

+

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

+ this->data = data;

+ }

+

+ int getBlockSize() const {

+ return blockSize;

+ }

+

+ void setBlockSize(int blockSize) {

+ this->blockSize = blockSize;

+ }

+

+ int getSequenceNumber() const {

+ return sequenceNumber;

+ }

+

+ void setSequenceNumber(int i) {

+ sequenceNumber = i;

+ }

+

+ private:

+ Action action;

+ std::string streamID;

+ std::vector<unsigned char> data;

+ StanzaType stanzaType;

+ int blockSize;

+ int sequenceNumber;

+ };

+ Type type, const JID& to, const std::string& id, boost::shared_ptr<Payload> payload) {

+ boost::shared_ptr<IQ> iq = boost::make_shared<IQ>(type);

+ if (to.isValid()) {

+ iq->setTo(to);

+ }

+ iq->setID(id);

+ if (payload) {

+ iq->addPayload(payload);

+ }

+ return iq;

+ boost::shared_ptr<IQ> iq = boost::make_shared<IQ>(Result);

+ iq->setTo(to);

+ iq->setID(id);

+ if (payload) {

+ iq->addPayload(payload);

+ }

+ return iq;

+ boost::shared_ptr<IQ> iq = boost::make_shared<IQ>(Result);

+ iq->setTo(to);

+ iq->setFrom(from);

+ iq->setID(id);

+ if (payload) {

+ iq->addPayload(payload);

+ }

+ return iq;

+ boost::shared_ptr<IQ> iq = boost::make_shared<IQ>(IQ::Error);

+ iq->setTo(to);

+ iq->setID(id);

+ boost::shared_ptr<ErrorPayload> errorPayload = boost::make_shared<Swift::ErrorPayload>(condition, type);

+ errorPayload->setPayload(payload);

+ iq->addPayload(errorPayload);

+ return iq;

+ boost::shared_ptr<IQ> iq = boost::make_shared<IQ>(IQ::Error);

+ iq->setTo(to);

+ iq->setFrom(from);

+ iq->setID(id);

+ boost::shared_ptr<ErrorPayload> errorPayload = boost::make_shared<Swift::ErrorPayload>(condition, type);

+ errorPayload->setPayload(payload);

+ iq->addPayload(errorPayload);

+ return iq;

+ class SWIFTEN_API IQ : public Stanza {

+ public:

+ typedef boost::shared_ptr<IQ> ref;

+

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

+

+ IQ(Type type = Get) : type_(type) { }

+

+ Type getType() const { return type_; }

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

+

+ static boost::shared_ptr<IQ> createRequest(

+ Type type,

+ const JID& to,

+ const std::string& id,

+ boost::shared_ptr<Payload> payload);

+ static boost::shared_ptr<IQ> createResult(

+ const JID& to,

+ const std::string& id,

+ boost::shared_ptr<Payload> payload = boost::shared_ptr<Payload>());

+ static boost::shared_ptr<IQ> createResult(

+ const JID& to,

+ const JID& from,

+ const std::string& id,

+ boost::shared_ptr<Payload> payload = boost::shared_ptr<Payload>());

+ static boost::shared_ptr<IQ> createError(

+ const JID& to,

+ const std::string& id,

+ ErrorPayload::Condition condition = ErrorPayload::BadRequest,

+ ErrorPayload::Type type = ErrorPayload::Cancel,

+ boost::shared_ptr<Payload> payload = boost::shared_ptr<Payload>());

+ static boost::shared_ptr<IQ> createError(

+ const JID& to,

+ const JID& from,

+ const std::string& id,

+ ErrorPayload::Condition condition = ErrorPayload::BadRequest,

+ ErrorPayload::Type type = ErrorPayload::Cancel,

+ boost::shared_ptr<Payload> payload = boost::shared_ptr<Payload>());

+

+ private:

+ Type type_;

+ };

+ class SWIFTEN_API Idle : public Payload {

+ public:

+ typedef boost::shared_ptr<Idle> ref;

+

+ public:

+ Idle() {}

+ Idle(boost::posix_time::ptime since) : since_(since) {

+ }

+

+ void setSince(boost::posix_time::ptime since) {

+ since_ = since;

+ }

+

+ boost::posix_time::ptime getSince() const {

+ return since_;

+ }

+

+ private:

+ boost::posix_time::ptime since_;

+ };

+ class SWIFTEN_API InBandRegistrationPayload : public Payload {

+ public:

+ typedef boost::shared_ptr<InBandRegistrationPayload> ref;

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

+ Form::ref getForm() const { return form; }

+ void setForm(Form::ref f) { form = f; }

+ bool isRegistered() const {

+ return registered;

+ }

+ void setRegistered(bool b) {

+ registered = b;

+ }

+ bool isRemove() const {

+ return remove;

+ }

+ void setRemove(bool b) {

+ remove = b;

+ }

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

+ return instructions;

+ }

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

+ return username;

+ }

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

+ return nick;

+ }

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

+ return password;

+ }

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

+ return name;

+ }

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

+ return first;

+ }

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

+ return last;

+ }

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

+ return email;

+ }

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

+ return address;

+ }

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

+ return city;

+ }

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

+ return state;

+ }

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

+ return zip;

+ }

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

+ return phone;

+ }

+

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

+ return url;

+ }

+

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

+ return date;

+ }

+

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

+ return misc;

+ }

+

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

+ return text;

+ }

+

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

+ return key;

+ }

+

+ void setInstructions(const std::string& v) {

+ this->instructions = v;

+ }

+

+ void setUsername(const std::string& v) {

+ this->username = v;

+ }

+

+ void setNick(const std::string& v) {

+ this->nick = v;

+ }

+

+ void setPassword(const std::string& v) {

+ this->password = v;

+ }

+

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

+ this->name = v;

+ }

+

+ void setFirst(const std::string& v) {

+ this->first = v;

+ }

+

+ void setLast(const std::string& v) {

+ this->last = v;

+ }

+

+ void setEMail(const std::string& v) {

+ this->email = v;

+ }

+

+ void setAddress(const std::string& v) {

+ this->address = v;

+ }

+

+ void setCity(const std::string& v) {

+ this->city = v;

+ }

+

+ void setState(const std::string& v) {

+ this->state = v;

+ }

+

+ void setZip(const std::string& v) {

+ this->zip = v;

+ }

+

+ void setPhone(const std::string& v) {

+ this->phone = v;

+ }

+

+ void setURL(const std::string& v) {

+ this->url = v;

+ }

+

+ void setDate(const std::string& v) {

+ this->date = v;

+ }

+

+ void setMisc(const std::string& v) {

+ this->misc = v;

+ }

+

+ void setText(const std::string& v) {

+ this->text = v;

+ }

+

+ void setKey(const std::string& v) {

+ this->key = v;

+ }

+

+ private:

+ Form::ref form;

+ bool registered;

+ bool remove;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ };

+ class SWIFTEN_API IsodeIQDelegation : public Payload {

+ public:

+ IsodeIQDelegation();

+ virtual ~IsodeIQDelegation();

+ boost::shared_ptr<Forwarded> getForward() const {

+ return forward;

+ }

+ void setForward(boost::shared_ptr<Forwarded> value) {

+ this->forward = value ;

+ }

+

+

+ private:

+ boost::shared_ptr<Forwarded> forward;

+ };

+ class SWIFTEN_API JingleContentPayload : public Payload {

+ public:

+ typedef boost::shared_ptr<JingleContentPayload> ref;

+

+ enum Creator {

+ UnknownCreator,

+ InitiatorCreator,

+ ResponderCreator

+ };

+

+ JingleContentPayload() : creator(UnknownCreator) {

+ }

+

+ /*enum Senders {

+ NoSenders,

+ InitiatorSender,

+ ResponderSender,

+ BothSenders,

+ };*/

+

+ Creator getCreator() const {

+ return creator;

+ }

+

+ void setCreator(Creator creator) {

+ this->creator = creator;

+ }

+

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

+ return name;

+ }

+

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

+ this->name = name;

+ }

+

+ const std::vector<JingleDescription::ref>& getDescriptions() const {

+ return descriptions;

+ }

+

+ void addDescription(JingleDescription::ref description) {

+ descriptions.push_back(description);

+ }

+

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

+ return transports;

+ }

+

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

+ transports.push_back(transport);

+ }

+

+ template<typename T>

+ boost::shared_ptr<T> getDescription() const {

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

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

+ if (result) {

+ return result;

+ }

+ }

+ return boost::shared_ptr<T>();

+ }

+

+ template<typename T>

+ boost::shared_ptr<T> getTransport() const {

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

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

+ if (result) {

+ return result;

+ }

+ }

+ return boost::shared_ptr<T>();

+ }

+

+ private:

+ Creator creator;

+ std::string name;

+ //Senders senders;

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

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

+ };

+ class SWIFTEN_API JingleDescription : public Payload {

+ public:

+ typedef boost::shared_ptr<JingleDescription> ref;

+ };

+ class SWIFTEN_API JingleFileTransferDescription : public JingleDescription {

+ public:

+ typedef boost::shared_ptr<JingleFileTransferDescription> ref;

+ void setFileInfo(const JingleFileTransferFileInfo& fileInfo) {

+ fileInfo_ = fileInfo;

+ }

+ const JingleFileTransferFileInfo& getFileInfo() {

+ return fileInfo_;

+ }

+ private:

+ JingleFileTransferFileInfo fileInfo_;

+ };

+ /**

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

+ */

+ class SWIFTEN_API JingleFileTransferFileInfo : public Payload {

+ typedef boost::shared_ptr<JingleFileTransferFileInfo> ref;

+

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

+ name_(name), description_(description), size_(size), date_(date), supportsRangeRequests_(false), rangeOffset_(0) {

+ }

+

+ public:

+ typedef std::map<std::string, ByteArray> HashElementMap;

+

+ public:

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

+ name_ = name;;

+ }

+

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

+ return name_;

+ }

+

+ void setDescription(const std::string& description) {

+ description_ = description;

+ }

+

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

+ return description_;

+ }

+

+ void setMediaType(const std::string& mediaType) {

+ mediaType_ = mediaType;

+ }

+

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

+ return mediaType_;

+ }

+

+ void setSize(const boost::uintmax_t size) {

+ size_ = size;

+ }

+

+ boost::uintmax_t getSize() const {

+ return size_;

+ }

+

+ void setDate(const boost::posix_time::ptime& date) {

+ date_ = date;

+ }

+

+ const boost::posix_time::ptime& getDate() const {

+ return date_;

+ }

+

+ void setSupportsRangeRequests(const bool supportsIt) {

+ supportsRangeRequests_ = supportsIt;

+ }

+

+ bool getSupportsRangeRequests() const {

+ return supportsRangeRequests_;

+ }

+

+ void setRangeOffset(const boost::uintmax_t offset) {

+ supportsRangeRequests_ = true;

+ rangeOffset_ = offset;

+ }

+

+ boost::uintmax_t getRangeOffset() const {

+ return rangeOffset_;

+ }

+

+ void addHash(const HashElement& hash) {

+ hashes_[hash.getAlgorithm()] = hash.getHashValue();

+ }

+

+ const std::map<std::string, ByteArray>& getHashes() const {

+ return hashes_;

+ }

+

+ boost::optional<ByteArray> getHash(const std::string& algorithm) const {

+ boost::optional<ByteArray> ret;

+ if (hashes_.find(algorithm) != hashes_.end()) {

+ ret = boost::optional<ByteArray>(hashes_.find(algorithm)->second);

+ }

+ return ret;

+ }

+

+ private:

+ std::string name_;

+ std::string description_;

+ std::string mediaType_;

+ boost::uintmax_t size_;

+ boost::posix_time::ptime date_;

+ bool supportsRangeRequests_;

+ boost::uintmax_t rangeOffset_;

+ HashElementMap hashes_;

+ };

+ typedef boost::shared_ptr<JingleFileTransferHash> ref;

+ void setFileInfo(const JingleFileTransferFileInfo& fileInfo) {

+ fileInfo_ = fileInfo;

+ }

+ JingleFileTransferFileInfo& getFileInfo() {

+ return fileInfo_;

+ }

+ JingleFileTransferFileInfo fileInfo_;

+

+ class SWIFTEN_API JingleIBBTransportPayload : public JingleTransportPayload {

+ public:

+ typedef boost::shared_ptr<JingleIBBTransportPayload> ref;

+

+ enum StanzaType {

+ IQStanza,

+ MessageStanza

+ };

+

+ JingleIBBTransportPayload() : stanzaType(IQStanza) {

+ }

+

+ void setStanzaType(StanzaType stanzaType) {

+ this->stanzaType = stanzaType;

+ }

+

+ StanzaType getStanzaType() const {

+ return stanzaType;

+ }

+

+ boost::optional<unsigned int> getBlockSize() const {

+ return blockSize;

+ }

+

+ void setBlockSize(unsigned int blockSize) {

+ this->blockSize = blockSize;

+ }

+

+ private:

+ boost::optional<unsigned int> blockSize;

+ StanzaType stanzaType;

+ };

+ class SWIFTEN_API JinglePayload : public Payload {

+ public:

+ typedef boost::shared_ptr<JinglePayload> ref;

+ struct Reason : public Payload {

+ enum Type {

+ UnknownType,

+ AlternativeSession,

+ Busy,

+ Cancel,

+ ConnectivityError,

+ Decline,

+ Expired,

+ FailedApplication,

+ FailedTransport,

+ GeneralError,

+ Gone,

+ IncompatibleParameters,

+ MediaError,

+ SecurityError,

+ Success,

+ Timeout,

+ UnsupportedApplications,

+ UnsupportedTransports

+ };

+ Reason() : type(UnknownType), text("") {}

+ Reason(Type type, const std::string& text = "") : type(type), text(text) {}

+ Type type;

+ std::string text;

+ };

+

+ enum Action {

+ UnknownAction,

+ ContentAccept,

+ ContentAdd,

+ ContentModify,

+ ContentReject,

+ ContentRemove,

+ DescriptionInfo,

+ SecurityInfo,

+ SessionAccept,

+ SessionInfo,

+ SessionInitiate,

+ SessionTerminate,

+ TransportAccept,

+ TransportInfo,

+ TransportReject,

+ TransportReplace

+ };

+ JinglePayload() : action(SessionTerminate), sessionID("") {

+ }

+

+ JinglePayload(Action action, const std::string& sessionID) : action(action), sessionID(sessionID) {

+

+ }

+

+ void setAction(Action action) {

+ this->action = action;

+ }

+

+ Action getAction() const {

+ return action;

+ }

+

+ void setInitiator(const JID& initiator) {

+ this->initiator = initiator;

+ }

+

+ const JID& getInitiator() const {

+ return initiator;

+ }

+

+ void setResponder(const JID& responder) {

+ this->responder = responder;

+ }

+

+ const JID& getResponder() const {

+ return responder;

+ }

+

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

+ sessionID = id;

+ }

+

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

+ return sessionID;

+ }

+

+ void addContent(JingleContentPayload::ref content) {

+ this->payloads.push_back(content);

+ }

+

+ void addPayload(boost::shared_ptr<Payload> payload) {

+ this->payloads.push_back(payload);

+ }

+

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

+ return getPayloads<JingleContentPayload>();

+ }

+

+ const std::vector<boost::shared_ptr<Payload> > getPayloads() const {

+ return payloads;

+ }

+

+ template<typename T>

+ const std::vector<boost::shared_ptr<T> > getPayloads() const {

+ std::vector<boost::shared_ptr<T> > matched_payloads;

+ for (std::vector<boost::shared_ptr<Payload> >::const_iterator i = payloads.begin(); i != payloads.end(); ++i) {

+ boost::shared_ptr<T> result = boost::dynamic_pointer_cast<T>(*i);

+ if (result) {

+ matched_payloads.push_back(result);

+ }

+ }

+

+ return matched_payloads;

+

+ }

+

+ template<typename T>

+ const boost::shared_ptr<T> getPayload() const {

+ boost::shared_ptr<T> result;

+ for (std::vector<boost::shared_ptr<Payload> >::const_iterator i = payloads.begin(); i != payloads.end(); ++i) {

+ result = boost::dynamic_pointer_cast<T>(*i);

+ if (result) {

+ return result;

+ }

+ }

+

+ return result;

+ }

+

+ void setReason(const Reason& reason) {

+ this->reason = reason;

+ }

+

+ const boost::optional<Reason>& getReason() const {

+ return reason;

+ }

+

+ private:

+ Action action;

+ JID initiator;

+ JID responder;

+ std::string sessionID;

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

+ boost::optional<Reason> reason;

+ };

+ class SWIFTEN_API JingleS5BTransportPayload : public JingleTransportPayload {

+ public:

+ enum Mode {

+ TCPMode, // default case

+ UDPMode

+ };

+

+ struct Candidate {

+ enum Type {

+ DirectType, // default case

+ AssistedType,

+ TunnelType,

+ ProxyType

+ };

+

+ Candidate() : priority(0), type(DirectType) {}

+

+ std::string cid;

+ JID jid;

+ HostAddressPort hostPort;

+ int priority;

+ Type type;

+ };

+

+ struct CompareCandidate {

+ bool operator() (const JingleS5BTransportPayload::Candidate& c1, const JingleS5BTransportPayload::Candidate& c2) const {

+ if (c1.priority < c2.priority) return true;

+ return false;

+ }

+ };

+

+ public:

+ JingleS5BTransportPayload() : mode(TCPMode), candidateError(false), proxyError(false) {}

+

+ Mode getMode() const {

+ return mode;

+ }

+

+ void setMode(Mode mode) {

+ this->mode = mode;

+ }

+

+ const std::vector<Candidate>& getCandidates() const {

+ return candidates;

+ }

+

+ void addCandidate(const Candidate& candidate) {

+ candidates.push_back(candidate);

+ }

+

+ void setCandidateUsed(const std::string& cid) {

+ candidateUsedCID = cid;

+ }

+

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

+ return candidateUsedCID;

+ }

+

+ void setActivated(const std::string& cid) {

+ activatedCID = cid;

+ }

+

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

+ return activatedCID;

+ }

+

+ void setDstAddr(const std::string& addr) {

+ dstAddr = addr;

+ }

+

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

+ return dstAddr;

+ }

+

+ void setCandidateError(bool hasError) {

+ candidateError = hasError;

+ }

+

+ bool hasCandidateError() const {

+ return candidateError;

+ }

+

+ void setProxyError(bool hasError) {

+ proxyError = hasError;

+ }

+

+ bool hasProxyError() const {

+ return proxyError;

+ }

+ public:

+ typedef boost::shared_ptr<JingleS5BTransportPayload> ref;

+

+ private:

+ Mode mode;

+ std::vector<Candidate> candidates;

+

+ std::string candidateUsedCID;

+ std::string activatedCID;

+ std::string dstAddr;

+ bool candidateError;

+ bool proxyError;

+ };

+ class SWIFTEN_API JingleTransportPayload : public Payload {

+ public:

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

+ sessionID = id;

+ }

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

+ return sessionID;

+ }

+ public:

+ typedef boost::shared_ptr<JingleTransportPayload> ref;

+ private:

+ std::string sessionID;

+ };

+ class SWIFTEN_API Last : public Payload {

+ public:

+ Last(int seconds = 0) : seconds_(seconds) {}

+ int getSeconds() const {return seconds_;}

+ void setSeconds(int seconds) {seconds_ = seconds;}

+ private:

+ int seconds_;

+ };

+ class SWIFTEN_API MAMFin : public Payload {

+ public:

+ MAMFin() : isComplete_(false), isStable_(true) {}

+ virtual ~MAMFin();

+

+ void setComplete(const bool isComplete) {

+ isComplete_ = isComplete;

+ }

+

+ bool isComplete() const {

+ return isComplete_;

+ }

+

+ void setStable(const bool isStable) {

+ isStable_ = isStable;

+ }

+

+ bool isStable() const {

+ return isStable_;

+ }

+

+ void setResultSet(boost::shared_ptr<ResultSet> resultSet) {

+ resultSet_ = resultSet;

+ }

+

+ boost::shared_ptr<ResultSet> getResultSet() const {

+ return resultSet_;

+ }

+

+ void setQueryID(const std::string& queryID) {

+ queryID_ = queryID;

+ }

+

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

+ return queryID_;

+ }

+

+

+ private:

+ bool isComplete_;

+ bool isStable_;

+ boost::shared_ptr<ResultSet> resultSet_;

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

+ };

+ class SWIFTEN_API MAMQuery : public Payload {

+ public:

+ virtual ~MAMQuery();

+ void setQueryID(const boost::optional<std::string>& queryID) { queryID_ = queryID; }

+ const boost::optional<std::string>& getQueryID() const { return queryID_; }

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

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

+ void setForm(boost::shared_ptr<Form> form) { form_ = form; }

+ const boost::shared_ptr<Form>& getForm() const { return form_; }

+ void setResultSet(boost::shared_ptr<ResultSet> resultSet) { resultSet_ = resultSet; }

+ const boost::shared_ptr<ResultSet>& getResultSet() const { return resultSet_; }

+ private:

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

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

+ boost::shared_ptr<Form> form_;

+ boost::shared_ptr<ResultSet> resultSet_;

+ };

+ class SWIFTEN_API MAMResult : public ContainerPayload<Forwarded> {

+ public:

+ virtual ~MAMResult();

+ void setID(const std::string& id) { id_ = id; }

+ const std::string& getID() const { return id_; }

+ void setQueryID(const boost::optional<std::string>& queryID) { queryID_ = queryID; }

+ const boost::optional<std::string>& getQueryID() const { return queryID_; }

+ private:

+ std::string id_;

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

+ };

+ class SWIFTEN_API MUCAdminPayload : public Payload {

+ public:

+ typedef boost::shared_ptr<MUCAdminPayload> ref;

+ MUCAdminPayload() {

+ }

+ void addItem(const MUCItem& item) {items_.push_back(item);}

+ const std::vector<MUCItem>& getItems() const {return items_;}

+ private:

+ std::vector<MUCItem> items_;

+ };

+ class SWIFTEN_API MUCDestroyPayload : public Payload {

+ public:

+ typedef boost::shared_ptr<MUCDestroyPayload> ref;

+ MUCDestroyPayload() {

+ }

+ void setNewVenue(const JID& jid) {

+ newVenue_ = jid;

+ }

+ const JID& getNewVenue() const {

+ return newVenue_;

+ }

+ void setReason(const std::string& reason) {

+ reason_ = reason;

+ }

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

+ return reason_;

+ }

+ private:

+ JID newVenue_;

+ std::string reason_;

+ };

+ class SWIFTEN_API MUCInvitationPayload : public Payload {

+ public:

+ typedef boost::shared_ptr<MUCInvitationPayload> ref;

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

+ }

+

+ void setIsContinuation(bool b) {

+ continuation_ = b;

+ }

+

+ bool getIsContinuation() const {

+ return continuation_;

+ }

+

+ void setIsImpromptu(bool b) {

+ impromptu_ = b;

+ }

+

+ bool getIsImpromptu() const {

+ return impromptu_;

+ }

+

+ void setJID(const JID& jid) {

+ jid_ = jid;

+ }

+

+ const JID& getJID() const {

+ return jid_;

+ }

+

+ void setPassword(const std::string& password) {

+ password_ = password;

+ }

+

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

+ return password_;

+ }

+

+ void setReason(const std::string& text) {

+ reason_ = text;

+ }

+

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

+ return reason_;

+ }

+

+ void setThread(const std::string& thread) {

+ thread_ = thread;

+ }

+

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

+ return thread_;

+ }

+

+ private:

+ bool continuation_;

+ bool impromptu_;

+ JID jid_;

+ std::string password_;

+ std::string reason_;

+ std::string thread_;

+ };

+ MUCItem() {}

+ boost::optional<JID> realJID;

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

+ boost::optional<MUCOccupant::Affiliation> affiliation;

+ boost::optional<MUCOccupant::Role> role;

+ boost::optional<JID> actor;

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

+ return nick_;

+ return role_;

+ return affiliation_;

+ realJID_ = realJID;

+ nick_ = nick;

+ return realJID_;

+ class Client;

+

+ class SWIFTEN_API MUCOccupant {

+ public:

+ enum Role {Moderator, Participant, Visitor, NoRole};

+ enum Affiliation {Owner, Admin, Member, Outcast, NoAffiliation};

+

+ MUCOccupant(const std::string &nick, Role role, Affiliation affiliation);

+ MUCOccupant(const MUCOccupant& other);

+ ~MUCOccupant();

+

+ std::string getNick() const;

+ Role getRole() const;

+ Affiliation getAffiliation() const;

+ boost::optional<JID> getRealJID() const;

+ void setRealJID(const JID& jid);

+ void setNick(const std::string& nick);

+

+ private:

+ std::string nick_;

+ Role role_;

+ Affiliation affiliation_;

+ boost::optional<JID> realJID_;

+ /* If you add a field, remember to update the const copy constructor */

+ };

+ class SWIFTEN_API MUCOwnerPayload : public Payload {

+ public:

+ typedef boost::shared_ptr<MUCOwnerPayload> ref;

+ MUCOwnerPayload() {

+ }

+ boost::shared_ptr<Payload> getPayload() const {

+ return payload;

+ }

+ void setPayload(boost::shared_ptr<Payload> p) {

+ payload = p;

+ }

+ Form::ref getForm() {

+ return boost::dynamic_pointer_cast<Form>(payload);

+ }

+ private:

+ boost::shared_ptr<Payload> payload;

+ };

+ class SWIFTEN_API MUCPayload : public Payload {

+ public:

+ typedef boost::shared_ptr<MUCPayload> ref;

+

+ MUCPayload() {

+ maxChars_ = -1;

+ maxStanzas_ = -1;

+ seconds_ = -1;

+ }

+

+ void setMaxChars(int maxChars) {

+ maxChars_ = maxChars;

+ }

+

+ void setMaxStanzas(int maxStanzas) {

+ maxStanzas_ = maxStanzas;

+ }

+

+ void setSeconds(int seconds) {

+ seconds_ = seconds;

+ }

+

+ void setSince(boost::posix_time::ptime since) {

+ since_ = since;

+ }

+

+ void setPassword(const std::string& password) {

+ password_ = password;

+ }

+

+ int getMaxChars() const{

+ return maxChars_;

+ }

+

+ int getMaxStanzas() const{

+ return maxStanzas_;

+ }

+

+ int getSeconds() const {

+ return seconds_;

+ }

+

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

+ return password_;

+ }

+

+ const boost::posix_time::ptime& getSince() const {

+ return since_;

+ }

+

+ private:

+ int maxChars_;

+ int maxStanzas_;

+ int seconds_;

+ boost::posix_time::ptime since_;

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

+ };