ynkmr/Sourcetrail
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

logic: Show non-indexed nodes within their parents and their childs

Browse Source 
* Added support for access nodes without title
This commit is contained in:
Eberhard Graether
2017-02-10 14:49:26 +01:00
parent e2a6d4e237
commit 3a540285a3
7 changed files with 156 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib/data/HierarchyCache.cpp
+63 -6
View File
@@ -5,6 +5,7 @@ HierarchyCache::HierarchyNode::HierarchyNode(Id nodeId)
, m_edgeId(0)
, m_parent(nullptr)
, m_isVisible(true)
, m_isIndexed(true)
{
}
@@ -51,12 +52,21 @@ void HierarchyCache::HierarchyNode::addChildIds(std::vector<Id>* nodeIds) const
}
}
void HierarchyCache::HierarchyNode::addChildIdsRecursive(std::vector<Id>* nodeIds, std::vector<Id>* edgeIds) const
void HierarchyCache::HierarchyNode::addChildIds(std::set<Id>* nodeIds, std::set<Id>* edgeIds) const
{
for (const HierarchyNode* child : m_children)
{
nodeIds->push_back(child->getNodeId());
edgeIds->push_back(child->getEdgeId());
nodeIds->insert(child->getNodeId());
edgeIds->insert(child->getEdgeId());
}
}
void HierarchyCache::HierarchyNode::addChildIdsRecursive(std::set<Id>* nodeIds, std::set<Id>* edgeIds) const
{
for (const HierarchyNode* child : m_children)
{
nodeIds->insert(child->getNodeId());
edgeIds->insert(child->getEdgeId());
child->addChildIdsRecursive(nodeIds, edgeIds);
}
@@ -87,13 +97,23 @@ void HierarchyCache::HierarchyNode::setIsVisible(bool isVisible)
m_isVisible = isVisible;
}
bool HierarchyCache::HierarchyNode::isIndexed() const
{
return m_isIndexed;
}
void HierarchyCache::HierarchyNode::setIsIndexed(bool isIndexed)
{
m_isIndexed = isIndexed;
}
void HierarchyCache::clear()
{
m_nodes.clear();
}
void HierarchyCache::createConnection(Id edgeId, Id fromId, Id toId, bool fromVisible)
void HierarchyCache::createConnection(Id edgeId, Id fromId, Id toId, bool sourceVisible, bool sourceIndexed, bool targetIndexed)
{
HierarchyNode* from = createNode(fromId);
HierarchyNode* to = createNode(toId);
@@ -101,8 +121,11 @@ void HierarchyCache::createConnection(Id edgeId, Id fromId, Id toId, bool fromVi
from->addChild(to);
to->setParent(from);
from->setIsVisible(sourceVisible);
from->setIsIndexed(sourceIndexed);
to->setEdgeId(edgeId);
from->setIsVisible(fromVisible);
to->setIsIndexed(targetIndexed);
}
Id HierarchyCache::getLastVisibleParentNodeId(Id nodeId) const
@@ -147,7 +170,7 @@ size_t HierarchyCache::getIndexOfLastVisibleParentNode(Id nodeId) const
return idx;
}
void HierarchyCache::addAllChildIdsForNodeId(Id nodeId, std::vector<Id>* nodeIds, std::vector<Id>* edgeIds) const
void HierarchyCache::addAllChildIdsForNodeId(Id nodeId, std::set<Id>* nodeIds, std::set<Id>* edgeIds) const
{
HierarchyNode* node = getNode(nodeId);
if (node)
@@ -156,6 +179,29 @@ void HierarchyCache::addAllChildIdsForNodeId(Id nodeId, std::vector<Id>* nodeIds
}
}
void HierarchyCache::addAllVisibleParentsAndChildIdsForNodeId(Id nodeId, std::set<Id>* nodeIds, std::set<Id>* edgeIds) const
{
HierarchyNode* node = getNode(nodeId);
if (node)
{
node->addChildIds(nodeIds, edgeIds);
}
Id edgeId = 0;
while (node && node->isVisible())
{
if (edgeId)
{
edgeIds->insert(edgeId);
}
nodeIds->insert(node->getNodeId());
edgeId = node->getEdgeId();
node = node->getParent();
}
}
void HierarchyCache::addFirstChildIdsForNodeId(Id nodeId, std::vector<Id>* nodeIds) const
{
HierarchyNode* node = getNode(nodeId);
@@ -203,6 +249,17 @@ bool HierarchyCache::isChildOfVisibleNodeOrInvisible(Id nodeId) const
return false;
}
bool HierarchyCache::isIndexed(Id nodeId) const
{
HierarchyNode* node = getNode(nodeId);
if (!node)
{
return true;
}
return node->isIndexed();
}
bool HierarchyCache::nodeHasChildren(Id nodeId) const
{
HierarchyNode* node = getNode(nodeId);
src/lib/data/HierarchyCache.h
+14 -3
View File
@@ -3,6 +3,7 @@
#include <map>
#include <memory>
#include <set>
#include <vector>
#include "utility/types.h"
@@ -12,16 +13,21 @@ class HierarchyCache
public:
void clear();
void createConnection(Id edgeId, Id fromId, Id toId, bool fromVisible);
void createConnection(Id edgeId, Id fromId, Id toId, bool sourceVisible, bool sourceIndexed, bool targetIndexed);
Id getLastVisibleParentNodeId(Id nodeId) const;
size_t getIndexOfLastVisibleParentNode(Id nodeId) const;
void addAllChildIdsForNodeId(Id nodeId, std::vector<Id>* nodeIds, std::vector<Id>* edgeIds) const;
void addAllChildIdsForNodeId(Id nodeId, std::set<Id>* nodeIds, std::set<Id>* edgeIds) const;
void addAllVisibleParentsAndChildIdsForNodeId(Id nodeId, std::set<Id>* nodeIds, std::set<Id>* edgeIds) const;
void addAllVisibleParentsRecursive(Id nodeId, std::set<Id>* nodeIds, std::set<Id>* edgeIds) const;
void addFirstChildIdsForNodeId(Id nodeId, std::vector<Id>* nodeIds) const;
void addFirstVisibleChildIdsForNodeId(Id nodeId, std::vector<Id>* nodeIds) const;
bool isChildOfVisibleNodeOrInvisible(Id nodeId) const;
bool isIndexed(Id nodeId) const;
bool nodeHasChildren(Id nodeId) const;
private:
@@ -42,12 +48,16 @@ private:
const std::vector<HierarchyNode*>& getChildren() const;
void addChildIds(std::vector<Id>* nodeIds) const;
void addChildIdsRecursive(std::vector<Id>* nodeIds, std::vector<Id>* edgeIds) const;
void addChildIds(std::set<Id>* nodeIds, std::set<Id>* edgeIds) const;
void addChildIdsRecursive(std::set<Id>* nodeIds, std::set<Id>* edgeIds) const;
void addVisibleNodeIdsRecursive(std::vector<Id>* nodeIds) const;
bool isVisible() const;
void setIsVisible(bool isVisible);
bool isIndexed() const;
void setIsIndexed(bool isIndexed);
private:
const Id m_nodeId;
Id m_edgeId;
@@ -56,6 +66,7 @@ private:
std::vector<HierarchyNode*> m_children;
bool m_isVisible;
bool m_isIndexed;
};
HierarchyNode* getNode(Id nodeId) const;
src/lib/data/PersistentStorage.cpp
+45 -23
View File
@@ -843,11 +843,6 @@ std::shared_ptr<Graph> PersistentStorage::getGraphForActiveTokenIds(const std::v
if (!isNamespace)
{
for (const StorageFile& file : m_sqliteStorage.getAllByIds<StorageFile>(ids))
{
nodeIds.push_back(file.id);
}
if (nodeIds.size() != ids.size())
{
std::vector<StorageEdge> edges = m_sqliteStorage.getAllByIds<StorageEdge>(ids);
@@ -1453,12 +1448,12 @@ Id PersistentStorage::getLastVisibleParentNodeId(const Id nodeId) const
std::vector<Id> PersistentStorage::getAllChildNodeIds(const Id nodeId) const
{
std::vector<Id> childNodeIds;
std::vector<Id> edgeIds;
std::set<Id> childNodeIds;
std::set<Id> edgeIds;
m_hierarchyCache.addAllChildIdsForNodeId(nodeId, &childNodeIds, &edgeIds);
return childNodeIds;
return utility::toVector(childNodeIds);
}
void PersistentStorage::addNodesToGraph(const std::vector<Id>& nodeIds, Graph* graph) const
@@ -1563,33 +1558,47 @@ void PersistentStorage::addNodesWithChildrenAndEdgesToGraph(
{
TRACE();
std::set<Id> parentNodeIds;
for (Id nodeId : nodeIds)
{
parentNodeIds.insert(getLastVisibleParentNodeId(nodeId));
}
std::vector<Id> nodeIdsFull = nodeIds;
if (edgeIds.size() > 0)
{
for (const StorageEdge& storageEdge : m_sqliteStorage.getAllByIds<StorageEdge>(edgeIds))
{
parentNodeIds.insert(getLastVisibleParentNodeId(storageEdge.sourceNodeId));
parentNodeIds.insert(getLastVisibleParentNodeId(storageEdge.targetNodeId));
nodeIdsFull.push_back(storageEdge.sourceNodeId);
nodeIdsFull.push_back(storageEdge.targetNodeId);
}
}
std::vector<Id> allNodeIds;
std::vector<Id> allEdgeIds = edgeIds;
std::set<Id> parentNodeIds;
std::set<Id> nonIndexedNodeIds;
for (Id nodeId : nodeIdsFull)
{
if (m_hierarchyCache.isIndexed(nodeId))
{
parentNodeIds.insert(getLastVisibleParentNodeId(nodeId));
}
else
{
nonIndexedNodeIds.insert(nodeId);
}
}
std::set<Id> allNodeIds;
std::set<Id> allEdgeIds(edgeIds.begin(), edgeIds.end());
for (Id parentNodeId : parentNodeIds)
{
allNodeIds.push_back(parentNodeId);
allNodeIds.insert(parentNodeId);
m_hierarchyCache.addAllChildIdsForNodeId(parentNodeId, &allNodeIds, &allEdgeIds);
}
addNodesToGraph(allNodeIds, graph);
addEdgesToGraph(allEdgeIds, graph);
for (Id nonIndexedNodeId : nonIndexedNodeIds)
{
m_hierarchyCache.addAllVisibleParentsAndChildIdsForNodeId(nonIndexedNodeId, &allNodeIds, &allEdgeIds);
}
addNodesToGraph(utility::toVector(allNodeIds), graph);
addEdgesToGraph(utility::toVector(allEdgeIds), graph);
}
void PersistentStorage::addAggregationEdgesToGraph(
@@ -1796,10 +1805,23 @@ void PersistentStorage::buildHierarchyCache()
return Node::intToType(m_sqliteStorage.getFirstById<StorageNode>(id).type);
});
Cache<Id, bool> indexedNodeCache([this](Id id){
StorageSymbol symbol = m_sqliteStorage.getFirstById<StorageSymbol>(id);
if (symbol.id > 0)
{
return intToDefinitionKind(symbol.definitionKind) != DEFINITION_NONE;
}
return false;
});
for (const StorageEdge& edge : memberEdges)
{
bool isVisible = !(nodeTypeCache.getValue(edge.sourceNodeId) & Node::NODE_NOT_VISIBLE);
m_hierarchyCache.createConnection(edge.id, edge.sourceNodeId, edge.targetNodeId, isVisible);
bool sourceIsIndexed = indexedNodeCache.getValue(edge.sourceNodeId);
bool targetIsIndexed = indexedNodeCache.getValue(edge.targetNodeId);
m_hierarchyCache.createConnection(
edge.id, edge.sourceNodeId, edge.targetNodeId, isVisible, sourceIsIndexed, targetIsIndexed);
}
}
src/lib/data/graph/Node.cpp
+1 -1
View File
@@ -12,7 +12,7 @@
#include "data/graph/token_component/TokenComponentFilePath.h"
#include "data/graph/token_component/TokenComponentSignature.h"
const Node::NodeTypeMask Node::NODE_NOT_VISIBLE = Node::NODE_NON_INDEXED | Node::NODE_NAMESPACE | Node::NODE_PACKAGE;
const Node::NodeTypeMask Node::NODE_NOT_VISIBLE = Node::NODE_NAMESPACE | Node::NODE_PACKAGE;
const Node::NodeTypeMask Node::NODE_USEABLE_TYPE = Node::NODE_NON_INDEXED | Node::NODE_BUILTIN_TYPE |
Node::NODE_BUILTIN_TYPE | Node::NODE_STRUCT | Node::NODE_CLASS | Node::NODE_INTERFACE | Node::NODE_TYPEDEF;