logic: fallback selection after refresh

* extracted code for translating input messages to token activations from the FeatureController to the helper class ActivationTranslator.
* used ActivationTranslator in UndoRedoController to determine if the symbols that have been selected before refresh are still available after parsing again.

bin/app/data/src/test2/main.cpp

@@ -1,16 +1,7 @@
 #include "header.h"
 
-#include <vector>
-
 int main()
 {
-	std::vector<Fooo<int>> yay;
-	
-	for (Fooo<int> a: yay)
-	{
-		a;
-	}
-	
 	Foo<true, int, float> ft;
 	ft.bar();
 	return 0;

src/lib/CMakeLists.txt

@@ -35,6 +35,8 @@ add_files(
 add_files(
 	LIB_FILES
 
+	component/controller/helper/ActivationTranslator.cpp
+	component/controller/helper/ActivationTranslator.h
 	component/controller/helper/BucketGrid.cpp
 	component/controller/helper/BucketGrid.h
 	component/controller/helper/DummyEdge.h

src/lib/component/controller/FeatureController.cpp

@@ -8,6 +8,7 @@
 
 FeatureController::FeatureController(StorageAccess* storageAccess)
 	: m_storageAccess(storageAccess)
+	, m_activationTranslator(storageAccess)
 {
 }
 
@@ -17,73 +18,38 @@ FeatureController::~FeatureController()
 
 void FeatureController::handleMessage(MessageActivateEdge* message)
 {
-	if (message->type == Edge::EDGE_AGGREGATION)
+	std::shared_ptr<MessageActivateTokens> m = m_activationTranslator.translateMessage(message);
+	if (m)
 	{
-		const Id sourceId = m_storageAccess->getIdForNodeWithNameHierarchy(message->fromNameHierarchy);
+		m->dispatchImmediately();
-		const Id targetId = m_storageAccess->getIdForNodeWithNameHierarchy(message->toNameHierarchy);
-
-		MessageActivateTokens m(m_storageAccess->getTokenIdsForAggregationEdge(sourceId, targetId));
-		m.isAggregation = true;
-		m.undoRedoType = message->undoRedoType;
-		m.dispatchImmediately();
-	}
-	else
-	{
-		Id edgeId = message->tokenId;
-
-		if (!message->isFresh())
-		{
-			edgeId = m_storageAccess->getIdForEdge(message->type, message->fromNameHierarchy, message->toNameHierarchy);
-		}
-
-		if (!edgeId)
-		{
-			return;
-		}
-
-		MessageActivateTokens m(std::vector<Id>(1, edgeId));
-		m.isEdge = true;
-		m.undoRedoType = message->undoRedoType;
-		m.setKeepContent(message->keepContent());
-		m.dispatchImmediately();
 	}
 }
 
 void FeatureController::handleMessage(MessageActivateFile* message)
 {
-	MessageActivateTokens m(std::vector<Id>(1, m_storageAccess->getTokenIdForFileNode(message->filePath)));
+	std::shared_ptr<MessageActivateTokens> m = m_activationTranslator.translateMessage(message);
-	m.undoRedoType = message->undoRedoType;
+	if (m)
-	m.setKeepContent(message->keepContent());
+	{
-	m.dispatchImmediately();
+		m->dispatchImmediately();
+	}
 }
 
 void FeatureController::handleMessage(MessageActivateNodes* message)
 {
-	std::vector<Id> nodeIds;
+	std::shared_ptr<MessageActivateTokens> m = m_activationTranslator.translateMessage(message);
-	if (message->isFresh())
+	if (m)
 	{
-		for (const MessageActivateNodes::ActiveNode& node : message->nodes)
+		m->dispatchImmediately();
-		{
-			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);
-			}
-		}
 	}
+}
 
-	MessageActivateTokens m(nodeIds);
+void FeatureController::handleMessage(MessageSearch* message)
-	m.isFromSystem = message->isFromSystem;
+{
-	m.undoRedoType = message->undoRedoType;
+	std::shared_ptr<MessageActivateTokens> m = m_activationTranslator.translateMessage(message);
-	m.setKeepContent(message->keepContent());
+	if (m)
-	m.dispatchImmediately();
+	{
+		m->dispatchImmediately();
+	}
 }
 
 void FeatureController::handleMessage(MessageActivateTokenLocations* message)
@@ -98,22 +64,11 @@ void FeatureController::handleMessage(MessageActivateTokenLocations* message)
 			nodeId,
 			m_storageAccess->getNodeTypeForNodeWithId(nodeId),
 			m_storageAccess->getNameHierarchyForNodeWithId(nodeId)
-		);
+			);
 	}
 	m.dispatchImmediately();
 }
 
