From 5d2a476813f21587ecea2b1e4c87076fcd097368 Mon Sep 17 00:00:00 2001 From: Eberhard Graether Date: Sat, 21 May 2016 00:01:46 +0200 Subject: [PATCH] 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 --- .../component/controller/CodeController.cpp | 9 +- .../component/controller/GraphController.cpp | 487 ++++++++---------- .../component/controller/GraphController.h | 28 +- .../controller/helper/BucketGrid.cpp | 30 +- .../component/controller/helper/BucketGrid.h | 7 +- .../component/controller/helper/DummyNode.h | 32 +- .../controller/helper/GraphLayouter.cpp | 2 +- src/lib/component/view/GraphView.h | 4 +- src/lib/data/SqliteStorage.cpp | 2 + .../utility/scheduling/TaskGroupParallel.cpp | 2 - .../utility/scheduling/TaskGroupParallel.h | 4 +- src/lib_gui/qt/view/QtGraphView.cpp | 54 +- src/lib_gui/qt/view/QtGraphView.h | 20 +- 13 files changed, 335 insertions(+), 346 deletions(-) diff --git a/src/lib/component/controller/CodeController.cpp b/src/lib/component/controller/CodeController.cpp index 745b4ba4..d92aa9c4 100644 --- a/src/lib/component/controller/CodeController.cpp +++ b/src/lib/component/controller/CodeController.cpp @@ -303,6 +303,7 @@ std::vector CodeController::getSnippetsForActiveTokenLocation ) const { std::vector snippets; size_t definitionFileCount = 0; + size_t declarationFileCount = 0; collection->forEachTokenLocationFile( [&](std::shared_ptr file) -> void @@ -324,7 +325,9 @@ std::vector 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 fileSnippets = getSnippetsForActiveTokenLocationsInFile(file); @@ -350,6 +353,10 @@ std::vector CodeController::getSnippetsForActiveTokenLocation { definitionFileCount++; } + else if (isDeclarationFile) + { + declarationFileCount++; + } } ); diff --git a/src/lib/component/controller/GraphController.cpp b/src/lib/component/controller/GraphController.cpp index bcc6a5d6..fcc6b82a 100644 --- a/src/lib/component/controller/GraphController.cpp +++ b/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& tokenId } m_dummyEdges.clear(); + m_dummyGraphNodes.clear(); std::set addedNodes; - std::vector dummyNodes; + std::vector> dummyNodes; graph->forEachNode( [&addedNodes, &dummyNodes, this](Node* node) @@ -216,10 +219,22 @@ void GraphController::createDummyGraphForTokenIds(const std::vector& tokenId } ); - for (DummyNode& node : dummyNodes) + std::set 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(edge->getFrom()->getId(), edge->getTo()->getId(), edge)); + addedEdges.insert(edge->getId()); + } + } + ); + + for (std::shared_ptr 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& tokenId m_graph = graph; } -DummyNode GraphController::createDummyNodeTopDown(Node* node) +std::shared_ptr GraphController::createDummyNodeTopDown(Node* node) { - DummyNode result; - result.data = node; - result.tokenId = node->getId(); - result.name = node->getName(); + std::shared_ptr result = std::make_shared(); + 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 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 accessNode = std::make_shared(); + 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& 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& activeTokenI if (activeTokenIds.size() > 0) { noActive = true; - for (DummyNode& node : m_dummyNodes) + for (std::shared_ptr node : m_dummyNodes) { - setNodeActiveRecursive(node, activeTokenIds, &noActive); + setNodeActiveRecursive(node.get(), activeTokenIds, &noActive); } } - for (DummyEdge& edge : m_dummyEdges) + for (std::shared_ptr 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 node : m_dummyNodes) { - removeImplicitChildrenRecursive(node); + removeImplicitChildrenRecursive(node.get()); - setNodeVisibilityRecursiveBottomUp(node, noActive); + setNodeVisibilityRecursiveBottomUp(node.get(), noActive); } } -void GraphController::setNodeActiveRecursive(DummyNode& node, const std::vector& activeTokenIds, bool* noActive) const +void GraphController::setNodeActiveRecursive(DummyNode* node, const std::vector& 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 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 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 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 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 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 bundleNode = std::make_shared(); + 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 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 bundleEdges; - std::vector bundledNodes = bundleNode.getAllBundledNodes(); + std::vector> bundleEdges; + std::vector bundledNodes = bundleNode->getAllBundledNodes(); for (const DummyNode* node : bundledNodes) { - for (DummyEdge& edge : m_dummyEdges) + for (std::shared_ptr 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 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 bundleEdge = std::make_shared(); + 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& nodes, std::function matcher, const std::string& name) +void GraphController::bundleNodesMatching(std::list>& nodes, std::function matcher, const std::string& name) { - std::vector::iterator> matchedNodes; - for (std::list::iterator it = nodes.begin(); it != nodes.end(); it++) + std::vector>::iterator> matchedNodes; + for (std::list>::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& nodes, std::fun return; } - DummyNode bundleNode; - bundleNode.name = name; - bundleNode.visible = true; + std::shared_ptr bundleNode = std::make_shared(); + bundleNode->name = name; + bundleNode->visible = true; for (int i = matchedNodes.size() - 1; i >= 0; i--) { - DummyNode* node = *matchedNodes[i]; + std::shared_ptr 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 oldNodes = m_dummyNodes; + std::vector> oldNodes = m_dummyNodes; m_dummyNodes.clear(); - std::list nodes; + std::list> 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 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 a, const std::shared_ptr 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 node : m_dummyNodes) { - layoutNestingRecursive(node); + layoutNestingRecursive(node.get()); } - for (DummyNode& node : m_dummyNodes) + for (std::shared_ptr 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 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 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 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 expandNode = std::make_shared(); + 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 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 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& nodes, Id tokenId) const +DummyNode* GraphController::getDummyGraphNodeById(Id tokenId) const { - for (DummyNode& node : nodes) + std::map::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& nodes, Id tokenId) const -{ - for (DummyNode& node : nodes) - { - if (node.isGraphNode() && node.data->getId() == tokenId) - { - return &node; - } - } - - return nullptr; -} - -DummyNode* GraphController::findDummyNodeAccessRecursive( - std::vector& 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()) diff --git a/src/lib/component/controller/GraphController.h b/src/lib/component/controller/GraphController.h index 478fc9f8..b19e8f4b 100644 --- a/src/lib/component/controller/GraphController.h +++ b/src/lib/component/controller/GraphController.h @@ -61,38 +61,38 @@ private: void clear(); void createDummyGraphForTokenIds(const std::vector& tokenIds, const std::shared_ptr graph); - DummyNode createDummyNodeTopDown(Node* node); + std::shared_ptr createDummyNodeTopDown(Node* node); void autoExpandActiveNode(const std::vector& activeTokenIds); void setActiveAndVisibility(const std::vector& activeTokenIds); - void setNodeActiveRecursive(DummyNode& node, const std::vector& 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& 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 matcher, size_t count, const std::string& name); - void bundleNodesMatching(std::list& nodes, std::function matcher, const std::string& name); + void bundleNodesMatching(std::list>& nodes, std::function 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& nodes, Id tokenId) const; - DummyNode* findTopLevelDummyNodeRecursive(std::vector& nodes, Id tokenId) const; - DummyNode* findDummyNodeAccessRecursive(std::vector& nodes, Id parentId, TokenComponentAccess::AccessType type) const; + DummyNode* getDummyGraphNodeById(Id tokenId) const; void buildGraph(MessageBase* message); StorageAccess* m_storageAccess; - std::vector m_dummyNodes; - std::vector m_dummyEdges; + std::vector> m_dummyNodes; + std::vector> m_dummyEdges; + + std::map m_dummyGraphNodes; std::vector m_activeNodeIds; std::vector m_activeEdgeIds; diff --git a/src/lib/component/controller/helper/BucketGrid.cpp b/src/lib/component/controller/helper/BucketGrid.cpp index 778978a4..c617ea9a 100644 --- a/src/lib/component/controller/helper/BucketGrid.cpp +++ b/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& nodes, const std::vector& edges) -{ +void BucketGrid::createBuckets( + std::vector>& nodes, const std::vector>& edges +){ if (!nodes.size()) { return; } bool activeNodeAdded = false; - for (DummyNode& node : nodes) + for (std::shared_ptr 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& nodes, const std::vector< if (!activeNodeAdded) { - addNode(&nodes[0]); + addNode(nodes[0].get()); } std::vector remainingEdges; - for (const DummyEdge& edge : edges) + for (std::shared_ptr 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& nodes, Id tokenId, DummyNode* top) -{ - for (DummyNode& node : nodes) +DummyNode* BucketGrid::findTopMostDummyNodeRecursive( + std::vector>& nodes, Id tokenId, DummyNode* top +){ + for (std::shared_ptr 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; diff --git a/src/lib/component/controller/helper/BucketGrid.h b/src/lib/component/controller/helper/BucketGrid.h index 8ff7efd4..1be46be6 100644 --- a/src/lib/component/controller/helper/BucketGrid.h +++ b/src/lib/component/controller/helper/BucketGrid.h @@ -43,12 +43,15 @@ class BucketGrid { public: BucketGrid(Vec2i viewSize); - void createBuckets(std::vector& nodes, const std::vector& edges); + void createBuckets( + std::vector>& nodes, + const std::vector>& edges); void sortBuckets(); void layoutBuckets(); private: - DummyNode* findTopMostDummyNodeRecursive(std::vector& nodes, Id tokenId, DummyNode* top = nullptr); + DummyNode* findTopMostDummyNodeRecursive( + std::vector>& nodes, Id tokenId, DummyNode* top = nullptr); void addNode(DummyNode* node); bool addNode(DummyNode* owner, DummyNode* target, bool horizontal); diff --git a/src/lib/component/controller/helper/DummyNode.h b/src/lib/component/controller/helper/DummyNode.h index 11abe166..5fc33e0d 100644 --- a/src/lib/component/controller/helper/DummyNode.h +++ b/src/lib/component/controller/helper/DummyNode.h @@ -73,9 +73,9 @@ public: bool hasVisibleSubNode() const { - for (const DummyNode& node : subNodes) + for (std::shared_ptr 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 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 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 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 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 node : subNodes) { - utility::append(nodes, node.getConnectedSubNodes()); + utility::append(nodes, node->getConnectedSubNodes()); } return nodes; @@ -174,9 +174,9 @@ public: std::vector getAllBundledNodes() const { std::vector nodes; - for (const DummyNode& node : bundledNodes) + for (std::shared_ptr 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 subNodes; + std::vector> subNodes; // GraphNode const Node* data; @@ -221,7 +221,7 @@ public: BundleInfo bundleInfo; // BundleNode - std::vector bundledNodes; + std::vector> bundledNodes; size_t bundledNodeCount; }; diff --git a/src/lib/component/controller/helper/GraphLayouter.cpp b/src/lib/component/controller/helper/GraphLayouter.cpp index 34af8310..1b4ac45d 100644 --- a/src/lib/component/controller/helper/GraphLayouter.cpp +++ b/src/lib/component/controller/helper/GraphLayouter.cpp @@ -170,7 +170,7 @@ MatrixDynamicBase 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()); } } diff --git a/src/lib/component/view/GraphView.h b/src/lib/component/view/GraphView.h index 7ccaa00b..15478952 100644 --- a/src/lib/component/view/GraphView.h +++ b/src/lib/component/view/GraphView.h @@ -18,7 +18,9 @@ public: virtual std::string getName() const; virtual void rebuildGraph( - std::shared_ptr graph, const std::vector& nodes, const std::vector& edges) = 0; + std::shared_ptr graph, + const std::vector>& nodes, + const std::vector>& edges) = 0; virtual void clear() = 0; virtual void focusTokenIds(const std::vector& focusedTokenIds) = 0; diff --git a/src/lib/data/SqliteStorage.cpp b/src/lib/data/SqliteStorage.cpp index ac986d81..82bcf041 100644 --- a/src/lib/data/SqliteStorage.cpp +++ b/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, " diff --git a/src/lib/utility/scheduling/TaskGroupParallel.cpp b/src/lib/utility/scheduling/TaskGroupParallel.cpp index 5ef60ea9..8f63ce8c 100644 --- a/src/lib/utility/scheduling/TaskGroupParallel.cpp +++ b/src/lib/utility/scheduling/TaskGroupParallel.cpp @@ -1,7 +1,5 @@ #include "utility/scheduling/TaskGroupParallel.h" -#include - TaskGroupParallel::TaskGroupParallel() { } diff --git a/src/lib/utility/scheduling/TaskGroupParallel.h b/src/lib/utility/scheduling/TaskGroupParallel.h index 76ad9f7c..796b13d1 100644 --- a/src/lib/utility/scheduling/TaskGroupParallel.h +++ b/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 +#include + +#include "utility/scheduling/TaskGroup.h" class TaskGroupParallel : public TaskGroup diff --git a/src/lib_gui/qt/view/QtGraphView.cpp b/src/lib_gui/qt/view/QtGraphView.cpp index add9b2fd..c00ff3be 100644 --- a/src/lib_gui/qt/view/QtGraphView.cpp +++ b/src/lib_gui/qt/view/QtGraphView.cpp @@ -81,8 +81,8 @@ void QtGraphView::refreshView() void QtGraphView::rebuildGraph( std::shared_ptr graph, - const std::vector& nodes, - const std::vector& edges + const std::vector>& nodes, + const std::vector>& edges ){ m_rebuildGraphFunctor(graph, nodes, edges); } @@ -193,8 +193,8 @@ QtGraphicsView* QtGraphView::getView() const void QtGraphView::doRebuildGraph( std::shared_ptr graph, - const std::vector& nodes, - const std::vector& edges + const std::vector>& nodes, + const std::vector>& 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 node = createNodeRecursive(view, NULL, nodes[i], activeNodeCount > 1); + std::shared_ptr 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 edge = createEdge(view, edges[i]); + std::shared_ptr edge = createEdge(view, edges[i].get()); if (edge) { m_edges.push_back(edge); @@ -296,34 +296,34 @@ std::shared_ptr QtGraphView::findNodeRecursive(const std::list QtGraphView::createNodeRecursive( - QGraphicsView* view, std::shared_ptr parentNode, const DummyNode& node, bool multipleActive + QGraphicsView* view, std::shared_ptr parentNode, const DummyNode* node, bool multipleActive ){ - if (!node.visible) + if (!node->visible) { return NULL; } std::shared_ptr newNode; - if (node.isGraphNode()) + if (node->isGraphNode()) { - newNode = std::make_shared(node.data, node.name, node.hasParent, node.childVisible); + newNode = std::make_shared(node->data, node->name, node->hasParent, node->childVisible); } - else if (node.isAccessNode()) + else if (node->isAccessNode()) { - newNode = std::make_shared(node.accessType); + newNode = std::make_shared(node->accessType); } - else if (node.isExpandToggleNode()) + else if (node->isExpandToggleNode()) { - newNode = std::make_shared(node.isExpanded(), node.invisibleSubNodeCount); + newNode = std::make_shared(node->isExpanded(), node->invisibleSubNodeCount); } - else if (node.isBundleNode()) + else if (node->isBundleNode()) { - newNode = std::make_shared(node.tokenId, node.getBundledNodeCount(), node.name); + newNode = std::make_shared(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(newNode)); @@ -339,9 +339,9 @@ std::shared_ptr QtGraphView::createNodeRecursive( newNode->addComponent(std::make_shared(newNode)); } - for (unsigned int i = 0; i < node.subNodes.size(); i++) + for (unsigned int i = 0; i < node->subNodes.size(); i++) { - std::shared_ptr subNode = createNodeRecursive(view, newNode, node.subNodes[i], multipleActive); + std::shared_ptr subNode = createNodeRecursive(view, newNode, node->subNodes[i].get(), multipleActive); if (subNode) { newNode->addSubNode(subNode); @@ -353,20 +353,20 @@ std::shared_ptr QtGraphView::createNodeRecursive( return newNode; } -std::shared_ptr QtGraphView::createEdge(QGraphicsView* view, const DummyEdge& edge) +std::shared_ptr QtGraphView::createEdge(QGraphicsView* view, const DummyEdge* edge) { - if (!edge.visible) + if (!edge->visible) { return NULL; } - std::shared_ptr owner = findNodeRecursive(m_nodes, edge.ownerId); - std::shared_ptr target = findNodeRecursive(m_nodes, edge.targetId); + std::shared_ptr owner = findNodeRecursive(m_nodes, edge->ownerId); + std::shared_ptr target = findNodeRecursive(m_nodes, edge->targetId); if (owner != NULL && target != NULL) { std::shared_ptr qtEdge = - std::make_shared(owner, target, edge.data, edge.getWeight(), edge.active, edge.getDirection()); + std::make_shared(owner, target, edge->data, edge->getWeight(), edge->active, edge->getDirection()); owner->addOutEdge(qtEdge); target->addInEdge(qtEdge); diff --git a/src/lib_gui/qt/view/QtGraphView.h b/src/lib_gui/qt/view/QtGraphView.h index dc41a0f1..ae120e33 100644 --- a/src/lib_gui/qt/view/QtGraphView.h +++ b/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, const std::vector& nodes, const std::vector& edges); + virtual void rebuildGraph( + std::shared_ptr graph, + const std::vector>& nodes, + const std::vector>& edges); virtual void clear(); virtual void focusTokenIds(const std::vector& focusedTokenIds); @@ -51,7 +54,10 @@ private: QtGraphicsView* getView() const; - void doRebuildGraph(std::shared_ptr graph, const std::vector& nodes, const std::vector& edges); + void doRebuildGraph( + std::shared_ptr graph, + const std::vector>& nodes, + const std::vector>& edges); void doClear(); void doResize(); void doRefreshView(); @@ -62,8 +68,8 @@ private: std::shared_ptr findNodeRecursive(const std::list>& nodes, Id tokenId); std::shared_ptr createNodeRecursive( - QGraphicsView* view, std::shared_ptr parentNode, const DummyNode& node, bool multipleActive); - std::shared_ptr createEdge(QGraphicsView* view, const DummyEdge& edge); + QGraphicsView* view, std::shared_ptr parentNode, const DummyNode* node, bool multipleActive); + std::shared_ptr createEdge(QGraphicsView* view, const DummyEdge* edge); QRectF itemsBoundingRect(const std::list>& items) const; QRectF getSceneRect(const std::list>& items) const; @@ -77,7 +83,11 @@ private: void createTransition(); - QtThreadedFunctor, const std::vector&, const std::vector&> m_rebuildGraphFunctor; + QtThreadedFunctor< + std::shared_ptr, + const std::vector>&, + const std::vector>& + > m_rebuildGraphFunctor; QtThreadedFunctor m_clearFunctor; QtThreadedFunctor m_resizeFunctor; QtThreadedFunctor m_refreshFunctor;