727 lines
19 KiB
C++
727 lines
19 KiB
C++
#include "BookmarkController.h"
|
|
|
|
#include "component/view/BookmarkView.h"
|
|
|
|
#include "data/access/StorageAccess.h"
|
|
#include "data/bookmark/Bookmark.h"
|
|
|
|
#include "data/location/TokenLocation.h"
|
|
#include "data/location/TokenLocationCollection.h"
|
|
#include "data/location/TokenLocationFile.h"
|
|
|
|
#include "utility/messaging/type/MessageActivateEdge.h"
|
|
#include "utility/messaging/type/MessageActivateNodes.h"
|
|
|
|
#include "utility/logging/logging.h"
|
|
#include "utility/utilityString.h"
|
|
|
|
#include "data/bookmark/EdgeBookmark.h"
|
|
#include "data/bookmark/NodeBookmark.h"
|
|
|
|
const std::string BookmarkController::m_edgeSeperatorToken = "=>";
|
|
|
|
BookmarkController::BookmarkController(StorageAccess* storageAccess)
|
|
: m_storageAccess(storageAccess)
|
|
, m_activeTokens()
|
|
, m_activeTokenNames()
|
|
, m_activeTokenDisplayNames()
|
|
, m_activeTokenTypes()
|
|
, m_activeEdges()
|
|
, m_activeEdgeNames()
|
|
, m_activeEdgeDisplayNames()
|
|
, m_activeEdgeTypes()
|
|
, m_activeTokenExists(false)
|
|
{
|
|
}
|
|
|
|
BookmarkController::~BookmarkController()
|
|
{
|
|
}
|
|
|
|
void BookmarkController::clear()
|
|
{
|
|
}
|
|
|
|
std::vector<std::shared_ptr<Bookmark>> BookmarkController::getAllBookmarks() const
|
|
{
|
|
LOG_INFO_STREAM(<< "Retrieving all bookmarks");
|
|
|
|
std::vector<std::shared_ptr<Bookmark>> bookmarks;
|
|
|
|
std::vector<NodeBookmark> nodeBookmarks = m_storageAccess->getAllNodeBookmarks();
|
|
|
|
for (unsigned int i = 0; i < nodeBookmarks.size(); i++)
|
|
{
|
|
bookmarks.push_back(std::make_shared<NodeBookmark>(nodeBookmarks[i]));
|
|
}
|
|
|
|
std::vector<EdgeBookmark> edgeBookmarks = m_storageAccess->getAllEdgeBookmarks();
|
|
|
|
for (unsigned int i = 0; i < edgeBookmarks.size(); i++)
|
|
{
|
|
bookmarks.push_back(std::make_shared<EdgeBookmark>(edgeBookmarks[i]));
|
|
}
|
|
|
|
// std::vector<Bookmark> bookmarks = m_storageAccess->getAllBookmarks();
|
|
|
|
// check whether bookmarks are still valid (so, no referenced tokens have been removed)
|
|
for (unsigned int i = 0; i < bookmarks.size(); i++)
|
|
{
|
|
for (unsigned int j = 0; j < bookmarks[i]->getTokenNames().size(); j++)
|
|
{
|
|
std::string name = bookmarks[i]->getTokenNames()[j];
|
|
int type = bookmarks[i]->getTokenTypes()[j];
|
|
|
|
bool exists = false;
|
|
|
|
if (dynamic_cast<EdgeBookmark*>(bookmarks[i].get()) != NULL)
|
|
{
|
|
TempEdge tmpEdge = getEdge(name, type);
|
|
|
|
exists = m_storageAccess->checkEdgeExists(tmpEdge.edgeId);
|
|
}
|
|
else
|
|
{
|
|
exists = m_storageAccess->checkNodeExistsByName(name);
|
|
}
|
|
|
|
std::vector<Id> tokenIds = bookmarks[i]->getTokenIds();
|
|
|
|
bookmarks[i]->setValid(exists);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
return bookmarks;
|
|
}
|
|
|
|
std::vector<std::shared_ptr<Bookmark>> BookmarkController::getBookmarks(const MessageDisplayBookmarks::BookmarkFilter& filter, const MessageDisplayBookmarks::BookmarkOrder& order) const
|
|
{
|
|
LOG_INFO_STREAM(<< "Retrieving bookmarks with filter '" << std::to_string(filter) << "' and order '" << std::to_string(order) << "'");
|
|
|
|
std::vector<std::shared_ptr<Bookmark>> bookmarks = getAllBookmarks();
|
|
|
|
int bookmarkCount = bookmarks.size();
|
|
bookmarks = getFilteredBookmarks(bookmarks, filter);
|
|
|
|
bookmarkCount = bookmarks.size();
|
|
bookmarks = getOrderedBookmarks(bookmarks, order);
|
|
|
|
return bookmarks;
|
|
}
|
|
|
|
std::vector<std::string> BookmarkController::getActiveTokenNames() const
|
|
{
|
|
return m_activeTokenNames;
|
|
}
|
|
|
|
std::vector<std::string> BookmarkController::getActiveTokenDisplayNames() const
|
|
{
|
|
if (m_activeEdgeDisplayNames.size() > 0)
|
|
{
|
|
return m_activeEdgeDisplayNames;
|
|
}
|
|
else
|
|
{
|
|
return m_activeTokenDisplayNames;
|
|
}
|
|
}
|
|
|
|
std::vector<BookmarkCategory> BookmarkController::getAllBookmarkCategories() const
|
|
{
|
|
return m_storageAccess->getAllBookmarkCategories();
|
|
}
|
|
|
|
bool BookmarkController::activeTokenExists() const
|
|
{
|
|
return m_activeTokenExists;
|
|
}
|
|
|
|
std::shared_ptr<Bookmark> BookmarkController::getBookmarkForActiveToken() const
|
|
{
|
|
if (m_activeEdgeNames.size() > 0)
|
|
{
|
|
std::vector<EdgeBookmark> bookmarks = m_storageAccess->getAllEdgeBookmarks();
|
|
|
|
for (unsigned int i = 0; i < bookmarks.size(); i++)
|
|
{
|
|
if (bookmarks[i].getTokenNames() == m_activeEdgeNames)
|
|
{
|
|
return std::make_shared<EdgeBookmark>(bookmarks[i]);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::vector<NodeBookmark> bookmarks = m_storageAccess->getAllNodeBookmarks();
|
|
|
|
for (unsigned int i = 0; i < bookmarks.size(); i++)
|
|
{
|
|
if (bookmarks[i].getTokenNames() == m_activeTokenNames)
|
|
{
|
|
return std::make_shared<NodeBookmark>(bookmarks[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void BookmarkController::handleMessage(MessageActivateBookmark* message)
|
|
{
|
|
LOG_INFO_STREAM(<< "Attempting to activate Bookmark");
|
|
|
|
if (dynamic_cast<EdgeBookmark*>(message->bookmark.get()) != NULL)
|
|
{
|
|
EdgeBookmark* bookmark = dynamic_cast<EdgeBookmark*>(message->bookmark.get());
|
|
|
|
NodeBookmark baseBookmark = bookmark->getBaseBookmark();
|
|
|
|
MessageActivateNodes activateNodes;
|
|
|
|
for (unsigned int i = 0; i < baseBookmark.getTokenNames().size(); i++)
|
|
{
|
|
NameHierarchy nh = NameHierarchy::deserialize(baseBookmark.getTokenNames()[i]);
|
|
activateNodes.addNode(0, nh);
|
|
}
|
|
|
|
activateNodes.dispatch();
|
|
|
|
NameHierarchy source;
|
|
NameHierarchy target;
|
|
for (unsigned int i = 0; i < bookmark->getTokenNames().size(); i++)
|
|
{
|
|
int tokenType = bookmark->getTokenTypes()[i];
|
|
TempEdge tmpEdge = getEdge(bookmark->getTokenNames()[i], tokenType);
|
|
|
|
MessageActivateEdge activateEdge(tmpEdge.edgeId, Edge::intToType(tokenType), tmpEdge.source, tmpEdge.target);
|
|
activateEdge.dispatch();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NodeBookmark* bookmark = dynamic_cast<NodeBookmark*>(message->bookmark.get());
|
|
|
|
MessageActivateNodes activateNodes;
|
|
|
|
for (unsigned int i = 0; i < bookmark->getTokenNames().size(); i++)
|
|
{
|
|
NameHierarchy nh = NameHierarchy::deserialize(bookmark->getTokenNames()[i]);
|
|
activateNodes.addNode(0, nh);
|
|
}
|
|
|
|
activateNodes.dispatch();
|
|
}
|
|
}
|
|
|
|
void BookmarkController::handleMessage(MessageActivateTokens* message)
|
|
{
|
|
LOG_INFO_STREAM(<< "Registering new active token");
|
|
|
|
if (message->isEdge)
|
|
{
|
|
LOG_INFO_STREAM(<< "Registering new Edge");
|
|
|
|
std::vector<std::string> tokenNames;
|
|
std::vector<std::string> tokenDisplayNames;
|
|
std::vector<int> tokenTypes;
|
|
|
|
for (unsigned int i = 0; i < message->tokenIds.size(); i++)
|
|
{
|
|
StorageEdge edge = m_storageAccess->getEdgeById(message->tokenIds[i]);
|
|
|
|
int typeId = edge.type;
|
|
|
|
tokenTypes.push_back(typeId);
|
|
|
|
NameHierarchy sourceHierarchy = m_storageAccess->getNameHierarchyForNodeId(edge.sourceNodeId);
|
|
NameHierarchy targetHierarchy = m_storageAccess->getNameHierarchyForNodeId(edge.targetNodeId);
|
|
|
|
std::string sourceNode = NameHierarchy::serialize(sourceHierarchy);
|
|
std::string targetNode = NameHierarchy::serialize(targetHierarchy);
|
|
|
|
std::string tokenName = sourceNode + m_edgeSeperatorToken + targetNode;
|
|
|
|
tokenNames.push_back(tokenName);
|
|
|
|
tokenDisplayNames.push_back(sourceHierarchy.getRawName() + m_edgeSeperatorToken + targetHierarchy.getRawName());
|
|
}
|
|
|
|
m_activeEdges = message->tokenIds;
|
|
m_activeEdgeNames = tokenNames;
|
|
m_activeEdgeTypes = tokenTypes;
|
|
m_activeEdgeDisplayNames = tokenDisplayNames;
|
|
|
|
if (m_storageAccess->checkEdgeBookmarkExistsByTokens(tokenNames))
|
|
{
|
|
m_activeTokenExists = true;
|
|
getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::ALREADY_CREATED);
|
|
}
|
|
else
|
|
{
|
|
m_activeTokenExists = false;
|
|
getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG_INFO_STREAM(<< "Registering new Node");
|
|
|
|
m_activeTokens = message->tokenIds;
|
|
m_activeTokenNames = getTokenNames(m_activeTokens);
|
|
m_activeTokenTypes = getTokenTypes(m_activeTokens);
|
|
m_activeTokenDisplayNames = getTokenDisplayNames(m_activeTokens);
|
|
|
|
m_activeEdges.clear();
|
|
m_activeEdgeNames.clear();
|
|
m_activeEdgeTypes.clear();
|
|
m_activeEdgeDisplayNames.clear();
|
|
|
|
if (m_storageAccess->checkNodeBookmarkExistsByTokens(m_activeTokenNames))
|
|
{
|
|
m_activeTokenExists = true;
|
|
getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::ALREADY_CREATED);
|
|
}
|
|
else
|
|
{
|
|
m_activeTokenExists = false;
|
|
getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
|
|
}
|
|
}
|
|
}
|
|
|
|
void BookmarkController::handleMessage(MessageCreateBookmark* message)
|
|
{
|
|
LOG_INFO_STREAM(<< "Attempting to create new bookmark");
|
|
|
|
if (m_activeTokens.size() > 0)
|
|
{
|
|
if (m_activeEdges.size() > 0)
|
|
{
|
|
LOG_INFO_STREAM(<< "Creating Edge Bookmark");
|
|
|
|
std::string displayName = message->displayName;
|
|
if (displayName.size() <= 0)
|
|
{
|
|
displayName = getDisplayName(m_activeTokens[0]);
|
|
}
|
|
|
|
EdgeBookmark bookmark(displayName, m_activeTokens, m_activeTokenNames, message->comment, TimePoint::now());
|
|
|
|
bookmark.setDisplayName(message->displayName);
|
|
bookmark.setComment(message->comment);
|
|
bookmark.setTokenTypes(m_activeTokenTypes);
|
|
|
|
BookmarkCategory category;
|
|
category.setName(message->categoryName);
|
|
|
|
bookmark.setCategory(category);
|
|
|
|
bookmark.setEdgeTokenIds(m_activeEdges);
|
|
bookmark.setEdgeTokenNames(m_activeEdgeNames);
|
|
bookmark.setEdgeTokenTypes(m_activeEdgeTypes);
|
|
|
|
Id id = m_storageAccess->addEdgeBookmark(bookmark);
|
|
|
|
bookmark.setId(id);
|
|
|
|
m_activeTokenExists = true;
|
|
getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::ALREADY_CREATED);
|
|
getView<BookmarkView>()->update();
|
|
}
|
|
else
|
|
{
|
|
LOG_INFO_STREAM(<< "Creating Node Bookmark");
|
|
|
|
std::string displayName = message->displayName;
|
|
if (displayName.size() <= 0)
|
|
{
|
|
displayName = getDisplayName(m_activeTokens[0]);
|
|
}
|
|
|
|
NodeBookmark bookmark(displayName, m_activeTokens, m_activeTokenNames, message->comment, TimePoint::now());
|
|
|
|
bookmark.setTokenTypes(m_activeTokenTypes);
|
|
|
|
BookmarkCategory category;
|
|
category.setName(message->categoryName);
|
|
|
|
bookmark.setCategory(category);
|
|
|
|
Id id = m_storageAccess->addNodeBookmark(bookmark);
|
|
|
|
bookmark.setId(id);
|
|
|
|
m_activeTokenExists = true;
|
|
getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::ALREADY_CREATED);
|
|
getView<BookmarkView>()->update();
|
|
}
|
|
}
|
|
}
|
|
|
|
void BookmarkController::handleMessage(MessageCreateBookmarkCategory* message)
|
|
{
|
|
std::string categoryName = message->name;
|
|
LOG_INFO_STREAM(<< "Attempting to create new Bookmark category '" << categoryName << "'");
|
|
|
|
if (m_storageAccess->checkBookmarkCategoryExists(message->name) == false)
|
|
{
|
|
BookmarkCategory category;
|
|
category.setName(message->name);
|
|
|
|
m_storageAccess->addBookmarkCategory(category);
|
|
}
|
|
}
|
|
|
|
void BookmarkController::handleMessage(MessageDeleteBookmark* message)
|
|
{
|
|
LOG_INFO_STREAM(<< "Attempting to delete Bookmark " << std::to_string(message->bookmarkId));
|
|
|
|
if (message->isEdge)
|
|
{
|
|
m_storageAccess->removeEdgeBookmark(message->bookmarkId);
|
|
}
|
|
else
|
|
{
|
|
m_storageAccess->removeNodeBookmark(message->bookmarkId);
|
|
}
|
|
|
|
cleanBookmarkCategories();
|
|
|
|
getView<BookmarkView>()->update();
|
|
}
|
|
|
|
void BookmarkController::handleMessage(MessageDeleteBookmarkCategoryWithBookmarks* message)
|
|
{
|
|
std::vector<BookmarkCategory> categories = m_storageAccess->getAllBookmarkCategories();
|
|
|
|
for (unsigned int i = 0; i < categories.size(); i++)
|
|
{
|
|
if (categories[i].getId() == message->categoryId)
|
|
{
|
|
std::vector<NodeBookmark> nodeBookmarks = m_storageAccess->getAllNodeBookmarks();
|
|
for (unsigned int j = 0; j < nodeBookmarks.size(); j++)
|
|
{
|
|
if (nodeBookmarks[j].getCategory().getName() == categories[i].getName())
|
|
{
|
|
m_storageAccess->removeNodeBookmark(nodeBookmarks[j].getId());
|
|
}
|
|
}
|
|
|
|
std::vector<EdgeBookmark> edgeBookmarks = m_storageAccess->getAllEdgeBookmarks();
|
|
for (unsigned int j = 0; j < edgeBookmarks.size(); j++)
|
|
{
|
|
if (edgeBookmarks[j].getCategory().getName() == categories[i].getName())
|
|
{
|
|
m_storageAccess->removeEdgeBookmark(edgeBookmarks[j].getId());
|
|
}
|
|
}
|
|
|
|
cleanBookmarkCategories();
|
|
getView<BookmarkView>()->update();
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void BookmarkController::handleMessage(MessageDeleteBookmarkForActiveTokens* message)
|
|
{
|
|
std::shared_ptr<Bookmark> bookmark = getBookmarkForActiveToken();
|
|
|
|
if (bookmark != NULL)
|
|
{
|
|
LOG_INFO_STREAM(<< "Deleting bookmark " << bookmark->getDisplayName());
|
|
|
|
if (dynamic_cast<EdgeBookmark*>(bookmark.get()) != NULL)
|
|
{
|
|
m_storageAccess->removeEdgeBookmark(bookmark->getId());
|
|
}
|
|
else if(dynamic_cast<NodeBookmark*>(bookmark.get()) != NULL)
|
|
{
|
|
m_storageAccess->removeNodeBookmark(bookmark->getId());
|
|
}
|
|
|
|
cleanBookmarkCategories();
|
|
|
|
m_activeTokenExists = false;
|
|
getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
|
|
getView<BookmarkView>()->update();
|
|
}
|
|
else
|
|
{
|
|
LOG_WARNING_STREAM(<< "No Bookmark to delete for active tokens.");
|
|
}
|
|
}
|
|
|
|
void BookmarkController::handleMessage(MessageEditBookmark* message)
|
|
{
|
|
LOG_INFO_STREAM(<< "Attempting to update Bookmark " << std::to_string(message->bookmarkId));
|
|
|
|
if (message->isEdge)
|
|
{
|
|
EdgeBookmark bookmark = m_storageAccess->getEdgeBookmarkById(message->bookmarkId);
|
|
|
|
bookmark.setDisplayName(message->displayName);
|
|
bookmark.setComment(message->comment);
|
|
BookmarkCategory category;
|
|
category.setName(message->categoryName);
|
|
bookmark.setCategory(category);
|
|
|
|
m_storageAccess->editEdgeBookmark(bookmark);
|
|
}
|
|
else
|
|
{
|
|
NodeBookmark bookmark = m_storageAccess->getNodeBookmarkById(message->bookmarkId);
|
|
|
|
bookmark.setDisplayName(message->displayName);
|
|
bookmark.setComment(message->comment);
|
|
BookmarkCategory category;
|
|
category.setName(message->categoryName);
|
|
bookmark.setCategory(category);
|
|
|
|
m_storageAccess->editNodeBookmark(bookmark);
|
|
}
|
|
|
|
getView<BookmarkView>()->update();
|
|
}
|
|
|
|
void BookmarkController::handleMessage(MessageFinishedParsing* message)
|
|
{
|
|
getView<BookmarkView>()->enableDisplayBookmarks(true);
|
|
}
|
|
|
|
std::vector<std::string> BookmarkController::getTokenNames(const std::vector<Id>& ids) const
|
|
{
|
|
std::vector<std::string> names;
|
|
|
|
for (unsigned int i = 0; i < ids.size(); i++)
|
|
{
|
|
NameHierarchy nameHierarchy = m_storageAccess->getNameHierarchyForNodeId(ids[i]);
|
|
names.push_back(NameHierarchy::serialize(nameHierarchy));
|
|
}
|
|
|
|
return names;
|
|
}
|
|
|
|
std::vector<std::string> BookmarkController::getTokenDisplayNames(const std::vector<Id>& ids) const
|
|
{
|
|
std::vector<std::string> names;
|
|
|
|
for (unsigned int i = 0; i < ids.size(); i++)
|
|
{
|
|
NameHierarchy nameHierarchy = m_storageAccess->getNameHierarchyForNodeId(ids[i]);
|
|
names.push_back(nameHierarchy.getRawName());
|
|
}
|
|
|
|
return names;
|
|
}
|
|
|
|
std::vector<int> BookmarkController::getTokenTypes(const std::vector<Id>& ids) const
|
|
{
|
|
std::vector<int> types;
|
|
|
|
for (unsigned int i = 0; i < ids.size(); i++)
|
|
{
|
|
int type = m_storageAccess->getNodeTypeForNodeWithId(ids[i]);
|
|
types.push_back(type);
|
|
}
|
|
|
|
return types;
|
|
}
|
|
|
|
std::string BookmarkController::getDisplayName(Id id) const
|
|
{
|
|
NameHierarchy nameHierarchy = m_storageAccess->getNameHierarchyForNodeId(id);
|
|
return nameHierarchy.getRawName();
|
|
}
|
|
|
|
BookmarkController::TempEdge BookmarkController::getEdge(const std::string& tokenName, const int tokenType) const
|
|
{
|
|
std::pair<std::string, std::string> edgeTokens = seperateEdgeToken(tokenName);
|
|
|
|
NameHierarchy source = NameHierarchy::deserialize(edgeTokens.first);
|
|
NameHierarchy target = NameHierarchy::deserialize(edgeTokens.second);
|
|
|
|
Id edgeId = m_storageAccess->getIdForEdge(Edge::intToType(tokenType), source, target);
|
|
|
|
TempEdge result;
|
|
|
|
result.edgeId = edgeId;
|
|
result.source = source;
|
|
result.target = target;
|
|
result.type = tokenType;
|
|
|
|
return result;
|
|
}
|
|
|
|
std::pair<std::string, std::string> BookmarkController::seperateEdgeToken(const std::string& token) const
|
|
{
|
|
std::pair<std::string, std::string> result;
|
|
|
|
if (token.find(m_edgeSeperatorToken) != std::string::npos)
|
|
{
|
|
std::vector<std::string> st = utility::splitToVector(token, m_edgeSeperatorToken);
|
|
|
|
if (st.size() != 2)
|
|
{
|
|
LOG_ERROR_STREAM(<< "Invalid edge token found: " << token);
|
|
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
result.first = st[0];
|
|
result.second = st[1];
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::shared_ptr<Bookmark>> BookmarkController::getFilteredBookmarks(const std::vector<std::shared_ptr<Bookmark>>& bookmarks, const MessageDisplayBookmarks::BookmarkFilter& filter) const
|
|
{
|
|
std::vector<std::shared_ptr<Bookmark>> result;
|
|
|
|
if (filter == MessageDisplayBookmarks::BookmarkFilter::ALL)
|
|
{
|
|
return bookmarks;
|
|
}
|
|
else if (filter == MessageDisplayBookmarks::BookmarkFilter::NODES)
|
|
{
|
|
for (unsigned int i = 0; i < bookmarks.size(); i++)
|
|
{
|
|
if (dynamic_cast<EdgeBookmark*>(bookmarks[i].get()) == NULL)
|
|
{
|
|
result.push_back(bookmarks[i]);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
else if (filter == MessageDisplayBookmarks::BookmarkFilter::EDGES)
|
|
{
|
|
for (unsigned int i = 0; i < bookmarks.size(); i++)
|
|
{
|
|
if (dynamic_cast<EdgeBookmark*>(bookmarks[i].get()) != NULL)
|
|
{
|
|
result.push_back(bookmarks[i]);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::shared_ptr<Bookmark>> BookmarkController::getOrderedBookmarks(const std::vector<std::shared_ptr<Bookmark>>& bookmarks, const MessageDisplayBookmarks::BookmarkOrder& order) const
|
|
{
|
|
std::vector<std::shared_ptr<Bookmark>> result = bookmarks;
|
|
|
|
if (order == MessageDisplayBookmarks::BookmarkOrder::DATE_ASCENDING)
|
|
{
|
|
return getDateOrderedBookmarks(result, true);
|
|
}
|
|
else if (order == MessageDisplayBookmarks::BookmarkOrder::DATE_DESCENDING)
|
|
{
|
|
return getDateOrderedBookmarks(result, false);
|
|
}
|
|
else if (order == MessageDisplayBookmarks::BookmarkOrder::NAME_ASCENDING)
|
|
{
|
|
return getNameOrderedBookmarks(result, true);
|
|
}
|
|
else if (order == MessageDisplayBookmarks::BookmarkOrder::NAME_DESCENDING)
|
|
{
|
|
return getNameOrderedBookmarks(result, false);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::shared_ptr<Bookmark>> BookmarkController::getDateOrderedBookmarks(const std::vector<std::shared_ptr<Bookmark>>& bookmarks, const bool ascending) const
|
|
{
|
|
std::vector<std::shared_ptr<Bookmark>> result = bookmarks;
|
|
|
|
std::sort(result.begin(), result.end(), BookmarkController::bookmarkDateCompare);
|
|
|
|
if (ascending == false)
|
|
{
|
|
std::reverse(result.begin(), result.end());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::shared_ptr<Bookmark>> BookmarkController::getNameOrderedBookmarks(const std::vector<std::shared_ptr<Bookmark>>& bookmarks, const bool ascending) const
|
|
{
|
|
std::vector<std::shared_ptr<Bookmark>> result = bookmarks;
|
|
|
|
std::sort(result.begin(), result.end(), BookmarkController::bookmarkNameCompare);
|
|
|
|
if (ascending == false)
|
|
{
|
|
std::reverse(result.begin(), result.end());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void BookmarkController::cleanBookmarkCategories()
|
|
{
|
|
std::vector<std::shared_ptr<Bookmark>> bookmarks = getAllBookmarks();
|
|
|
|
std::vector<BookmarkCategory> categories = getAllBookmarkCategories();
|
|
|
|
for (unsigned int i = 0; i < categories.size(); i++)
|
|
{
|
|
BookmarkCategory category = categories[i];
|
|
bool used = false;
|
|
|
|
for (unsigned int j = 0; j < bookmarks.size(); j++)
|
|
{
|
|
if (bookmarks[j]->getCategory().getName() == category.getName())
|
|
{
|
|
used = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (used == false)
|
|
{
|
|
m_storageAccess->removeBookmarkCategory(category.getId());
|
|
}
|
|
}
|
|
}
|
|
|
|
bool BookmarkController::bookmarkDateCompare(const std::shared_ptr<Bookmark> a, const std::shared_ptr<Bookmark> b)
|
|
{
|
|
return a->getTimeStamp() < b->getTimeStamp();
|
|
}
|
|
|
|
bool BookmarkController::bookmarkNameCompare(const std::shared_ptr<Bookmark> a, const std::shared_ptr<Bookmark> b)
|
|
{
|
|
std::string aName = a->getDisplayName();
|
|
std::string bName = b->getDisplayName();
|
|
|
|
aName = utility::toLowerCase(aName);
|
|
bName = utility::toLowerCase(bName);
|
|
|
|
unsigned int i = 0;
|
|
while (i < aName.length() && i < bName.length())
|
|
{
|
|
if (std::tolower(aName[i]) < std::tolower(bName[i]))
|
|
{
|
|
return true;
|
|
}
|
|
else if (std::tolower(aName[i]) > std::tolower(bName[i]))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
++i;
|
|
}
|
|
|
|
return aName.length() < bName.length();
|
|
} |