-void FeatureController::handleMessage(MessageSearch* message)
-{
-	std::vector<Id> tokenIds = m_storageAccess->getTokenIdsForMatches(message->getMatches());
-	tokenIds = m_storageAccess->getActiveTokenIdsForTokenIds(tokenIds);
-
-	MessageActivateTokens m(tokenIds);
-	m.undoRedoType = message->undoRedoType;
-	m.setKeepContent(message->keepContent());
-	m.dispatchImmediately();
-}
-
 void FeatureController::handleMessage(MessageSwitchColorScheme* message)
 {
 	ApplicationSettings* settings = ApplicationSettings::getInstance().get();
@@ -131,3 +86,4 @@ void FeatureController::handleMessage(MessageZoom* message)
 
 	MessageRefresh().refreshUiOnly().dispatch();
 }
+

src/lib/component/controller/FeatureController.h

@@ -1,6 +1,8 @@
 #ifndef FEATURE_CONTROLLER_H
 #define FEATURE_CONTROLLER_H
 
+#include <memory>
+
 #include "utility/messaging/MessageListener.h"
 #include "utility/messaging/type/MessageActivateEdge.h"
 #include "utility/messaging/type/MessageActivateFile.h"
@@ -11,6 +13,7 @@
 #include "utility/messaging/type/MessageZoom.h"
 
 #include "component/controller/Controller.h"
+#include "component/controller/helper/ActivationTranslator.h"
 
 class StorageAccess;
 
@@ -32,12 +35,13 @@ private:
 	virtual void handleMessage(MessageActivateEdge* message);
 	virtual void handleMessage(MessageActivateFile* message);
 	virtual void handleMessage(MessageActivateNodes* message);
-	virtual void handleMessage(MessageActivateTokenLocations* message);
 	virtual void handleMessage(MessageSearch* message);
+	virtual void handleMessage(MessageActivateTokenLocations* message);
 	virtual void handleMessage(MessageSwitchColorScheme* message);
 	virtual void handleMessage(MessageZoom* message);
 
 	StorageAccess* m_storageAccess;
+	ActivationTranslator m_activationTranslator;
 };
 
 #endif // FEATURE_CONTROLLER_H

src/lib/component/controller/UndoRedoController.cpp

@@ -1,6 +1,7 @@
 #include "component/controller/UndoRedoController.h"
 
 #include "utility/logging/logging.h"
+#include "utility/messaging/type/MessageActivateTokens.h"
 #include "utility/messaging/type/MessageFlushUpdates.h"
 
 #include "component/view/UndoRedoView.h"
@@ -8,6 +9,7 @@
 
 UndoRedoController::UndoRedoController(StorageAccess* storageAccess)
 	: m_storageAccess(storageAccess)
+	, m_activationTranslator(storageAccess)
 	, m_lastCommand(nullptr, 0)
 {
 }
@@ -136,7 +138,7 @@ void UndoRedoController::handleMessage(MessageRefresh* message)
 		return;
 	}
 
-	if (!m_lastCommand.message)
+	if (requiresActivateFallbackToken())
 	{
 		Id nodeId = m_storageAccess->getIdForNodeWithNameHierarchy(NameHierarchy("main"));
 		if (!nodeId)
@@ -151,35 +153,35 @@ void UndoRedoController::handleMessage(MessageRefresh* message)
 				nodeId,
 				m_storageAccess->getNodeTypeForNodeWithId(nodeId),
 				m_storageAccess->getNameHierarchyForNodeWithId(nodeId)
-			);
+				);
 			m.isFromSystem = true;
 			m.dispatch();
 		}
