+#include <Swift/Controllers/Roster/ContactRosterItem.h>

+ chatWindow_->onOccupantSelectionChanged.connect(boost::bind(&MUCController::handleWindowOccupantSelectionChanged, this, _1));

+ chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));

+void MUCController::handleWindowOccupantSelectionChanged(ContactRosterItem* item) {

+ std::vector<ChatWindow::OccupantAction> actions;

+ //FIXME

+ if (item) {

+ actions.push_back(ChatWindow::Kick);

+ }

+ chatWindow_->setAvailableOccupantActions(actions);

+}

+

+void MUCController::handleActionRequestedOnOccupant(ChatWindow::OccupantAction action, ContactRosterItem* item) {

+ switch (action) {

+ case ChatWindow::Kick: muc_->kickUser(item->getJID());break;

+ }

+}

+

+#include <Swift/Controllers/Roster/RosterItem.h>

+#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

+ void handleWindowOccupantSelectionChanged(ContactRosterItem* item);

+ void handleActionRequestedOnOccupant(ChatWindow::OccupantAction, ContactRosterItem* item);

+ class RosterItem;

+ class ContactRosterItem;

+ enum OccupantAction {Kick};

+ /**

+ * Actions that can be performed on the selected occupant.

+ */

+ virtual void setAvailableOccupantActions(const std::vector<OccupantAction>& actions) = 0;

+ boost::signal<void (ContactRosterItem*)> onOccupantSelectionChanged;

+ boost::signal<void (ChatWindow::OccupantAction, ContactRosterItem*)> onOccupantActionSelected;

+ void setAvailableOccupantActions(const std::vector<OccupantAction>& actions) {}

+#include "Swift/Controllers/Roster/RosterItem.h"

+#include "Swift/Controllers/Roster/ContactRosterItem.h"

+#include "Roster/QtOccupantListWidget.h"

+ treeWidget_ = new QtOccupantListWidget(eventStream_, this);

+ treeWidget_->onSomethingSelectedChanged.connect(boost::bind(&QtChatWindow::handleOccupantSelectionChanged, this, _1));

+ treeWidget_->onOccupantActionSelected.connect(boost::bind(boost::ref(onOccupantActionSelected), _1, _2));

+void QtChatWindow::handleOccupantSelectionChanged(RosterItem* item) {

+ onOccupantSelectionChanged(dynamic_cast<ContactRosterItem*>(item));

+}

+void QtChatWindow::setAvailableOccupantActions(const std::vector<OccupantAction>& actions) {

+ treeWidget_->setAvailableOccupantActions(actions);

+}

+

+ class QtOccupantListWidget;

+ virtual void setAvailableOccupantActions(const std::vector<OccupantAction>& actions);

+ void handleOccupantSelectionChanged(RosterItem* item);

+ QtOccupantListWidget* treeWidget_;

+ treeWidget_ = new QtRosterWidget(uiEventStream_, this);

+ treeWidget_->onSomethingSelectedChanged.connect(boost::bind(&QAction::setEnabled, editUserAction_, _1));

+#include <QAction>

+void QtOccupantListWidget::setAvailableOccupantActions(const std::vector<ChatWindow::OccupantAction>& actions) {

+ availableOccupantActions_ = actions;

+}

+

+ QModelIndex index = indexAt(event->pos());

+ if (!index.isValid()) {

+ return;

+ }

+ RosterItem* item = static_cast<RosterItem*>(index.internalPointer());

+ ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);

+ if (contact) {

+ QMenu contextMenu;

+ std::map<QAction*, ChatWindow::OccupantAction> actions;

+ foreach (ChatWindow::OccupantAction availableAction, availableOccupantActions_) {

+ QString text = "Error: missing string";

+ switch (availableAction) {

+ case ChatWindow::Kick: text = tr("Kick user"); break;

+ }

+ QAction* action = contextMenu.addAction(text);

+ actions[action] = availableAction;

+ }

+ QAction* result = contextMenu.exec(event->globalPos());

+ if (result) {

+ onOccupantActionSelected(actions[result], contact);

+ }

+ }

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

