139 lines
3.9 KiB
C++
139 lines
3.9 KiB
C++
#include "component/controller/helper/ActivationTranslator.h"
|
|
|
|
#include "data/access/StorageAccess.h"
|
|
#include "utility/messaging/type/MessageActivateAll.h"
|
|
#include "utility/messaging/type/MessageActivateEdge.h"
|
|
#include "utility/messaging/type/MessageActivateFile.h"
|
|
#include "utility/messaging/type/MessageActivateNodes.h"
|
|
#include "utility/messaging/type/MessageActivateTokenIds.h"
|
|
#include "utility/messaging/type/MessageActivateTokens.h"
|
|
#include "utility/messaging/type/MessageChangeFileView.h"
|
|
#include "utility/messaging/type/MessageSearch.h"
|
|
#include "utility/messaging/type/MessageShowErrors.h"
|
|
|
|
ActivationTranslator::ActivationTranslator(StorageAccess* storageAccess)
|
|
: m_storageAccess(storageAccess)
|
|
{
|
|
}
|
|
|
|
ActivationTranslator::~ActivationTranslator()
|
|
{
|
|
}
|
|
|
|
std::shared_ptr<MessageActivateTokens> ActivationTranslator::translateMessage(const MessageActivateEdge* message) const
|
|
{
|
|
std::shared_ptr<MessageActivateTokens> m;
|
|
if (message->isAggregation())
|
|
{
|
|
// TODO: validate aggregationIds
|
|
m = std::make_shared<MessageActivateTokens>(message, message->aggregationIds);
|
|
m->setKeepContent(false);
|
|
m->isAggregation = true;
|
|
}
|
|
else
|
|
{
|
|
Id edgeId = message->tokenId;
|
|
|
|
if (message->isReplayed())
|
|
{
|
|
edgeId = m_storageAccess->getIdForEdge(message->type, message->fromNameHierarchy, message->toNameHierarchy);
|
|
}
|
|
|
|
if (edgeId)
|
|
{
|
|
m = std::make_shared<MessageActivateTokens>(message, std::vector<Id>(1, edgeId));
|
|
m->isEdge = true;
|
|
}
|
|
}
|
|
return m;
|
|
}
|
|
|
|
std::shared_ptr<MessageActivateTokens> ActivationTranslator::translateMessage(const MessageActivateFile* message) const
|
|
{
|
|
Id fileId = m_storageAccess->getTokenIdForFileNode(message->filePath);
|
|
|
|
if (fileId == 0)
|
|
{
|
|
MessageChangeFileView msg(
|
|
message->filePath,
|
|
MessageChangeFileView::FILE_MAXIMIZED,
|
|
true,
|
|
false,
|
|
nullptr
|
|
);
|
|
msg.setIsReplayed(message->isReplayed());
|
|
msg.setKeepContent(message->keepContent());
|
|
msg.dispatch();
|
|
return nullptr;
|
|
}
|
|
|
|
return std::make_shared<MessageActivateTokens>(message, std::vector<Id>(1, fileId));
|
|
}
|
|
|
|
std::shared_ptr<MessageActivateTokens> ActivationTranslator::translateMessage(const MessageActivateNodes* message) const
|
|
{
|
|
std::vector<Id> nodeIds;
|
|
if (!message->isReplayed())
|
|
{
|
|
for (const MessageActivateNodes::ActiveNode& node : message->nodes)
|
|
{
|
|
nodeIds.push_back(node.nodeId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (const MessageActivateNodes::ActiveNode& node : message->nodes)
|
|
{
|
|
Id nodeId = m_storageAccess->getIdForNodeWithNameHierarchy(node.nameHierarchy);
|
|
if (nodeId > 0)
|
|
{
|
|
nodeIds.push_back(nodeId);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<MessageActivateTokens> m;
|
|
m = std::make_shared<MessageActivateTokens>(message, nodeIds);
|
|
return m;
|
|
}
|
|
|
|
std::shared_ptr<MessageActivateTokens> ActivationTranslator::translateMessage(const MessageActivateTokenIds* message) const
|
|
{
|
|
return std::make_shared<MessageActivateTokens>(message, message->tokenIds);
|
|
}
|
|
|
|
std::shared_ptr<MessageActivateTokens> ActivationTranslator::translateMessage(const MessageSearch* message) const
|
|
{
|
|
const std::vector<SearchMatch>& matches = message->getMatches();
|
|
|
|
for (const SearchMatch& match : matches)
|
|
{
|
|
if (match.searchType == SearchMatch::SEARCH_COMMAND &&
|
|
match.getFullName() == SearchMatch::getCommandName(SearchMatch::COMMAND_ALL))
|
|
{
|
|
MessageActivateAll msg;
|
|
msg.setIsReplayed(message->isReplayed());
|
|
msg.dispatchImmediately();
|
|
return nullptr;
|
|
}
|
|
else if (match.searchType == SearchMatch::SEARCH_COMMAND &&
|
|
match.getFullName() == SearchMatch::getCommandName(SearchMatch::COMMAND_ERROR))
|
|
{
|
|
MessageShowErrors msg(ErrorCountInfo(-1, 0));
|
|
msg.setIsReplayed(message->isReplayed());
|
|
msg.dispatchImmediately();
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
std::vector<Id> tokenIds = m_storageAccess->getTokenIdsForMatches(matches);
|
|
|
|
std::shared_ptr<MessageActivateTokens> m = std::make_shared<MessageActivateTokens>(message, tokenIds);
|
|
if (!message->isReplayed())
|
|
{
|
|
m->isFromSearch = true;
|
|
}
|
|
|
|
return m;
|
|
}
|