-
-		return;
-	}
-
-	if (m_lastCommand.order > 0)
-	{
-		replayCommands(false);
-	}
-
-	std::shared_ptr<MessageBase> msg = m_lastCommand.message;
-
-	if (m_undo.size())
-	{
-		m_lastCommand = m_undo.back();
-		m_undo.pop_back();
 	}
 	else
 	{
-		m_lastCommand.message.reset();
+		if (m_lastCommand.order > 0)
+		{
+			replayCommands(false);
+		}
+
+		std::shared_ptr<MessageBase> msg = m_lastCommand.message;
+
+		if (m_undo.size() > 0)
+		{
+			m_lastCommand = m_undo.back();
+			m_undo.pop_back();
+		}
+		else
+		{
+			m_lastCommand.message.reset();
+		}
+
+		msg->undoRedoType = MessageBase::UNDOTYPE_REDO;
+		msg->dispatch();
+
+		MessageFlushUpdates().dispatch();
 	}
-
-	msg->undoRedoType = MessageBase::UNDOTYPE_REDO;
-	msg->dispatch();
-
-	MessageFlushUpdates().dispatch();
 }
 
 void UndoRedoController::handleMessage(MessageSearch* message)
@@ -328,3 +330,57 @@ void UndoRedoController::clear()
 	getView()->setUndoButtonEnabled(false);
 	getView()->setRedoButtonEnabled(false);
 }
+
+bool UndoRedoController::requiresActivateFallbackToken() const
+{
+	bool activateFallbackToken = true;
+	if (m_lastCommand.message)
+	{
+		if (m_lastCommand.order == 0)
+		{
+			activateFallbackToken = !checkCommandCausesTokenActivation(m_lastCommand);
+		}
+		else
+		{
+			for (int i = m_undo.size() - 1; i >= 0; i--)
+			{
+				if (m_undo[i].order == 0)
+				{
+					activateFallbackToken = !checkCommandCausesTokenActivation(m_undo[i]);
+					break;
+				}
+			}
+		}
+	}
+	return activateFallbackToken;
+}
+
+bool UndoRedoController::checkCommandCausesTokenActivation(const Command& command) const
+{
+	MessageBase* commandMessage = command.message.get();
+	if (commandMessage)
+	{
+		std::shared_ptr<MessageActivateTokens> m;
+		std::string commandMessageTypeString = commandMessage->getType();
+		if (commandMessageTypeString == MessageActivateEdge::getStaticType())
+		{
+			m = m_activationTranslator.translateMessage(dynamic_cast<const MessageActivateEdge*>(commandMessage));
+		}
+		else if (commandMessageTypeString == MessageActivateFile::getStaticType())
+		{
+			m = m_activationTranslator.translateMessage(dynamic_cast<const MessageActivateFile*>(commandMessage));
+		}
+		else if (commandMessageTypeString == MessageActivateNodes::getStaticType())
+		{
+			MessageActivateNodes inputMessage(*dynamic_cast<MessageActivateNodes*>(commandMessage));
+			inputMessage.undoRedoType = MessageBase::UNDOTYPE_REDO;
+			m = m_activationTranslator.translateMessage(&inputMessage);
+		}
+		else if (commandMessageTypeString == MessageSearch::getStaticType())
+		{
+			m = m_activationTranslator.translateMessage(dynamic_cast<const MessageSearch*>(commandMessage));
+		}
+		return (m && m->tokenIds.size() > 0);
+	}
+	return false;
+}

src/lib/component/controller/UndoRedoController.h

@@ -20,6 +20,7 @@
 #include "utility/messaging/type/MessageShowScope.h"
 #include "utility/messaging/type/MessageUndo.h"
 
+#include "component/controller/helper/ActivationTranslator.h"
 #include "component/controller/Controller.h"
 
 class StorageAccess;
@@ -81,6 +82,10 @@ private:
 
 	void clear();
 
+	bool requiresActivateFallbackToken() const;
+	bool checkCommandCausesTokenActivation(const Command& command) const;
+
+	ActivationTranslator m_activationTranslator;
 	StorageAccess* m_storageAccess;
 
 	Command m_lastCommand;

src/lib/component/controller/helper/ActivationTranslator.cpp

