logic: refactored GraphAccess and GraphController to use single call that returns Graph

This change refactors the GraphController to use the GraphAccess only with a single call that returns a Graph. The Graph
contains all information for visually representing the active Token with all parent and child nodes and edges. This
reduces coupling of the data and logic tiers.

src/app/qt/view/QtGraphView.cpp

@@ -6,6 +6,7 @@
 #include <QGraphicsView>
 
 #include "qt/utility/utilityQt.h"
+
 #include "qt/view/QtViewWidgetWrapper.h"
 #include "qt/view/graphElements/QtGraphEdge.h"
 #include "qt/view/graphElements/QtGraphNode.h"

src/app/qt/view/QtGraphView.h

@@ -1,11 +1,12 @@
 #ifndef QT_GRAPH_VIEW_H
 #define QT_GRAPH_VIEW_H
 
-#include "component/view/GraphView.h"
 #include "qt/utility/QtThreadedFunctor.h"
 #include "utility/math/Vector4.h"
 #include "utility/types.h"
 
+#include "component/view/GraphView.h"
+
 struct DummyEdge;
 struct DummyNode;
 class QGraphicsView;

src/app/qt/view/graphElements/QtGraphEdge.cpp

@@ -28,6 +28,7 @@ QtGraphEdge::QtGraphEdge(const std::weak_ptr<GraphNode>& owner, const std::weak_
     blackPen.setWidth(2);
 
 	this->setPen(blackPen);
+	this->setZValue(1); // Used to draw edges always on top of nodes.
 }
 
 QtGraphEdge::~QtGraphEdge()

src/app/qt/view/graphElements/QtGraphEdge.h

@@ -5,9 +5,10 @@
 
 #include <QGraphicsItem>
 
-#include "component/view/graphElements/GraphEdge.h"
 #include "utility/messaging/type/MessageActivateToken.h"
 
+#include "component/view/graphElements/GraphEdge.h"
+
 class GraphNode;
 
 class QtGraphEdge

src/app/qt/view/graphElements/QtGraphNode.cpp

@@ -73,7 +73,7 @@ bool QtGraphNode::addOutEdge(const std::shared_ptr<GraphEdge>& edge)
 
 bool QtGraphNode::addInEdge(const std::weak_ptr<GraphEdge>& edge)
 {
-	for (std::list<std::weak_ptr<GraphEdge> >::iterator it = m_inEdges.begin(); it != m_inEdges.end(); it++)
+	for (std::list<std::weak_ptr<GraphEdge>>::iterator it = m_inEdges.begin(); it != m_inEdges.end(); it++)
 	{
 		std::shared_ptr<GraphEdge> existingEdge = it->lock();
 		if (existingEdge != NULL)
@@ -92,7 +92,7 @@ bool QtGraphNode::addInEdge(const std::weak_ptr<GraphEdge>& edge)
 
 void QtGraphNode::removeOutEdge(GraphEdge* edge)
 {
-	std::list<std::shared_ptr<GraphEdge> >::iterator it = m_outEdges.begin();
+	std::list<std::shared_ptr<GraphEdge>>::iterator it = m_outEdges.begin();
 	while (it != m_outEdges.end())
 	{
 		if ((*it).get() == edge)
@@ -105,7 +105,7 @@ void QtGraphNode::removeOutEdge(GraphEdge* edge)
 	}
 }
 
-std::list<std::shared_ptr<GraphNode> > QtGraphNode::getSubNodes() const
+std::list<std::shared_ptr<GraphNode>> QtGraphNode::getSubNodes() const
 {
 	return m_subNodes;
 }
@@ -128,12 +128,12 @@ void QtGraphNode::notifyParentMoved()
 
 void QtGraphNode::notifyEdgesAfterMove()
 {
-	for (std::list<std::shared_ptr<GraphEdge> >::iterator it = m_outEdges.begin(); it != m_outEdges.end(); it++)
+	for (std::list<std::shared_ptr<GraphEdge>>::iterator it = m_outEdges.begin(); it != m_outEdges.end(); it++)
 	{
 		(*it)->ownerMoved();
 	}
 
-	std::list<std::weak_ptr<GraphEdge> >::iterator it2 = m_inEdges.begin();
+	std::list<std::weak_ptr<GraphEdge>>::iterator it2 = m_inEdges.begin();
 	while (it2 != m_inEdges.end())
 	{
 		 std::shared_ptr<GraphEdge> edge = it2->lock();
@@ -148,7 +148,7 @@ void QtGraphNode::notifyEdgesAfterMove()
 		 }
 	}
 
-	for (std::list<std::shared_ptr<GraphNode> >::iterator it3 = m_subNodes.begin(); it3 != m_subNodes.end(); it3++)
+	for (std::list<std::shared_ptr<GraphNode>>::iterator it3 = m_subNodes.begin(); it3 != m_subNodes.end(); it3++)
 	{
 		(*it3)->notifyParentMoved();
 	}

src/app/qt/view/graphElements/QtGraphNode.h

@@ -3,9 +3,10 @@
 
 #include <QGraphicsItem>
 
-#include "component/view/graphElements/GraphNode.h"
-#include "utility/messaging/type/MessageActivateToken.h"
 #include "utility/math/Vector2.h"
+#include "utility/messaging/type/MessageActivateToken.h"
+
+#include "component/view/graphElements/GraphNode.h"
 
 class QtGraphEdge;
 
@@ -26,7 +27,7 @@ public:
 
 	virtual void removeOutEdge(GraphEdge* edge);
 
-	virtual std::list<std::shared_ptr<GraphNode> > getSubNodes() const;
+	virtual std::list<std::shared_ptr<GraphNode>> getSubNodes() const;
 	virtual void addSubNode(const std::shared_ptr<GraphNode>& node);
 
 	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event);
@@ -36,13 +37,13 @@ public:
 protected:
 	void notifyEdgesAfterMove();
 
-	std::list<std::shared_ptr<GraphEdge> > m_outEdges;
-	std::list<std::weak_ptr<GraphEdge> > m_inEdges;
+	std::list<std::shared_ptr<GraphEdge>> m_outEdges;
+	std::list<std::weak_ptr<GraphEdge>> m_inEdges;
 
 private:
 	QGraphicsTextItem* m_text;
 
-	std::list<std::shared_ptr<GraphNode> > m_subNodes;
+	std::list<std::shared_ptr<GraphNode>> m_subNodes;
 };
 
 #endif // QT_GRAPH_NODE_H

