logic: Improved graph and code view performance

* added sql index for component_access
* improved policy for expanded code files
* reduced amount of initially expanded code files
* faster DummyEdge creation
* faster DummyNode search by token id
* switched GraphController DummyNodes and DummyEdges to shared_ptr for memory safety

src/lib/component/controller/CodeController.cpp

@@ -303,6 +303,7 @@ std::vector<CodeSnippetParams> CodeController::getSnippetsForActiveTokenLocation
 ) const {
 	std::vector<CodeSnippetParams> snippets;
 	size_t definitionFileCount = 0;
+	size_t declarationFileCount = 0;
 
 	collection->forEachTokenLocationFile(
 		[&](std::shared_ptr<TokenLocationFile> file) -> void
@@ -324,7 +325,9 @@ std::vector<CodeSnippetParams> CodeController::getSnippetsForActiveTokenLocation
 				}
 			);
 
-			if (definitionFileCount < 5 && (isDeclarationFile || collection->getTokenLocationFileCount() < 5 || file->isWholeCopy))
+			if (collection->getTokenLocationFileCount() < 5 || file->isWholeCopy ||
+				(isDefinitionFile && definitionFileCount < 3) ||
+				(!isDefinitionFile && isDeclarationFile && declarationFileCount < 3))
 			{
 				std::vector<CodeSnippetParams> fileSnippets = getSnippetsForActiveTokenLocationsInFile(file);
 
@@ -350,6 +353,10 @@ std::vector<CodeSnippetParams> CodeController::getSnippetsForActiveTokenLocation
 			{
 				definitionFileCount++;
 			}
+			else if (isDeclarationFile)
+			{
+				declarationFileCount++;
+			}
 		}
 	);
 

src/lib/component/controller/GraphController.cpp