@@ -0,0 +1,100 @@
+#include "component/controller/helper/ActivationTranslator.h"
+
+#include "data/access/StorageAccess.h"
+#include "utility/messaging/type/MessageActivateEdge.h"
+#include "utility/messaging/type/MessageActivateFile.h"
+#include "utility/messaging/type/MessageActivateNodes.h"
+#include "utility/messaging/type/MessageActivateTokens.h"
+#include "utility/messaging/type/MessageSearch.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->type == Edge::EDGE_AGGREGATION)
+	{
+		const Id sourceId = m_storageAccess->getIdForNodeWithNameHierarchy(message->fromNameHierarchy);
+		const Id targetId = m_storageAccess->getIdForNodeWithNameHierarchy(message->toNameHierarchy);
+
+		m = std::make_shared<MessageActivateTokens>(m_storageAccess->getTokenIdsForAggregationEdge(sourceId, targetId));
+		m->isAggregation = true;
+		m->undoRedoType = message->undoRedoType;
+	}
+	else
+	{
+		Id edgeId = message->tokenId;
+
+		if (!message->isFresh())
+		{
+			edgeId = m_storageAccess->getIdForEdge(message->type, message->fromNameHierarchy, message->toNameHierarchy);
+		}
+
+		if (edgeId)
+		{
+			m = std::make_shared<MessageActivateTokens>(std::vector<Id>(1, edgeId));
+			m->isEdge = true;
+			m->undoRedoType = message->undoRedoType;
+			m->setKeepContent(message->keepContent());
+		}
+	}
+	return m;
+}
+
+std::shared_ptr<MessageActivateTokens> ActivationTranslator::translateMessage(const MessageActivateFile* message) const
+{
+	std::shared_ptr<MessageActivateTokens> m;
+	m = std::make_shared<MessageActivateTokens>(std::vector<Id>(1, m_storageAccess->getTokenIdForFileNode(message->filePath)));
+	m->undoRedoType = message->undoRedoType;
+	m->setKeepContent(message->keepContent());
+	return m;
+}
+
+std::shared_ptr<MessageActivateTokens> ActivationTranslator::translateMessage(const MessageActivateNodes* message) const
+{
+	std::vector<Id> nodeIds;
+	if (message->isFresh())
+	{
+		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>(nodeIds);
+	m->isFromSystem = message->isFromSystem;
+	m->undoRedoType = message->undoRedoType;
+	m->setKeepContent(message->keepContent());
+	return m;
+}
+
+std::shared_ptr<MessageActivateTokens> ActivationTranslator::translateMessage(const MessageSearch* message) const
+{
+	std::vector<Id> tokenIds = m_storageAccess->getTokenIdsForMatches(message->getMatches());
+	tokenIds = m_storageAccess->getActiveTokenIdsForTokenIds(tokenIds);
+
+	std::shared_ptr<MessageActivateTokens> m;
+	m = std::make_shared<MessageActivateTokens>(tokenIds);
+	m->undoRedoType = message->undoRedoType;
+	m->setKeepContent(message->keepContent());
+	return m;
+}

src/lib/component/controller/helper/ActivationTranslator.h

@@ -0,0 +1,28 @@
+#ifndef ACTIVATION_TRANSLATOR_H
+#define ACTIVATION_TRANSLATOR_H
+
+#include <memory>
+
+class MessageActivateEdge;
+class MessageActivateFile;
+class MessageActivateNodes;
+class MessageActivateTokens;
+class MessageSearch;
+class StorageAccess;
+
+class ActivationTranslator
+{
+public:
+	ActivationTranslator(StorageAccess* storageAccess);
+	~ActivationTranslator();
+
+	std::shared_ptr<MessageActivateTokens> translateMessage(const MessageActivateEdge* message) const;
+	std::shared_ptr<MessageActivateTokens> translateMessage(const MessageActivateFile* message) const;
+	std::shared_ptr<MessageActivateTokens> translateMessage(const MessageActivateNodes* message) const;
+	std::shared_ptr<MessageActivateTokens> translateMessage(const MessageSearch* message) const;
+
+private:
+	StorageAccess* m_storageAccess;
+};
+
+#endif // ACTIVATION_TRANSLATOR_H

src/lib/data/Storage.cpp

@@ -970,7 +970,10 @@ std::vector<Id> Storage::getTokenIdsForMatches(const std::vector<SearchMatch>& m
 	for (const SearchMatch& match : matches)
 	{
 		SearchNode* searchNode = m_tokenIndex.getNode(match.nameHierarchy);
-		utility::append(idSet, searchNode->getTokenIds());
+		if (searchNode)
+		{
+			utility::append(idSet, searchNode->getTokenIds());
+		}
 	}
 
 	std::vector<Id> ids;