src/lib/component/controller/GraphController.cpp

@@ -1,12 +1,13 @@
 #include "component/controller/GraphController.h"
 
-#include <unordered_set>
+#include <set>
+
+#include "utility/logging/logging.h"
 
 #include "component/view/graphElements/GraphEdge.h"
 #include "component/view/graphElements/GraphNode.h"
 #include "component/view/GraphView.h"
 #include "data/access/GraphAccess.h"
-#include "utility/logging/logging.h"
 
 GraphController::GraphController(GraphAccess* graphAccess)
 	: m_graphAccess(graphAccess)
@@ -19,12 +20,12 @@ GraphController::~GraphController()
 
 void GraphController::handleMessage(MessageActivateToken* message)
 {
-	createDummyGraph(message->tokenId, &GraphLayouter::layoutSimpleRing);
+	createDummyGraphForTokenId(message->tokenId, &GraphLayouter::layoutSimpleRing);
 }
 
 void GraphController::handleMessage(MessageActivateTokens* message)
 {
-	createDummyGraph(message->tokenIds[0], &GraphLayouter::layoutSimpleRing);
+	createDummyGraphForTokenId(message->tokenIds[0], &GraphLayouter::layoutSimpleRing);
 }
 
 GraphView* GraphController::getView()
@@ -32,250 +33,76 @@ GraphView* GraphController::getView()
 	return Controller::getView<GraphView>();
 }
 
