+ MessageFolder::filterFolders() method converted to function and removed from the header.
+ Replace MessageUtils::folderToJson() with MessageFolder::toJSON() method.
+ Replace all MessageFolder attributes with single picojson object.
+ Move folder-related methods and types from messaging_util to message_folder module.
+ Replace jsonToFolder() method with MessageFolder(picojson::value) constructor.
[Verification] tct-messaging-*-tizen-tests 100% pass.
Signed-off-by: Michal Michalski <m.michalski2@partner.samsung.com>
Change-Id: I08143e5fa65978a6979b4a9a1753cfba8adaa3ed
EventFolders* eventFolder = new EventFolders();
eventFolder->service_type = MessageType::EMAIL;
eventFolder->service_id = account_id;
- FolderPtr folder;
+ std::shared_ptr<MessageFolder> folder;
if (event == NOTI_MAILBOX_DELETE) {
// this event is triggered after mailbox is removed
// so we just create folder with id
const char* FOLDERSUPDATED = "foldersupdated";
const char* FOLDERSREMOVED = "foldersremoved";
+namespace {
+
+FolderPtrVector filterFolders(tizen::AbstractFilterPtr filter,
+ const FolderPtrVector& source_folders) {
+ ScopeLogger();
+
+ if (!filter) {
+ LoggerW("Filer is null.");
+ return source_folders;
+ }
+
+ FolderPtrVector filtered_folders;
+ FolderPtrVector::const_iterator it = source_folders.begin();
+ FolderPtrVector::const_iterator end_it = source_folders.end();
+
+ for (int i = 0; it != end_it; ++i, ++it) {
+ const FolderPtr& folder = *it;
+ const bool matched = filter->isMatching(folder.get());
+ if (matched) {
+ filtered_folders.push_back(folder);
+ }
+
+ LoggerD("[%d] folder id:%s", i, folder->getId().c_str());
+ LoggerD("[%d] folder name:%s", i, folder->getName().c_str());
+ LoggerD("[%d] matched filter: %s", i, matched ? "YES" : "NO");
+ }
+
+ return filtered_folders;
+}
+
+} // namespace
+
FoldersChangeCallback::FoldersChangeCallback(int service_id, MessageType service_type,
MessagingInstance& instance)
: m_id(service_id), m_msg_type(service_type), m_is_act(true), m_messaging_instance(instance) {
ScopeLogger();
}
-FolderPtrVector FoldersChangeCallback::filterFolders(tizen::AbstractFilterPtr filter,
- const FolderPtrVector& source_folders) {
- ScopeLogger();
- if (filter) {
- LoggerD("filter pointer is valid");
- FolderPtrVector filtered_folders;
- FolderPtrVector::const_iterator it = source_folders.begin();
- FolderPtrVector::const_iterator end_it = source_folders.end();
-
- for (int i = 0; it != end_it; ++i, ++it) {
- const FolderPtr& folder = *it;
- const bool matched = filter->isMatching(folder.get());
- if (matched) {
- filtered_folders.push_back(folder);
- }
-
- LoggerD("[%d] folder id:%s", i, folder->getId().c_str());
- LoggerD("[%d] folder name:%s", i, folder->getName().c_str());
- LoggerD("[%d] matched filter: %s", i, matched ? "YES" : "NO");
- }
-
- return filtered_folders;
- } else {
- return source_folders;
- }
-}
-
void FoldersChangeCallback::Handler(const FolderPtrVector& folders, const char* action) {
ScopeLogger("action: %s, folders.size() = %zu", action, folders.size());
if (!m_is_act) {
}
picojson::array array;
- auto each = [&array](std::shared_ptr<MessageFolder> f) -> void {
- array.push_back(MessagingUtil::folderToJson(f));
- };
+ auto each = [&array](std::shared_ptr<MessageFolder> f) -> void { array.push_back(f->toJSON()); };
for_each(filtered.begin(), filtered.end(), each);
LoggerD("Calling:%s with:%zu added folders", action, filtered.size());
MessageType getServiceType() const;
private:
- static FolderPtrVector filterFolders(tizen::AbstractFilterPtr filter,
- const FolderPtrVector& source_folders);
-
tizen::AbstractFilterPtr m_filter;
int m_id;
MessageType m_msg_type;
using namespace tizen;
-MessageFolder::MessageFolder(std::string id, std::string parent_id, std::string service_id,
- std::string content_type, std::string name, std::string path,
- MessageFolderType type, bool synchronizable)
- : m_id(id),
- m_parent_id(parent_id),
- m_parent_id_set(true),
- m_service_id(service_id),
- m_content_type(content_type),
- m_name(name),
- m_path(path),
- m_type(type),
- m_synchronizable(synchronizable) {
+namespace {
+const std::string FOLDER_TYPE_INBOX = "INBOX";
+const std::string FOLDER_TYPE_OUTBOX = "OUTBOX";
+const std::string FOLDER_TYPE_DRAFTS = "DRAFTS";
+const std::string FOLDER_TYPE_SENTBOX = "SENTBOX";
+
+MessageFolderType convertPlatformFolderType(email_mailbox_type_e folderType) {
+ ScopeLogger();
+ switch (folderType) {
+ case email_mailbox_type_e::EMAIL_MAILBOX_TYPE_INBOX:
+ return MessageFolderType::MESSAGE_FOLDER_TYPE_INBOX;
+ case email_mailbox_type_e::EMAIL_MAILBOX_TYPE_SENTBOX:
+ return MessageFolderType::MESSAGE_FOLDER_TYPE_SENTBOX;
+ case email_mailbox_type_e::EMAIL_MAILBOX_TYPE_DRAFT:
+ return MessageFolderType::MESSAGE_FOLDER_TYPE_DRAFTS;
+ case email_mailbox_type_e::EMAIL_MAILBOX_TYPE_OUTBOX:
+ return MessageFolderType::MESSAGE_FOLDER_TYPE_OUTBOX;
+ case email_mailbox_type_e::EMAIL_MAILBOX_TYPE_ALL_EMAILS:
+ return MessageFolderType::MESSAGE_FOLDER_TYPE_NOTSTANDARD;
+ default:
+ return MessageFolderType::MESSAGE_FOLDER_TYPE_NOTSTANDARD;
+ }
+}
+} // namespace
+
+std::string messageFolderTypeToString(MessageFolderType type) {
ScopeLogger();
+ switch (type) {
+ case MessageFolderType::MESSAGE_FOLDER_TYPE_INBOX:
+ return FOLDER_TYPE_INBOX;
+ case MessageFolderType::MESSAGE_FOLDER_TYPE_OUTBOX:
+ return FOLDER_TYPE_OUTBOX;
+ case MessageFolderType::MESSAGE_FOLDER_TYPE_DRAFTS:
+ return FOLDER_TYPE_DRAFTS;
+ case MessageFolderType::MESSAGE_FOLDER_TYPE_SENTBOX:
+ return FOLDER_TYPE_SENTBOX;
+ default:
+ return "";
+ }
}
-MessageFolder::MessageFolder(email_mailbox_t mailbox) {
+MessageFolderType stringToMessageFolderType(const std::string& type) {
ScopeLogger();
- m_id = std::to_string(mailbox.mailbox_id);
- m_parent_id_set = false;
- m_service_id = std::to_string(mailbox.account_id);
- m_content_type = MessagingUtil::messageTypeToString(EMAIL);
- m_name = mailbox.alias;
- m_path = mailbox.mailbox_name;
- m_type = convertPlatformFolderType(mailbox.mailbox_type);
- if (0 == mailbox.local) {
- m_synchronizable = true;
- } else {
- m_synchronizable = false;
+ if (FOLDER_TYPE_INBOX == type) {
+ return MessageFolderType::MESSAGE_FOLDER_TYPE_INBOX;
+ }
+ if (FOLDER_TYPE_OUTBOX == type) {
+ return MessageFolderType::MESSAGE_FOLDER_TYPE_OUTBOX;
}
+ if (FOLDER_TYPE_DRAFTS == type) {
+ return MessageFolderType::MESSAGE_FOLDER_TYPE_DRAFTS;
+ }
+ if (FOLDER_TYPE_SENTBOX == type) {
+ return MessageFolderType::MESSAGE_FOLDER_TYPE_SENTBOX;
+ }
+ return MessageFolderType::MESSAGE_FOLDER_TYPE_NOTSTANDARD;
+}
+
+MessageFolder::MessageFolder(const std::string& id, const std::string& parent_id,
+ const std::string& service_id, const std::string& content_type,
+ const std::string& name, const std::string& path,
+ MessageFolderType type, bool synchronizable) {
+ ScopeLogger();
+ attributes["id"] = picojson::value(id);
+ attributes["parentId"] = picojson::value(parent_id);
+ attributes["serviceId"] = picojson::value(service_id);
+ attributes["contentType"] = picojson::value(content_type);
+ attributes["name"] = picojson::value(name);
+ attributes["path"] = picojson::value(path);
+ attributes["type"] = picojson::value(static_cast<double>(type));
+ attributes["synchronizable"] = picojson::value(synchronizable);
+}
+
+MessageFolder::MessageFolder(email_mailbox_t mailbox)
+ : MessageFolder(std::to_string(mailbox.mailbox_id), "", std::to_string(mailbox.account_id),
+ MessagingUtil::messageTypeToString(EMAIL), mailbox.alias, mailbox.mailbox_name,
+ convertPlatformFolderType(mailbox.mailbox_type), mailbox.local == 0) {
+ ScopeLogger("from email_mailbox_t");
+}
+
+MessageFolder::MessageFolder(const picojson::value& json) {
+ ScopeLogger("from json");
+ attributes = json.get<picojson::object>();
}
std::string MessageFolder::getId() const {
- return m_id;
+ return attributes.at("id").get<std::string>();
}
std::string MessageFolder::getParentId() const {
- return m_parent_id;
+ return attributes.at("parentId").get<std::string>();
}
bool MessageFolder::isParentIdSet() const {
- return m_parent_id_set;
+ return attributes.at("parentId").is<std::string>() &&
+ not attributes.at("parentId").get<std::string>().empty();
}
void MessageFolder::setParentId(const std::string& parentId) {
- m_parent_id = parentId;
- m_parent_id_set = true;
+ attributes["parentId"] = picojson::value(parentId);
}
std::string MessageFolder::getServiceId() const {
- return m_service_id;
+ return attributes.at("serviceId").get<std::string>();
}
std::string MessageFolder::getContentType() const {
- return m_content_type;
+ return attributes.at("contentType").get<std::string>();
}
std::string MessageFolder::getName() const {
- return m_name;
+ return attributes.at("name").get<std::string>();
+}
+
+void MessageFolder::setName(const std::string& value) {
+ attributes["name"] = picojson::value(value);
}
std::string MessageFolder::getPath() const {
- return m_path;
+ return attributes.at("path").get<std::string>();
}
MessageFolderType MessageFolder::getType() const {
- return m_type;
+ return static_cast<MessageFolderType>(static_cast<int>(attributes.at("type").get<double>()));
}
bool MessageFolder::getSynchronizable() const {
- return m_synchronizable;
-}
-
-void MessageFolder::setName(const std::string& value) {
- m_name = value;
+ return attributes.at("synchronizable").get<bool>();
}
void MessageFolder::setSynchronizable(const bool& value) {
- m_synchronizable = value;
+ attributes.at("synchronizable") = picojson::value(value);
}
-MessageFolderType MessageFolder::convertPlatformFolderType(email_mailbox_type_e folderType) {
- ScopeLogger();
- switch (folderType) {
- case email_mailbox_type_e::EMAIL_MAILBOX_TYPE_INBOX:
- return MessageFolderType::MESSAGE_FOLDER_TYPE_INBOX;
- case email_mailbox_type_e::EMAIL_MAILBOX_TYPE_SENTBOX:
- return MessageFolderType::MESSAGE_FOLDER_TYPE_SENTBOX;
- case email_mailbox_type_e::EMAIL_MAILBOX_TYPE_DRAFT:
- return MessageFolderType::MESSAGE_FOLDER_TYPE_DRAFTS;
- case email_mailbox_type_e::EMAIL_MAILBOX_TYPE_OUTBOX:
- return MessageFolderType::MESSAGE_FOLDER_TYPE_OUTBOX;
- case email_mailbox_type_e::EMAIL_MAILBOX_TYPE_ALL_EMAILS:
- return MessageFolderType::MESSAGE_FOLDER_TYPE_NOTSTANDARD;
- default:
- return MessageFolderType::MESSAGE_FOLDER_TYPE_NOTSTANDARD;
- }
+picojson::value MessageFolder::toJSON() const {
+ picojson::value json(attributes);
+ json.get<picojson::object>()["type"] = picojson::value(messageFolderTypeToString(getType()));
+ return json;
}
-/**
- *
- * Attribute | Attribute filter| Attribute range filter
- * | supported | supported
- * ----------------+-----------------+------------------------
- * id | Yes | No
- * parentId | Yes | No
- * serviceId | Yes | No
- * contentType | Yes | No
- * name | Yes | No
- * path | Yes | No
- * type | Yes | No
- * synchronizable | Yes | No
- */
-
bool MessageFolder::isMatchingAttribute(const std::string& attribute_name,
const common::AttributeMatchFlag match_flag,
AnyPtr match_value) const {
common::AttributeMatchFlagToString(match_flag).c_str(), match_value->toString().c_str());
if (common::AttributeMatchFlag::kExists == match_flag) {
- return m_message_folder_filterable_attributes.find(attribute_name) !=
- m_message_folder_filterable_attributes.end();
+ return attributes.find(attribute_name) != attributes.end();
}
if (MESSAGE_FOLDER_ATTRIBUTE_ID == attribute_name) {
} else if (MESSAGE_FOLDER_ATTRIBUTE_PATH == attribute_name) {
return FilterUtils::isMatching(*match_value, getPath(), match_flag);
} else if (MESSAGE_FOLDER_ATTRIBUTE_TYPE == attribute_name) {
- return FilterUtils::isMatching(*match_value,
- MessagingUtil::messageFolderTypeToString(getType()), match_flag);
+ return FilterUtils::isMatching(*match_value, messageFolderTypeToString(getType()), match_flag);
} else if (MESSAGE_FOLDER_ATTRIBUTE_SYNCHRONIZABLE == attribute_name) {
return FilterUtils::isMatching(*match_value, getSynchronizable(), match_flag);
}
return false;
}
-// clang-format off
-const std::set<std::string> MessageFolder::m_message_folder_filterable_attributes = {
- MESSAGE_FOLDER_ATTRIBUTE_ID,
- MESSAGE_FOLDER_ATTRIBUTE_PARENT_ID,
- MESSAGE_FOLDER_ATTRIBUTE_SERVICE_ID,
- MESSAGE_FOLDER_ATTRIBUTE_CONTENT_TYPE,
- MESSAGE_FOLDER_ATTRIBUTE_NAME,
- MESSAGE_FOLDER_ATTRIBUTE_PATH,
- MESSAGE_FOLDER_ATTRIBUTE_TYPE,
- MESSAGE_FOLDER_ATTRIBUTE_SYNCHRONIZABLE};
-// clang-format on
-
} // messaging
} // extension
MESSAGE_FOLDER_TYPE_NOTSTANDARD
};
-class MessageFolder;
-
-struct MessageFolderHolder {
- std::shared_ptr<MessageFolder> ptr;
-};
-
-typedef std::shared_ptr<MessageFolder> FolderPtr;
-
-typedef std::vector<FolderPtr> FolderPtrVector;
-
class MessageFolder : public tizen::FilterableObject {
public:
- MessageFolder(std::string id, std::string parent_id, std::string service_id,
- std::string content_type, std::string name, std::string path,
+ MessageFolder(const std::string& id, const std::string& parent_id, const std::string& service_id,
+ const std::string& content_type, const std::string& name, const std::string& path,
MessageFolderType type, bool synchronizable);
+
MessageFolder(email_mailbox_t mailbox);
+ MessageFolder(const picojson::value& json);
std::string getId() const;
std::string getParentId() const;
MessageFolderType getType() const;
bool getSynchronizable() const;
void setSynchronizable(const bool& value);
+ picojson::value toJSON() const;
- // tizen::FilterableObject
virtual bool isMatchingAttribute(const std::string& attribute_name,
const common::AttributeMatchFlag match_flag,
- tizen::AnyPtr match_value) const;
-
+ tizen::AnyPtr match_value) const override;
virtual bool isMatchingAttributeRange(const std::string& attribute_name,
- tizen::AnyPtr initial_value, tizen::AnyPtr end_value) const;
+ tizen::AnyPtr initial_value,
+ tizen::AnyPtr end_value) const override;
private:
- MessageFolderType convertPlatformFolderType(email_mailbox_type_e folderType);
+ picojson::object attributes;
+};
- std::string m_id;
- std::string m_parent_id;
- bool m_parent_id_set;
- std::string m_service_id;
- std::string m_content_type;
- std::string m_name;
- std::string m_path;
- MessageFolderType m_type;
- bool m_synchronizable;
+typedef std::shared_ptr<MessageFolder> FolderPtr;
+typedef std::vector<FolderPtr> FolderPtrVector;
- static const std::set<std::string> m_message_folder_filterable_attributes;
-};
+std::string messageFolderTypeToString(MessageFolderType);
+MessageFolderType stringToMessageFolderType(std::string type);
} // messaging
} // extension
auto& folders_list = json.get<picojson::array>();
for (const auto& folder : folders) {
if (params->filter->isMatching(&folder)) {
- folders_list.push_back(MessagingUtil::folderToJson(folder));
+ folders_list.push_back(folder.toJSON());
}
}
std::unique_ptr<FindFoldersTaskParams> params(static_cast<FindFoldersTaskParams*>(data));
std::string content_type = params->message_type;
- FolderPtr folder;
+ std::shared_ptr<MessageFolder> folder;
picojson::object response;
picojson::array array;
for (int i = MESSAGE_FOLDER_TYPE_INBOX; i < MESSAGE_FOLDER_TYPE_NOTSTANDARD; ++i) {
- MessageFolder folder(
- std::to_string(i), "", std::to_string(params->account_id), content_type,
- MessagingUtil::messageFolderTypeToString(static_cast<MessageFolderType>(i)), "",
- static_cast<MessageFolderType>(i), false);
+ MessageFolder folder(std::to_string(i), "", std::to_string(params->account_id), content_type,
+ messageFolderTypeToString(static_cast<MessageFolderType>(i)), "",
+ static_cast<MessageFolderType>(i), false);
if (params->filter->isMatching(&folder)) {
- array.push_back(MessagingUtil::folderToJson(folder));
+ array.push_back(folder.toJSON());
}
}
SyncFolderCallbackData* callback = new SyncFolderCallbackData(queue_, callbackId, *this);
callback->setAccountId(id);
- callback->setMessageFolder(MessagingUtil::jsonToMessageFolder(v_folder));
+ callback->setMessageFolder(std::make_shared<MessageFolder>(v_folder));
callback->setLimit(limit);
callback->AddToQueue();
const std::map<MessageType, std::string> typeToStringMap = {
{MessageType::SMS, TYPE_SMS}, {MessageType::MMS, TYPE_MMS}, {MessageType::EMAIL, TYPE_EMAIL}};
-const std::string FOLDER_TYPE_INBOX = "INBOX";
-const std::string FOLDER_TYPE_OUTBOX = "OUTBOX";
-const std::string FOLDER_TYPE_DRAFTS = "DRAFTS";
-const std::string FOLDER_TYPE_SENTBOX = "SENTBOX";
-
} // namespace
-std::string MessagingUtil::messageFolderTypeToString(MessageFolderType type) {
- ScopeLogger();
- switch (type) {
- case MessageFolderType::MESSAGE_FOLDER_TYPE_INBOX:
- return FOLDER_TYPE_INBOX;
- case MessageFolderType::MESSAGE_FOLDER_TYPE_OUTBOX:
- return FOLDER_TYPE_OUTBOX;
- case MessageFolderType::MESSAGE_FOLDER_TYPE_DRAFTS:
- return FOLDER_TYPE_DRAFTS;
- case MessageFolderType::MESSAGE_FOLDER_TYPE_SENTBOX:
- return FOLDER_TYPE_SENTBOX;
- default:
- return "";
- }
-}
-
-MessageFolderType MessagingUtil::stringToMessageFolderType(std::string type) {
- ScopeLogger();
- if (FOLDER_TYPE_INBOX == type) {
- return MessageFolderType::MESSAGE_FOLDER_TYPE_INBOX;
- }
- if (FOLDER_TYPE_OUTBOX == type) {
- return MessageFolderType::MESSAGE_FOLDER_TYPE_OUTBOX;
- }
- if (FOLDER_TYPE_DRAFTS == type) {
- return MessageFolderType::MESSAGE_FOLDER_TYPE_DRAFTS;
- }
- if (FOLDER_TYPE_SENTBOX == type) {
- return MessageFolderType::MESSAGE_FOLDER_TYPE_SENTBOX;
- }
- return MessageFolderType::MESSAGE_FOLDER_TYPE_NOTSTANDARD;
-}
-
PlatformResult MessagingUtil::stringToMessageType(const std::string& str, MessageType* out) {
ScopeLogger();
const auto it = stringToTypeMap.find(str);
return v;
}
-picojson::value MessagingUtil::folderToJson(const MessageFolder& folder) {
- ScopeLogger();
- picojson::object o;
- o[MESSAGE_FOLDER_ATTRIBUTE_ID] = picojson::value(folder.getId());
- o[MESSAGE_FOLDER_ATTRIBUTE_PARENT_ID] =
- folder.isParentIdSet() ? picojson::value(folder.getParentId()) : picojson::value();
- o[MESSAGE_FOLDER_ATTRIBUTE_SERVICE_ID] = picojson::value(folder.getServiceId());
- o[MESSAGE_FOLDER_ATTRIBUTE_CONTENT_TYPE] = picojson::value(folder.getContentType());
- o[MESSAGE_FOLDER_ATTRIBUTE_NAME] = picojson::value(folder.getName());
- o[MESSAGE_FOLDER_ATTRIBUTE_PATH] = picojson::value(folder.getPath());
- o[MESSAGE_FOLDER_ATTRIBUTE_TYPE] =
- picojson::value(MessagingUtil::messageFolderTypeToString(folder.getType()));
- o[MESSAGE_FOLDER_ATTRIBUTE_SYNCHRONIZABLE] = picojson::value(folder.getSynchronizable());
- return picojson::value(o);
-}
-
-picojson::value MessagingUtil::folderToJson(std::shared_ptr<MessageFolder> folder) {
- return folderToJson(*folder);
-}
-
PlatformResult MessagingUtil::jsonToMessage(const picojson::value& json,
std::shared_ptr<Message>* result_message,
MessagingInstance& instance) {
return body;
}
-std::shared_ptr<MessageFolder> MessagingUtil::jsonToMessageFolder(const picojson::value& json) {
- ScopeLogger();
-
- picojson::object data = json.get<picojson::object>();
-
- std::string id =
- MessagingUtil::getValueFromJSONObject<std::string>(data, MESSAGE_FOLDER_ATTRIBUTE_ID).c_str();
-
- std::string parent_id =
- MessagingUtil::getValueFromJSONObject<std::string>(data, MESSAGE_FOLDER_ATTRIBUTE_PARENT_ID)
- .c_str();
-
- std::string service_id =
- MessagingUtil::getValueFromJSONObject<std::string>(data, MESSAGE_FOLDER_ATTRIBUTE_SERVICE_ID)
- .c_str();
-
- std::string content_type = MessagingUtil::getValueFromJSONObject<std::string>(
- data, MESSAGE_FOLDER_ATTRIBUTE_CONTENT_TYPE)
- .c_str();
-
- std::string name =
- MessagingUtil::getValueFromJSONObject<std::string>(data, MESSAGE_FOLDER_ATTRIBUTE_NAME)
- .c_str();
-
- std::string path =
- MessagingUtil::getValueFromJSONObject<std::string>(data, MESSAGE_FOLDER_ATTRIBUTE_PATH)
- .c_str();
-
- std::string type_str =
- MessagingUtil::getValueFromJSONObject<std::string>(data, MESSAGE_FOLDER_ATTRIBUTE_TYPE)
- .c_str();
- MessageFolderType type = MessagingUtil::stringToMessageFolderType(type_str);
-
- bool synchronizable =
- MessagingUtil::getValueFromJSONObject<bool>(data, MESSAGE_FOLDER_ATTRIBUTE_SYNCHRONIZABLE);
-
- std::shared_ptr<MessageFolder> folder = std::shared_ptr<MessageFolder>(
- new MessageFolder(id, parent_id, service_id, content_type, name, path, type, synchronizable));
-
- return folder;
-}
-
tizen::SortModePtr MessagingUtil::jsonToSortMode(const picojson::object& json) {
ScopeLogger();
using namespace tizen;
class MessagingUtil {
public:
- static std::string messageFolderTypeToString(MessageFolderType);
- static MessageFolderType stringToMessageFolderType(std::string type);
static common::PlatformResult stringToMessageType(const std::string& str, MessageType* out);
static common::PlatformResult messageTypeToString(MessageType type, std::string* out);
static std::string messageTypeToString(MessageType type);
static picojson::value messageToJson(std::shared_ptr<Message> message);
static picojson::value messageAttachmentToJson(std::shared_ptr<MessageAttachment> attachment);
static picojson::value conversationToJson(std::shared_ptr<MessageConversation> conversation);
-
- static picojson::value folderToJson(const MessageFolder& folder);
- static picojson::value folderToJson(std::shared_ptr<MessageFolder> folder);
-
static common::PlatformResult jsonToMessage(const picojson::value& json,
std::shared_ptr<Message>* result,
MessagingInstance& instance);
static std::shared_ptr<MessageBody> jsonToMessageBody(const picojson::value& json);
- static std::shared_ptr<MessageFolder> jsonToMessageFolder(const picojson::value& json);
static tizen::SortModePtr jsonToSortMode(const picojson::object& json);
static common::PlatformResult jsonToAbstractFilter(const picojson::object& json,
tizen::AbstractFilterPtr* result);
projects / platform / core / api / webapi-plugins.git / commitdiff