@@ -103,10 +103,10 @@ void GraphController::handleMessage(MessageGraphNodeBundleSplit* message)
 {
 	for (size_t i = 0; i < m_dummyNodes.size(); i++)
 	{
-		DummyNode& node = m_dummyNodes[i];
-		if (node.isBundleNode() && node.tokenId == message->bundleId)
+		DummyNode* node = m_dummyNodes[i].get();
+		if (node->isBundleNode() && node->tokenId == message->bundleId)
 		{
-			m_dummyNodes.insert(m_dummyNodes.begin() + i + 1, node.bundledNodes.begin(), node.bundledNodes.end());
+			m_dummyNodes.insert(m_dummyNodes.begin() + i + 1, node->bundledNodes.begin(), node->bundledNodes.end());
 			m_dummyNodes.erase(m_dummyNodes.begin() + i);
 			break;
 		}
@@ -114,8 +114,8 @@ void GraphController::handleMessage(MessageGraphNodeBundleSplit* message)
 
 	for (size_t i = 0; i < m_dummyEdges.size(); i++)
 	{
-		DummyEdge& edge = m_dummyEdges[i];
-		if (!edge.data && edge.targetId == message->bundleId)
+		DummyEdge* edge = m_dummyEdges[i].get();
+		if (!edge->data && edge->targetId == message->bundleId)
 		{
 			m_dummyEdges.erase(m_dummyEdges.begin() + i);
 			break;
@@ -133,7 +133,7 @@ void GraphController::handleMessage(MessageGraphNodeBundleSplit* message)
 
 void GraphController::handleMessage(MessageGraphNodeExpand* message)
 {
-	DummyNode* node = findDummyNodeRecursive(m_dummyNodes, message->tokenId);
+	DummyNode* node = getDummyGraphNodeById(message->tokenId);
 	if (node)
 	{
 		node->expanded = message->expand;
@@ -149,7 +149,7 @@ void GraphController::handleMessage(MessageGraphNodeExpand* message)
 
 void GraphController::handleMessage(MessageGraphNodeMove* message)
 {
-	DummyNode* node = findDummyNodeRecursive(m_dummyNodes, message->tokenId);
+	DummyNode* node = getDummyGraphNodeById(message->tokenId);
 	if (node)
 	{
 		node->position += message->delta;
@@ -180,6 +180,8 @@ void GraphController::clear()
 	m_dummyNodes.clear();
 	m_dummyEdges.clear();
 
+	m_dummyGraphNodes.clear();
+
 	m_activeNodeIds.clear();
 	m_activeEdgeIds.clear();
 
@@ -197,9 +199,10 @@ void GraphController::createDummyGraphForTokenIds(const std::vector<Id>& tokenId
 	}
 
 	m_dummyEdges.clear();
+	m_dummyGraphNodes.clear();
 
 	std::set<Id> addedNodes;
-	std::vector<DummyNode> dummyNodes;
+	std::vector<std::shared_ptr<DummyNode>> dummyNodes;
 
 	graph->forEachNode(
 		[&addedNodes, &dummyNodes, this](Node* node)
@@ -216,10 +219,22 @@ void GraphController::createDummyGraphForTokenIds(const std::vector<Id>& tokenId
 		}
 	);
 
-	for (DummyNode& node : dummyNodes)
+	std::set<Id> addedEdges;
+	graph->forEachEdge(
+		[&addedEdges, this](Edge* edge)
+		{
+			if (!edge->isType(Edge::EDGE_MEMBER) && addedEdges.find(edge->getId()) == addedEdges.end())
+			{
+				m_dummyEdges.push_back(std::make_shared<DummyEdge>(edge->getFrom()->getId(), edge->getTo()->getId(), edge));
+				addedEdges.insert(edge->getId());
+			}
+		}
+	);
+
+	for (std::shared_ptr<DummyNode> node : dummyNodes)
 	{
-		node.hasParent = false;
-		node.name = node.data->getFullName();
+		node->hasParent = false;
+		node->name = node->data->getFullName();
 	}
 
 	m_dummyNodes = dummyNodes;
@@ -230,12 +245,12 @@ void GraphController::createDummyGraphForTokenIds(const std::vector<Id>& tokenId
 	m_graph = graph;
 }
 
-DummyNode GraphController::createDummyNodeTopDown(Node* node)
+std::shared_ptr<DummyNode> GraphController::createDummyNodeTopDown(Node* node)
 {
-	DummyNode result;
-	result.data = node;
-	result.tokenId = node->getId();
-	result.name = node->getName();
+	std::shared_ptr<DummyNode> result = std::make_shared<DummyNode>();
+	result->data = node;
+	result->tokenId = node->getId();
+	result->name = node->getName();
 
 	// there is a global root node with id 0 afaik, so here we actually want the one node below this global root
 	Node* parent = node;
@@ -246,14 +261,14 @@ DummyNode GraphController::createDummyNodeTopDown(Node* node)
 
 	if (parent != NULL)
 	{
-		result.topLevelAncestorId = parent->getId();
+		result->topLevelAncestorId = parent->getId();
 	}
 
 	// Expand nodes that were expanded before, except functions.
-	DummyNode* oldNode = findDummyNodeRecursive(m_dummyNodes, node->getId());
+	DummyNode* oldNode = getDummyGraphNodeById(node->getId());
 	if (oldNode && oldNode->isGraphNode() && !oldNode->data->isType(Node::NODE_FUNCTION | Node::NODE_METHOD))
 	{
-		result.expanded = oldNode->isExpanded();
+		result->expanded = oldNode->isExpanded();
 	}
 
 	node->forEachChildNode(
@@ -277,27 +292,27 @@ DummyNode GraphController::createDummyNodeTopDown(Node* node)
 				}
 				else
 				{
-					parent = &result;
+					parent = result.get();
 				}
 			}
 
 			if (accessType != TokenComponentAccess::ACCESS_NONE)
 			{
-				for (DummyNode& dummy : result.subNodes)
+				for (std::shared_ptr<DummyNode> dummy : result->subNodes)
 				{
-					if (dummy.accessType == accessType)
+					if (dummy->accessType == accessType)
 					{
-						parent = &dummy;
+						parent = dummy.get();
 						break;
 					}
 				}
 
 				if (!parent)
 				{
-					DummyNode accessNode;
-					accessNode.accessType = accessType;
-					result.subNodes.push_back(accessNode);
-					parent = &result.subNodes.back();
+					std::shared_ptr<DummyNode> accessNode = std::make_shared<DummyNode>();
+					accessNode->accessType = accessType;
+					result->subNodes.push_back(accessNode);
+					parent = accessNode.get();
 				}
 			}
 
@@ -305,21 +320,7 @@ DummyNode GraphController::createDummyNodeTopDown(Node* node)
 		}
 	);
 
-	node->forEachEdgeOfType(
-		~Edge::EDGE_MEMBER,
-		[&result, node, this](Edge* edge)
-		{
-			for (const DummyEdge& dummy : m_dummyEdges)
-			{
-				if (dummy.data->getId() == edge->getId())
-				{
-					return;
-				}
-			}
-
-			m_dummyEdges.push_back(DummyEdge(edge->getFrom()->getId(), edge->getTo()->getId(), edge));
-		}
-	);
+	m_dummyGraphNodes.emplace(result->data->getId(), result.get());
 
 	return result;
 }
@@ -329,7 +330,7 @@ void GraphController::autoExpandActiveNode(const std::vector<Id>& activeTokenIds
 	DummyNode* node = nullptr;
 	if (activeTokenIds.size() == 1)
 	{
-		node = findDummyNodeRecursive(m_dummyNodes, activeTokenIds[0]);
+		node = getDummyGraphNodeById(activeTokenIds[0]);
 	}
 
 	if (node)
@@ -344,78 +345,78 @@ void GraphController::setActiveAndVisibility(const std::vector<Id>& activeTokenI
 	if (activeTokenIds.size() > 0)
 	{
 		noActive = true;
-		for (DummyNode& node : m_dummyNodes)
+		for (std::shared_ptr<DummyNode> node : m_dummyNodes)
 		{
-			setNodeActiveRecursive(node, activeTokenIds, &noActive);
+			setNodeActiveRecursive(node.get(), activeTokenIds, &noActive);
 		}
 	}
 
-	for (DummyEdge& edge : m_dummyEdges)
+	for (std::shared_ptr<DummyEdge> edge : m_dummyEdges)
 	{
-		if (!edge.data)
+		if (!edge->data)
 		{
 			continue;
 		}
 
-		edge.active = false;
-		if (find(activeTokenIds.begin(), activeTokenIds.end(), edge.data->getId()) != activeTokenIds.end())
+		edge->active = false;
+		if (find(activeTokenIds.begin(), activeTokenIds.end(), edge->data->getId()) != activeTokenIds.end())
 		{
-			edge.active = true;
+			edge->active = true;
 			noActive = false;
 		}
 
-		DummyNode* from = findDummyNodeRecursive(m_dummyNodes, edge.ownerId);
-		DummyNode* to = findDummyNodeRecursive(m_dummyNodes, edge.targetId);
+		DummyNode* from = getDummyGraphNodeById(edge->ownerId);
+		DummyNode* to = getDummyGraphNodeById(edge->targetId);
 
-		if (from && to && (noActive || from->active || to->active || edge.active))
+		if (from && to && (noActive || from->active || to->active || edge->active))
 		{
-			edge.visible = true;
+			edge->visible = true;
 			from->connected = true;
 			to->connected = true;
 		}
 	}
 
-	for (DummyNode& node : m_dummyNodes)
+	for (std::shared_ptr<DummyNode> node : m_dummyNodes)
 	{
-		removeImplicitChildrenRecursive(node);
+		removeImplicitChildrenRecursive(node.get());
 
-		setNodeVisibilityRecursiveBottomUp(node, noActive);
+		setNodeVisibilityRecursiveBottomUp(node.get(), noActive);
 	}
 }
 
-void GraphController::setNodeActiveRecursive(DummyNode& node, const std::vector<Id>& activeTokenIds, bool* noActive) const
+void GraphController::setNodeActiveRecursive(DummyNode* node, const std::vector<Id>& activeTokenIds, bool* noActive) const
 {
-	node.active = false;
+	node->active = false;
 
-	if (node.isGraphNode())
+	if (node->isGraphNode())
 	{
-		node.active = find(activeTokenIds.begin(), activeTokenIds.end(), node.data->getId()) != activeTokenIds.end();
+		node->active = find(activeTokenIds.begin(), activeTokenIds.end(), node->data->getId()) != activeTokenIds.end();
 
-		if (node.active)
+		if (node->active)
 		{
 			*noActive = false;
 		}
 	}
 
-	for (DummyNode& subNode : node.subNodes)
+	for (std::shared_ptr<DummyNode> subNode : node->subNodes)
 	{
-		setNodeActiveRecursive(subNode, activeTokenIds, noActive);
+		setNodeActiveRecursive(subNode.get(), activeTokenIds, noActive);
 	}
 }
 
-void GraphController::removeImplicitChildrenRecursive(DummyNode& node)
+void GraphController::removeImplicitChildrenRecursive(DummyNode* node)
 {
-	if (node.isGraphNode() && !node.data->isExplicit())
+	if (node->isGraphNode() && !node->data->isExplicit())
 	{
 		return;
 	}
 
-	for (size_t i = 0; i < node.subNodes.size(); i++)
+	for (size_t i = 0; i < node->subNodes.size(); i++)
 	{
 		bool removeNode = false;
 
-		DummyNode& subNode = node.subNodes[i];
-		if (subNode.isGraphNode() && subNode.data->isImplicit() && !subNode.connected && !subNode.active && !subNode.subNodes.size())
+		DummyNode* subNode = node->subNodes[i].get();
+		if (subNode->isGraphNode() && subNode->data->isImplicit() && !subNode->connected && !subNode->active && !subNode->subNodes.size())
 		{
 			removeNode = true;
 		}
@@ -423,7 +424,7 @@ void GraphController::removeImplicitChildrenRecursive(DummyNode& node)
 		{
 			removeImplicitChildrenRecursive(subNode);
 
-			if (subNode.isAccessNode() && subNode.subNodes.size() == 0)
+			if (subNode->isAccessNode() && subNode->subNodes.size() == 0)
 			{
 				removeNode = true;
 			}
@@ -431,56 +432,56 @@ void GraphController::removeImplicitChildrenRecursive(DummyNode& node)
 
 		if (removeNode)
 		{
-			node.subNodes.erase(node.subNodes.begin() + i);
+			node->subNodes.erase(node->subNodes.begin() + i);
 			i--;
 		}
 	}
 }
 
-bool GraphController::setNodeVisibilityRecursiveBottomUp(DummyNode& node, bool noActive) const
+bool GraphController::setNodeVisibilityRecursiveBottomUp(DummyNode* node, bool noActive) const
 {
-	node.visible = false;
-	node.childVisible = false;
+	node->visible = false;
+	node->childVisible = false;
 
-	if (node.isExpandToggleNode())
+	if (node->isExpandToggleNode())
 	{
-		node.visible = true;
+		node->visible = true;
 		return false;
 	}
-	else if (node.isBundleNode())
+	else if (node->isBundleNode())
 	{
-		node.visible = true;
+		node->visible = true;
 		return true;
 	}
 
-	for (DummyNode& subNode : node.subNodes)
+	for (std::shared_ptr<DummyNode> subNode : node->subNodes)
 	{
-		if (setNodeVisibilityRecursiveBottomUp(subNode, noActive))
+		if (setNodeVisibilityRecursiveBottomUp(subNode.get(), noActive))
 		{
-			node.childVisible = true;
+			node->childVisible = true;
 		}
 	}
 
-	if (noActive || node.active || node.connected || node.childVisible)
+	if (noActive || node->active || node->connected || node->childVisible)
 	{
 		setNodeVisibilityRecursiveTopDown(node, false);
 	}
 
-	return node.visible;
+	return node->visible;
 }
 
-void GraphController::setNodeVisibilityRecursiveTopDown(DummyNode& node, bool parentExpanded) const
+void GraphController::setNodeVisibilityRecursiveTopDown(DummyNode* node, bool parentExpanded) const
 {
-	node.visible = true;
+	node->visible = true;
 
-	if ((node.isGraphNode() && node.isExpanded()) ||
-		(node.isAccessNode() && parentExpanded) ||
-		(node.isGraphNode() && parentExpanded && node.data->isType(Node::NODE_ENUM_CONSTANT)))
+	if ((node->isGraphNode() && node->isExpanded()) ||
+		(node->isAccessNode() && parentExpanded) ||
+		(node->isGraphNode() && parentExpanded && node->data->isType(Node::NODE_ENUM_CONSTANT)))
 	{
-		for (DummyNode& subNode : node.subNodes)
+		for (std::shared_ptr<DummyNode> subNode : node->subNodes)
 		{
-			node.childVisible = true;
-			setNodeVisibilityRecursiveTopDown(subNode, node.isExpanded());
+			node->childVisible = true;
+			setNodeVisibilityRecursiveTopDown(subNode.get(), node->isExpanded());
 		}
 	}
 }
@@ -488,17 +489,17 @@ void GraphController::setNodeVisibilityRecursiveTopDown(DummyNode& node, bool pa
 void GraphController::bundleNodes()
 {
 	// evaluate top level nodes
-	for (DummyNode& node : m_dummyNodes)
+	for (std::shared_ptr<DummyNode> node : m_dummyNodes)
 	{
-		if (!node.isGraphNode() || !node.visible)
+		if (!node->isGraphNode() || !node->visible)
 		{
 			continue;
 		}
 
-		DummyNode::BundleInfo* bundleInfo = &node.bundleInfo;
-		bundleInfo->isActive = node.hasActiveSubNode();
+		DummyNode::BundleInfo* bundleInfo = &node->bundleInfo;
+		bundleInfo->isActive = node->hasActiveSubNode();
 
-		node.data->forEachNodeRecursive(
+		node->data->forEachNodeRecursive(
 			[&bundleInfo](const Node* n)
 			{
 				if (n->isDefined())
@@ -625,13 +626,13 @@ void GraphController::bundleNodesAndEdgesMatching(std::function<bool(const Dummy
 	std::vector<size_t> matchedNodeIndices;
 	for (size_t i = 0; i < m_dummyNodes.size(); i++)
 	{
-		const DummyNode& node = m_dummyNodes[i];
-		if (node.bundleInfo.isActive || !node.visible)
+		const DummyNode* node = m_dummyNodes[i].get();
+		if (node->bundleInfo.isActive || !node->visible)
 		{
 			continue;
 		}
 
-		if (matcher(node.bundleInfo))
+		if (matcher(node->bundleInfo))
 		{
 			matchedNodeIndices.push_back(i);
 		}
@@ -642,23 +643,23 @@ void GraphController::bundleNodesAndEdgesMatching(std::function<bool(const Dummy
 		return;
 	}
 
-	DummyNode bundleNode;
-	bundleNode.name = name;
-	bundleNode.visible = true;
+	std::shared_ptr<DummyNode> bundleNode = std::make_shared<DummyNode>();
+	bundleNode->name = name;
+	bundleNode->visible = true;
 
 	for (int i = matchedNodeIndices.size() - 1; i >= 0; i--)
 	{
-		DummyNode node = m_dummyNodes[matchedNodeIndices[i]];
-		node.visible = false;
+		std::shared_ptr<DummyNode> node = m_dummyNodes[matchedNodeIndices[i]];
+		node->visible = false;
 
-		bundleNode.bundledNodes.push_back(node);
-		bundleNode.bundledNodeCount += node.getConnectedSubNodeCount();
+		bundleNode->bundledNodes.push_back(node);
+		bundleNode->bundledNodeCount += node->getConnectedSubNodeCount();
 
 		m_dummyNodes.erase(m_dummyNodes.begin() + matchedNodeIndices[i]);
 	}
 
-	bundleNode.tokenId = bundleNode.bundledNodes[0].data->getId();
-	bundleNode.bundleInfo.layoutVertical = bundleNode.bundledNodes[0].bundleInfo.layoutVertical;
+	bundleNode->tokenId = bundleNode->bundledNodes[0]->data->getId();
+	bundleNode->bundleInfo.layoutVertical = bundleNode->bundledNodes[0]->bundleInfo.layoutVertical;
 	m_dummyNodes.push_back(bundleNode);
 
 	if (m_dummyEdges.size() == 0)
@@ -666,14 +667,14 @@ void GraphController::bundleNodesAndEdgesMatching(std::function<bool(const Dummy
 		return;
 	}
 
-	std::vector<DummyEdge> bundleEdges;
-	std::vector<const DummyNode*> bundledNodes = bundleNode.getAllBundledNodes();
+	std::vector<std::shared_ptr<DummyEdge>> bundleEdges;
+	std::vector<const DummyNode*> bundledNodes = bundleNode->getAllBundledNodes();
 	for (const DummyNode* node : bundledNodes)
 	{
-		for (DummyEdge& edge : m_dummyEdges)
+		for (std::shared_ptr<DummyEdge> edge : m_dummyEdges)
 		{
-			bool owner = (edge.ownerId == node->data->getId());
-			bool target = (edge.targetId == node->data->getId());
+			bool owner = (edge->ownerId == node->data->getId());
+			bool target = (edge->targetId == node->data->getId());
 
 			if (!owner && !target)
 			{
@@ -681,41 +682,41 @@ void GraphController::bundleNodesAndEdgesMatching(std::function<bool(const Dummy
 			}
 
 			DummyEdge* bundleEdgePtr = nullptr;
-			for (DummyEdge& bundleEdge : bundleEdges)
+			for (std::shared_ptr<DummyEdge> bundleEdge : bundleEdges)
 			{
-				if ((owner && bundleEdge.ownerId == edge.targetId) ||
-					(target && bundleEdge.ownerId == edge.ownerId))
+				if ((owner && bundleEdge->ownerId == edge->targetId) ||
+					(target && bundleEdge->ownerId == edge->ownerId))
 				{
-					bundleEdgePtr = &bundleEdge;
+					bundleEdgePtr = bundleEdge.get();
 					break;
 				}
 			}
 
 			if (!bundleEdgePtr)
 			{
-				DummyEdge bundleEdge;
-				bundleEdge.visible = true;
-				bundleEdge.ownerId = (owner ? edge.targetId : edge.ownerId);
-				bundleEdge.targetId = bundleNode.bundledNodes.front().data->getId();
+				std::shared_ptr<DummyEdge> bundleEdge = std::make_shared<DummyEdge>();
+				bundleEdge->visible = true;
+				bundleEdge->ownerId = (owner ? edge->targetId : edge->ownerId);
+				bundleEdge->targetId = bundleNode->bundledNodes.front()->data->getId();
 				bundleEdges.push_back(bundleEdge);
-				bundleEdgePtr = &bundleEdges.back();
+				bundleEdgePtr = bundleEdges.back().get();
 			}
 
-			bundleEdgePtr->weight += edge.getWeight();
-			bundleEdgePtr->updateDirection(edge.getDirection(), owner);
-			edge.visible = false;
+			bundleEdgePtr->weight += edge->getWeight();
+			bundleEdgePtr->updateDirection(edge->getDirection(), owner);
+			edge->visible = false;
 		}
 	}
 
 	m_dummyEdges.insert(m_dummyEdges.end(), bundleEdges.begin(), bundleEdges.end());
 }
 
-void GraphController::bundleNodesMatching(std::list<DummyNode*>& nodes, std::function<bool(const DummyNode&)> matcher, const std::string& name)
+void GraphController::bundleNodesMatching(std::list<std::shared_ptr<DummyNode>>& nodes, std::function<bool(const DummyNode*)> matcher, const std::string& name)
 {
-	std::vector<std::list<DummyNode*>::iterator> matchedNodes;
-	for (std::list<DummyNode*>::iterator it = nodes.begin(); it != nodes.end(); it++)
+	std::vector<std::list<std::shared_ptr<DummyNode>>::iterator> matchedNodes;
+	for (std::list<std::shared_ptr<DummyNode>>::iterator it = nodes.begin(); it != nodes.end(); it++)
 	{
-		if (matcher(**it))
+		if (matcher(it->get()))
 		{
 			matchedNodes.push_back(it);
 		}
@@ -726,44 +727,44 @@ void GraphController::bundleNodesMatching(std::list<DummyNode*>& nodes, std::fun
 		return;
 	}
 
-	DummyNode bundleNode;
-	bundleNode.name = name;
-	bundleNode.visible = true;
+	std::shared_ptr<DummyNode> bundleNode = std::make_shared<DummyNode>();
+	bundleNode->name = name;
+	bundleNode->visible = true;
 
 	for (int i = matchedNodes.size() - 1; i >= 0; i--)
 	{
-		DummyNode* node = *matchedNodes[i];
+		std::shared_ptr<DummyNode> node = *matchedNodes[i];
 		node->visible = false;
 
-		bundleNode.bundledNodes.push_back(*node);
-		bundleNode.bundledNodeCount += node->getConnectedSubNodeCount();
+		bundleNode->bundledNodes.push_back(node);
+		bundleNode->bundledNodeCount += node->getConnectedSubNodeCount();
 
 		nodes.erase(matchedNodes[i]);
 	}
 
-	bundleNode.tokenId = bundleNode.bundledNodes[0].data->getId();
+	bundleNode->tokenId = bundleNode->bundledNodes[0]->data->getId();
 	m_dummyNodes.push_back(bundleNode);
 }
 
 #define BUNDLE_BY_TYPE(__nodes__, __type__, __name__) \
 	bundleNodesMatching( \
 		__nodes__, \
-		[&](const DummyNode& node) \
+		[&](const DummyNode* node) \
 		{ \
-			return node.visible && node.isGraphNode() && node.data->isType(__type__); \
+			return node->visible && node->isGraphNode() && node->data->isType(__type__); \
 		}, \
 		__name__ \
 	); \
 
 void GraphController::bundleNodesByType()
 {
-	std::vector<DummyNode> oldNodes = m_dummyNodes;
+	std::vector<std::shared_ptr<DummyNode>> oldNodes = m_dummyNodes;
 	m_dummyNodes.clear();
 
-	std::list<DummyNode*> nodes;
+	std::list<std::shared_ptr<DummyNode>> nodes;
 	for (size_t i = 0; i < oldNodes.size(); i++)
 	{
-		nodes.push_back(&oldNodes[i]);
+		nodes.push_back(oldNodes[i]);
 	}
 
 	BUNDLE_BY_TYPE(nodes, Node::NODE_NAMESPACE, "Namespaces");
@@ -788,14 +789,14 @@ void GraphController::bundleNodesByType()
 	BUNDLE_BY_TYPE(nodes, Node::NODE_TEMPLATE_PARAMETER_TYPE, "Template Parameter Types");
 	BUNDLE_BY_TYPE(nodes, Node::NODE_UNDEFINED, "Undefined Symbols");
 
-	for (DummyNode& node : m_dummyNodes)
+	for (std::shared_ptr<DummyNode> node : m_dummyNodes)
 	{
-		if (node.isBundleNode())
+		if (node->isBundleNode())
 		{
-			sort(node.bundledNodes.begin(), node.bundledNodes.end(),
-				[](const DummyNode& a, const DummyNode& b) -> bool
+			sort(node->bundledNodes.begin(), node->bundledNodes.end(),
+				[](const std::shared_ptr<DummyNode> a, const std::shared_ptr<DummyNode> b) -> bool
 				{
-					return utility::toLowerCase(a.name) < utility::toLowerCase(b.name);
+					return utility::toLowerCase(a->name) < utility::toLowerCase(b->name);
 				}
 			);
 		}
@@ -804,39 +805,39 @@ void GraphController::bundleNodesByType()
 
 void GraphController::layoutNesting()
 {
-	for (DummyNode& node : m_dummyNodes)
+	for (std::shared_ptr<DummyNode> node : m_dummyNodes)
 	{
-		layoutNestingRecursive(node);
+		layoutNestingRecursive(node.get());
 	}
 
-	for (DummyNode& node : m_dummyNodes)
+	for (std::shared_ptr<DummyNode> node : m_dummyNodes)
 	{
-		layoutToGrid(node);
+		layoutToGrid(node.get());
 	}
 }
 
-void GraphController::layoutNestingRecursive(DummyNode& node) const
+void GraphController::layoutNestingRecursive(DummyNode* node) const
 {
-	if (!node.visible)
+	if (!node->visible)
 	{
 		return;
 	}
 
 	GraphViewStyle::NodeMargins margins;
 
-	if (node.isGraphNode())
+	if (node->isGraphNode())
 	{
-		margins = GraphViewStyle::getMarginsForNodeType(node.data->getType(), node.childVisible);
+		margins = GraphViewStyle::getMarginsForNodeType(node->data->getType(), node->childVisible);
 	}
-	else if (node.isAccessNode())
+	else if (node->isAccessNode())
 	{
-		margins = GraphViewStyle::getMarginsOfAccessNode(node.accessType);
+		margins = GraphViewStyle::getMarginsOfAccessNode(node->accessType);
 	}
-	else if (node.isExpandToggleNode())
+	else if (node->isExpandToggleNode())
 	{
 		margins = GraphViewStyle::getMarginsOfExpandToggleNode();
 	}
-	else if (node.isBundleNode())
+	else if (node->isBundleNode())
 	{
 		margins = GraphViewStyle::getMarginsOfBundleNode();
 	}
@@ -846,24 +847,24 @@ void GraphController::layoutNestingRecursive(DummyNode& node) const
 	int width = margins.minWidth;
 	int height = 0;
 
-	if (node.isGraphNode())
+	if (node->isGraphNode())
 	{
 		size_t maxNameSize = 50;
-		if (!node.active && node.name.size() > maxNameSize)
+		if (!node->active && node->name.size() > maxNameSize)
 		{
-			node.name = node.name.substr(0, maxNameSize - 3) + "...";
+			node->name = node->name.substr(0, maxNameSize - 3) + "...";
 		}
 
-		width = margins.charWidth * node.name.size();
+		width = margins.charWidth * node->name.size();
 
-		if (node.data->isType(Node::NODE_TYPE | Node::NODE_CLASS | Node::NODE_STRUCT | Node::NODE_ENUM) && node.subNodes.size())
+		if (node->data->isType(Node::NODE_TYPE | Node::NODE_CLASS | Node::NODE_STRUCT | Node::NODE_ENUM) && node->subNodes.size())
 		{
 			addExpandToggleNode(node);
 		}
 	}
-	else if (node.isBundleNode())
+	else if (node->isBundleNode())
 	{
-		width = margins.charWidth * node.name.size();
+		width = margins.charWidth * node->name.size();
 	}
 
 	width += margins.iconWidth;
@@ -871,45 +872,45 @@ void GraphController::layoutNestingRecursive(DummyNode& node) const
 	// Horizontal layouting is currently not used, but left in place for experimentation.
 	bool layoutHorizontal = false;
 
-	for (DummyNode& subNode : node.subNodes)
+	for (std::shared_ptr<DummyNode> subNode : node->subNodes)
 	{
-		if (!subNode.visible)
+		if (!subNode->visible)
 		{
 			continue;
 		}
 
-		layoutNestingRecursive(subNode);
+		layoutNestingRecursive(subNode.get());
 
-		if (subNode.isExpandToggleNode())
+		if (subNode->isExpandToggleNode())
 		{
-			width += margins.spacingX + subNode.size.x;
+			width += margins.spacingX + subNode->size.x;
 		}
 	}
 
-	for (DummyNode& subNode : node.subNodes)
+	for (std::shared_ptr<DummyNode> subNode : node->subNodes)
 	{
-		if (!subNode.visible || subNode.isExpandToggleNode())
+		if (!subNode->visible || subNode->isExpandToggleNode())
 		{
 			continue;
 		}
 
-		subNode.position.x = margins.left + x;
-		subNode.position.y = margins.top + margins.charHeight + y;
+		subNode->position.x = margins.left + x;
+		subNode->position.y = margins.top + margins.charHeight + y;
 
 		if (layoutHorizontal)
 		{
-			x += subNode.size.x + margins.spacingX;
-			if (subNode.size.y > height)
+			x += subNode->size.x + margins.spacingX;
+			if (subNode->size.y > height)
 			{
-				height = subNode.size.y;
+				height = subNode->size.y;
 			}
 		}
 		else
 		{
-			y += subNode.size.y + margins.spacingY;
-			if (subNode.size.x > width)
+			y += subNode->size.y + margins.spacingY;
+			if (subNode->size.x > width)
 			{
-				width = subNode.size.x;
+				width = subNode->size.x;
 			}
 		}
 	}
@@ -928,102 +929,102 @@ void GraphController::layoutNestingRecursive(DummyNode& node) const
 		width = x;
 	}
 
-	node.size.x = margins.left + width + margins.right;
-	node.size.y = margins.top + margins.charHeight + y + height + margins.bottom;
+	node->size.x = margins.left + width + margins.right;
+	node->size.y = margins.top + margins.charHeight + y + height + margins.bottom;
 
-	for (DummyNode& subNode : node.subNodes)
+	for (std::shared_ptr<DummyNode> subNode : node->subNodes)
 	{
-		if (!subNode.visible)
+		if (!subNode->visible)
 		{
 			continue;
 		}
 
-		if (subNode.isAccessNode())
+		if (subNode->isAccessNode())
 		{
-			subNode.size.x = width;
+			subNode->size.x = width;
 		}
-		else if (subNode.isExpandToggleNode())
+		else if (subNode->isExpandToggleNode())
 		{
-			subNode.position.x = margins.left + width - subNode.size.x;
-			subNode.position.y = 6;
+			subNode->position.x = margins.left + width - subNode->size.x;
+			subNode->position.y = 6;
 		}
 	}
 }
 
-void GraphController::addExpandToggleNode(DummyNode& node) const
+void GraphController::addExpandToggleNode(DummyNode* node) const
 {
-	DummyNode expandNode;
-	expandNode.visible = true;
-	expandNode.expanded = node.expanded;
+	std::shared_ptr<DummyNode> expandNode = std::make_shared<DummyNode>();
+	expandNode->visible = true;
+	expandNode->expanded = node->expanded;
 
-	for (size_t i = 0; i < node.subNodes.size(); i++)
+	for (size_t i = 0; i < node->subNodes.size(); i++)
 	{
-		DummyNode& subNode = node.subNodes[i];
+		DummyNode* subNode = node->subNodes[i].get();
 
-		if (subNode.isExpandToggleNode())
+		if (subNode->isExpandToggleNode())
 		{
-			node.subNodes.erase(node.subNodes.begin() + i);
+			node->subNodes.erase(node->subNodes.begin() + i);
 			i--;
 			continue;
 		}
-		else if (subNode.isGraphNode() && subNode.data->isType(Node::NODE_ENUM_CONSTANT) && !subNode.visible)
+		else if (subNode->isGraphNode() && subNode->data->isType(Node::NODE_ENUM_CONSTANT) && !subNode->visible)
 		{
-			expandNode.invisibleSubNodeCount++;
+			expandNode->invisibleSubNodeCount++;
 			continue;
 		}
 
-		for (DummyNode& subSubNode : subNode.subNodes)
+		for (std::shared_ptr<DummyNode> subSubNode : subNode->subNodes)
 		{
-			if (!subSubNode.visible)
+			if (!subSubNode->visible)
 			{
-				expandNode.invisibleSubNodeCount++;
+				expandNode->invisibleSubNodeCount++;
 			}
 		}
 	}
 
-	if (expandNode.isExpanded() || expandNode.invisibleSubNodeCount)
+	if (expandNode->isExpanded() || expandNode->invisibleSubNodeCount)
 	{
-		node.subNodes.push_back(expandNode);
+		node->subNodes.push_back(expandNode);
 	}
 }
 
-void GraphController::layoutToGrid(DummyNode& node) const
+void GraphController::layoutToGrid(DummyNode* node) const
 {
-	if (!node.visible)
+	if (!node->visible)
 	{
 		return;
 	}
 
-	size_t width = GraphViewStyle::toGridSize(node.size.x);
-	size_t height = GraphViewStyle::toGridSize(node.size.y);
+	size_t width = GraphViewStyle::toGridSize(node->size.x);
+	size_t height = GraphViewStyle::toGridSize(node->size.y);
 
-	size_t incX = width - node.size.x;
-	size_t incY = height - node.size.y;
+	size_t incX = width - node->size.x;
+	size_t incY = height - node->size.y;
 
-	node.size.x = width;
-	node.size.y = height;
+	node->size.x = width;
+	node->size.y = height;
 
-	if (!node.isGraphNode())
+	if (!node->isGraphNode())
 	{
 		return;
 	}
 
 	DummyNode* lastAccessNode = nullptr;
-	for (DummyNode& subNode : node.subNodes)
+	for (std::shared_ptr<DummyNode> subNode : node->subNodes)
 	{
-		if (!subNode.visible)
+		if (!subNode->visible)
 		{
 			continue;
 		}
 
-		if (subNode.isAccessNode())
+		if (subNode->isAccessNode())
 		{
-			subNode.size.x = subNode.size.x + incX;
-			lastAccessNode = &subNode;
+			subNode->size.x = subNode->size.x + incX;
+			lastAccessNode = subNode.get();
 		}
-		else if (subNode.isExpandToggleNode())
+		else if (subNode->isExpandToggleNode())
 		{
-			subNode.position.x = subNode.position.x + incX;
+			subNode->position.x = subNode->position.x + incX;
 		}
 	}
 
@@ -1046,55 +1047,17 @@ void GraphController::layoutGraph(bool sort)
 	grid.layoutBuckets();
 }
 
-DummyNode* GraphController::findDummyNodeRecursive(std::vector<DummyNode>& nodes, Id tokenId) const
+DummyNode* GraphController::getDummyGraphNodeById(Id tokenId) const
 {
-	for (DummyNode& node : nodes)
+	std::map<Id, DummyNode*>::const_iterator it = m_dummyGraphNodes.find(tokenId);
+	if (it != m_dummyGraphNodes.end())
 	{
-		if (node.isGraphNode() && node.data->getId() == tokenId)
-		{
-			return &node;
-		}
-
-		DummyNode* result = findDummyNodeRecursive(node.subNodes, tokenId);
-		if (result != nullptr)
-		{
-			return result;
-		}
+		return it->second;
 	}
 
 	return nullptr;
 }
 
-DummyNode* GraphController::findTopLevelDummyNodeRecursive(std::vector<DummyNode>& nodes, Id tokenId) const
-{
-	for (DummyNode& node : nodes)
-	{
-		if (node.isGraphNode() && node.data->getId() == tokenId)
-		{
-			return &node;
-		}
-	}
-
-	return nullptr;
-}
-
-DummyNode* GraphController::findDummyNodeAccessRecursive(
-	std::vector<DummyNode>& nodes, Id parentId, TokenComponentAccess::AccessType type
-) const {
-	DummyNode* node = findDummyNodeRecursive(nodes, parentId);
-	if (node)
-	{
-		for (DummyNode& subNode : node->subNodes)
-		{
-			if (subNode.isAccessNode() && subNode.accessType == type)
-			{
-				return &subNode;
-			}
-		}
-	}
-	return nullptr;
-}
-
 void GraphController::buildGraph(MessageBase* message)
 {
 	if (!message->isReplayed())

src/lib/component/controller/GraphController.h

@@ -61,38 +61,38 @@ private:
 	void clear();
 
 	void createDummyGraphForTokenIds(const std::vector<Id>& tokenIds, const std::shared_ptr<Graph> graph);
-	DummyNode createDummyNodeTopDown(Node* node);
+	std::shared_ptr<DummyNode> createDummyNodeTopDown(Node* node);
 
 	void autoExpandActiveNode(const std::vector<Id>& activeTokenIds);
 
 	void setActiveAndVisibility(const std::vector<Id>& activeTokenIds);
-	void setNodeActiveRecursive(DummyNode& node, const std::vector<Id>& activeTokenIds, bool* noActive) const;
-	void removeImplicitChildrenRecursive(DummyNode& node);
-	bool setNodeVisibilityRecursiveBottomUp(DummyNode& node, bool noActive) const;
-	void setNodeVisibilityRecursiveTopDown(DummyNode& node, bool parentExpanded) const;
+	void setNodeActiveRecursive(DummyNode* node, const std::vector<Id>& activeTokenIds, bool* noActive) const;
+	void removeImplicitChildrenRecursive(DummyNode* node);
+	bool setNodeVisibilityRecursiveBottomUp(DummyNode* node, bool noActive) const;
+	void setNodeVisibilityRecursiveTopDown(DummyNode* node, bool parentExpanded) const;
 
 	void bundleNodes();
 	void bundleNodesAndEdgesMatching(std::function<bool(const DummyNode::BundleInfo&)> matcher, size_t count, const std::string& name);
-	void bundleNodesMatching(std::list<DummyNode*>& nodes, std::function<bool(const DummyNode&)> matcher, const std::string& name);
+	void bundleNodesMatching(std::list<std::shared_ptr<DummyNode>>& nodes, std::function<bool(const DummyNode*)> matcher, const std::string& name);
 	void bundleNodesByType();
 
 	void layoutNesting();
-	void layoutNestingRecursive(DummyNode& node) const;
-	void addExpandToggleNode(DummyNode& node) const;
-	void layoutToGrid(DummyNode& node) const;
+	void layoutNestingRecursive(DummyNode* node) const;
+	void addExpandToggleNode(DummyNode* node) const;
+	void layoutToGrid(DummyNode* node) const;
 
 	void layoutGraph(bool sort = false);
 
-	DummyNode* findDummyNodeRecursive(std::vector<DummyNode>& nodes, Id tokenId) const;
-	DummyNode* findTopLevelDummyNodeRecursive(std::vector<DummyNode>& nodes, Id tokenId) const;
-	DummyNode* findDummyNodeAccessRecursive(std::vector<DummyNode>& nodes, Id parentId, TokenComponentAccess::AccessType type) const;
+	DummyNode* getDummyGraphNodeById(Id tokenId) const;
 
 	void buildGraph(MessageBase* message);
 
 	StorageAccess* m_storageAccess;
 
-	std::vector<DummyNode> m_dummyNodes;
-	std::vector<DummyEdge> m_dummyEdges;
+	std::vector<std::shared_ptr<DummyNode>> m_dummyNodes;
+	std::vector<std::shared_ptr<DummyEdge>> m_dummyEdges;
+
+	std::map<Id, DummyNode*> m_dummyGraphNodes;
 
 	std::vector<Id> m_activeNodeIds;
 	std::vector<Id> m_activeEdgeIds;

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

@@ -130,19 +130,20 @@ BucketGrid::BucketGrid(Vec2i viewSize)
 	m_buckets[0][0] = Bucket(0, 0);
 }
 
-void BucketGrid::createBuckets(std::vector<DummyNode>& nodes, const std::vector<DummyEdge>& edges)
-{
+void BucketGrid::createBuckets(
+	std::vector<std::shared_ptr<DummyNode>>& nodes, const std::vector<std::shared_ptr<DummyEdge>>& edges
+){
 	if (!nodes.size())
 	{
 		return;
 	}
 
 	bool activeNodeAdded = false;
-	for (DummyNode& node : nodes)
+	for (std::shared_ptr<DummyNode> node : nodes)
 	{
-		if (node.hasActiveSubNode() || !edges.size())
+		if (node->hasActiveSubNode() || !edges.size())
 		{
-			addNode(&node);
+			addNode(node.get());
 			activeNodeAdded = true;
 		}
 	}
@@ -154,13 +155,13 @@ void BucketGrid::createBuckets(std::vector<DummyNode>& nodes, const std::vector<
 
 	if (!activeNodeAdded)
 	{
-		addNode(&nodes[0]);
+		addNode(nodes[0].get());
 	}
 
 	std::vector<const DummyEdge*> remainingEdges;
-	for (const DummyEdge& edge : edges)
+	for (std::shared_ptr<DummyEdge> edge : edges)
 	{
-		remainingEdges.push_back(&edge);
+		remainingEdges.push_back(edge.get());
 	}
 
 	size_t i = 0;
@@ -265,18 +266,19 @@ void BucketGrid::layoutBuckets()
 	}
 }
 
-DummyNode* BucketGrid::findTopMostDummyNodeRecursive(std::vector<DummyNode>& nodes, Id tokenId, DummyNode* top)
-{
-	for (DummyNode& node : nodes)
+DummyNode* BucketGrid::findTopMostDummyNodeRecursive(
+	std::vector<std::shared_ptr<DummyNode>>& nodes, Id tokenId, DummyNode* top
+){
+	for (std::shared_ptr<DummyNode> node : nodes)
 	{
-		DummyNode* t = (top ? top : &node);
+		DummyNode* t = (top ? top : node.get());
 
-		if (node.visible && node.tokenId == tokenId)
+		if (node->visible && node->tokenId == tokenId)
 		{
 			return t;
 		}
 
-		DummyNode* result = findTopMostDummyNodeRecursive(node.subNodes, tokenId, t);
+		DummyNode* result = findTopMostDummyNodeRecursive(node->subNodes, tokenId, t);
 		if (result != nullptr)
 		{
 			return result;

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

@@ -43,12 +43,15 @@ class BucketGrid
 {
 public:
 	BucketGrid(Vec2i viewSize);
-	void createBuckets(std::vector<DummyNode>& nodes, const std::vector<DummyEdge>& edges);
+	void createBuckets(
+		std::vector<std::shared_ptr<DummyNode>>& nodes,
+		const std::vector<std::shared_ptr<DummyEdge>>& edges);
 	void sortBuckets();
 	void layoutBuckets();
 
 private:
-	DummyNode* findTopMostDummyNodeRecursive(std::vector<DummyNode>& nodes, Id tokenId, DummyNode* top = nullptr);
+	DummyNode* findTopMostDummyNodeRecursive(
+		std::vector<std::shared_ptr<DummyNode>>& nodes, Id tokenId, DummyNode* top = nullptr);
 
 	void addNode(DummyNode* node);
 	bool addNode(DummyNode* owner, DummyNode* target, bool horizontal);

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

@@ -73,9 +73,9 @@ public:
 
 	bool hasVisibleSubNode() const
 	{
-		for (const DummyNode& node : subNodes)
+		for (std::shared_ptr<DummyNode> node : subNodes)
 		{
-			if (node.visible)
+			if (node->visible)
 			{
 				return true;
 			}
@@ -91,9 +91,9 @@ public:
 			return true;
 		}
 
-		for (const DummyNode& node : subNodes)
+		for (std::shared_ptr<DummyNode> node : subNodes)
 		{
-			if (node.hasActiveSubNode())
+			if (node->hasActiveSubNode())
 			{
 				return true;
 			}
@@ -111,9 +111,9 @@ public:
 			count += 1;
 		}
 
-		for (const DummyNode& node : subNodes)
+		for (std::shared_ptr<DummyNode> node : subNodes)
 		{
-			count += node.getActiveSubNodeCount();
+			count += node->getActiveSubNodeCount();
 		}
 
 		return count;
@@ -126,9 +126,9 @@ public:
 			return true;
 		}
 
-		for (const DummyNode& node : subNodes)
+		for (std::shared_ptr<DummyNode> node : subNodes)
 		{
-			if (node.hasConnectedSubNode())
+			if (node->hasConnectedSubNode())
 			{
 				return true;
 			}
@@ -146,9 +146,9 @@ public:
 			count += 1;
 		}
 
-		for (const DummyNode& node : subNodes)
+		for (std::shared_ptr<DummyNode> node : subNodes)
 		{
-			count += node.getConnectedSubNodeCount();
+			count += node->getConnectedSubNodeCount();
 		}
 
 		return count;
@@ -163,9 +163,9 @@ public:
 			nodes.push_back(this);
 		}
 
-		for (const DummyNode& node : subNodes)
+		for (std::shared_ptr<DummyNode> node : subNodes)
 		{
-			utility::append(nodes, node.getConnectedSubNodes());
+			utility::append(nodes, node->getConnectedSubNodes());
 		}
 
 		return nodes;
@@ -174,9 +174,9 @@ public:
 	std::vector<const DummyNode*> getAllBundledNodes() const
 	{
 		std::vector<const DummyNode*> nodes;
-		for (const DummyNode& node : bundledNodes)
+		for (std::shared_ptr<DummyNode> node : bundledNodes)
 		{
-			utility::append(nodes, node.getConnectedSubNodes());
+			utility::append(nodes, node->getConnectedSubNodes());
 		}
 		return nodes;
 	}
@@ -200,7 +200,7 @@ public:
 	Id topLevelAncestorId;
 	Id tokenId;
 
-	std::vector<DummyNode> subNodes;
+	std::vector<std::shared_ptr<DummyNode>> subNodes;
 
 	// GraphNode
 	const Node* data;
@@ -221,7 +221,7 @@ public:
 	BundleInfo bundleInfo;
 
 	// BundleNode
-	std::vector<DummyNode> bundledNodes;
+	std::vector<std::shared_ptr<DummyNode>> bundledNodes;
 	size_t bundledNodeCount;
 };
 

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

@@ -170,7 +170,7 @@ MatrixDynamicBase<int> GraphLayouter::buildLaplacianMatrix(
 		{
 			for(unsigned int i = 0; i < remainingNodes.front().subNodes.size(); i++)
 			{
-				remainingNodes.push(remainingNodes.front().subNodes[i]);
+				remainingNodes.push(*remainingNodes.front().subNodes[i].get());
 			}
 		}
 

src/lib/component/view/GraphView.h

@@ -18,7 +18,9 @@ public:
 	virtual std::string getName() const;
 
 	virtual void rebuildGraph(
-		std::shared_ptr<Graph> graph, const std::vector<DummyNode>& nodes, const std::vector<DummyEdge>& edges) = 0;
+		std::shared_ptr<Graph> graph,
+		const std::vector<std::shared_ptr<DummyNode>>& nodes,
+		const std::vector<std::shared_ptr<DummyEdge>>& edges) = 0;
 	virtual void clear() = 0;
 
 	virtual void focusTokenIds(const std::vector<Id>& focusedTokenIds) = 0;

src/lib/data/SqliteStorage.cpp

@@ -776,6 +776,8 @@ void SqliteStorage::setupTables()
 			"FOREIGN KEY(edge_id) REFERENCES edge(id) ON DELETE CASCADE);"
 	);
 
+	SqliteIndex("component_access_edge_id_index", "component_access(edge_id)").createOnDatabase(m_database);
+
 	m_database.execDML(
 		"CREATE TABLE IF NOT EXISTS comment_location("
 			"id INTEGER NOT NULL, "

src/lib/utility/scheduling/TaskGroupParallel.cpp

@@ -1,7 +1,5 @@
 #include "utility/scheduling/TaskGroupParallel.h"
 
-#include <thread>
-
 TaskGroupParallel::TaskGroupParallel()
 {
 }

src/lib/utility/scheduling/TaskGroupParallel.h

@@ -1,8 +1,10 @@
 #ifndef TASK_GROUP_PARALLEL_H
 #define TASK_GROUP_PARALLEL_H
 
-#include "utility/scheduling/TaskGroup.h"
 #include <mutex>
+#include <thread>
+
+#include "utility/scheduling/TaskGroup.h"
 
 class TaskGroupParallel
 	: public TaskGroup

src/lib_gui/qt/view/QtGraphView.cpp

@@ -81,8 +81,8 @@ void QtGraphView::refreshView()
 
 void QtGraphView::rebuildGraph(
 	std::shared_ptr<Graph> graph,
-	const std::vector<DummyNode>& nodes,
-	const std::vector<DummyEdge>& edges
+	const std::vector<std::shared_ptr<DummyNode>>& nodes,
+	const std::vector<std::shared_ptr<DummyEdge>>& edges
 ){
 	m_rebuildGraphFunctor(graph, nodes, edges);
 }
@@ -193,8 +193,8 @@ QtGraphicsView* QtGraphView::getView() const
 
 void QtGraphView::doRebuildGraph(
 	std::shared_ptr<Graph> graph,
-	const std::vector<DummyNode>& nodes,
-	const std::vector<DummyEdge>& edges
+	const std::vector<std::shared_ptr<DummyNode>>& nodes,
+	const std::vector<std::shared_ptr<DummyEdge>>& edges
 ){
 	if (m_transition && m_transition->currentTime() < m_transition->totalDuration())
 	{
@@ -207,13 +207,13 @@ void QtGraphView::doRebuildGraph(
 	size_t activeNodeCount = 0;
 	for (unsigned int i = 0; i < nodes.size(); i++)
 	{
-		activeNodeCount += nodes[i].getActiveSubNodeCount();
+		activeNodeCount += nodes[i]->getActiveSubNodeCount();
 	}
 
 	m_nodes.clear();
 	for (unsigned int i = 0; i < nodes.size(); i++)
 	{
-		std::shared_ptr<QtGraphNode> node = createNodeRecursive(view, NULL, nodes[i], activeNodeCount > 1);
+		std::shared_ptr<QtGraphNode> node = createNodeRecursive(view, NULL, nodes[i].get(), activeNodeCount > 1);
 		if (node)
 		{
 			m_nodes.push_back(node);
@@ -233,7 +233,7 @@ void QtGraphView::doRebuildGraph(
 	m_edges.clear();
 	for (unsigned int i = 0; i < edges.size(); i++)
 	{
-		std::shared_ptr<QtGraphEdge> edge = createEdge(view, edges[i]);
+		std::shared_ptr<QtGraphEdge> edge = createEdge(view, edges[i].get());
 		if (edge)
 		{
 			m_edges.push_back(edge);
@@ -296,34 +296,34 @@ std::shared_ptr<QtGraphNode> QtGraphView::findNodeRecursive(const std::list<std:
 }
 
 std::shared_ptr<QtGraphNode> QtGraphView::createNodeRecursive(
-	QGraphicsView* view, std::shared_ptr<QtGraphNode> parentNode, const DummyNode& node, bool multipleActive
+	QGraphicsView* view, std::shared_ptr<QtGraphNode> parentNode, const DummyNode* node, bool multipleActive
 ){
-	if (!node.visible)
+	if (!node->visible)
 	{
 		return NULL;
 	}
 
 	std::shared_ptr<QtGraphNode> newNode;
-	if (node.isGraphNode())
+	if (node->isGraphNode())
 	{
-		newNode = std::make_shared<QtGraphNodeData>(node.data, node.name, node.hasParent, node.childVisible);
+		newNode = std::make_shared<QtGraphNodeData>(node->data, node->name, node->hasParent, node->childVisible);
 	}
-	else if (node.isAccessNode())
+	else if (node->isAccessNode())
 	{
-		newNode = std::make_shared<QtGraphNodeAccess>(node.accessType);
+		newNode = std::make_shared<QtGraphNodeAccess>(node->accessType);
 	}
-	else if (node.isExpandToggleNode())
+	else if (node->isExpandToggleNode())
 	{
-		newNode = std::make_shared<QtGraphNodeExpandToggle>(node.isExpanded(), node.invisibleSubNodeCount);
+		newNode = std::make_shared<QtGraphNodeExpandToggle>(node->isExpanded(), node->invisibleSubNodeCount);
 	}
-	else if (node.isBundleNode())
+	else if (node->isBundleNode())
 	{
-		newNode = std::make_shared<QtGraphNodeBundle>(node.tokenId, node.getBundledNodeCount(), node.name);
+		newNode = std::make_shared<QtGraphNodeBundle>(node->tokenId, node->getBundledNodeCount(), node->name);
 	}
 
-	newNode->setPosition(node.position);
-	newNode->setSize(node.size);
-	newNode->setIsActive(node.active);
+	newNode->setPosition(node->position);
+	newNode->setSize(node->size);
+	newNode->setIsActive(node->active);
 	newNode->setMultipleActive(multipleActive);
 
 	newNode->addComponent(std::make_shared<QtGraphNodeComponentClickable>(newNode));
@@ -339,9 +339,9 @@ std::shared_ptr<QtGraphNode> QtGraphView::createNodeRecursive(
 		newNode->addComponent(std::make_shared<QtGraphNodeComponentMoveable>(newNode));
 	}
 
-	for (unsigned int i = 0; i < node.subNodes.size(); i++)
+	for (unsigned int i = 0; i < node->subNodes.size(); i++)
 	{
-		std::shared_ptr<QtGraphNode> subNode = createNodeRecursive(view, newNode, node.subNodes[i], multipleActive);
+		std::shared_ptr<QtGraphNode> subNode = createNodeRecursive(view, newNode, node->subNodes[i].get(), multipleActive);
 		if (subNode)
 		{
 			newNode->addSubNode(subNode);
@@ -353,20 +353,20 @@ std::shared_ptr<QtGraphNode> QtGraphView::createNodeRecursive(
 	return newNode;
 }
 
-std::shared_ptr<QtGraphEdge> QtGraphView::createEdge(QGraphicsView* view, const DummyEdge& edge)
+std::shared_ptr<QtGraphEdge> QtGraphView::createEdge(QGraphicsView* view, const DummyEdge* edge)
 {
-	if (!edge.visible)
+	if (!edge->visible)
 	{
 		return NULL;
 	}
 
-	std::shared_ptr<QtGraphNode> owner = findNodeRecursive(m_nodes, edge.ownerId);
-	std::shared_ptr<QtGraphNode> target = findNodeRecursive(m_nodes, edge.targetId);
+	std::shared_ptr<QtGraphNode> owner = findNodeRecursive(m_nodes, edge->ownerId);
+	std::shared_ptr<QtGraphNode> target = findNodeRecursive(m_nodes, edge->targetId);
 
 	if (owner != NULL && target != NULL)
 	{
 		std::shared_ptr<QtGraphEdge> qtEdge =
-			std::make_shared<QtGraphEdge>(owner, target, edge.data, edge.getWeight(), edge.active, edge.getDirection());
+			std::make_shared<QtGraphEdge>(owner, target, edge->data, edge->getWeight(), edge->active, edge->getDirection());
 
 		owner->addOutEdge(qtEdge);
 		target->addInEdge(qtEdge);

src/lib_gui/qt/view/QtGraphView.h

@@ -31,7 +31,10 @@ public:
 	virtual void initView();
 	virtual void refreshView();
 
-	virtual void rebuildGraph(std::shared_ptr<Graph> graph, const std::vector<DummyNode>& nodes, const std::vector<DummyEdge>& edges);
+	virtual void rebuildGraph(
+		std::shared_ptr<Graph> graph,
+		const std::vector<std::shared_ptr<DummyNode>>& nodes,
+		const std::vector<std::shared_ptr<DummyEdge>>& edges);
 	virtual void clear();
 
 	virtual void focusTokenIds(const std::vector<Id>& focusedTokenIds);
@@ -51,7 +54,10 @@ private:
 
 	QtGraphicsView* getView() const;
 
-	void doRebuildGraph(std::shared_ptr<Graph> graph, const std::vector<DummyNode>& nodes, const std::vector<DummyEdge>& edges);
+	void doRebuildGraph(
+		std::shared_ptr<Graph> graph,
+		const std::vector<std::shared_ptr<DummyNode>>& nodes,
+		const std::vector<std::shared_ptr<DummyEdge>>& edges);
 	void doClear();
 	void doResize();
 	void doRefreshView();
@@ -62,8 +68,8 @@ private:
 	std::shared_ptr<QtGraphNode> findNodeRecursive(const std::list<std::shared_ptr<QtGraphNode>>& nodes, Id tokenId);
 
 	std::shared_ptr<QtGraphNode> createNodeRecursive(
-		QGraphicsView* view, std::shared_ptr<QtGraphNode> parentNode, const DummyNode& node, bool multipleActive);
-	std::shared_ptr<QtGraphEdge> createEdge(QGraphicsView* view, const DummyEdge& edge);
+		QGraphicsView* view, std::shared_ptr<QtGraphNode> parentNode, const DummyNode* node, bool multipleActive);
+	std::shared_ptr<QtGraphEdge> createEdge(QGraphicsView* view, const DummyEdge* edge);
 
 	QRectF itemsBoundingRect(const std::list<std::shared_ptr<QtGraphNode>>& items) const;
 	QRectF getSceneRect(const std::list<std::shared_ptr<QtGraphNode>>& items) const;
@@ -77,7 +83,11 @@ private:
 
 	void createTransition();
 
-	QtThreadedFunctor<std::shared_ptr<Graph>, const std::vector<DummyNode>&, const std::vector<DummyEdge>&> m_rebuildGraphFunctor;
+	QtThreadedFunctor<
+		std::shared_ptr<Graph>,
+		const std::vector<std::shared_ptr<DummyNode>>&,
+		const std::vector<std::shared_ptr<DummyEdge>>&
+	> m_rebuildGraphFunctor;
 	QtThreadedFunctor<void> m_clearFunctor;
 	QtThreadedFunctor<void> m_resizeFunctor;
 	QtThreadedFunctor<void> m_refreshFunctor;