-void GraphController::createDummyGraph(const Id activeId, const LayoutFunction layoutFunction)
+void GraphController::createDummyGraphForTokenId(Id tokenId, const GraphLayouter::LayoutFunction layoutFunction)
 {
 	GraphView* view = getView();
-	if (view != NULL)
+	if (!view)
 	{
-		std::vector<DummyNode> nodes;
+		LOG_ERROR("GraphController has no associated GraphView");
+		return;
+	}
 
-		if (m_graphAccess->checkTokenIsNode(activeId))
+	std::vector<Id> activeTokenIds;
+	activeTokenIds.push_back(tokenId);
+	std::shared_ptr<Graph> graph = m_graphAccess->getGraphForActiveTokenIds(activeTokenIds);
+
+	std::vector<DummyNode> dummyNodes;
+	std::vector<DummyEdge> dummyEdges;
+	std::set<Id> addedNodes;
+
+	graph->forEachNode(
+		[&dummyNodes, &dummyEdges, &addedNodes, this](Node* node)
 		{
-			nodes.push_back(createDummyNode(activeId));
-			std::vector<DummyNode> neighbours = createNeighbourNodes(nodes[0]);
-			nodes.insert(nodes.end(), neighbours.begin(), neighbours.end());
-		}
-		else
-		{
-			std::pair<Id, Id> nodeIds = m_graphAccess->getNodesOfEdge(activeId);
-			nodes.push_back(createDummyNode(nodeIds.first));
-			nodes.push_back(createDummyNode(nodeIds.second));
-		}
-
-		layoutFunction(nodes);
-
-		std::vector<DummyEdge> edges;
-		edges = createEdges(nodes);
-
-		view->rebuildGraph(nodes, edges);
-	}
-}
-
-DummyNode GraphController::createDummyNode(const Id nodeId)
-{
-	DummyNode result("invalid", 0, Vec2i());
-
-	Id topLevelId = findTopLevelNode(nodeId);
-
-	result = buildNodeTopDown(topLevelId);
-
-	return result;
-}
-
-Id GraphController::findTopLevelNode(const Id nodeId)
-{
-	std::vector<std::tuple<Id, Id, Id>> memberEdges = m_graphAccess->getMemberEdgesOfNode(nodeId);
-
-	for (unsigned int i = 0; i < memberEdges.size(); i++)
-	{
-		if (std::get<0>(memberEdges[i]) != nodeId)
-		{
-			return findTopLevelNode(std::get<0>(memberEdges[i]));
-		}
-	}
-
-	return nodeId;
-}
-
-DummyNode GraphController::buildNodeTopDown(const Id nodeId)
-{
-	DummyNode result("invalid", 0, Vec2i());
-
-	result.name = m_graphAccess->getNameForNodeWithId(nodeId);
-	result.tokenId = nodeId;
-
-	std::vector<std::tuple<Id, Id, Id>> memberEdges = m_graphAccess->getMemberEdgesOfNode(nodeId);
-	for (unsigned int i = 0; i < memberEdges.size(); i++)
-	{
-		if (std::get<1>(memberEdges[i]) != nodeId)
-		{
-			result.subNodes.push_back(buildNodeTopDown(std::get<1>(memberEdges[i])));
-		}
-	}
-
-	return result;
-}
-
-std::vector<DummyNode> GraphController::createNeighbourNodes(const Id nodeId)
-{
-	std::vector<DummyNode> result;
-
-	std::vector<std::tuple<Id, Id, Id>> edges;
-	std::vector<std::tuple<Id, Id, Id>> callEdges = m_graphAccess->getCallEdgesOfNode(nodeId);
-	std::vector<std::tuple<Id, Id, Id>> usageEdges = m_graphAccess->getUsageEdgesOfNode(nodeId);
-	std::vector<std::tuple<Id, Id, Id>> typeOfEdges = m_graphAccess->getTypeOfEdgesOfNode(nodeId);
-	std::vector<std::tuple<Id, Id, Id>> returnTypeEdges = m_graphAccess->getReturnTypeOfEdgesOfNode(nodeId);
-	std::vector<std::tuple<Id, Id, Id>> parameterEdges = m_graphAccess->getParameterOfEdgesOfNode(nodeId);
-	std::vector<std::tuple<Id, Id, Id>> inheritanceEdges = m_graphAccess->getInheritanceEdgesOfNode(nodeId);
-
-	if (callEdges.size() > 0)
-	{
-		edges.insert(edges.end(), callEdges.begin(), callEdges.end());
-	}
-	if (usageEdges.size() > 0)
-	{
-		edges.insert(edges.end(), usageEdges.begin(), usageEdges.end());
-	}
-	if (typeOfEdges.size() > 0)
-	{
-		edges.insert(edges.end(), typeOfEdges.begin(), typeOfEdges.end());
-	}
-	if (returnTypeEdges.size() > 0)
-	{
-		edges.insert(edges.end(), returnTypeEdges.begin(), returnTypeEdges.end());
-	}
-	if (parameterEdges.size() > 0)
-	{
-		edges.insert(edges.end(), parameterEdges.begin(), parameterEdges.end());
-	}
-	if (inheritanceEdges.size() > 0)
-	{
-		edges.insert(edges.end(), inheritanceEdges.begin(), inheritanceEdges.end());
-	}
-
-	for (unsigned int i = 0; i < edges.size(); i++)
-	{
-		if (std::get<0>(edges[i]) == nodeId)
-		{
-			result.push_back(createDummyNode(std::get<1>(edges[i])));
-		}
-		else
-		{
-			result.push_back(createDummyNode(std::get<0>(edges[i])));
-		}
-	}
-
-	return result;
-}
-
-std::vector<DummyNode> GraphController::createNeighbourNodes(const DummyNode& node)
-{
-	std::vector<DummyNode> result;
-
-	std::set<DummyNode> tmpNodes; // to make it easier to keep the nodes unique
-
-	result = createNeighbourNodes(node.tokenId);
-	for (unsigned int i = 0; i < result.size(); i++)
-	{
-		tmpNodes.insert(result[i]);
-	}
-
-	for (unsigned int i = 0; i < node.subNodes.size(); i++)
-	{
-		std::vector<DummyNode> tmpNeighbours = createNeighbourNodes(node.subNodes[i].tokenId);
-		for (unsigned int j = 0; j < tmpNeighbours.size(); j++)
-		{
-			tmpNodes.insert(tmpNeighbours[j]);
-		}
-	}
-
-	result.clear();
-
-	for (std::set<DummyNode>::iterator it = tmpNodes.begin(); it != tmpNodes.end(); it++)
-	{
-		result.push_back(*it);
-	}
-
-	return result;
-}
-
-std::vector<DummyEdge> GraphController::createEdges(const std::vector<DummyNode>& nodes)
-{
-	std::vector<DummyEdge> result;
-
-	std::unordered_set<Id> nodeIds; // to help discard edges that point to non-existing nodes in the sub-graph
-	std::queue<DummyNode> nodeQueue;
-	for (unsigned int i = 0; i < nodes.size(); i++)
-	{
-		nodeQueue.push(nodes[i]);
-	}
-
-	while (nodeQueue.size() > 0)
-	{
-		DummyNode n = nodeQueue.front();
-		nodeQueue.pop();
-
-		for (unsigned int i = 0; i < n.subNodes.size(); i++)
-		{
-			nodeQueue.push(n.subNodes[i]);
-		}
-
-		nodeIds.insert(n.tokenId);
-	}
-
-	std::set<DummyEdge> tmpEdges; // to make it easier to keep the edges unique
-	for (unsigned int i = 0; i < nodes.size(); i++)
-	{
-		std::set<DummyEdge> tmp = getNeighbourEdgesOfNode(nodes[i]);
-
-		for (std::set<DummyEdge>::iterator it = tmp.begin(); it != tmp.end(); it++)
-		{
-			if (nodeIds.find(it->ownerId) != nodeIds.end() && nodeIds.find(it->targetId) != nodeIds.end())
+			Node* parent = node->getLastParentNode();
+			Id id = parent->getId();
+			if (addedNodes.find(id) != addedNodes.end())
 			{
-				tmpEdges.insert(tmp.begin(), tmp.end());
+				return;
 			}
+			addedNodes.insert(id);
+
+			dummyNodes.push_back(createDummyNodeTopDown(parent, &dummyEdges));
 		}
-	}
+	);
 