+#include "Swift/Controllers/UIInterfaces/ChatWindow.h"

+

+ void setAvailableOccupantActions(const std::vector<ChatWindow::OccupantAction>& actions);

+ boost::signal<void (ChatWindow::OccupantAction, ContactRosterItem*)> onOccupantActionSelected;

+ private:

+ std::vector<ChatWindow::OccupantAction> availableOccupantActions_;

+void QtTreeWidget::currentChanged(const QModelIndex& current, const QModelIndex& previous) {

+ RosterItem* item = NULL;

+ QModelIndexList selectedIndexList = getSelectedIndexes();

+ if (selectedIndexList.empty() || !selectedIndexList[0].isValid()) {

+ /* I didn't quite understand why using current didn't seem to work here.*/

+ }

+ else if (current.isValid()) {

+ item = static_cast<RosterItem*>(current.internalPointer());

+ item = dynamic_cast<ContactRosterItem*>(item);

+ }

+ onSomethingSelectedChanged(item);

+ QTreeView::currentChanged(current, previous);

+}

+

+

+ boost::signal<void (RosterItem*)> onSomethingSelectedChanged;

+ protected slots:

+ virtual void currentChanged(const QModelIndex& current, const QModelIndex& previous);

+/*

+ * Copyright (c) 2010 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <boost/optional.hpp>

+#include <boost/shared_ptr.hpp>

+#include <string>

+#include <vector>

+

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

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

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

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

+

+namespace Swift {

+ class MUCAdminPayload : public Payload {

+ public:

+ typedef boost::shared_ptr<MUCAdminPayload> ref;

+

+

+ MUCAdminPayload() {

+ }

+

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

+

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

+

+ private:

+ std::vector<MUCItem> items_;

+ };

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

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

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

+namespace Swift {

+struct MUCItem {

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

+};

+}

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

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

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

+ std::vector<MUCItem> items_;

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

+ role = mucPayload->getItems()[0].role ? mucPayload->getItems()[0].role.get() : MUCOccupant::NoRole;

+ affiliation = mucPayload->getItems()[0].affiliation ? mucPayload->getItems()[0].affiliation.get() : MUCOccupant::NoAffiliation;

+void MUC::kickUser(const JID& jid) {

+ MUCAdminPayload::ref mucPayload = boost::make_shared<MUCAdminPayload>();

+ MUCItem item;

+ item.role = MUCOccupant::NoRole;

+ item.nick = jid.getResource();

+ mucPayload->addItem(item);

+ GenericRequest<MUCAdminPayload>* request = new GenericRequest<MUCAdminPayload>(IQ::Set, getJID(), mucPayload, iqRouter_);

+ request->onResponse.connect(boost::bind(&MUC::handleKickResponse, this, _1, _2, jid));

+ request->send();

+}

+

+void MUC::handleKickResponse(MUCAdminPayload::ref /*unused*/, ErrorPayload::ref error, const JID& jid) {

+ if (error) {

+ onKickFailed(error, jid);

+ }

+}

+

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

+ void kickUser(const JID& jid);

+ boost::signal<void (ErrorPayload::ref, const JID&)> onKickFailed;

+ void handleKickResponse(MUCAdminPayload::ref, ErrorPayload::ref, const JID&);

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/Parser/GenericPayloadTreeParser.h>

+

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <deque>

+

+#include <boost/shared_ptr.hpp>

+#include <boost/smart_ptr/make_shared.hpp>

+

+#include <Swiften/Parser/GenericPayloadParser.h>

+#include <Swiften/Parser/Tree/ParserElement.h>

+#include <Swiften/Parser/Tree/NullParserElement.h>

+

+#include <iostream>

+

