From 78db15a780cc5389fc6e01d500d5c91bdd8bc422 Mon Sep 17 00:00:00 2001 From: Matthias Schiffer Date: Sat, 19 Sep 2009 18:12:26 +0200 Subject: UserListManager: Added user list diff support. --- src/modules/UserListManager/CMakeLists.txt | 2 + .../UserListDiffUploadRequestHandler.cpp | 82 ++++++++++++++++++++ .../UserListDiffUploadRequestHandler.h | 51 +++++++++++++ .../UserListRequestHandlerGroup.cpp | 44 +++++++++++ .../RequestHandlers/UserListRequestHandlerGroup.h | 4 + src/modules/UserListManager/UserListDiff.cpp | 46 +++++++++++ src/modules/UserListManager/UserListDiff.h | 88 ++++++++++++++++++++++ src/modules/UserListManager/UserListEntry.h | 4 + src/modules/UserListManager/UserListManager.cpp | 35 +++++++-- src/modules/UserListManager/UserListManager.h | 15 +++- src/modules/UserListManager/Util.cpp | 83 +++++++++++++++----- src/modules/UserListManager/Util.h | 14 ++-- 12 files changed, 436 insertions(+), 32 deletions(-) create mode 100644 src/modules/UserListManager/RequestHandlers/UserListDiffUploadRequestHandler.cpp create mode 100644 src/modules/UserListManager/RequestHandlers/UserListDiffUploadRequestHandler.h create mode 100644 src/modules/UserListManager/UserListDiff.cpp create mode 100644 src/modules/UserListManager/UserListDiff.h (limited to 'src/modules') diff --git a/src/modules/UserListManager/CMakeLists.txt b/src/modules/UserListManager/CMakeLists.txt index 0ab429f..f8e72ce 100644 --- a/src/modules/UserListManager/CMakeLists.txt +++ b/src/modules/UserListManager/CMakeLists.txt @@ -1,11 +1,13 @@ include_directories(${INCLUDES}) mad_module(UserListManager + RequestHandlers/UserListDiffUploadRequestHandler.cpp RequestHandlers/UserListDiffUploadRequestHandler.h RequestHandlers/UserListRequestHandlerGroup.cpp RequestHandlers/UserListRequestHandlerGroup.h RequestHandlers/UserListUploadRequestHandler.cpp RequestHandlers/UserListUploadRequestHandler.h Module.cpp Module.h UserList.h + UserListDiff.cpp UserListDiff.h UserListEntry.h UserListManager.cpp UserListManager.h Util.cpp Util.h diff --git a/src/modules/UserListManager/RequestHandlers/UserListDiffUploadRequestHandler.cpp b/src/modules/UserListManager/RequestHandlers/UserListDiffUploadRequestHandler.cpp new file mode 100644 index 0000000..4660850 --- /dev/null +++ b/src/modules/UserListManager/RequestHandlers/UserListDiffUploadRequestHandler.cpp @@ -0,0 +1,82 @@ +/* + * UserListDiffUploadRequestHandler.cpp + * + * Copyright (C) 2009 Matthias Schiffer + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see . + */ + +#include "UserListDiffUploadRequestHandler.h" +#include "../UserListManager.h" +#include "../Util.h" + +#include + +namespace Mad { +namespace Modules { +namespace UserListManager { +namespace RequestHandlers { + +void UserListDiffUploadRequestHandler::handlePacket(boost::shared_ptr packet) { + if(packet->getType() == "Cancel") { + Common::XmlData ret; + ret.setType("OK"); + sendPacket(ret); + + signalFinished(); + return; + } + else if(packet->getType() != "UploadUserListDiff") { + getApplication()->log(Core::Logger::LOG_ERROR, "Received an unexpected packet."); + + Common::XmlData ret; + ret.setType("Error"); + ret.set("ErrorCode", Core::Exception::UNEXPECTED_PACKET); + + sendPacket(ret); + + signalFinished(); + return; + } + + if(!getConnection()->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + if(name.empty()) { // Request + name = packet->get("name"); + + if(name.empty()) + name = boost::posix_time::to_simple_string(boost::posix_time::second_clock::universal_time()); + + Common::XmlData ret; + ret.setType("Continue"); + ret.set("exists", userListManager->existsUserListDiff(name)); + sendPacket(ret); + } + else { // Upload + boost::shared_ptr diff = Util::deserializeUserListDiff(packet.get()); + userListManager->storeUserListDiff(name, diff.get()); + + Common::XmlData ret; + ret.setType("OK"); + sendPacket(ret); + + signalFinished(); + } +} + +} +} +} +} diff --git a/src/modules/UserListManager/RequestHandlers/UserListDiffUploadRequestHandler.h b/src/modules/UserListManager/RequestHandlers/UserListDiffUploadRequestHandler.h new file mode 100644 index 0000000..205a87f --- /dev/null +++ b/src/modules/UserListManager/RequestHandlers/UserListDiffUploadRequestHandler.h @@ -0,0 +1,51 @@ +/* + * UserListDiffUploadRequestHandler.h + * + * Copyright (C) 2009 Matthias Schiffer + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see . + */ + +#ifndef MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTDIFFUPLOADREQUESTHANDLER_H_ +#define MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTDIFFUPLOADREQUESTHANDLER_H_ + +#include + +namespace Mad { +namespace Modules { +namespace UserListManager { + +class UserListManager; + +namespace RequestHandlers { + +class UserListDiffUploadRequestHandler : public Common::RequestHandler { + private: + std::string name; + + UserListManager *userListManager; + + protected: + virtual void handlePacket(boost::shared_ptr packet); + + public: + UserListDiffUploadRequestHandler(Common::Application *application, UserListManager *userListManager0) : Common::RequestHandler(application), userListManager(userListManager0) {} +}; + +} +} +} +} + +#endif /* MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTDIFFUPLOADREQUESTHANDLER_H_ */ diff --git a/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.cpp b/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.cpp index 98d2815..99d2818 100644 --- a/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.cpp +++ b/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.cpp @@ -64,11 +64,55 @@ void UserListRequestHandlerGroup::handleUserListRemoveRequest(boost::shared_ptr< ret->setType("OK"); } + +void UserListRequestHandlerGroup::handleUserListDiffListRequest(boost::shared_ptr /*packet*/, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + const std::set &userListDiffs = userListManager->getUserListDiffs(); + + ret->setType("OK"); + Common::XmlData::List *list = ret->createList("userListDiffs"); + + for(std::set::const_iterator diff = userListDiffs.begin(); diff != userListDiffs.end(); ++diff) { + Common::XmlData::List::iterator entry = list->addEntry(); + + entry->set("name", *diff); + } + +} + +void UserListRequestHandlerGroup::handleUserListDiffDownloadRequest(boost::shared_ptr packet, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + boost::shared_ptr diff = userListManager->loadUserListDiff(packet->get("name")); + if(!diff) + throw(Core::Exception(Core::Exception::NOT_FOUND)); + + ret->setType("OK"); + Util::serializeUserListDiff(diff.get(), ret); +} + +void UserListRequestHandlerGroup::handleUserListDiffRemoveRequest(boost::shared_ptr packet, Common::XmlData *ret, Common::Connection *connection) { + if(!connection->isAuthenticated()) + throw(Core::Exception(Core::Exception::PERMISSION)); + + userListManager->removeUserListDiff(packet->get("name")); + + ret->setType("OK"); +} + + UserListRequestHandlerGroup::UserListRequestHandlerGroup(Server::Application *application0, UserListManager *userListManager0) : application(application0), userListManager(userListManager0) { registerHandler("ListUserLists", boost::bind(&UserListRequestHandlerGroup::handleUserListListRequest, this, _1, _2, _3)); registerHandler("DownloadUserList", boost::bind(&UserListRequestHandlerGroup::handleUserListDownloadRequest, this, _1, _2, _3)); registerHandler("RemoveUserList", boost::bind(&UserListRequestHandlerGroup::handleUserListRemoveRequest, this, _1, _2, _3)); + + registerHandler("ListUserListDiffs", boost::bind(&UserListRequestHandlerGroup::handleUserListDiffListRequest, this, _1, _2, _3)); + registerHandler("DownloadUserListDiff", boost::bind(&UserListRequestHandlerGroup::handleUserListDiffDownloadRequest, this, _1, _2, _3)); + registerHandler("RemoveUserListDiff", boost::bind(&UserListRequestHandlerGroup::handleUserListDiffRemoveRequest, this, _1, _2, _3)); } } diff --git a/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.h b/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.h index 2aeda6b..105621b 100644 --- a/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.h +++ b/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.h @@ -46,6 +46,10 @@ class MAD_MODULE_EXPORT UserListRequestHandlerGroup : public Common::RequestHan void handleUserListDownloadRequest(boost::shared_ptr packet, Common::XmlData *ret, Common::Connection *connection); void handleUserListRemoveRequest(boost::shared_ptr packet, Common::XmlData *ret, Common::Connection *connection); + void handleUserListDiffListRequest(boost::shared_ptr packet, Common::XmlData *ret, Common::Connection *connection); + void handleUserListDiffDownloadRequest(boost::shared_ptr packet, Common::XmlData *ret, Common::Connection *connection); + void handleUserListDiffRemoveRequest(boost::shared_ptr packet, Common::XmlData *ret, Common::Connection *connection); + public: UserListRequestHandlerGroup(Server::Application *application0, UserListManager *userListManager0); }; diff --git a/src/modules/UserListManager/UserListDiff.cpp b/src/modules/UserListManager/UserListDiff.cpp new file mode 100644 index 0000000..a7b5f2f --- /dev/null +++ b/src/modules/UserListManager/UserListDiff.cpp @@ -0,0 +1,46 @@ +/* + * UserListDiff.cpp + * + * Copyright (C) 2009 Matthias Schiffer + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see . + */ + +#include "UserListDiff.h" +#include "UserList.h" + +namespace Mad { +namespace Modules { +namespace UserListManager { + +UserListDiff::UserListDiff(const UserList *oldList, const UserList *newList) { + for(UserList::const_iterator user = oldList->begin(); user != oldList->end(); ++user) + deletedUsers.insert(*user); + + for(UserList::const_iterator user = newList->begin(); user != newList->end(); ++user) { + std::set::const_iterator it = deletedUsers.find(*user); + + if(it != deletedUsers.end()) { + deletedUsers.erase(it); + unchangedUsers.insert(*user); + } + else { + addedUsers.insert(*user); + } + } +} + +} +} +} diff --git a/src/modules/UserListManager/UserListDiff.h b/src/modules/UserListManager/UserListDiff.h new file mode 100644 index 0000000..de881bd --- /dev/null +++ b/src/modules/UserListManager/UserListDiff.h @@ -0,0 +1,88 @@ +/* + * UserListDiff.h + * + * Copyright (C) 2009 Matthias Schiffer + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see . + */ + +#ifndef MAD_MODULES_USERLISTMANAGER_USERLISTDIFF_H_ +#define MAD_MODULES_USERLISTMANAGER_USERLISTDIFF_H_ + +#include "../export.h" + +#include "UserListEntry.h" +#include + +#include + +namespace Mad { +namespace Modules { +namespace UserListManager { + +class UserList; + +class MAD_MODULE_EXPORT UserListDiff { + private: + std::set addedUsers; + std::set deletedUsers; + std::set unchangedUsers; + + public: + UserListDiff() {} + UserListDiff(const UserList *oldList, const UserList *newList); + + void invert() { + addedUsers.swap(deletedUsers); + } + + const std::set& getAddedUsers() const { + return addedUsers; + } + + const std::set& getDeletedUsers() const { + return deletedUsers; + } + + const std::set& getUnchangedUsers() const { + return unchangedUsers; + } + + bool insertAddedUser(UserListEntry user) { + if(deletedUsers.count(user) || unchangedUsers.count(user)) + return false; + + return addedUsers.insert(user).second; + } + + bool insertDeletedUser(UserListEntry user) { + if(addedUsers.count(user) || unchangedUsers.count(user)) + return false; + + return deletedUsers.insert(user).second; + } + + bool insertUnchangedUser(UserListEntry user) { + if(addedUsers.count(user) || deletedUsers.count(user)) + return false; + + return unchangedUsers.insert(user).second; + } +}; + +} +} +} + +#endif /* MAD_MODULES_USERLISTMANAGER_USERLISTDIFF_H_ */ diff --git a/src/modules/UserListManager/UserListEntry.h b/src/modules/UserListManager/UserListEntry.h index 719787f..59776d6 100644 --- a/src/modules/UserListManager/UserListEntry.h +++ b/src/modules/UserListManager/UserListEntry.h @@ -80,6 +80,10 @@ class UserListEntry { void unsetDetail(const std::string &name) { details.erase(name); } + + bool operator<(const UserListEntry o) const { + return (name < o.name); + } }; } diff --git a/src/modules/UserListManager/UserListManager.cpp b/src/modules/UserListManager/UserListManager.cpp index 18ed83c..e947e24 100644 --- a/src/modules/UserListManager/UserListManager.cpp +++ b/src/modules/UserListManager/UserListManager.cpp @@ -22,6 +22,7 @@ #include "Util.h" #include "RequestHandlers/UserListRequestHandlerGroup.h" #include "RequestHandlers/UserListUploadRequestHandler.h" +#include "RequestHandlers/UserListDiffUploadRequestHandler.h" #include #include @@ -39,6 +40,7 @@ UserListManager::UserListManager(Server::Application *application0) : applicatio UserListManager::~UserListManager() { application->getRequestManager()->unregisterPacketType("UploadUserList"); + application->getRequestManager()->unregisterPacketType("UploadUserListDiff"); application->getRequestManager()->unregisterRequestHandlerGroup(requestHandlerGroup); application->getConfigManager()->unregisterConfigurable(this); } @@ -46,17 +48,13 @@ UserListManager::~UserListManager() { void UserListManager::configFinished() { userLists = application->getStorageManager()->list("UserList"); + userListDiffs = application->getStorageManager()->list("UserListDiff"); application->getRequestManager()->registerRequestHandlerGroup(requestHandlerGroup); application->getRequestManager()->registerPacketType("UploadUserList", this); + application->getRequestManager()->registerPacketType("UploadUserListDiff", this); } - -const std::set& UserListManager::getUserLists() const { - return userLists; -} - - bool UserListManager::existsUserList(const std::string &name) { return application->getStorageManager()->exists("UserList", name); } @@ -81,6 +79,31 @@ void UserListManager::removeUserList(const std::string &name) { application->getStorageManager()->remove("UserList", name); } + +bool UserListManager::existsUserListDiff(const std::string &name) { + return application->getStorageManager()->exists("UserListDiff", name); +} + +boost::shared_ptr UserListManager::loadUserListDiff(const std::string &name) { + boost::shared_ptr data = application->getStorageManager()->load("UserListDiff", name); + + if(!data) + return boost::shared_ptr(); + + return Util::deserializeUserListDiff(data.get()); +} + +void UserListManager::storeUserListDiff(const std::string &name, const UserListDiff *list) { + Common::XmlData data; + + Util::serializeUserListDiff(list, &data); + application->getStorageManager()->store("UserListDiff", name, &data); +} + +void UserListManager::removeUserListDiff(const std::string &name) { + application->getStorageManager()->remove("UserListDiff", name); +} + boost::shared_ptr UserListManager::getCurrentUserList() { boost::shared_ptr list(new UserList); diff --git a/src/modules/UserListManager/UserListManager.h b/src/modules/UserListManager/UserListManager.h index 3f806e9..6d2599b 100644 --- a/src/modules/UserListManager/UserListManager.h +++ b/src/modules/UserListManager/UserListManager.h @@ -43,6 +43,7 @@ class UserListRequestHandlerGroup; } class UserList; +class UserListDiff; class MAD_MODULE_EXPORT UserListManager : private Core::Configurable, private boost::noncopyable { private: @@ -51,6 +52,7 @@ class MAD_MODULE_EXPORT UserListManager : private Core::Configurable, private bo boost::shared_ptr requestHandlerGroup; std::set userLists; + std::set userListDiffs; protected: virtual void configFinished(); @@ -61,13 +63,24 @@ class MAD_MODULE_EXPORT UserListManager : private Core::Configurable, private bo UserListManager(Server::Application *application0); virtual ~UserListManager(); - const std::set& getUserLists() const; + const std::set& getUserLists() const { + return userLists; + } bool existsUserList(const std::string &name); boost::shared_ptr loadUserList(const std::string &name); void storeUserList(const std::string &name, const UserList *list); void removeUserList(const std::string &name); + const std::set& getUserListDiffs() const { + return userListDiffs; + } + + bool existsUserListDiff(const std::string &name); + boost::shared_ptr loadUserListDiff(const std::string &name); + void storeUserListDiff(const std::string &name, const UserListDiff *list); + void removeUserListDiff(const std::string &name); + boost::shared_ptr getCurrentUserList(); }; diff --git a/src/modules/UserListManager/Util.cpp b/src/modules/UserListManager/Util.cpp index f9b6a55..9b986d8 100644 --- a/src/modules/UserListManager/Util.cpp +++ b/src/modules/UserListManager/Util.cpp @@ -19,6 +19,7 @@ #include "Util.h" #include "UserList.h" +#include "UserListDiff.h" #include @@ -26,19 +27,34 @@ namespace Mad { namespace Modules { namespace UserListManager { -void Util::serializeUserList(const UserList *list, Common::XmlData *data) { - Common::XmlData::List *userList = data->createList("users"); +void Util::serializeUserListEntry(const UserListEntry *user, Common::XmlData::List::iterator entry) { + std::set details = user->getDetailList(); + for(std::set::iterator detail = details.begin(); detail != details.end(); ++detail) + entry->set(*detail, user->getDetail(*detail)); + + entry->set("name", user->getName()); + entry->set("group", user->getGroup()); +} - for(UserList::const_iterator user = list->begin(); user != list->end(); ++user) { - Common::XmlData::List::iterator entry = userList->addEntry(); +UserListEntry Util::deserializeUserListEntry(Common::XmlData::List::const_iterator entry) { + UserListEntry user(entry->get("name"), entry->get("group")); - std::set details = user->getDetailList(); - for(std::set::iterator detail = details.begin(); detail != details.end(); ++detail) - entry->set(*detail, user->getDetail(*detail)); + std::set details = entry->getChildren(); + for(std::set::iterator detail = details.begin(); detail != details.end(); ++detail) { + if(*detail == "user" || *detail == "group") + continue; - entry->set("name", user->getName()); - entry->set("group", user->getGroup()); + user.setDetail(*detail, entry->get(*detail)); } + + return user; +} + +void Util::serializeUserList(const UserList *list, Common::XmlData *data) { + Common::XmlData::List *userList = data->createList("users"); + + for(UserList::const_iterator user = list->begin(); user != list->end(); ++user) + serializeUserListEntry(&*user, userList->addEntry()); } boost::shared_ptr Util::deserializeUserList(const Common::XmlData *data) { @@ -47,22 +63,49 @@ boost::shared_ptr Util::deserializeUserList(const Common::XmlData *dat const Common::XmlData::List *userList = data->getList("users"); if(userList) { - for(Common::XmlData::List::const_iterator user = userList->begin(); user != userList->end(); ++user) { - UserListEntry entry(user->get("name"), user->get("group")); + for(Common::XmlData::List::const_iterator user = userList->begin(); user != userList->end(); ++user) + users->push_back(deserializeUserListEntry(user)); + } - std::set details = user->getChildren(); - for(std::set::iterator detail = details.begin(); detail != details.end(); ++detail) { - if(*detail == "user" || *detail == "group") - continue; + return users; +} - entry.setDetail(*detail, user->get(*detail)); - } +void Util::serializeUserListDiff(const UserListDiff *diff, Common::XmlData *data) { + Common::XmlData::List *userList = data->createList("addedUsers"); + for(std::set::const_iterator user = diff->getAddedUsers().begin(); user != diff->getAddedUsers().end(); ++user) + serializeUserListEntry(&*user, userList->addEntry()); - users->push_back(entry); - } + userList = data->createList("deletedUsers"); + for(std::set::const_iterator user = diff->getDeletedUsers().begin(); user != diff->getDeletedUsers().end(); ++user) + serializeUserListEntry(&*user, userList->addEntry()); + + userList = data->createList("unchangedUsers"); + for(std::set::const_iterator user = diff->getUnchangedUsers().begin(); user != diff->getUnchangedUsers().end(); ++user) + serializeUserListEntry(&*user, userList->addEntry()); +} + +boost::shared_ptr Util::deserializeUserListDiff(const Common::XmlData *data) { + boost::shared_ptr diff(new UserListDiff); + + const Common::XmlData::List *userList = data->getList("addedUsers"); + if(userList) { + for(Common::XmlData::List::const_iterator user = userList->begin(); user != userList->end(); ++user) + diff->insertAddedUser(deserializeUserListEntry(user)); } - return users; + userList = data->getList("deletedUsers"); + if(userList) { + for(Common::XmlData::List::const_iterator user = userList->begin(); user != userList->end(); ++user) + diff->insertDeletedUser(deserializeUserListEntry(user)); + } + + userList = data->getList("unchangedUsers"); + if(userList) { + for(Common::XmlData::List::const_iterator user = userList->begin(); user != userList->end(); ++user) + diff->insertUnchangedUser(deserializeUserListEntry(user)); + } + + return diff; } } diff --git a/src/modules/UserListManager/Util.h b/src/modules/UserListManager/Util.h index 6af35cc..c9b9a2c 100644 --- a/src/modules/UserListManager/Util.h +++ b/src/modules/UserListManager/Util.h @@ -22,26 +22,30 @@ #include "../export.h" +#include #include namespace Mad { - -namespace Common { -class XmlData; -} - namespace Modules { namespace UserListManager { class UserList; +class UserListDiff; +class UserListEntry; class MAD_MODULE_EXPORT Util { private: + static void serializeUserListEntry(const UserListEntry *user, Common::XmlData::List::iterator entry); + static UserListEntry deserializeUserListEntry(Common::XmlData::List::const_iterator entry); + Util(); public: static void serializeUserList(const UserList *list, Common::XmlData *data); static boost::shared_ptr deserializeUserList(const Common::XmlData *data); + + static void serializeUserListDiff(const UserListDiff *diff, Common::XmlData *data); + static boost::shared_ptr deserializeUserListDiff(const Common::XmlData *data); }; } -- cgit v1.2.3