-	for (std::set<DummyEdge>::iterator it = tmpEdges.begin(); it != tmpEdges.end(); it++)
-	{
-		result.push_back(*it);
-	}
-
-	return result;
+	layoutFunction(dummyNodes);
+	view->rebuildGraph(dummyNodes, dummyEdges);
 }
 
-std::set<DummyEdge> GraphController::getNeighbourEdgesOfNode(const DummyNode& node)
+DummyNode GraphController::createDummyNodeTopDown(Node* node, std::vector<DummyEdge>* dummyEdges) const
 {
-	std::set<DummyEdge> result;
+	DummyNode result("invalid", 0, Vec2i());
 
-	std::vector<std::tuple<Id, Id, Id>> callEdges = m_graphAccess->getCallEdgesOfNode(node.tokenId);
-	std::vector<std::tuple<Id, Id, Id>> usageEdges = m_graphAccess->getUsageEdgesOfNode(node.tokenId);
-	std::vector<std::tuple<Id, Id, Id>> typeOfEdges = m_graphAccess->getTypeOfEdgesOfNode(node.tokenId);
-	std::vector<std::tuple<Id, Id, Id>> returnTypeEdges = m_graphAccess->getReturnTypeOfEdgesOfNode(node.tokenId);
-	std::vector<std::tuple<Id, Id, Id>> parameterEdges = m_graphAccess->getParameterOfEdgesOfNode(node.tokenId);
-	std::vector<std::tuple<Id, Id, Id>> inheritanceEdges = m_graphAccess->getInheritanceEdgesOfNode(node.tokenId);
+	result.name = node->getName();
+	result.tokenId = node->getId();
 
-	for (unsigned int i = 0; i < callEdges.size(); i++)
-	{
-		result.insert(DummyEdge(std::get<0>(callEdges[i]), std::get<1>(callEdges[i]), std::get<2>(callEdges[i]), Edge::EDGE_CALL));
-	}
-	for (unsigned int i = 0; i < usageEdges.size(); i++)
-	{
-		result.insert(DummyEdge(std::get<0>(usageEdges[i]), std::get<1>(usageEdges[i]), std::get<2>(usageEdges[i]), Edge::EDGE_USAGE));
-	}
-	for (unsigned int i = 0; i < typeOfEdges.size(); i++)
-	{
-		result.insert(DummyEdge(std::get<0>(typeOfEdges[i]), std::get<1>(typeOfEdges[i]), std::get<2>(typeOfEdges[i]), Edge::EDGE_TYPE_OF));
-	}
-	for (unsigned int i = 0; i < returnTypeEdges.size(); i++)
-	{
-		result.insert(DummyEdge(std::get<0>(returnTypeEdges[i]), std::get<1>(returnTypeEdges[i]), std::get<2>(returnTypeEdges[i]), Edge::EDGE_RETURN_TYPE_OF));
-	}
-	for (unsigned int i = 0; i < parameterEdges.size(); i++)
-	{
-		result.insert(DummyEdge(std::get<0>(parameterEdges[i]), std::get<1>(parameterEdges[i]), std::get<2>(parameterEdges[i]), Edge::EDGE_PARAMETER_TYPE_OF));
-	}
-	for (unsigned int i = 0; i < inheritanceEdges.size(); i++)
-	{
-		result.insert(DummyEdge(std::get<0>(inheritanceEdges[i]), std::get<1>(inheritanceEdges[i]), std::get<2>(inheritanceEdges[i]), Edge::EDGE_INHERITANCE));
-	}
+	node->forEachChildNode(
+		[&result, dummyEdges, this](Node* child)
+		{
+			result.subNodes.push_back(createDummyNodeTopDown(child, dummyEdges));
+		}
+	);
 
-	for (unsigned int i = 0; i < node.subNodes.size(); i++)
-	{
-		std::set<DummyEdge> tmpNeighbours = getNeighbourEdgesOfNode(node.subNodes[i]);
-		result.insert(tmpNeighbours.begin(), tmpNeighbours.end());
-	}
+	node->forEachEdge(
+		[&result, node, dummyEdges](Edge* edge)
+		{
+			if (edge->isType(Edge::EDGE_MEMBER))
+			{
+				return;
+			}
+
+			for (const DummyEdge& dummy : *dummyEdges)
+			{
+				if (dummy.tokenId == edge->getId())
+				{
+					return;
+				}
+			}
+
+			dummyEdges->push_back(
+				DummyEdge(edge->getFrom()->getId(), edge->getTo()->getId(), edge->getId(), edge->getType()));
+		}
+	);
 
 	return result;
 }