+namespace Swift {

+

+

+ /**

+ * Generic parser offering something a bit like a DOM to work with.

+ */

+ template<typename PAYLOAD_TYPE>

+ class GenericPayloadTreeParser : public GenericPayloadParser<PAYLOAD_TYPE> {

+ public:

+ virtual void handleStartElement(const std::string& element, const std::string& xmlns, const AttributeMap& attributes) {

+ //std::cerr << element << ", " << xmlns << ", " << attributes.getEntries().size();

+ if (!root_) {

+ root_ = boost::make_shared<ParserElement>(element, xmlns, attributes);

+ elementStack_.push_back(root_);

+ } else {

+ ParserElement::ref current = *elementStack_.rbegin();

+ elementStack_.push_back(current->addChild(element, xmlns, attributes));

+ }

+ }

+

+ virtual void handleEndElement(const std::string& /*element*/, const std::string&) {

+ elementStack_.pop_back();

+ if (elementStack_.empty()) {

+ handleTree(root_);

+ }

+ }

+

+ virtual void handleCharacterData(const std::string& data) {

+ ParserElement::ref current = *elementStack_.rbegin();

+ current->appendCharacterData(data);

+ }

+

+ virtual void handleTree(ParserElement::ref root) = 0;

+

+ private:

+ std::deque<ParserElement::ref> elementStack_;

+ ParserElement::ref root_;

+ };

+}

+#include <Swiften/Parser/PayloadParsers/MUCAdminPayloadParser.h>

+ factories_.push_back(shared_ptr<PayloadParserFactory>(new GenericPayloadParserFactory<MUCAdminPayloadParser>("query", "http://jabber.org/protocol/muc#admin")));

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/Parser/PayloadParsers/MUCAdminPayloadParser.h>

+

+#include <boost/lexical_cast.hpp>

+

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

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

+