src/lib/component/controller/GraphController.h

@@ -1,19 +1,20 @@
 #ifndef GRAPH_CONTROLLER_H
 #define GRAPH_CONTROLLER_H
 
-#include <set>
 #include <vector>
 
-#include "component/controller/Controller.h"
-#include "component/controller/GraphLayouter.h"
 #include "utility/messaging/MessageListener.h"
 #include "utility/messaging/type/MessageActivateToken.h"
 #include "utility/messaging/type/MessageActivateTokens.h"
 
+#include "component/controller/Controller.h"
+#include "component/controller/GraphLayouter.h"
+
 struct DummyNode;
 struct DummyEdge;
 class GraphView;
 class GraphAccess;
+class Node;
 
 class GraphController
 	: public Controller
@@ -29,17 +30,9 @@ private:
 	virtual void handleMessage(MessageActivateTokens* message);
 
 	GraphView* getView();
-	void createDummyGraph(const Id activeId, const LayoutFunction layoutFunction);
 
-	DummyNode createDummyNode(const Id nodeId);
-	Id findTopLevelNode(const Id nodeId);
-	DummyNode buildNodeTopDown(const Id nodeId);
-
-	std::vector<DummyNode> createNeighbourNodes(const Id nodeId);
-	std::vector<DummyNode> createNeighbourNodes(const DummyNode& node);
-
-	std::vector<DummyEdge> createEdges(const std::vector<DummyNode>& nodes);
-	std::set<DummyEdge> getNeighbourEdgesOfNode(const DummyNode& node);
+	void createDummyGraphForTokenId(Id tokenId, const GraphLayouter::LayoutFunction layoutFunction);
+	DummyNode createDummyNodeTopDown(Node* node, std::vector<DummyEdge>* dummyEdges) const;
 
 	GraphAccess* m_graphAccess;
 };

src/lib/component/controller/GraphLayouter.h

@@ -5,11 +5,11 @@
 
 struct DummyNode;
 
-typedef void (*LayoutFunction)(std::vector<DummyNode>&);
-
 class GraphLayouter
 {
 public:
+	typedef void (*LayoutFunction)(std::vector<DummyNode>&);
+
 	static void layoutSimpleRaster(std::vector<DummyNode>& nodes);
 	static void layoutSimpleRing(std::vector<DummyNode>& nodes);
 };

src/lib/data/Storage.cpp

@@ -347,127 +347,39 @@ std::vector<std::string> Storage::getNamesForNodesWithNamePrefix(const std::stri
 	return names;
 }
 
-std::vector<Id> Storage::getIdsOfNeighbours(const Id id) const
+std::shared_ptr<Graph> Storage::getGraphForActiveTokenIds(const std::vector<Id>& tokenIds) const
 {
-	std::vector<Id> result;
+	std::shared_ptr<Graph> graph = std::make_shared<Graph>();
 
-	Node* node = m_graph.findNode([&](Node* node){
-		return node->getId() == id;
-	});
-
-	if (node != NULL)
+	for (Id tokenId : tokenIds)
 	{
-		std::map<Id, bool> addedIds;
-		addedIds[id] = true;
+		Token* token = m_graph.getTokenById(tokenId);
+		if (!token)
+		{
+			LOG_ERROR_STREAM(<< "Token with id " << tokenId << " was not found");
+			continue;
+		}
 
-		node->forEachEdge(
-				[&result, &addedIds](Edge* e)
+		if (token->isNode())
+		{
+			Node* node = dynamic_cast<Node*>(token);
+			graph->addNodeAndAllChildrenAsPlainCopy(node->getLastParentNode());
+
+			node->forEachEdge(
+				[graph](Edge* edge)
 				{
-					Id fromId = e->getFrom()->getId();
-					if (addedIds.find(fromId) == addedIds.end())
-					{
-						result.push_back(fromId);
-						addedIds[fromId] = true;
-					}
-
-					Id toId = e->getTo()->getId();
-					if (addedIds.find(toId) == addedIds.end())
-					{
-						result.push_back(toId);
-						addedIds[toId] = true;
-					}
+					graph->addEdgeAndAllChildrenAsPlainCopy(edge);
 				}
 			);
+		}
+		else
+		{
+			Edge* edge = dynamic_cast<Edge*>(token);
+			graph->addEdgeAndAllChildrenAsPlainCopy(edge);
+		}
 	}
 
-	return result;
-}
-
-std::vector<std::tuple<Id, Id, Id>> Storage::getNeighbourEdgesOfNode(const Id id) const
-{
-	std::vector<std::tuple<Id, Id, Id>> result;
-
-	Node* node = m_graph.findNode([&](Node* node){
-		return node->getId() == id;
-	});
-
-	if (node != NULL)
-	{
-		node->forEachEdge(
-				[&result](Edge* e)
-				{
-					result.push_back(std::tuple<Id, Id, Id>(e->getFrom()->getId(), e->getTo()->getId(), e->getId()));
-				}
-			);
-	}
-
-	return result;
-}
-
-std::vector<std::tuple<Id, Id, Id>> Storage::getMemberEdgesOfNode(const Id id) const
-{
-	return getEdgesOfTypeOfNode(id, Edge::EdgeType::EDGE_MEMBER);
-}
-
-std::vector<std::tuple<Id, Id, Id>> Storage::getUsageEdgesOfNode(const Id id) const
-{
-	return getEdgesOfTypeOfNode(id, Edge::EdgeType::EDGE_USAGE);
-}
-
-std::vector<std::tuple<Id, Id, Id>> Storage::getCallEdgesOfNode(const Id id) const
-{
-	return getEdgesOfTypeOfNode(id, Edge::EdgeType::EDGE_CALL);
-}
-
-std::vector<std::tuple<Id, Id, Id>> Storage::getTypeOfEdgesOfNode(const Id id) const
-{
-	return getEdgesOfTypeOfNode(id, Edge::EdgeType::EDGE_TYPE_OF);
-}
-
-std::vector<std::tuple<Id, Id, Id>> Storage::getReturnTypeOfEdgesOfNode(const Id id) const
-{
-	return getEdgesOfTypeOfNode(id, Edge::EdgeType::EDGE_RETURN_TYPE_OF);
-}
-
-std::vector<std::tuple<Id, Id, Id>> Storage::getParameterOfEdgesOfNode(const Id id) const
-{
-	return getEdgesOfTypeOfNode(id, Edge::EdgeType::EDGE_PARAMETER_TYPE_OF);
-}
-
-std::vector<std::tuple<Id, Id, Id>> Storage::getInheritanceEdgesOfNode(const Id id) const
-{
-	return getEdgesOfTypeOfNode(id, Edge::EdgeType::EDGE_INHERITANCE);
-}
-
-std::pair<Id, Id> Storage::getNodesOfEdge(const Id id) const
-{
-	std::pair<Id, Id> result;
-
-	Edge* edge = m_graph.findEdge([&](Edge* edge){
-		return edge->getId() == id;
-	});
-
-	if(edge != NULL)
-	{
-		result.first = edge->getFrom()->getId();
-		result.second = edge->getTo()->getId();
-	}
-
-	return result;
-}
-
-bool Storage::checkTokenIsNode(const Id id) const
-{
-	Token* token = m_graph.findToken([&](Token* token){
-		return token->getId() == id;
-	});
-
-	if(token != NULL)
-	{
-		return token->isNode();
-	}
-
-	return false;
+	return graph;
 }
 
 std::vector<Id> Storage::getActiveTokenIdsForId(Id tokenId) const
@@ -790,27 +702,3 @@ void Storage::log(std::string type, std::string str, const ParseLocation& locati
 		<< location.endLineNumber << ":" << location.endColumnNumber << ">"
 	);
 }
-
-std::vector<std::tuple<Id, Id, Id>> Storage::getEdgesOfTypeOfNode(const Id id, const Edge::EdgeType type) const
-{
-	std::vector<std::tuple<Id, Id, Id>> result;
-
-	Node* node = m_graph.findNode([&](Node* node){
-		return node->getId() == id;
-	});
-
-	if (node != NULL)
-	{
-		node->forEachEdge(
-				[&result, &type](Edge* e)
-				{
-					if(e->getType() == type)
-					{
-						result.push_back(std::tuple<Id, Id, Id>(e->getFrom()->getId(), e->getTo()->getId(), e->getId()));
-					}
-				}
-			);
-	}
-
-	return result;
-}

src/lib/data/Storage.h

@@ -68,19 +68,8 @@ public:
 	virtual Id getIdForNodeWithName(const std::string& fullName) const;
 	virtual std::string getNameForNodeWithId(Id id) const;
 	virtual std::vector<std::string> getNamesForNodesWithNamePrefix(const std::string& prefix) const;