+namespace Swift {

+

+void MUCAdminPayloadParser::handleTree(ParserElement::ref root) {

+ foreach (ParserElement::ref itemElement, root->getChildren("item", "http://jabber.org/protocol/muc#admin")) {

+ MUCItem item = MUCItemParser::itemFromTree(itemElement);

+ getPayloadInternal()->addItem(item);

+ }

+}

+

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <boost/optional.hpp>

+

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

+#include <Swiften/Parser/GenericPayloadTreeParser.h>

+#include <Swiften/Parser/PayloadParsers/MUCItemParser.h>

+

+namespace Swift {

+ class MUCAdminPayloadParser : public GenericPayloadTreeParser<MUCAdminPayload> {

+ public:

+ virtual void handleTree(ParserElement::ref root);

+ };

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/Parser/PayloadParsers/MUCItemParser.h>

+

+#include <boost/lexical_cast.hpp>

+

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

+

+#include <cassert>

+#include <iostream>

+

+namespace Swift {

+

+MUCItem MUCItemParser::itemFromTree(ParserElement::ref root) {

+ MUCItem item;

+ std::string affiliation = root->getAttributes().getAttribute("affiliation");

+ std::string role = root->getAttributes().getAttribute("role");

+ std::string nick = root->getAttributes().getAttribute("nick");

+ std::string jid = root->getAttributes().getAttribute("jid");

+ item.affiliation = parseAffiliation(affiliation);

+ item.role = parseRole(role);

+ if (!jid.empty()) {

+ item.realJID = JID(jid);

+ }

+ if (!nick.empty()) {

+ item.nick = nick;

+ }

+ std::string xmlns = root->getNamespace();

+ std::string reason = root->getChild("reason", xmlns)->getText();

+ std::string actor = root->getChild("actor", xmlns)->getAttributes().getAttribute("jid");

+ if (!reason.empty()) {

+ item.reason = reason;

+ }

+ if (!actor.empty()) {

+ item.actor = JID(actor);

+ }

+

+ return item;

+}

+

+boost::optional<MUCOccupant::Role> MUCItemParser::parseRole(const std::string& roleString) {

+ if (roleString == "moderator") {

+ return MUCOccupant::Moderator;

+ }

+ if (roleString == "participant") {

+ return MUCOccupant::Participant;

+ }

+ if (roleString == "visitor") {

+ return MUCOccupant::Visitor;

+ }

+ if (roleString == "none") {

+ return MUCOccupant::NoRole;

+ }

+ return boost::optional<MUCOccupant::Role>();

+}

+

+boost::optional<MUCOccupant::Affiliation> MUCItemParser::parseAffiliation(const std::string& affiliationString) {

+ if (affiliationString == "owner") {

+ return MUCOccupant::Owner;

+ }

+ if (affiliationString == "admin") {

+ return MUCOccupant::Admin;

+ }

+ if (affiliationString == "member") {

+ return MUCOccupant::Member;

+ }

+ if (affiliationString == "outcast") {

+ return MUCOccupant::Outcast;

+ }

+ if (affiliationString == "none") {

+ return MUCOccupant::NoAffiliation;

+ }

+ return boost::optional<MUCOccupant::Affiliation>();

+}

+

+}

+

+

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

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

+#include <Swiften/Parser/GenericPayloadTreeParser.h>

+

+namespace Swift {

+ class MUCItemParser {

+ public:

+ static MUCItem itemFromTree(ParserElement::ref root);

+ private:

+ static boost::optional<MUCOccupant::Role> parseRole(const std::string& itemString);

+ static boost::optional<MUCOccupant::Affiliation> parseAffiliation(const std::string& statusString);

+ };

+}

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

+void MUCUserPayloadParser::handleTree(ParserElement::ref root) {

+ foreach (ParserElement::ref itemElement, root->getChildren("item", "http://jabber.org/protocol/muc#user")) {

+ MUCItem item = MUCItemParser::itemFromTree(itemElement);

+ getPayloadInternal()->addItem(item);

+ }

+ foreach (ParserElement::ref statusElement, root->getChildren("item", "http://jabber.org/protocol/muc#user")) {

+ MUCUserPayload::StatusCode status;

+ try {

+ status.code = boost::lexical_cast<int>(statusElement->getAttributes().getAttribute("code").c_str());

+ getPayloadInternal()->addStatusCode(status);

+ } catch (boost::bad_lexical_cast&) {

+#include <Swiften/Parser/GenericPayloadTreeParser.h>

+#include <Swiften/Parser/PayloadParsers/MUCItemParser.h>

+ class MUCUserPayloadParser : public GenericPayloadTreeParser<MUCUserPayload> {

+ virtual void handleTree(ParserElement::ref root);

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <Swiften/Parser/PayloadParsers/MUCAdminPayloadParser.h>

+#include <Swiften/Parser/PayloadParsers/UnitTest/PayloadsParserTester.h>

+

+using namespace Swift;

+

+class MUCAdminPayloadParserTest : public CppUnit::TestFixture

+{

+ CPPUNIT_TEST_SUITE(MUCAdminPayloadParserTest);

+ CPPUNIT_TEST(testParse);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ MUCAdminPayloadParserTest() {}

+

+ void testParse() {

+ PayloadsParserTester parser;

+

+ CPPUNIT_ASSERT(parser.parse("<query xmlns=\"http://jabber.org/protocol/muc#admin\"><item affiliation=\"owner\" role=\"visitor\"><actor jid=\"kev@tester.lit\"/><reason>malice</reason></item></query>"));

+

+ MUCAdminPayload::ref payload = boost::dynamic_pointer_cast<MUCAdminPayload>(parser.getPayload());

+ MUCItem item = payload->getItems()[0];

+ CPPUNIT_ASSERT_EQUAL(MUCOccupant::Owner, item.affiliation.get());

+ CPPUNIT_ASSERT_EQUAL(MUCOccupant::Visitor, item.role.get());

+ CPPUNIT_ASSERT_EQUAL(JID("kev@tester.lit"), item.actor.get());

+ CPPUNIT_ASSERT_EQUAL(std::string("malice"), item.reason.get());

+ }

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(MUCAdminPayloadParserTest);

+

+

+

+ "GenericPayloadTreeParser.cpp",

+ "PayloadParsers/MUCAdminPayloadParser.cpp",

+ "PayloadParsers/MUCItemParser.cpp",

+ "Tree/ParserElement.cpp",

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <string>

+#include <Swiften/Parser/Tree/ParserElement.h>

+

+namespace Swift {

+

+ class NullParserElement : public ParserElement {

+ public:

+ NullParserElement() : ParserElement("", "", AttributeMap()) {}

+ virtual operator bool() {return false;};

+ };

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+

+#include <Swiften/Parser/Tree/ParserElement.h>

+#include <Swiften/Parser/Tree/NullParserElement.h>

+

+#include <iostream>

+

+namespace Swift{

+

+ParserElement::ParserElement(const std::string& name, const std::string& xmlns, const AttributeMap& attributes) : name_(name), xmlns_(xmlns), attributes_(attributes) {

+

+}

+

+ParserElement::~ParserElement() {

+

+}

+

+ParserElement::operator bool() {

+ return true;

+}

+

+ParserElement::ref ParserElement::addChild(const std::string& name, const std::string& xmlns, const AttributeMap& attributes) {

+ ParserElement::ref child = boost::make_shared<ParserElement>(name, xmlns, attributes);

+ children_.push_back(child);

+ return child;

+}

+

+void ParserElement::appendCharacterData(const std::string& data) {

+ text_ += data;

+}

+

+std::string ParserElement::getText() {

+ return text_;

+}

+

+std::string ParserElement::getName() {

+ return name_;

+}

+

+std::string ParserElement::getNamespace() {

+ return xmlns_;

+}

+

+struct DoesntMatch {

+ public:

+ DoesntMatch(const std::string& tagName, const std::string& ns) : tagName(tagName), ns(ns) {}

+ bool operator()(ParserElement::ref element) { return element->getName() != tagName || element->getNamespace() != ns; }

+ private:

+ std::string tagName;

+ std::string ns;

+};

+

+

+std::vector<ParserElement::ref> ParserElement::getChildren(const std::string& name, const std::string& xmlns) {

+ std::vector<ParserElement::ref> result;

+ std::remove_copy_if(children_.begin(), children_.end(), std::back_inserter(result), DoesntMatch(name, xmlns));

+ return result;

+}

+

+ParserElement::ref ParserElement::getChild(const std::string& name, const std::string& xmlns) {

+ std::vector<ParserElement::ref> results = getChildren(name, xmlns);

+ boost::shared_ptr<NullParserElement> nullParser = boost::make_shared<NullParserElement>();

+ ParserElement::ref result = results.empty() ? boost::dynamic_pointer_cast<ParserElement>(nullParser) : results[0];

+ return result;

+}

+

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+

+#pragma once

+

+#include <string>

+#include <vector>

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

+#include <Swiften/Parser/AttributeMap.h>

+#include <boost/shared_ptr.hpp>

+#include <boost/smart_ptr/make_shared.hpp>

+

+namespace Swift {

+class ParserElement {

+ public:

+ typedef boost::shared_ptr<ParserElement> ref;

+ ParserElement(const std::string& name, const std::string& xmlns, const AttributeMap& attributes);

+ virtual ~ParserElement();

+ virtual operator bool();

+ ParserElement::ref addChild(const std::string& name, const std::string& xmlns, const AttributeMap& attributes);

+ void appendCharacterData(const std::string& data);

+ std::string getText();

+ std::string getName();

+ std::string getNamespace();

+ std::vector<ParserElement::ref> getChildren(const std::string& name, const std::string& xmlns);

+ ParserElement::ref getChild(const std::string& name, const std::string& xmlns);

+ const AttributeMap& getAttributes() const {return attributes_;}

+ private:

+ std::vector<ParserElement::ref> children_;

+ std::string name_;

+ std::string xmlns_;

+ AttributeMap attributes_;

+ std::string text_;

+

+};

+

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <Swiften/Parser/GenericPayloadTreeParser.h>

+#include <Swiften/Parser/PayloadParsers/UnitTest/PayloadParserTester.h>

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

+

+using namespace Swift;

+

+class GenericPayloadTreeParserTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(GenericPayloadTreeParserTest);

+ CPPUNIT_TEST(testTree);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testTree() {

+ MyParser testling;

+

+ std::string data = "<topLevel xmlns='urn:test:top'><firstLevelInheritedEmpty/><firstLevelInherited><secondLevelMultiChildren num='1'/><secondLevelMultiChildren num='2'/></firstLevelInherited><firstLevelNS xmlns='urn:test:first'/></topLevel>";

+

+ PayloadParserTester tester(&testling);

+ tester.parse(data);

+

+ ParserElement::ref tree = testling.tree;

+

+ CPPUNIT_ASSERT_EQUAL(std::string("topLevel"), tree->getName());

+ CPPUNIT_ASSERT_EQUAL(std::string("urn:test:top"), tree->getNamespace());

+ CPPUNIT_ASSERT(tree->getChild("firstLevelInheritedEmpty", "urn:test:top"));

+ CPPUNIT_ASSERT(!*tree->getChild("firstLevelInheritedEmpty", ""));

+ CPPUNIT_ASSERT(tree->getChild("firstLevelInherited", "urn:test:top"));

+ CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(2), tree->getChild("firstLevelInherited", "urn:test:top")->getChildren("secondLevelMultiChildren", "urn:test:top").size());

+ CPPUNIT_ASSERT_EQUAL(std::string("1"), tree->getChild("firstLevelInherited", "urn:test:top")->getChildren("secondLevelMultiChildren", "urn:test:top")[0]->getAttributes().getAttribute("num"));

+ CPPUNIT_ASSERT_EQUAL(std::string("2"), tree->getChild("firstLevelInherited", "urn:test:top")->getChildren("secondLevelMultiChildren", "urn:test:top")[1]->getAttributes().getAttribute("num"));

+ CPPUNIT_ASSERT(tree->getChild("firstLevelNS", "urn:test:first"));

+ }

+

+ private:

+

+

+ class MyParser : public GenericPayloadTreeParser<RawXMLPayload>

+ {

+ public:

+ virtual ~MyParser() {}

+ virtual void handleTree(ParserElement::ref root) {

+ tree = root;

+ }

+ ParserElement::ref tree;

+ };

+

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(GenericPayloadTreeParserTest);

+ "Serializer/PayloadSerializers/MUCAdminPayloadSerializer.cpp",

+ File("Parser/PayloadParsers/UnitTest/MUCAdminPayloadParserTest.cpp"),

+ File("Parser/UnitTest/GenericPayloadTreeParserTest.cpp"),

+ File("Serializer/PayloadSerializers/UnitTest/MUCAdminPayloadSerializerTest.cpp"),

+#include <Swiften/Serializer/PayloadSerializers/MUCAdminPayloadSerializer.h>

+ serializers_.push_back(new MUCAdminPayloadSerializer());

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swiften/Serializer/PayloadSerializers/MUCAdminPayloadSerializer.h>

+

+#include <sstream>

+

+#include <boost/shared_ptr.hpp>

+#include <boost/smart_ptr/make_shared.hpp>

+

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

+#include <Swiften/Serializer/XML/XMLElement.h>

+#include <Swiften/Serializer/XML/XMLTextNode.h>

+#include <Swiften/Serializer/PayloadSerializers/MUCItemSerializer.h>

+

+

+namespace Swift {

+

+MUCAdminPayloadSerializer::MUCAdminPayloadSerializer() : GenericPayloadSerializer<MUCAdminPayload>() {

+}

+

+std::string MUCAdminPayloadSerializer::serializePayload(boost::shared_ptr<MUCAdminPayload> payload) const {

+ XMLElement mucElement("query", "http://jabber.org/protocol/muc#admin");

+ foreach (const MUCItem item, payload->getItems()) {

+ mucElement.addNode(MUCItemSerializer::itemToElement(item));

+ }

+ return mucElement.serialize();

+}

+

+

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

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

+

+namespace Swift {

+ class MUCAdminPayloadSerializer : public GenericPayloadSerializer<MUCAdminPayload> {

+ public:

+ MUCAdminPayloadSerializer();

+ std::string affiliationToString(MUCOccupant::Affiliation affiliation) const;

+ std::string roleToString(MUCOccupant::Role role) const;

+

+ virtual std::string serializePayload(boost::shared_ptr<MUCAdminPayload> version) const;

+ };

+}

+

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <Swiften/Serializer/GenericPayloadSerializer.h>

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

+#include <boost/smart_ptr/make_shared.hpp>

+

+namespace Swift {

+ class MUCItemSerializer {

+ public:

+ static std::string affiliationToString(MUCOccupant::Affiliation affiliation) {

+ std::string result;

+ switch (affiliation) {

+ case MUCOccupant::Owner: result = "owner"; break;

+ case MUCOccupant::Admin: result = "admin"; break;

+ case MUCOccupant::Member: result = "member"; break;

+ case MUCOccupant::Outcast: result = "outcast"; break;

+ case MUCOccupant::NoAffiliation: result = "none"; break;

+ default: assert(false);

+ }

+ return result;

+ }

+

+ static std::string roleToString(MUCOccupant::Role role) {

+ std::string result;

+ switch (role) {

+ case MUCOccupant::Moderator: result = "moderator"; break;

+ case MUCOccupant::NoRole: result = "none"; break;

+ case MUCOccupant::Participant: result = "participant"; break;

+ case MUCOccupant::Visitor: result = "visitor"; break;

+ default: assert(false);

+ }

+ return result;

+

+ }

+

+ static boost::shared_ptr<XMLElement> itemToElement(const MUCItem& item) {

+ boost::shared_ptr<XMLElement> itemElement(new XMLElement("item"));

+ if (item.affiliation) {

+ itemElement->setAttribute("affiliation", affiliationToString(item.affiliation.get()));

+ }

+ if (item.role) {

+ itemElement->setAttribute("role", roleToString(item.role.get()));

+ }

+ if (item.realJID) {

+ itemElement->setAttribute("jid", item.realJID.get());

+ }

+ if (item.nick) {

+ itemElement->setAttribute("nick", item.nick.get());

+ }

+ if (item.actor) {

+ boost::shared_ptr<XMLElement> actorElement(new XMLElement("actor"));

+ actorElement->setAttribute("jid", item.actor->toString());

+ itemElement->addNode(actorElement);

+ }

+ if (item.reason) {

+ boost::shared_ptr<XMLElement> reasonElement(new XMLElement("reason"));

+ reasonElement->addNode(boost::make_shared<XMLTextNode>(*item.reason));

+ itemElement->addNode(reasonElement);

+ }

+ return itemElement;

+ }

+ };

+}

+#include <Swiften/Serializer/PayloadSerializers/MUCItemSerializer.h>

+ foreach (const MUCItem item, payload->getItems()) {

+ mucElement.addNode(MUCItemSerializer::itemToElement(item));

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <boost/smart_ptr/make_shared.hpp>

+

+#include <Swiften/Serializer/PayloadSerializers/MUCAdminPayloadSerializer.h>

+

+using namespace Swift;

+

+class MUCAdminPayloadSerializerTest : public CppUnit::TestFixture

+{

+ CPPUNIT_TEST_SUITE(MUCAdminPayloadSerializerTest);

+ CPPUNIT_TEST(testSerialize);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ MUCAdminPayloadSerializerTest() {}

+

+ void testSerialize() {

+ MUCAdminPayloadSerializer testling;

+ boost::shared_ptr<MUCAdminPayload> admin = boost::make_shared<MUCAdminPayload>();

+ MUCItem item;

+ item.affiliation = MUCOccupant::Owner;

+ item.role = MUCOccupant::Visitor;

+ item.reason = "malice";

+ item.actor = JID("kev@tester.lit");

+ admin->addItem(item);

+

+ CPPUNIT_ASSERT_EQUAL(std::string("<query xmlns=\"http://jabber.org/protocol/muc#admin\"><item affiliation=\"owner\" role=\"visitor\"><actor jid=\"kev@tester.lit\"/><reason>malice</reason></item></query>"), testling.serialize(admin));

+ }

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(MUCAdminPayloadSerializerTest);