-	virtual std::vector<Id> getIdsOfNeighbours(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getNeighbourEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getMemberEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getUsageEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getCallEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getTypeOfEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getReturnTypeOfEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getParameterOfEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getInheritanceEdgesOfNode(const Id id) const;
 
-	virtual std::pair<Id, Id> getNodesOfEdge(const Id id) const;
-
-	virtual bool checkTokenIsNode(const Id id) const;
+	virtual std::shared_ptr<Graph> getGraphForActiveTokenIds(const std::vector<Id>& tokenIds) const;
 
 	virtual std::vector<Id> getActiveTokenIdsForId(Id tokenId) const;
 	virtual std::vector<Id> getLocationIdsForTokenIds(const std::vector<Id>& tokenIds) const;
@@ -117,8 +106,6 @@ private:
 
 	void log(std::string type, std::string str, const ParseLocation& location) const;
 
-	std::vector<std::tuple<Id, Id, Id>> getEdgesOfTypeOfNode(const Id id, const Edge::EdgeType type) const;
-
 	StorageGraph m_graph;
 	TokenLocationCollection m_locationCollection;
 	SearchIndex m_index;

src/lib/data/access/GraphAccess.h

@@ -1,14 +1,13 @@
 #ifndef GRAPH_ACCESS_H
 #define GRAPH_ACCESS_H
 
+#include <memory>
 #include <string>
 #include <vector>
 
+#include "data/graph/Graph.h"
 #include "utility/types.h"
 
-class Edge;
-class Token;
-
 class GraphAccess
 {
 public:
@@ -17,19 +16,8 @@ public:
 	virtual Id getIdForNodeWithName(const std::string& name) const = 0;
 	virtual std::string getNameForNodeWithId(Id id) const = 0;
 	virtual std::vector<std::string> getNamesForNodesWithNamePrefix(const std::string& prefix) const = 0;
-	virtual std::vector<Id> getIdsOfNeighbours(const Id id) const = 0;
-	virtual std::vector<std::tuple<Id, Id, Id>> getNeighbourEdgesOfNode(const Id id) const = 0;
-	virtual std::vector<std::tuple<Id, Id, Id>> getMemberEdgesOfNode(const Id id) const = 0;
-	virtual std::vector<std::tuple<Id, Id, Id>> getUsageEdgesOfNode(const Id id) const = 0;
-	virtual std::vector<std::tuple<Id, Id, Id>> getCallEdgesOfNode(const Id id) const = 0;
-	virtual std::vector<std::tuple<Id, Id, Id>> getTypeOfEdgesOfNode(const Id id) const = 0;
-	virtual std::vector<std::tuple<Id, Id, Id>> getReturnTypeOfEdgesOfNode(const Id id) const = 0;
-	virtual std::vector<std::tuple<Id, Id, Id>> getParameterOfEdgesOfNode(const Id id) const = 0;
-	virtual std::vector<std::tuple<Id, Id, Id>> getInheritanceEdgesOfNode(const Id id) const = 0;
 
-	virtual std::pair<Id, Id> getNodesOfEdge(const Id id) const = 0;
-
-	virtual bool checkTokenIsNode(const Id id) const = 0;
+	virtual std::shared_ptr<Graph> getGraphForActiveTokenIds(const std::vector<Id>& tokenIds) const = 0;
 
 	virtual std::vector<Id> getActiveTokenIdsForId(Id tokenId) const = 0;
 	virtual std::vector<Id> getLocationIdsForTokenIds(const std::vector<Id>& tokenIds) const = 0;

src/lib/data/access/GraphAccessProxy.cpp

@@ -57,114 +57,14 @@ std::vector<std::string> GraphAccessProxy::getNamesForNodesWithNamePrefix(const
 	return std::vector<std::string>();
 }
 
-std::vector<Id> GraphAccessProxy::getIdsOfNeighbours(const Id id) const
+std::shared_ptr<Graph> GraphAccessProxy::getGraphForActiveTokenIds(const std::vector<Id>& tokenIds) const
 {
 	if (hasSubject())
 	{
-		return m_subject->getIdsOfNeighbours(id);
+		return m_subject->getGraphForActiveTokenIds(tokenIds);
 	}
 
-	return std::vector<Id>();
-}
-
-std::vector<std::tuple<Id, Id, Id>> GraphAccessProxy::getNeighbourEdgesOfNode(const Id id) const
-{
-	if (hasSubject())
-	{
-		return m_subject->getNeighbourEdgesOfNode(id);
-	}
-
-	return std::vector<std::tuple<Id, Id, Id>>();
-}
-
-std::vector<std::tuple<Id, Id, Id>> GraphAccessProxy::getMemberEdgesOfNode(const Id id) const
-{
-	if (hasSubject())
-	{
-		return m_subject->getMemberEdgesOfNode(id);
-	}
-
-	return std::vector<std::tuple<Id, Id, Id>>();
-}
-
-std::vector<std::tuple<Id, Id, Id>> GraphAccessProxy::getUsageEdgesOfNode(const Id id) const
-{
-	if (hasSubject())
-	{
-		return m_subject->getUsageEdgesOfNode(id);
-	}
-
-	return std::vector<std::tuple<Id, Id, Id>>();
-}
-
-std::vector<std::tuple<Id, Id, Id>> GraphAccessProxy::getCallEdgesOfNode(const Id id) const
-{
-	if (hasSubject())
-	{
-		return m_subject->getCallEdgesOfNode(id);
-	}
-
-	return std::vector<std::tuple<Id, Id, Id>>();
-}
-
-std::vector<std::tuple<Id, Id, Id>> GraphAccessProxy::getTypeOfEdgesOfNode(const Id id) const
-{
-	if (hasSubject())
-	{
-		return m_subject->getTypeOfEdgesOfNode(id);
-	}
-
-	return std::vector<std::tuple<Id, Id, Id>>();
-}
-
-std::vector<std::tuple<Id, Id, Id>> GraphAccessProxy::getReturnTypeOfEdgesOfNode(const Id id) const
-{
-	if (hasSubject())
-	{
-		return m_subject->getReturnTypeOfEdgesOfNode(id);
-	}
-
-	return std::vector<std::tuple<Id, Id, Id>>();
-}
-
-std::vector<std::tuple<Id, Id, Id>> GraphAccessProxy::getParameterOfEdgesOfNode(const Id id) const
-{
-	if (hasSubject())
-	{
-		return m_subject->getParameterOfEdgesOfNode(id);
-	}
-
-	return std::vector<std::tuple<Id, Id, Id>>();
-}
-
-std::vector<std::tuple<Id, Id, Id>> GraphAccessProxy::getInheritanceEdgesOfNode(const Id id) const
-{
-	if (hasSubject())
-	{
-		return m_subject->getInheritanceEdgesOfNode(id);
-	}
-
-	return std::vector<std::tuple<Id, Id, Id>>();
-}
-
-std::pair<Id, Id> GraphAccessProxy::getNodesOfEdge(const Id id) const
-{
-	if (hasSubject())
-	{
-		return m_subject->getNodesOfEdge(id);
-	}
-
-	return std::pair<Id, Id>();
-}
-
-bool GraphAccessProxy::checkTokenIsNode(const Id id) const
-{
-	if (hasSubject())
-	{
-		return m_subject->checkTokenIsNode(id);
-	}
-
-	return false;
+	return std::make_shared<Graph>();
 }
 
 std::vector<Id> GraphAccessProxy::getActiveTokenIdsForId(Id tokenId) const

src/lib/data/access/GraphAccessProxy.h

@@ -16,19 +16,8 @@ public:
 	virtual Id getIdForNodeWithName(const std::string& name) const;
 	virtual std::string getNameForNodeWithId(Id id) const;
 	virtual std::vector<std::string> getNamesForNodesWithNamePrefix(const std::string& prefix) const;
-	virtual std::vector<Id> getIdsOfNeighbours(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getNeighbourEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getMemberEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getUsageEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getCallEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getTypeOfEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getReturnTypeOfEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getParameterOfEdgesOfNode(const Id id) const;
-	virtual std::vector<std::tuple<Id, Id, Id>> getInheritanceEdgesOfNode(const Id id) const;
 
-	virtual std::pair<Id, Id> getNodesOfEdge(const Id id) const;
-
-	virtual bool checkTokenIsNode(const Id id) const;
+	virtual std::shared_ptr<Graph> getGraphForActiveTokenIds(const std::vector<Id>& tokenIds) const;
 
 	virtual std::vector<Id> getActiveTokenIdsForId(Id tokenId) const;
 	virtual std::vector<Id> getLocationIdsForTokenIds(const std::vector<Id>& tokenIds) const;

src/lib/data/graph/Graph.cpp

@@ -244,6 +244,32 @@ Edge* Graph::addEdgeAsPlainCopy(Edge* edge)
 	return copy.get();
 }
 
+Node* Graph::addNodeAndAllChildrenAsPlainCopy(Node* node)
+{
+	Node* n = addNodeAsPlainCopy(node);
+
+	node->forEachEdgeOfType(Edge::EDGE_MEMBER,
+		[node, this](Edge* edge)
+		{
+			if (edge->getFrom() == node)
+			{
+				addEdgeAsPlainCopy(edge);
+				addNodeAndAllChildrenAsPlainCopy(edge->getTo());
+			}
+		}
+	);
+
+	return n;
+}
+
+Edge* Graph::addEdgeAndAllChildrenAsPlainCopy(Edge* edge)
+{
+	addNodeAndAllChildrenAsPlainCopy(edge->getFrom()->getLastParentNode());
+	addNodeAndAllChildrenAsPlainCopy(edge->getTo()->getLastParentNode());
+
+	return addEdgeAsPlainCopy(edge);
+}
+
 void Graph::removeEdgeInternal(Edge* edge)
 {
 	std::map<Id, std::shared_ptr<Edge> >::const_iterator it = m_edges.find(edge->getId());

src/lib/data/graph/Graph.h

@@ -49,6 +49,9 @@ public:
 	Node* addNodeAsPlainCopy(Node* node);
 	Edge* addEdgeAsPlainCopy(Edge* edge);
 
+	Node* addNodeAndAllChildrenAsPlainCopy(Node* node);
+	Edge* addEdgeAndAllChildrenAsPlainCopy(Edge* edge);
+
 protected:
 	std::map<Id, std::shared_ptr<Node>> m_nodes;
 	std::map<Id, std::shared_ptr<Edge>> m_edges;

src/lib/data/graph/Node.cpp

@@ -89,6 +89,16 @@ Node* Node::getParentNode() const
 	return nullptr;
 }
 
+Node* Node::getLastParentNode()
+{
+	Node* parent = getParentNode();
+	if (parent)
+	{
+		return parent->getLastParentNode();
+	}
+	return this;
+}
+
 Edge* Node::getMemberEdge() const
 {
 	return findEdgeOfType(Edge::EDGE_MEMBER,
@@ -179,9 +189,12 @@ void Node::forEachEdgeOfType(Edge::EdgeType type, std::function<void(Edge*)> fun
 void Node::forEachChildNode(std::function<void(Node*)> func) const
 {
 	forEachEdgeOfType(Edge::EDGE_MEMBER,
-		[func](Edge* e)
+		[func, this](Edge* e)
 		{
-			func(e->getTo());
+			if (this != e->getTo())
+			{
+				func(e->getTo());
+			}
 		}
 	);
 }

src/lib/data/graph/Node.h

@@ -54,6 +54,7 @@ public:
 	void removeEdge(Edge* edge);
 
 	Node* getParentNode() const;
+	Node* getLastParentNode();
 	Edge* getMemberEdge() const;
 
 	Edge* findEdge(std::function<bool(Edge*)> func) const;