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

src: extract NoteType::Type to NodeKind (#925)

Browse Source
This commit is contained in:
Malte Langkabel
2020-02-14 20:35:02 +01:00
committed by GitHub
parent a30f47e27f
commit 437f06d21b
34 changed files with 577 additions and 600 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib/CMakeLists.txt
+2
View File
@@ -305,6 +305,8 @@ add_files(
data/GroupType.h
data/HierarchyCache.cpp
data/HierarchyCache.h
data/NodeKind.cpp
data/NodeKind.h
data/NodeType.cpp
data/NodeType.h
data/NodeTypeSet.cpp
src/lib/component/controller/CustomTrailController.cpp
+3 -3
View File
@@ -19,9 +19,9 @@ void CustomTrailController::clear()
void CustomTrailController::autocomplete(const std::wstring query, bool from)
{
NodeTypeSet nodeTypes = NodeTypeSet::all();
nodeTypes.remove(NodeType(NodeType::NODE_MODULE));
nodeTypes.remove(NodeType(NodeType::NODE_NAMESPACE));
nodeTypes.remove(NodeType(NodeType::NODE_PACKAGE));
nodeTypes.remove(NodeType(NODE_MODULE));
nodeTypes.remove(NodeType(NODE_NAMESPACE));
nodeTypes.remove(NodeType(NODE_PACKAGE));
getView()->showAutocompletions(
m_storageAccess->getAutocompletionMatches(query, nodeTypes, false), from);
src/lib/component/controller/GraphController.cpp
+87 -106
View File
@@ -812,7 +812,7 @@ std::vector<Id> GraphController::getExpandedNodeIds() const
{
DummyNode* oldNode = p.second.get();
if (oldNode->expanded && !oldNode->autoExpanded && oldNode->isGraphNode() &&
!oldNode->data->isType(NodeType::NODE_FUNCTION | NodeType::NODE_METHOD))
!oldNode->data->isType(NODE_FUNCTION | NODE_METHOD))
{
nodeIds.push_back(p.first);
}
@@ -994,8 +994,7 @@ bool GraphController::setNodeVisibilityRecursiveBottomUp(DummyNode* node, bool n
void GraphController::setNodeVisibilityRecursiveTopDown(DummyNode* node, bool parentExpanded) const
{
if (node->isGraphNode() && node->data->getType().getType() == NodeType::NODE_ENUM &&
!node->isExpanded())
if (node->isGraphNode() && node->data->getType().getKind() == NODE_ENUM && !node->isExpanded())
{
node->visible = true;
return;
@@ -1142,7 +1141,7 @@ void GraphController::bundleNodes()
for (const std::shared_ptr<DummyNode>& node: m_dummyNodes)
{
if (node->bundleInfo.isActive &&
(node->data->isType(NodeType::NODE_FILE | NodeType::NODE_MACRO) ||
(node->data->isType(NODE_FILE | NODE_MACRO) ||
node->data->findEdgeOfType(Edge::EDGE_INCLUDE | Edge::EDGE_MACRO_USAGE) != nullptr))
{
fileOrMacroActive = true;
@@ -1444,7 +1443,7 @@ void GraphController::bundleNodesByType()
{
m_dummyNodes.push_back(bundleNode);
if (bundleNode->bundledNodeType.getType() != NodeType::NODE_FILE)
if (bundleNode->bundledNodeType.getKind() != NODE_FILE)
{
hasNonFileBundle = true;
}
@@ -1456,7 +1455,7 @@ void GraphController::bundleNodesByType()
{
Tree<NodeType::BundleInfo> bundleInfoTree(NodeType::BundleInfo(L"Symbols"));
std::shared_ptr<DummyNode> bundleNode = bundleByType(
nodes, NodeType::NODE_SYMBOL, bundleInfoTree, false);
nodes, NodeType(NODE_SYMBOL), bundleInfoTree, false);
if (bundleNode)
{
m_dummyNodes.push_back(bundleNode);
@@ -1866,8 +1865,7 @@ void GraphController::extendEqualFunctionNames(const std::vector<std::shared_ptr
std::multimap<std::wstring, std::shared_ptr<DummyNode>> functionNames;
for (auto& node: nodes)
{
if (node->visible && node->isGraphNode() &&
node->data->isType(NodeType::NODE_FUNCTION | NodeType::NODE_METHOD))
if (node->visible && node->isGraphNode() && node->data->isType(NODE_FUNCTION | NODE_METHOD))
{
functionNames.emplace(node->name, node);
}
@@ -1921,7 +1919,7 @@ Vec4i GraphController::layoutNestingRecursive(DummyNode* node, int relayoutAcces
}
else if (node->isBundleNode())
{
if (node->bundledNodeType.getType() != NodeType::NODE_SYMBOL)
if (node->bundledNodeType.getKind() != NODE_SYMBOL)
{
margins = GraphViewStyle::getMarginsForDataNode(
node->bundledNodeType.getNodeStyle(), node->bundledNodeType.hasIcon(), false);
@@ -2393,12 +2391,13 @@ void GraphController::createLegendGraph()
};
auto addNode = [&id, &graph, &nodePositions](
NodeType::Type type,
NodeKind kind,
const std::wstring& name,
Vec2i position,
DefinitionKind defKind = DEFINITION_EXPLICIT) {
nodePositions.emplace(++id, position);
return graph->createNode(id, type, NameHierarchy(name, NAME_DELIMITER_UNKNOWN), defKind);
return graph->createNode(
id, NodeType(kind), NameHierarchy(name, NAME_DELIMITER_UNKNOWN), defKind);
};
auto addEdge = [&id, &graph](Edge::EdgeType type, Node* from, Node* to) {
@@ -2425,11 +2424,11 @@ void GraphController::createLegendGraph()
x = 50;
y = 40;
Node* base = addNode(NodeType::NODE_CLASS, L"Base Class", Vec2i(x + 220, y + 50));
Node* main = addNode(NodeType::NODE_CLASS, L"Class", Vec2i(x + 200, y + 130));
Node* derived = addNode(NodeType::NODE_CLASS, L"Derived Class", Vec2i(x + 210, y + 380));
Node* user = addNode(NodeType::NODE_TYPE, L"Referencing Type", Vec2i(x - 10, y + 220));
Node* usee = addNode(NodeType::NODE_TYPE, L"Referenced Type", Vec2i(x + 410, y + 220));
Node* base = addNode(NODE_CLASS, L"Base Class", Vec2i(x + 220, y + 50));
Node* main = addNode(NODE_CLASS, L"Class", Vec2i(x + 200, y + 130));
Node* derived = addNode(NODE_CLASS, L"Derived Class", Vec2i(x + 210, y + 380));
Node* user = addNode(NODE_TYPE, L"Referencing Type", Vec2i(x - 10, y + 220));
Node* usee = addNode(NODE_TYPE, L"Referenced Type", Vec2i(x + 410, y + 220));
addEdge(Edge::EDGE_INHERITANCE, main, base);
addEdge(Edge::EDGE_INHERITANCE, derived, main);
@@ -2456,8 +2455,8 @@ void GraphController::createLegendGraph()
edge->addComponent(aggregationComp);
}
Node* publicMethod = addNode(NodeType::NODE_METHOD, L"public method", Vec2i());
Node* privateField = addNode(NodeType::NODE_FIELD, L"private field", Vec2i());
Node* publicMethod = addNode(NODE_METHOD, L"public method", Vec2i());
Node* privateField = addNode(NODE_FIELD, L"private field", Vec2i());
addMember(main, publicMethod, ACCESS_PUBLIC);
addMember(main, privateField, ACCESS_PRIVATE);
@@ -2465,12 +2464,11 @@ void GraphController::createLegendGraph()
y += 480;
x += 10;
Node* func = addNode(NodeType::NODE_FUNCTION, L"function", Vec2i(x + 220, y));
Node* caller = addNode(NodeType::NODE_FUNCTION, L"calling function", Vec2i(x, y));
Node* var = addNode(
NodeType::NODE_GLOBAL_VARIABLE, L"accessed variable", Vec2i(x + 410, y - 50));
Node* called = addNode(NodeType::NODE_FUNCTION, L"called function", Vec2i(x + 410, y - 10));
Node* type = addNode(NodeType::NODE_TYPE, L"Referenced Type", Vec2i(x + 410, y + 30));
Node* func = addNode(NODE_FUNCTION, L"function", Vec2i(x + 220, y));
Node* caller = addNode(NODE_FUNCTION, L"calling function", Vec2i(x, y));
Node* var = addNode(NODE_GLOBAL_VARIABLE, L"accessed variable", Vec2i(x + 410, y - 50));
Node* called = addNode(NODE_FUNCTION, L"called function", Vec2i(x + 410, y - 10));
Node* type = addNode(NODE_TYPE, L"Referenced Type", Vec2i(x + 410, y + 30));
addEdge(Edge::EDGE_CALL, func, called);
addEdge(Edge::EDGE_CALL, caller, func);
@@ -2488,49 +2486,44 @@ void GraphController::createLegendGraph()
int i = 0;
addText(L"Nodes", 3, Vec2i(x, y));
addNode(NodeType::NODE_FILE, L"File", Vec2i(x, y + dy * ++i));
addNode(NodeType::NODE_FILE, L"Non-Indexed File", Vec2i(x, y + dy * ++i), DEFINITION_NONE);
Node* incompleteFile = addNode(
NodeType::NODE_FILE, L"Incomplete File", Vec2i(x, y + dy * ++i));
addNode(NODE_FILE, L"File", Vec2i(x, y + dy * ++i));
addNode(NODE_FILE, L"Non-Indexed File", Vec2i(x, y + dy * ++i), DEFINITION_NONE);
Node* incompleteFile = addNode(NODE_FILE, L"Incomplete File", Vec2i(x, y + dy * ++i));
incompleteFile->addComponent(std::make_shared<TokenComponentFilePath>(FilePath(), false));
addNode(NodeType::NODE_MACRO, L"Macro", Vec2i(x, y + dy * ++i));
addNode(NodeType::NODE_ANNOTATION, L"Annotation", Vec2i(x, y + dy * ++i));
addNode(NODE_MACRO, L"Macro", Vec2i(x, y + dy * ++i));
addNode(NODE_ANNOTATION, L"Annotation", Vec2i(x, y + dy * ++i));
addNode(NodeType::NODE_MODULE, L"module", Vec2i(x, y + dy * ++i));
addNode(NODE_MODULE, L"module", Vec2i(x, y + dy * ++i));
y -= 15;
addNode(NodeType::NODE_NAMESPACE, L"namespace", Vec2i(x, y + dy * ++i));
addNode(NODE_NAMESPACE, L"namespace", Vec2i(x, y + dy * ++i));
y -= 15;
addNode(NodeType::NODE_PACKAGE, L"package", Vec2i(x, y + dy * ++i));
addNode(NODE_PACKAGE, L"package", Vec2i(x, y + dy * ++i));
y -= 15;
addNode(NodeType::NODE_TYPE, L"Type", Vec2i(x, y + dy * ++i));
addNode(NodeType::NODE_TYPE, L"Non-indexed Type", Vec2i(x, y + dy * ++i), DEFINITION_NONE);
addNode(NODE_TYPE, L"Type", Vec2i(x, y + dy * ++i));
addNode(NODE_TYPE, L"Non-indexed Type", Vec2i(x, y + dy * ++i), DEFINITION_NONE);
addNode(NodeType::NODE_GLOBAL_VARIABLE, L"variable", Vec2i(x, y + dy * ++i));
addNode(NODE_GLOBAL_VARIABLE, L"variable", Vec2i(x, y + dy * ++i));
y -= 15;
addNode(
NodeType::NODE_GLOBAL_VARIABLE,
L"non-indexed variable",
Vec2i(x, y + dy * ++i),
DEFINITION_NONE);
NODE_GLOBAL_VARIABLE, L"non-indexed variable", Vec2i(x, y + dy * ++i), DEFINITION_NONE);
y -= 15;
addNode(NodeType::NODE_FUNCTION, L"function", Vec2i(x, y + dy * ++i));
addNode(NODE_FUNCTION, L"function", Vec2i(x, y + dy * ++i));
y -= 15;
addNode(
NodeType::NODE_FUNCTION, L"non-indexed function", Vec2i(x, y + dy * ++i), DEFINITION_NONE);
addNode(NODE_FUNCTION, L"non-indexed function", Vec2i(x, y + dy * ++i), DEFINITION_NONE);
y -= 15;
Node* typeNode = addNode(NodeType::NODE_TYPE, L"Type with Members", Vec2i(x, y + dy * ++i));
Node* publicMethod = addNode(NodeType::NODE_METHOD, L"public method", Vec2i());
Node* protectedMethod = addNode(NodeType::NODE_METHOD, L"protected method", Vec2i());
Node* privateMethod = addNode(NodeType::NODE_METHOD, L"private method", Vec2i());
Node* defaultMethod = addNode(NodeType::NODE_METHOD, L"default method", Vec2i());
Node* publicField = addNode(NodeType::NODE_FIELD, L"public field", Vec2i());
Node* protectedField = addNode(NodeType::NODE_FIELD, L"protected field", Vec2i());
Node* privateField = addNode(NodeType::NODE_FIELD, L"private field", Vec2i());
Node* defaultField = addNode(NodeType::NODE_FIELD, L"default field", Vec2i());
Node* typeNode = addNode(NODE_TYPE, L"Type with Members", Vec2i(x, y + dy * ++i));
Node* publicMethod = addNode(NODE_METHOD, L"public method", Vec2i());
Node* protectedMethod = addNode(NODE_METHOD, L"protected method", Vec2i());
Node* privateMethod = addNode(NODE_METHOD, L"private method", Vec2i());
Node* defaultMethod = addNode(NODE_METHOD, L"default method", Vec2i());
Node* publicField = addNode(NODE_FIELD, L"public field", Vec2i());
Node* protectedField = addNode(NODE_FIELD, L"protected field", Vec2i());
Node* privateField = addNode(NODE_FIELD, L"private field", Vec2i());
Node* defaultField = addNode(NODE_FIELD, L"default field", Vec2i());
addMember(typeNode, publicMethod, ACCESS_PUBLIC);
addMember(typeNode, publicField, ACCESS_PUBLIC);
@@ -2544,23 +2537,22 @@ void GraphController::createLegendGraph()
y -= 15;
i += 9;
addNode(NodeType::NODE_CLASS, L"Class", Vec2i(x, y + dy * ++i));
addNode(NodeType::NODE_INTERFACE, L"Interface", Vec2i(x, y + dy * ++i));
addNode(NODE_CLASS, L"Class", Vec2i(x, y + dy * ++i));
addNode(NODE_INTERFACE, L"Interface", Vec2i(x, y + dy * ++i));
addNode(NodeType::NODE_STRUCT, L"Struct", Vec2i(x, y + dy * ++i));
addNode(NodeType::NODE_UNION, L"Union", Vec2i(x, y + dy * ++i));
addNode(NODE_STRUCT, L"Struct", Vec2i(x, y + dy * ++i));
addNode(NODE_UNION, L"Union", Vec2i(x, y + dy * ++i));
addNode(NodeType::NODE_TYPEDEF, L"TypeDef", Vec2i(x, y + dy * ++i));
Node* enumNode = addNode(NodeType::NODE_ENUM, L"Enum", Vec2i(x, y + dy * ++i));
Node* enumConstantNode = addNode(NodeType::NODE_ENUM_CONSTANT, L"ENUM_CONSTANT", Vec2i());
addNode(NODE_TYPEDEF, L"TypeDef", Vec2i(x, y + dy * ++i));
Node* enumNode = addNode(NODE_ENUM, L"Enum", Vec2i(x, y + dy * ++i));
Node* enumConstantNode = addNode(NODE_ENUM_CONSTANT, L"ENUM_CONSTANT", Vec2i());
addMember(enumNode, enumConstantNode);
y += 10;
i += 1;
Node* genericNode = addNode(
NodeType::NODE_TYPE, L"JavaGenericType<ParameterType>", Vec2i(x, y + dy * ++i));
Node* genericParameterNode = addNode(
NodeType::NODE_TYPE_PARAMETER, L"ParameterType", Vec2i());
NODE_TYPE, L"JavaGenericType<ParameterType>", Vec2i(x, y + dy * ++i));
Node* genericParameterNode = addNode(NODE_TYPE_PARAMETER, L"ParameterType", Vec2i());
addMember(genericNode, genericParameterNode, ACCESS_TYPE_PARAMETER);
i += 2;
@@ -2591,37 +2583,36 @@ void GraphController::createLegendGraph()
{
addText(L"file include", 0, Vec2i(x, y + dy * ++i));
Node* file = addNode(NodeType::NODE_FILE, L"File", Vec2i(x, y + dy * ++i));
Node* fileB = addNode(NodeType::NODE_FILE, L"File", Vec2i(x + dx, y + dy * i));
Node* file = addNode(NODE_FILE, L"File", Vec2i(x, y + dy * ++i));
Node* fileB = addNode(NODE_FILE, L"File", Vec2i(x + dx, y + dy * i));
addEdge(Edge::EDGE_INCLUDE, file, fileB);
}
{
addText(L"class import", 0, Vec2i(x, y + dy * ++i));
Node* file = addNode(NodeType::NODE_FILE, L"File", Vec2i(x, y + dy * ++i));
Node* type = addNode(NodeType::NODE_TYPE, L"Class", Vec2i(x + dx, y + dy * i));
Node* file = addNode(NODE_FILE, L"File", Vec2i(x, y + dy * ++i));
Node* type = addNode(NODE_TYPE, L"Class", Vec2i(x + dx, y + dy * i));
addEdge(Edge::EDGE_IMPORT, file, type);
}
{
addText(L"macro use", 0, Vec2i(x, y + dy * ++i));
Node* file = addNode(NodeType::NODE_FILE, L"File", Vec2i(x, y + dy * ++i));
Node* macro = addNode(NodeType::NODE_MACRO, L"Macro", Vec2i(x + dx, y + dy * i));
Node* file = addNode(NODE_FILE, L"File", Vec2i(x, y + dy * ++i));
Node* macro = addNode(NODE_MACRO, L"Macro", Vec2i(x + dx, y + dy * i));
addEdge(Edge::EDGE_MACRO_USAGE, file, macro);
}
{
addText(L"annotation use", 0, Vec2i(x, y + dy * ++i));
Node* type = addNode(NodeType::NODE_TYPE, L"Type", Vec2i(x, y + dy * ++i));
Node* macro = addNode(
NodeType::NODE_ANNOTATION, L"Annotation", Vec2i(x + dx, y + dy * i));
Node* type = addNode(NODE_TYPE, L"Type", Vec2i(x, y + dy * ++i));
Node* macro = addNode(NODE_ANNOTATION, L"Annotation", Vec2i(x + dx, y + dy * i));
addEdge(Edge::EDGE_ANNOTATION_USAGE, type, macro);
}
{
addText(L"aggregation", 0, Vec2i(x, y + dy * ++i));
Node* typeA = addNode(NodeType::NODE_TYPE, L"Type A", Vec2i(x, y + dy * ++i));
Node* typeB = addNode(NodeType::NODE_TYPE, L"Type B", Vec2i(x + dx, y + dy * i));
Node* typeA = addNode(NODE_TYPE, L"Type A", Vec2i(x, y + dy * ++i));
Node* typeB = addNode(NODE_TYPE, L"Type B", Vec2i(x + dx, y + dy * i));
Edge* edge = addEdge(Edge::EDGE_AGGREGATION, typeA, typeB);
std::shared_ptr<TokenComponentAggregation> aggregationComp =
std::make_shared<TokenComponentAggregation>();
@@ -2634,38 +2625,34 @@ void GraphController::createLegendGraph()
{
addText(L"type use", 0, Vec2i(x, y + dy * ++i));
Node* function = addNode(NodeType::NODE_FUNCTION, L"function", Vec2i(x, y + dy * ++i));
Node* type = addNode(NodeType::NODE_TYPE, L"Type", Vec2i(x + dx, y + dy * i));
Node* function = addNode(NODE_FUNCTION, L"function", Vec2i(x, y + dy * ++i));
Node* type = addNode(NODE_TYPE, L"Type", Vec2i(x + dx, y + dy * i));
addEdge(Edge::EDGE_TYPE_USAGE, function, type);
}
{
addText(L"function call", 0, Vec2i(x, y + dy * ++i));
Node* function = addNode(NodeType::NODE_FUNCTION, L"function", Vec2i(x, y + dy * ++i));
Node* functionB = addNode(
NodeType::NODE_FUNCTION, L"function", Vec2i(x + dx, y + dy * i));
Node* function = addNode(NODE_FUNCTION, L"function", Vec2i(x, y + dy * ++i));
Node* functionB = addNode(NODE_FUNCTION, L"function", Vec2i(x + dx, y + dy * i));
addEdge(Edge::EDGE_CALL, function, functionB);
}
{
addText(L"variable access", 0, Vec2i(x, y + dy * ++i));
Node* function = addNode(NodeType::NODE_FUNCTION, L"function", Vec2i(x, y + dy * ++i));
Node* variable = addNode(
NodeType::NODE_GLOBAL_VARIABLE, L"variable", Vec2i(x + dx, y + dy * i));
Node* function = addNode(NODE_FUNCTION, L"function", Vec2i(x, y + dy * ++i));
Node* variable = addNode(NODE_GLOBAL_VARIABLE, L"variable", Vec2i(x + dx, y + dy * i));
addEdge(Edge::EDGE_USAGE, function, variable);
}
{
addText(L"class inheritance", 0, Vec2i(x, y + dy * ++i));
Node* base = addNode(NodeType::NODE_CLASS, L"Base Class", Vec2i(x, y + dy * (i + 1)));
Node* derived = addNode(
NodeType::NODE_CLASS, L"Derived Class", Vec2i(x, y + dy * (i + 3)));
Node* base = addNode(NODE_CLASS, L"Base Class", Vec2i(x, y + dy * (i + 1)));
Node* derived = addNode(NODE_CLASS, L"Derived Class", Vec2i(x, y + dy * (i + 3)));
addEdge(Edge::EDGE_INHERITANCE, derived, base);
Node* base2 = addNode(
NodeType::NODE_CLASS, L"Base Class", Vec2i(x + 180, y + dy * (i + 1)));
Node* base2 = addNode(NODE_CLASS, L"Base Class", Vec2i(x + 180, y + dy * (i + 1)));
Node* derived2 = addNode(
NodeType::NODE_CLASS, L"Derived Derived Class", Vec2i(x + 180, y + dy * (i + 3)));
NODE_CLASS, L"Derived Derived Class", Vec2i(x + 180, y + dy * (i + 3)));
Edge* edge = addEdge(Edge::EDGE_INHERITANCE, derived2, base2);
edge->addComponent(
std::make_shared<TokenComponentInheritanceChain>(std::vector<Id>({1, 2})));
@@ -2674,11 +2661,11 @@ void GraphController::createLegendGraph()
{
addText(L"method override", 0, Vec2i(x, y + dy * ++i));
Node* base = addNode(NodeType::NODE_CLASS, L"Base Class", Vec2i(x, y + dy * ++i));
Node* base = addNode(NODE_CLASS, L"Base Class", Vec2i(x, y + dy * ++i));
i += 3;
Node* derived = addNode(NodeType::NODE_CLASS, L"Derived Class", Vec2i(x, y + dy * i));
Node* baseMethod = addNode(NodeType::NODE_METHOD, L"method", Vec2i());
Node* derivedMethod = addNode(NodeType::NODE_METHOD, L"method", Vec2i());
Node* derived = addNode(NODE_CLASS, L"Derived Class", Vec2i(x, y + dy * i));
Node* baseMethod = addNode(NODE_METHOD, L"method", Vec2i());
Node* derivedMethod = addNode(NODE_METHOD, L"method", Vec2i());
addMember(base, baseMethod, ACCESS_PUBLIC);
addMember(derived, derivedMethod, ACCESS_PUBLIC);
addEdge(Edge::EDGE_OVERRIDE, derivedMethod, baseMethod);
@@ -2688,12 +2675,10 @@ void GraphController::createLegendGraph()
{
addText(L"template specialization", 0, Vec2i(x, y + dy * ++i));
Node* templateFunctionNode = addNode(
NodeType::NODE_FUNCTION,
L"template_function<typename ParameterType>",
Vec2i(x, y + dy * ++i));
NODE_FUNCTION, L"template_function<typename ParameterType>", Vec2i(x, y + dy * ++i));
y += 20;
Node* templateFunctionSpecializationNode = addNode(
NodeType::NODE_FUNCTION,
NODE_FUNCTION,
L"template_function<ArgumentType>",
Vec2i(x, y + dy * ++i),
DEFINITION_IMPLICIT);
@@ -2703,15 +2688,11 @@ void GraphController::createLegendGraph()
templateFunctionNode);
Node* templateNode = addNode(
NodeType::NODE_TYPE, L"TemplateType<typename ParameterType>", Vec2i(x, y + dy * ++i));
NODE_TYPE, L"TemplateType<typename ParameterType>", Vec2i(x, y + dy * ++i));
y += 30;
Node* templateSpecializationNode = addNode(
NodeType::NODE_TYPE,
L"TemplateType<ArgumentType>",
Vec2i(x, y + dy * ++i),
DEFINITION_IMPLICIT);
Node* argumentNode = addNode(
NodeType::NODE_TYPE, L"ArgumentType", Vec2i(x + 270, y + dy * i));
NODE_TYPE, L"TemplateType<ArgumentType>", Vec2i(x, y + dy * ++i), DEFINITION_IMPLICIT);
Node* argumentNode = addNode(NODE_TYPE, L"ArgumentType", Vec2i(x + 270, y + dy * i));
addEdge(Edge::EDGE_TEMPLATE_SPECIALIZATION, templateSpecializationNode, templateNode);
addEdge(Edge::EDGE_TYPE_USAGE, templateSpecializationNode, argumentNode);
}
@@ -2719,19 +2700,19 @@ void GraphController::createLegendGraph()
{
addText(L"template member specialization", 0, Vec2i(x, y + dy * ++i));
Node* templateNode = addNode(
NodeType::NODE_TYPE, L"TemplateType<typename ParameterType>", Vec2i(x, y + dy * ++i));
Node* templateMethodNode = addNode(NodeType::NODE_METHOD, L"method", Vec2i());
NODE_TYPE, L"TemplateType<typename ParameterType>", Vec2i(x, y + dy * ++i));
Node* templateMethodNode = addNode(NODE_METHOD, L"method", Vec2i());
addMember(templateNode, templateMethodNode);
i += 1;
Node* templateSpecializationNode = addNode(
NodeType::NODE_TYPE,
NODE_TYPE,
L"TemplateType<ArgumentType>",
Vec2i(x, y + dy * ++i + 20),
DEFINITION_IMPLICIT);
Node* templateSpecializationMethodNode = addNode(
NodeType::NODE_METHOD, L"method", Vec2i(), DEFINITION_IMPLICIT);
NODE_METHOD, L"method", Vec2i(), DEFINITION_IMPLICIT);
addMember(templateSpecializationNode, templateSpecializationMethodNode);
addEdge(
Edge::EDGE_TEMPLATE_SPECIALIZATION,
src/lib/component/controller/UndoRedoController.cpp
+5 -4
View File
@@ -173,7 +173,8 @@ void UndoRedoController::handleMessage(MessageCodeShowDefinition* message)
void UndoRedoController::handleMessage(MessageDeactivateEdge* message)
{
if (sameMessageTypeAsLast(message) &&
static_cast<MessageDeactivateEdge*>(lastMessage())->scrollToDefinition == message->scrollToDefinition)
static_cast<MessageDeactivateEdge*>(lastMessage())->scrollToDefinition ==
message->scrollToDefinition)
{
return;
}
@@ -493,15 +494,15 @@ void UndoRedoController::replayCommand(std::list<Command>::iterator it)
for (SearchMatch match: matches)
{
// TODO: replace duplicate main definition fix with better solution
if (match.nodeType.getType() != NodeType::NODE_FUNCTION ||
!match.tokenNames.size() || match.tokenNames[0].getRawName() != L"main")
if (match.nodeType.getKind() != NODE_FUNCTION || !match.tokenNames.size() ||
match.tokenNames[0].getRawName() != L"main")
{
match.tokenIds = m_storageAccess->getNodeIdsForNameHierarchies(match.tokenNames);
}
if (!match.tokenIds.size())
{
match.nodeType = NodeType::NODE_SYMBOL;
match.nodeType = NodeType(NODE_SYMBOL);
}
utility::append(msg->tokenIds, match.tokenIds);
src/lib/component/controller/helper/DummyNode.h
+1 -1
View File
@@ -116,7 +116,7 @@ public:
, invisibleSubNodeCount(0)
, bundleId(0)
, bundledNodeCount(0)
, bundledNodeType(NodeType::NODE_SYMBOL)
, bundledNodeType(NODE_SYMBOL)
, qualifierName(NAME_DELIMITER_UNKNOWN)
, groupType(GroupType::DEFAULT)
, groupLayout(GroupLayout::LIST)
src/lib/component/view/CustomTrailView.h
+1 -1
View File
@@ -15,7 +15,7 @@ public:
}
virtual void clearView() = 0;
virtual void setAvailableNodeAndEdgeTypes(NodeType::TypeMask nodeTypes, Edge::TypeMask edgeTypes) = 0;
virtual void setAvailableNodeAndEdgeTypes(NodeKindMask nodeTypes, Edge::TypeMask edgeTypes) = 0;
virtual void showView() = 0;
virtual void hideView() = 0;
src/lib/data/NodeKind.cpp
+126
View File
@@ -0,0 +1,126 @@
#include "NodeKind.h"
int nodeKindToInt(NodeKind kind)
{
return kind;
}
NodeKind intToNodeKind(int value)
{
switch (value)
{
case NODE_TYPE:
return NODE_TYPE;
case NODE_BUILTIN_TYPE:
return NODE_BUILTIN_TYPE;
case NODE_MODULE:
return NODE_MODULE;
case NODE_NAMESPACE:
return NODE_NAMESPACE;
case NODE_PACKAGE:
return NODE_PACKAGE;
case NODE_STRUCT:
return NODE_STRUCT;
case NODE_CLASS:
return NODE_CLASS;
case NODE_INTERFACE:
return NODE_INTERFACE;
case NODE_ANNOTATION:
return NODE_ANNOTATION;
case NODE_GLOBAL_VARIABLE:
return NODE_GLOBAL_VARIABLE;
case NODE_FIELD:
return NODE_FIELD;
case NODE_FUNCTION:
return NODE_FUNCTION;
case NODE_METHOD:
return NODE_METHOD;
case NODE_ENUM:
return NODE_ENUM;
case NODE_ENUM_CONSTANT:
return NODE_ENUM_CONSTANT;
case NODE_TYPEDEF:
return NODE_TYPEDEF;
case NODE_TYPE_PARAMETER:
return NODE_TYPE_PARAMETER;
case NODE_FILE:
return NODE_FILE;
case NODE_MACRO:
return NODE_MACRO;
case NODE_UNION:
return NODE_UNION;
}
return NODE_SYMBOL;
}
std::string getReadableNodeKindString(NodeKind kind)
{
switch (kind)
{
case NODE_SYMBOL:
return "symbol";
case NODE_BUILTIN_TYPE:
return "built-in type";
case NODE_TYPE:
return "type";
case NODE_MODULE:
return "module";
case NODE_NAMESPACE:
return "namespace";
case NODE_PACKAGE:
return "package";
case NODE_STRUCT:
return "struct";
case NODE_CLASS:
return "class";
case NODE_INTERFACE:
return "interface";
case NODE_ANNOTATION:
return "annotation";
case NODE_GLOBAL_VARIABLE:
return "global variable";
case NODE_FIELD:
return "field";
case NODE_FUNCTION:
return "function";
case NODE_METHOD:
return "method";
case NODE_ENUM:
return "enum";
case NODE_ENUM_CONSTANT:
return "enum constant";
case NODE_TYPEDEF:
return "typedef";
case NODE_TYPE_PARAMETER:
return "type parameter";
case NODE_FILE:
return "file";
case NODE_MACRO:
return "macro";
case NODE_UNION:
return "union";
}
return "";
}
std::wstring getReadableNodeKindWString(NodeKind kind)
{
std::string str = getReadableNodeKindString(kind);
return std::wstring(str.begin(), str.end());
}
NodeKind getNodeKindForReadableNodeKindString(const std::wstring& str)
{
for (NodeKindMask mask = 1; mask <= NODE_MAX_VALUE; mask *= 2)
{
NodeKind kind = intToNodeKind(mask);
if (getReadableNodeKindWString(kind) == str)
{
return kind;
}
}
return NODE_SYMBOL;
}
src/lib/data/NodeKind.h
+44
View File
@@ -0,0 +1,44 @@
#ifndef NODE_KIND_H
#define NODE_KIND_H
#include <string>
typedef int NodeKindMask;
enum NodeKind : NodeKindMask
{ // make sure that the value of 0x0 is not used here because it doesn't work for bitmasking.
NODE_SYMBOL = 1 << 0,
NODE_TYPE = 1 << 1,
NODE_BUILTIN_TYPE = 1 << 2,
NODE_MODULE = 1 << 3,
NODE_NAMESPACE = 1 << 4,
NODE_PACKAGE = 1 << 5,
NODE_STRUCT = 1 << 6,
NODE_CLASS = 1 << 7,
NODE_INTERFACE = 1 << 8,
NODE_ANNOTATION = 1 << 9,
NODE_GLOBAL_VARIABLE = 1 << 10,
NODE_FIELD = 1 << 11,
NODE_FUNCTION = 1 << 12,
NODE_METHOD = 1 << 13,
NODE_ENUM = 1 << 14,
NODE_ENUM_CONSTANT = 1 << 15,
NODE_TYPEDEF = 1 << 16,
NODE_TYPE_PARAMETER = 1 << 17,
NODE_FILE = 1 << 18,
NODE_MACRO = 1 << 19,
NODE_UNION = 1 << 20,
NODE_MAX_VALUE = NODE_UNION
};
int nodeKindToInt(NodeKind kind);
NodeKind intToNodeKind(int value);
std::string getReadableNodeKindString(NodeKind kind);
std::wstring getReadableNodeKindWString(NodeKind kind);
NodeKind getNodeKindForReadableNodeKindString(const std::wstring& str);
#endif // NODE_KIND_H
src/lib/data/NodeType.cpp
+98 -234
View File
@@ -3,155 +3,29 @@
#include "ResourcePaths.h"
#include "utilityString.h"
std::vector<NodeType> const NodeType::overviewBundleNodeTypesOrdered =
{
NodeType(NodeType::NODE_FILE),
NodeType(NodeType::NODE_MACRO),
NodeType(NodeType::NODE_ANNOTATION),
NodeType(NodeType::NODE_MODULE),
NodeType(NodeType::NODE_NAMESPACE),
NodeType(NodeType::NODE_PACKAGE),
NodeType(NodeType::NODE_CLASS),
NodeType(NodeType::NODE_INTERFACE),
NodeType(NodeType::NODE_STRUCT),
NodeType(NodeType::NODE_UNION),
NodeType(NodeType::NODE_FUNCTION),
NodeType(NodeType::NODE_GLOBAL_VARIABLE),
NodeType(NodeType::NODE_TYPE),
NodeType(NodeType::NODE_TYPEDEF),
NodeType(NodeType::NODE_ENUM)
};
std::vector<NodeType> const NodeType::overviewBundleNodeTypesOrdered = {
NodeType(NODE_FILE),
NodeType(NODE_MACRO),
NodeType(NODE_ANNOTATION),
NodeType(NODE_MODULE),
NodeType(NODE_NAMESPACE),
NodeType(NODE_PACKAGE),
NodeType(NODE_CLASS),
NodeType(NODE_INTERFACE),
NodeType(NODE_STRUCT),
NodeType(NODE_UNION),
NodeType(NODE_FUNCTION),
NodeType(NODE_GLOBAL_VARIABLE),
NodeType(NODE_TYPE),
NodeType(NODE_TYPEDEF),
NodeType(NODE_ENUM)};
int NodeType::typeToInt(NodeType::Type type)
{
return type;
}
NodeType::Type NodeType::intToType(int value)
{
switch (value)
{
case NodeType::NODE_TYPE:
return NodeType::NODE_TYPE;
case NodeType::NODE_BUILTIN_TYPE:
return NodeType::NODE_BUILTIN_TYPE;
case NodeType::NODE_MODULE:
return NodeType::NODE_MODULE;
case NodeType::NODE_NAMESPACE:
return NodeType::NODE_NAMESPACE;
case NodeType::NODE_PACKAGE:
return NodeType::NODE_PACKAGE;
case NodeType::NODE_STRUCT:
return NodeType::NODE_STRUCT;
case NodeType::NODE_CLASS:
return NodeType::NODE_CLASS;
case NodeType::NODE_INTERFACE:
return NodeType::NODE_INTERFACE;
case NodeType::NODE_ANNOTATION:
return NodeType::NODE_ANNOTATION;
case NodeType::NODE_GLOBAL_VARIABLE:
return NodeType::NODE_GLOBAL_VARIABLE;
case NodeType::NODE_FIELD:
return NodeType::NODE_FIELD;
case NodeType::NODE_FUNCTION:
return NodeType::NODE_FUNCTION;
case NodeType::NODE_METHOD:
return NodeType::NODE_METHOD;
case NodeType::NODE_ENUM:
return NodeType::NODE_ENUM;
case NodeType::NODE_ENUM_CONSTANT:
return NodeType::NODE_ENUM_CONSTANT;
case NodeType::NODE_TYPEDEF:
return NodeType::NODE_TYPEDEF;
case NodeType::NODE_TYPE_PARAMETER:
return NodeType::NODE_TYPE_PARAMETER;
case NodeType::NODE_FILE:
return NodeType::NODE_FILE;
case NodeType::NODE_MACRO:
return NodeType::NODE_MACRO;
case NodeType::NODE_UNION:
return NodeType::NODE_UNION;
}
return NodeType::NODE_SYMBOL;
}
std::string NodeType::getReadableTypeString(NodeType::Type type)
{
switch (type)
{
case NodeType::NODE_SYMBOL:
return "symbol";
case NodeType::NODE_BUILTIN_TYPE:
return "built-in type";
case NodeType::NODE_TYPE:
return "type";
case NodeType::NODE_MODULE:
return "module";
case NodeType::NODE_NAMESPACE:
return "namespace";
case NodeType::NODE_PACKAGE:
return "package";
case NodeType::NODE_STRUCT:
return "struct";
case NodeType::NODE_CLASS:
return "class";
case NodeType::NODE_INTERFACE:
return "interface";
case NodeType::NODE_ANNOTATION:
return "annotation";
case NodeType::NODE_GLOBAL_VARIABLE:
return "global variable";
case NodeType::NODE_FIELD:
return "field";
case NodeType::NODE_FUNCTION:
return "function";
case NodeType::NODE_METHOD:
return "method";
case NodeType::NODE_ENUM:
return "enum";
case NodeType::NODE_ENUM_CONSTANT:
return "enum constant";
case NodeType::NODE_TYPEDEF:
return "typedef";
case NodeType::NODE_TYPE_PARAMETER:
return "type parameter";
case NodeType::NODE_FILE:
return "file";
case NodeType::NODE_MACRO:
return "macro";
case NodeType::NODE_UNION:
return "union";
}
return "";
}
std::wstring NodeType::getReadableTypeWString(NodeType::Type type)
{
std::string str = getReadableTypeString(type);
return std::wstring(str.begin(), str.end());
}
NodeType::Type NodeType::getTypeForReadableTypeString(const std::wstring& str)
{
for (NodeType::TypeMask mask = 1; mask <= NodeType::NODE_MAX_VALUE; mask *= 2)
{
NodeType::Type type = intToType(mask);
if (getReadableTypeWString(type) == str)
{
return type;
}
}
return NodeType::NODE_SYMBOL;
}
NodeType::NodeType(Type type): m_type(type) {}
NodeType::NodeType(NodeKind kind): m_kind(kind) {}
bool NodeType::operator==(const NodeType& o) const
{
return m_type == o.m_type;
return m_kind == o.m_kind;
}
bool NodeType::operator!=(const NodeType& o) const
@@ -161,91 +35,84 @@ bool NodeType::operator!=(const NodeType& o) const
bool NodeType::operator<(const NodeType& o) const
{
return m_type < o.m_type;
return m_kind < o.m_kind;
}
NodeType::Type NodeType::getType() const
NodeKind NodeType::getKind() const
{
return m_type;
return m_kind;
}
Id NodeType::getId() const
{
// TODO: add id in constructor and return it here
return typeToInt(m_type);
return nodeKindToInt(m_kind);
}
bool NodeType::isFile() const
{
const NodeType::TypeMask mask = NodeType::NODE_FILE;
return ((m_type & mask) > 0);
const NodeKindMask mask = NODE_FILE;
return ((m_kind & mask) > 0);
}
bool NodeType::isBuiltin() const
{
const NodeType::TypeMask mask = NodeType::NODE_BUILTIN_TYPE;
return ((m_type & mask) > 0);
const NodeKindMask mask = NODE_BUILTIN_TYPE;
return ((m_kind & mask) > 0);
}
bool NodeType::isUnknownSymbol() const
{
const NodeType::TypeMask mask = NodeType::NODE_SYMBOL;
return ((m_type & mask) > 0);
const NodeKindMask mask = NODE_SYMBOL;
return ((m_kind & mask) > 0);
}
bool NodeType::isInheritable() const
{
// what about java enums?
const NodeType::TypeMask mask = NodeType::NODE_SYMBOL | NodeType::NODE_BUILTIN_TYPE |
NodeType::NODE_TYPE | NodeType::NODE_STRUCT | NodeType::NODE_CLASS |
NodeType::NODE_INTERFACE;
const NodeKindMask mask = NODE_SYMBOL | NODE_BUILTIN_TYPE | NODE_TYPE | NODE_STRUCT |
NODE_CLASS | NODE_INTERFACE;
return ((m_type & mask) > 0);
return ((m_kind & mask) > 0);
}
bool NodeType::isPackage() const
{
const NodeType::TypeMask mask = NodeType::NODE_MODULE | NodeType::NODE_NAMESPACE |
NodeType::NODE_PACKAGE;
return ((m_type & mask) > 0);
const NodeKindMask mask = NODE_MODULE | NODE_NAMESPACE | NODE_PACKAGE;
return ((m_kind & mask) > 0);
}
bool NodeType::isCallable() const
{
const NodeType::TypeMask mask = NodeType::NODE_FUNCTION | NodeType::NODE_METHOD;
return ((m_type & mask) > 0);
const NodeKindMask mask = NODE_FUNCTION | NODE_METHOD;
return ((m_kind & mask) > 0);
}
bool NodeType::isVariable() const
{
const NodeType::TypeMask mask = NodeType::NODE_GLOBAL_VARIABLE | NodeType::NODE_FIELD;
return ((m_type & mask) > 0);
const NodeKindMask mask = NODE_GLOBAL_VARIABLE | NODE_FIELD;
return ((m_kind & mask) > 0);
}
bool NodeType::isUsable() const
{
const NodeType::TypeMask mask = NodeType::NODE_SYMBOL | NodeType::NODE_BUILTIN_TYPE |
NodeType::NODE_STRUCT | NodeType::NODE_CLASS | NodeType::NODE_ENUM | NodeType::NODE_UNION |
NodeType::NODE_INTERFACE | NodeType::NODE_ANNOTATION | NodeType::NODE_TYPEDEF;
return ((m_type & mask) > 0);
const NodeKindMask mask = NODE_SYMBOL | NODE_BUILTIN_TYPE | NODE_STRUCT | NODE_CLASS |
NODE_ENUM | NODE_UNION | NODE_INTERFACE | NODE_ANNOTATION | NODE_TYPEDEF;
return ((m_kind & mask) > 0);
}
bool NodeType::isPotentialMember() const
{
const NodeType::TypeMask mask = NodeType::NODE_METHOD | NodeType::NODE_FIELD |
NodeType::NODE_CLASS | NodeType::NODE_INTERFACE | NodeType::NODE_ANNOTATION |
NodeType::NODE_STRUCT | NodeType::NODE_UNION | NodeType::NODE_TYPEDEF | NodeType::NODE_ENUM;
const NodeKindMask mask = NODE_METHOD | NODE_FIELD | NODE_CLASS | NODE_INTERFACE |
NODE_ANNOTATION | NODE_STRUCT | NODE_UNION | NODE_TYPEDEF | NODE_ENUM;
return ((m_type & mask) > 0);
return ((m_kind & mask) > 0);
}
bool NodeType::isCollapsible() const
{
const NodeType::TypeMask mask = NodeType::NODE_SYMBOL | NodeType::NODE_TYPE |
NodeType::NODE_BUILTIN_TYPE | NodeType::NODE_STRUCT | NodeType::NODE_CLASS |
NodeType::NODE_INTERFACE | NodeType::NODE_ANNOTATION | NodeType::NODE_ENUM |
NodeType::NODE_UNION | NodeType::NODE_FILE;
return ((m_type & mask) > 0);
const NodeKindMask mask = NODE_SYMBOL | NODE_TYPE | NODE_BUILTIN_TYPE | NODE_STRUCT |
NODE_CLASS | NODE_INTERFACE | NODE_ANNOTATION | NODE_ENUM | NODE_UNION | NODE_FILE;
return ((m_kind & mask) > 0);
}
bool NodeType::isVisibleAsParentInGraph() const
@@ -255,24 +122,22 @@ bool NodeType::isVisibleAsParentInGraph() const
bool NodeType::hasSearchFilter() const
{
const NodeType::TypeMask mask = NodeType::NODE_BUILTIN_TYPE | NodeType::NODE_MODULE |
NodeType::NODE_NAMESPACE | NodeType::NODE_PACKAGE | NodeType::NODE_STRUCT |
NodeType::NODE_CLASS | NodeType::NODE_INTERFACE | NodeType::NODE_ANNOTATION |
NodeType::NODE_GLOBAL_VARIABLE | NodeType::NODE_FIELD | NodeType::NODE_FUNCTION |
NodeType::NODE_METHOD | NodeType::NODE_ENUM | NodeType::NODE_ENUM_CONSTANT |
NodeType::NODE_TYPEDEF | NodeType::NODE_FILE | NodeType::NODE_MACRO | NodeType::NODE_UNION;
return ((m_type & mask) > 0);
const NodeKindMask mask = NODE_BUILTIN_TYPE | NODE_MODULE | NODE_NAMESPACE | NODE_PACKAGE |
NODE_STRUCT | NODE_CLASS | NODE_INTERFACE | NODE_ANNOTATION | NODE_GLOBAL_VARIABLE |
NODE_FIELD | NODE_FUNCTION | NODE_METHOD | NODE_ENUM | NODE_ENUM_CONSTANT | NODE_TYPEDEF |
NODE_FILE | NODE_MACRO | NODE_UNION;
return ((m_kind & mask) > 0);
}
Tree<NodeType::BundleInfo> NodeType::getOverviewBundleTree() const
{
switch (m_type)
switch (m_kind)
{
case NodeType::NODE_FILE:
case NODE_FILE:
return Tree<BundleInfo>(BundleInfo(L"Files"));
case NodeType::NODE_MACRO:
case NODE_MACRO:
return Tree<BundleInfo>(BundleInfo(L"Macros"));
case NodeType::NODE_NAMESPACE:
case NODE_NAMESPACE:
{
Tree<BundleInfo> tree(BundleInfo(L"Namespaces"));
tree.children.push_back(Tree<BundleInfo>(BundleInfo(
@@ -282,29 +147,29 @@ Tree<NodeType::BundleInfo> NodeType::getOverviewBundleTree() const
L"Anonymous Namespaces")));
return tree;
}
case NodeType::NODE_MODULE:
case NODE_MODULE:
return Tree<BundleInfo>(BundleInfo(L"Modules"));
case NodeType::NODE_PACKAGE:
case NODE_PACKAGE:
return Tree<BundleInfo>(BundleInfo(L"Packages"));
case NodeType::NODE_CLASS:
case NODE_CLASS:
return Tree<BundleInfo>(BundleInfo(L"Classes"));
case NodeType::NODE_INTERFACE:
case NODE_INTERFACE:
return Tree<BundleInfo>(BundleInfo(L"Interfaces"));
case NodeType::NODE_ANNOTATION:
case NODE_ANNOTATION:
return Tree<BundleInfo>(BundleInfo(L"Annotations"));
case NodeType::NODE_STRUCT:
case NODE_STRUCT:
return Tree<BundleInfo>(BundleInfo(L"Structs"));
case NodeType::NODE_FUNCTION:
case NODE_FUNCTION:
return Tree<BundleInfo>(BundleInfo(L"Functions"));
case NodeType::NODE_GLOBAL_VARIABLE:
case NODE_GLOBAL_VARIABLE:
return Tree<BundleInfo>(BundleInfo(L"Global Variables"));
case NodeType::NODE_TYPE:
case NODE_TYPE:
return Tree<BundleInfo>(BundleInfo(L"Types"));
case NodeType::NODE_TYPEDEF:
case NODE_TYPEDEF:
return Tree<BundleInfo>(BundleInfo(L"Typedefs"));
case NodeType::NODE_ENUM:
case NODE_ENUM:
return Tree<BundleInfo>(BundleInfo(L"Enums"));
case NodeType::NODE_UNION:
case NODE_UNION:
return Tree<BundleInfo>(BundleInfo(L"Unions"));
default:
break;
@@ -321,17 +186,17 @@ FilePath NodeType::getIconPath() const
return ResourcePaths::getGuiPath().concatenate(L"graph_view/images/namespace.png");
}
switch (m_type)
switch (m_kind)
{
case NodeType::NODE_ANNOTATION:
case NODE_ANNOTATION:
return ResourcePaths::getGuiPath().concatenate(L"graph_view/images/annotation.png");
case NodeType::NODE_ENUM:
case NODE_ENUM:
return ResourcePaths::getGuiPath().concatenate(L"graph_view/images/enum.png");
case NodeType::NODE_TYPEDEF:
case NODE_TYPEDEF:
return ResourcePaths::getGuiPath().concatenate(L"graph_view/images/typedef.png");
case NodeType::NODE_MACRO:
case NODE_MACRO:
return ResourcePaths::getGuiPath().concatenate(L"graph_view/images/macro.png");
case NodeType::NODE_FILE:
case NODE_FILE:
return ResourcePaths::getGuiPath().concatenate(L"graph_view/images/file.png");
default:
return FilePath();
@@ -345,38 +210,37 @@ bool NodeType::hasIcon() const
return true;
}
const NodeType::TypeMask mask = NODE_ANNOTATION | NodeType::NODE_ENUM | NodeType::NODE_TYPEDEF |
NodeType::NODE_FILE | NodeType::NODE_MACRO;
return ((m_type & mask) > 0);
const NodeKindMask mask = NODE_ANNOTATION | NODE_ENUM | NODE_TYPEDEF | NODE_FILE | NODE_MACRO;
return ((m_kind & mask) > 0);
}
NodeType::StyleType NodeType::getNodeStyle() const
{
switch (m_type)
switch (m_kind)
{
case NodeType::NODE_MODULE:
case NodeType::NODE_NAMESPACE:
case NodeType::NODE_PACKAGE:
case NODE_MODULE:
case NODE_NAMESPACE:
case NODE_PACKAGE:
return STYLE_PACKAGE;
case NodeType::NODE_SYMBOL:
case NodeType::NODE_TYPE:
case NodeType::NODE_BUILTIN_TYPE:
case NodeType::NODE_STRUCT:
case NodeType::NODE_CLASS:
case NodeType::NODE_UNION:
case NodeType::NODE_INTERFACE:
case NodeType::NODE_ANNOTATION:
case NodeType::NODE_ENUM:
case NodeType::NODE_TYPEDEF:
case NodeType::NODE_TYPE_PARAMETER:
case NodeType::NODE_FILE:
case NodeType::NODE_MACRO:
case NODE_SYMBOL:
case NODE_TYPE:
case NODE_BUILTIN_TYPE:
case NODE_STRUCT:
case NODE_CLASS:
case NODE_UNION:
case NODE_INTERFACE:
case NODE_ANNOTATION:
case NODE_ENUM:
case NODE_TYPEDEF:
case NODE_TYPE_PARAMETER:
case NODE_FILE:
case NODE_MACRO:
return STYLE_BIG_NODE;
case NodeType::NODE_FUNCTION:
case NodeType::NODE_METHOD:
case NodeType::NODE_GLOBAL_VARIABLE:
case NodeType::NODE_FIELD:
case NodeType::NODE_ENUM_CONSTANT:
case NODE_FUNCTION:
case NODE_METHOD:
case NODE_GLOBAL_VARIABLE:
case NODE_FIELD:
case NODE_ENUM_CONSTANT:
default:
return STYLE_SMALL_NODE;
}
@@ -394,7 +258,7 @@ std::string NodeType::getUnderscoredTypeString() const
std::string NodeType::getReadableTypeString() const
{
return getReadableTypeString(m_type);
return getReadableNodeKindString(m_kind);
}
std::wstring NodeType::getUnderscoredTypeWString() const
src/lib/data/NodeType.h
+5 -40
View File
@@ -8,42 +8,13 @@
#include <vector>
#include "FilePath.h"
#include "NodeKind.h"
#include "Tree.h"
#include "types.h"
class NodeType
{
public:
typedef int TypeMask;
enum Type : NodeType::TypeMask
{ // make sure that the value of 0x0 is not used here because it doesn't work for bitmasking.
NODE_SYMBOL = 1 << 0,
NODE_TYPE = 1 << 1,
NODE_BUILTIN_TYPE = 1 << 2,
NODE_MODULE = 1 << 3,
NODE_NAMESPACE = 1 << 4,
NODE_PACKAGE = 1 << 5,
NODE_STRUCT = 1 << 6,
NODE_CLASS = 1 << 7,
NODE_INTERFACE = 1 << 8,
NODE_ANNOTATION = 1 << 9,
NODE_GLOBAL_VARIABLE = 1 << 10,
NODE_FIELD = 1 << 11,
NODE_FUNCTION = 1 << 12,
NODE_METHOD = 1 << 13,
NODE_ENUM = 1 << 14,
NODE_ENUM_CONSTANT = 1 << 15,
NODE_TYPEDEF = 1 << 16,
NODE_TYPE_PARAMETER = 1 << 17,
NODE_FILE = 1 << 18,
NODE_MACRO = 1 << 19,
NODE_UNION = 1 << 20,
NODE_MAX_VALUE = NODE_UNION
};
enum StyleType
{
STYLE_PACKAGE = 0,
@@ -77,20 +48,13 @@ public:
static std::vector<NodeType> getOverviewBundleNodeTypesOrdered();
static int typeToInt(NodeType::Type type);
static NodeType::Type intToType(int value);
static std::string getReadableTypeString(NodeType::Type type);
static std::wstring getReadableTypeWString(NodeType::Type type);
static NodeType::Type getTypeForReadableTypeString(const std::wstring& str);
NodeType(Type type);
explicit NodeType(NodeKind kind);
bool operator==(const NodeType& o) const;
bool operator!=(const NodeType& o) const;
bool operator<(const NodeType& o) const;
Type getType() const;
NodeKind getKind() const;
Id getId() const;
bool isFile() const;
@@ -119,8 +83,9 @@ public:
std::wstring getReadableTypeWString() const;
static std::vector<NodeType> const overviewBundleNodeTypesOrdered;
private:
Type m_type;
NodeKind m_kind;
};
#endif // NODE_TYPE_H
src/lib/data/NodeTypeSet.cpp
+10 -10
View File
@@ -166,13 +166,13 @@ NodeTypeSet::MaskType NodeTypeSet::nodeTypeToMask(const NodeType& nodeType)
}
const std::vector<NodeType> NodeTypeSet::s_allNodeTypes = {
NodeType(NodeType::NODE_SYMBOL), NodeType(NodeType::NODE_TYPE),
NodeType(NodeType::NODE_BUILTIN_TYPE), NodeType(NodeType::NODE_MODULE),
NodeType(NodeType::NODE_NAMESPACE), NodeType(NodeType::NODE_PACKAGE),
NodeType(NodeType::NODE_STRUCT), NodeType(NodeType::NODE_CLASS),
NodeType(NodeType::NODE_INTERFACE), NodeType(NodeType::NODE_GLOBAL_VARIABLE),
NodeType(NodeType::NODE_FIELD), NodeType(NodeType::NODE_FUNCTION),
NodeType(NodeType::NODE_METHOD), NodeType(NodeType::NODE_ENUM),
NodeType(NodeType::NODE_ENUM_CONSTANT), NodeType(NodeType::NODE_TYPEDEF),
NodeType(NodeType::NODE_TYPE_PARAMETER), NodeType(NodeType::NODE_FILE),
NodeType(NodeType::NODE_MACRO), NodeType(NodeType::NODE_UNION)};
NodeType(NODE_SYMBOL), NodeType(NODE_TYPE),
NodeType(NODE_BUILTIN_TYPE), NodeType(NODE_MODULE),
NodeType(NODE_NAMESPACE), NodeType(NODE_PACKAGE),
NodeType(NODE_STRUCT), NodeType(NODE_CLASS),
NodeType(NODE_INTERFACE), NodeType(NODE_GLOBAL_VARIABLE),
NodeType(NODE_FIELD), NodeType(NODE_FUNCTION),
NodeType(NODE_METHOD), NodeType(NODE_ENUM),
NodeType(NODE_ENUM_CONSTANT), NodeType(NODE_TYPEDEF),
NodeType(NODE_TYPE_PARAMETER), NodeType(NODE_FILE),
NodeType(NODE_MACRO), NodeType(NODE_UNION)};
src/lib/data/graph/Node.cpp
+3 -3
View File
@@ -36,7 +36,7 @@ NodeType Node::getType() const
void Node::setType(NodeType type)
{
if (!isType(type.getType() | NodeType::NODE_SYMBOL))
if (!isType(type.getKind() | NODE_SYMBOL))
{
LOG_WARNING(
L"Cannot change NodeType after it was already set from " + getReadableTypeString() +
@@ -46,9 +46,9 @@ void Node::setType(NodeType type)
m_type = type;
}
bool Node::isType(NodeType::TypeMask mask) const
bool Node::isType(NodeKindMask mask) const
{
return (m_type.getType() & mask) > 0;
return (m_type.getKind() & mask) > 0;
}
std::wstring Node::getName() const
src/lib/data/graph/Node.h
+1 -1
View File
@@ -21,7 +21,7 @@ public:
NodeType getType() const;
void setType(NodeType type);
bool isType(NodeType::TypeMask mask) const;
bool isType(NodeKindMask mask) const;
std::wstring getName() const;
std::wstring getFullName() const;
src/lib/data/indexer/TaskExecuteCustomCommands.cpp
+1 -1
View File
@@ -352,7 +352,7 @@ void TaskExecuteCustomCommands::runPythonPostProcessing(PersistentStorage& stora
for (const StorageNode& targetNode: nodeNameToStorageNodes[token])
{
if (Edge::intToType(edge.type) == Edge::EDGE_INHERITANCE &&
NodeType::intToType(targetNode.type) != NodeType::NODE_CLASS)
intToNodeKind(targetNode.type) != NODE_CLASS)
{
continue;
}
src/lib/data/parser/ParserClientImpl.cpp
+23 -24
View File
@@ -25,7 +25,7 @@ Id ParserClientImpl::recordSymbol(const NameHierarchy& symbolName)
void ParserClientImpl::recordSymbolKind(Id symbolId, SymbolKind symbolKind)
{
m_storage->setNodeType(symbolId, NodeType::typeToInt(symbolKindToNodeType(symbolKind).getType()));
m_storage->setNodeType(symbolId, nodeKindToInt(symbolKindToNodeKind(symbolKind)));
}
void ParserClientImpl::recordAccessKind(Id symbolId, AccessKind accessKind)
@@ -103,50 +103,50 @@ bool ParserClientImpl::hasContent() const
return m_storage->getByteSize(1) > 0;
}
NodeType ParserClientImpl::symbolKindToNodeType(SymbolKind symbolKind) const
NodeKind ParserClientImpl::symbolKindToNodeKind(SymbolKind symbolKind) const
{
switch (symbolKind)
{
case SYMBOL_ANNOTATION:
return NodeType::NODE_ANNOTATION;
return NODE_ANNOTATION;
case SYMBOL_BUILTIN_TYPE:
return NodeType::NODE_BUILTIN_TYPE;
return NODE_BUILTIN_TYPE;
case SYMBOL_CLASS:
return NodeType::NODE_CLASS;
return NODE_CLASS;
case SYMBOL_ENUM:
return NodeType::NODE_ENUM;
return NODE_ENUM;
case SYMBOL_ENUM_CONSTANT:
return NodeType::NODE_ENUM_CONSTANT;
return NODE_ENUM_CONSTANT;
case SYMBOL_FIELD:
return NodeType::NODE_FIELD;
return NODE_FIELD;
case SYMBOL_FUNCTION:
return NodeType::NODE_FUNCTION;
return NODE_FUNCTION;
case SYMBOL_GLOBAL_VARIABLE:
return NodeType::NODE_GLOBAL_VARIABLE;
return NODE_GLOBAL_VARIABLE;
case SYMBOL_INTERFACE:
return NodeType::NODE_INTERFACE;
return NODE_INTERFACE;
case SYMBOL_MACRO:
return NodeType::NODE_MACRO;
return NODE_MACRO;
case SYMBOL_METHOD:
return NodeType::NODE_METHOD;
return NODE_METHOD;
case SYMBOL_MODULE:
return NodeType::NODE_MODULE;
return NODE_MODULE;
case SYMBOL_NAMESPACE:
return NodeType::NODE_NAMESPACE;
return NODE_NAMESPACE;
case SYMBOL_PACKAGE:
return NodeType::NODE_PACKAGE;
return NODE_PACKAGE;
case SYMBOL_STRUCT:
return NodeType::NODE_STRUCT;
return NODE_STRUCT;
case SYMBOL_TYPEDEF:
return NodeType::NODE_TYPEDEF;
return NODE_TYPEDEF;
case SYMBOL_TYPE_PARAMETER:
return NodeType::NODE_TYPE_PARAMETER;
return NODE_TYPE_PARAMETER;
case SYMBOL_UNION:
return NodeType::NODE_UNION;
return NODE_UNION;
default:
break;
}
return NodeType::NODE_SYMBOL;
return NODE_SYMBOL;
}
Edge::EdgeType ParserClientImpl::referenceKindToEdgeType(ReferenceKind referenceKind) const
@@ -206,8 +206,7 @@ Id ParserClientImpl::addNodeHierarchy(const NameHierarchy& nameHierarchy)
for (size_t i = nameHierarchy.size(); i > 0; i--)
{
std::pair<Id, bool> ret = m_storage->addNode(StorageNodeData(
NodeType::typeToInt(NodeType::NODE_SYMBOL),
NameHierarchy::serializeRange(nameHierarchy, 0, i)));
nodeKindToInt(NODE_SYMBOL), NameHierarchy::serializeRange(nameHierarchy, 0, i)));
if (!firstNodeId)
{
@@ -240,7 +239,7 @@ Id ParserClientImpl::addFileName(const FilePath& filePath)
}
const Id fileId = addNodeHierarchy(NameHierarchy(file, NAME_DELIMITER_FILE));
m_storage->setNodeType(fileId, NodeType::typeToInt(NodeType::NODE_FILE));
m_storage->setNodeType(fileId, nodeKindToInt(NODE_FILE));
m_fileIdMap.emplace(file, fileId);
return fileId;
src/lib/data/parser/ParserClientImpl.h
+1 -1
View File
@@ -42,7 +42,7 @@ public:
bool hasContent() const override;
private:
NodeType symbolKindToNodeType(SymbolKind symbolType) const;
NodeKind symbolKindToNodeKind(SymbolKind symbolType) const;
Edge::EdgeType referenceKindToEdgeType(ReferenceKind referenceKind) const;
LocationType parseLocationTypeToLocationType(ParseLocationType type) const;
src/lib/data/search/SearchIndex.h
+1 -1
View File
@@ -39,7 +39,7 @@ public:
SearchIndex();
virtual ~SearchIndex();
void addNode(Id id, std::wstring name, NodeType type = NodeType::NODE_SYMBOL);
void addNode(Id id, std::wstring name, NodeType type = NodeType(NODE_SYMBOL));
void finishSetup();
void clear();
src/lib/data/search/SearchMatch.cpp
+3 -3
View File
@@ -44,7 +44,7 @@ std::wstring SearchMatch::searchMatchesToString(const std::vector<SearchMatch>&
for (const SearchMatch& match: matches)
{
ss << L'@' << match.getFullName() << L':'
<< NodeType::getReadableTypeWString(match.nodeType.getType()) << L' ';
<< getReadableNodeKindWString(match.nodeType.getKind()) << L' ';
}
return ss.str();
@@ -96,7 +96,7 @@ std::wstring SearchMatch::getCommandName(CommandType type)
}
SearchMatch::SearchMatch()
: typeName(L""), nodeType(NodeType::NODE_SYMBOL), searchType(SEARCH_NONE), hasChildren(false)
: typeName(L""), nodeType(NODE_SYMBOL), searchType(SEARCH_NONE), hasChildren(false)
{
}
@@ -104,7 +104,7 @@ SearchMatch::SearchMatch(const std::wstring& query)
: name(query)
, text(query)
, typeName(L"")
, nodeType(NodeType::NODE_SYMBOL)
, nodeType(NODE_SYMBOL)
, searchType(SEARCH_NONE)
, hasChildren(false)
{
src/lib/data/storage/PersistentStorage.cpp
+31 -34
View File
@@ -573,7 +573,7 @@ std::map<Id, std::pair<Id, NameHierarchy>> PersistentStorage::getNodeIdToParentF
NodeType PersistentStorage::getNodeTypeForNodeWithId(Id nodeId) const
{
return NodeType::intToType(m_sqliteIndexStorage.getFirstById<StorageNode>(nodeId).type);
return NodeType(intToNodeKind(m_sqliteIndexStorage.getFirstById<StorageNode>(nodeId).type));
}
StorageEdge PersistentStorage::getEdgeById(Id edgeId) const
@@ -875,7 +875,7 @@ std::vector<SearchMatch> PersistentStorage::getAutocompletionSymbolMatches(
match.indices = result.indices;
match.score = result.score;
match.nodeType = NodeType::intToType(firstNode->type);
match.nodeType = NodeType(intToNodeKind(firstNode->type));
match.typeName = match.nodeType.getReadableTypeWString();
match.searchType = SearchMatch::SEARCH_TOKEN;
@@ -925,7 +925,7 @@ std::vector<SearchMatch> PersistentStorage::getAutocompletionFileMatches(
match.indices = result.indices;
match.score = result.score;
match.nodeType = NodeType::NODE_FILE;
match.nodeType = NodeType(NODE_FILE);
match.typeName = match.nodeType.getReadableTypeWString();
match.searchType = SearchMatch::SEARCH_TOKEN;
@@ -959,7 +959,7 @@ std::vector<SearchMatch> PersistentStorage::getAutocompletionCommandMatches(
if (match.getCommandType() == SearchMatch::COMMAND_NODE_FILTER)
{
match.nodeType = NodeType::getTypeForReadableTypeString(match.name);
match.nodeType = NodeType(getNodeKindForReadableNodeKindString(match.name));
match.typeName = L"filter";
}
@@ -1006,7 +1006,7 @@ std::vector<SearchMatch> PersistentStorage::getSearchMatchesForTokenIds(
match.tokenIds.push_back(elementId);
match.tokenNames.push_back(nameHierarchy);
match.nodeType = NodeType::intToType(node.type);
match.nodeType = NodeType(intToNodeKind(node.type));
match.searchType = SearchMatch::SEARCH_TOKEN;
if (match.nodeType.isFile())
@@ -1027,7 +1027,7 @@ std::shared_ptr<Graph> PersistentStorage::getGraphForAll() const
std::shared_ptr<Graph> graph = std::make_shared<Graph>();
const size_t sdk_size = m_symbolDefinitionKinds.size();
m_sqliteIndexStorage.forEach<StorageNode>([&, sdk_size](StorageNode&& storageNode) {
const NodeType type(NodeType::intToType(storageNode.type));
const NodeType type(intToNodeKind(storageNode.type));
if (type.isFile())
{
auto fn_it = m_fileNodeIndexed.find(storageNode.id);
@@ -1044,11 +1044,9 @@ std::shared_ptr<Graph> PersistentStorage::getGraphForAll() const
auto it = m_symbolDefinitionKinds.find(storageNode.id);
showNode = (it != m_symbolDefinitionKinds.end() && it->second == DEFINITION_EXPLICIT);
}
if (showNode && (
type.isPackage() ||
!m_hierarchyCache.isChildOfVisibleNodeOrInvisible(storageNode.id)
)
)
if (showNode &&
(type.isPackage() ||
!m_hierarchyCache.isChildOfVisibleNodeOrInvisible(storageNode.id)))
{
addNodeToGraph(storageNode, type, graph.get(), false);
}
@@ -1064,7 +1062,7 @@ std::shared_ptr<Graph> PersistentStorage::getGraphForNodeTypes(NodeTypeSet nodeT
std::vector<Id> tokenIds;
m_sqliteIndexStorage.forEach<StorageNode>([&](StorageNode&& node) {
if (nodeTypes.contains(NodeType::intToType(node.type)))
if (nodeTypes.contains(NodeType(intToNodeKind(node.type))))
{
auto it = m_symbolDefinitionKinds.find(node.id);
if (it != m_symbolDefinitionKinds.end() && it->second == DEFINITION_EXPLICIT)
@@ -1111,7 +1109,7 @@ std::shared_ptr<Graph> PersistentStorage::getGraphForActiveTokenIds(
if (node.id > 0)
{
const NodeType nodeType = NodeType::intToType(node.type);
const NodeType nodeType(intToNodeKind(node.type));
if (nodeType.isPackage())
{
ids.clear();
@@ -1282,7 +1280,7 @@ std::shared_ptr<Graph> PersistentStorage::getGraphForChildrenOfNodeId(Id nodeId)
std::shared_ptr<Graph> PersistentStorage::getGraphForTrail(
Id originId,
Id targetId,
NodeType::TypeMask nodeTypes,
NodeKindMask nodeTypes,
Edge::TypeMask edgeTypes,
bool nodeNonIndexed,
size_t depth,
@@ -1379,12 +1377,12 @@ std::shared_ptr<Graph> PersistentStorage::getGraphForTrail(
for (const StorageNode& node:
m_sqliteIndexStorage.getAllByIds<StorageNode>(nodeIdsToCheck))
{
NodeType::Type type = NodeType::intToType(node.type);
if (type & nodeTypes || (type == NodeType::NODE_SYMBOL && nodeNonIndexed))
NodeKind kind = intToNodeKind(node.type);
if (kind & nodeTypes || (kind == NODE_SYMBOL && nodeNonIndexed))
{
if (!nodeNonIndexed)
{
if (type == NodeType::NODE_FILE)
if (kind == NODE_FILE)
{
auto it = m_fileNodeIndexed.find(node.id);
if (it == m_fileNodeIndexed.end() || !it->second)
@@ -1404,9 +1402,7 @@ std::shared_ptr<Graph> PersistentStorage::getGraphForTrail(
// FIXME: don't add namespace nodes to the graph, because it destroys trail
// layouting Remove when namespaces are proper nodes with children
if ((type &
(NodeType::NODE_MODULE | NodeType::NODE_NAMESPACE |
NodeType::NODE_PACKAGE)) == 0)
if ((kind & (NODE_MODULE | NODE_NAMESPACE | NODE_PACKAGE)) == 0)
{
nodeIds.insert(node.id);
for (const StorageEdge& edge: edgesToInsert[node.id])
@@ -1502,14 +1498,14 @@ std::shared_ptr<Graph> PersistentStorage::getGraphForTrail(
return graph;
}
NodeType::TypeMask PersistentStorage::getAvailableNodeTypes() const
NodeKindMask PersistentStorage::getAvailableNodeTypes() const
{
TRACE();
NodeType::TypeMask mask = 0;
NodeKindMask mask = 0;
for (int type: m_sqliteIndexStorage.getAvailableNodeTypes())
{
mask |= NodeType::intToType(type);
mask |= intToNodeKind(type);
}
return mask;
}
@@ -1610,7 +1606,7 @@ std::shared_ptr<SourceLocationCollection> PersistentStorage::getSourceLocationsF
if (path.empty() && m_symbolDefinitionKinds.find(tokenId) == m_symbolDefinitionKinds.end())
{
const StorageNode fileNode = m_sqliteIndexStorage.getNodeById(tokenId);
if (NodeType(NodeType::intToType(fileNode.type)).isFile())
if (NodeType(intToNodeKind(fileNode.type)).isFile())
{
path = FilePath(
NameHierarchy::deserialize(fileNode.serializedName).getQualifiedName());
@@ -2168,7 +2164,7 @@ TooltipInfo PersistentStorage::getTooltipInfoForTokenIds(
return info;
}
const NodeType type = NodeType::intToType(node.type);
const NodeType type(intToNodeKind(node.type));
info.title = type.getReadableTypeWString();
DefinitionKind defKind = DEFINITION_NONE;
@@ -2519,7 +2515,7 @@ TooltipInfo PersistentStorage::getTooltipInfoForSourceLocationIdsAndLocalSymbolI
snippet.locationFile->addSourceLocation(
LOCATION_TOKEN, 0, std::vector<Id>(1, node.id), 1, 1, 1, snippet.code.size());
if (NodeType(NodeType::intToType(node.type)).isCallable())
if (NodeType(intToNodeKind(node.type)).isCallable())
{
snippet.code += L"()";
}
@@ -2846,7 +2842,7 @@ void PersistentStorage::addNodesToGraph(
for (const StorageNode& storageNode: m_sqliteIndexStorage.getAllByIds<StorageNode>(nodeIds))
{
const NodeType type(NodeType::intToType(storageNode.type));
const NodeType type(intToNodeKind(storageNode.type));
if (type.isFile())
{
addFileNodeToGraph(storageNode, graph);
@@ -2867,14 +2863,15 @@ void PersistentStorage::addFileNodeToGraph(const StorageNode& storageNode, Graph
bool indexed = getFileNodeIndexed(storageNode.id);
Node* node = graph->createNode(
storageNode.id,
NodeType::NODE_FILE,
NameHierarchy(filePath.fileName(), NAME_DELIMITER_FILE),
indexed ? DEFINITION_EXPLICIT : DEFINITION_NONE);
storageNode.id,
NodeType(NODE_FILE),
NameHierarchy(filePath.fileName(), NAME_DELIMITER_FILE),
indexed ? DEFINITION_EXPLICIT : DEFINITION_NONE);
node->addComponent(std::make_shared<TokenComponentFilePath>(filePath, complete));
}
void PersistentStorage::addNodeToGraph(const StorageNode& newNode, const NodeType& type, Graph* graph, bool addChildCount) const
void PersistentStorage::addNodeToGraph(
const StorageNode& newNode, const NodeType& type, Graph* graph, bool addChildCount) const
{
NameHierarchy nameHierarchy = NameHierarchy::deserialize(newNode.serializedName);
DefinitionKind defKind = DEFINITION_NONE;
@@ -3272,7 +3269,7 @@ void PersistentStorage::buildSearchIndex()
const FilePath dbPath = getIndexDbFilePath();
m_sqliteIndexStorage.forEach<StorageNode>([&](StorageNode&& node) {
const NodeType type = NodeType::intToType(node.type);
const NodeType type(intToNodeKind(node.type));
if (type.isFile())
{
bool indexed = getFileNodeIndexed(node.id);
@@ -3455,7 +3452,7 @@ void PersistentStorage::buildHierarchyCache()
m_sqliteIndexStorage.forEachByIds<StorageNode>(
sourceNodeIds, [&invisibleParentSourceNodeIds](StorageNode&& node) {
if (!NodeType(NodeType::intToType(node.type)).isVisibleAsParentInGraph())
if (!NodeType(intToNodeKind(node.type)).isVisibleAsParentInGraph())
{
invisibleParentSourceNodeIds.insert(node.id);
}
src/lib/data/storage/PersistentStorage.h
+4 -3
View File
@@ -133,13 +133,13 @@ public:
std::shared_ptr<Graph> getGraphForTrail(
Id originId,
Id targetId,
NodeType::TypeMask nodeTypes,
NodeKindMask nodeTypes,
Edge::TypeMask trailType,
bool nodeNonIndexed,
size_t depth,
bool directed) const override;
NodeType::TypeMask getAvailableNodeTypes() const override;
NodeKindMask getAvailableNodeTypes() const override;
Edge::TypeMask getAvailableEdgeTypes() const override;
std::vector<Id> getActiveTokenIdsForId(Id tokenId, Id* declarationId) const override;
@@ -242,7 +242,8 @@ private:
Graph* graphh,
bool addChildCount) const;
inline void addFileNodeToGraph(const StorageNode& storageNode, Graph* const graph) const;
void addNodeToGraph(const StorageNode& newNode, const NodeType& type, Graph* graph, bool addChildCount) const;
void addNodeToGraph(
const StorageNode& newNode, const NodeType& type, Graph* graph, bool addChildCount) const;
void addAggregationEdgesToGraph(
Id nodeId, const std::vector<StorageEdge>& edgesToAggregate, Graph* graph) const;
void addFileContentsToGraph(Id fileId, Graph* graph) const;
src/lib/data/storage/StorageAccess.h
+2 -2
View File
@@ -67,13 +67,13 @@ public:
virtual std::shared_ptr<Graph> getGraphForTrail(
Id originId,
Id targetId,
NodeType::TypeMask nodeTypes,
NodeKindMask nodeTypes,
Edge::TypeMask edgeTypes,
bool nodeNonIndexed,
size_t depth,
bool directed) const = 0;
virtual NodeType::TypeMask getAvailableNodeTypes() const = 0;
virtual NodeKindMask getAvailableNodeTypes() const = 0;
virtual Edge::TypeMask getAvailableEdgeTypes() const = 0;
virtual std::vector<Id> getActiveTokenIdsForId(Id tokenId, Id* declarationId) const = 0;
src/lib/data/storage/StorageAccessProxy.cpp
+3 -3
View File
@@ -162,7 +162,7 @@ DEF_GETTER_1(getNameHierarchiesForNodeIds, const std::vector<Id>&, std::vector<N
typedef std::map<Id, std::pair<Id, NameHierarchy>> NodeIdToParentFileMap;
DEF_GETTER_1(getNodeIdToParentFileMap, const std::vector<Id>&, NodeIdToParentFileMap, {})
DEF_GETTER_1(getNodeTypeForNodeWithId, Id, NodeType, NodeType(NodeType::NODE_SYMBOL))
DEF_GETTER_1(getNodeTypeForNodeWithId, Id, NodeType, NodeType(NODE_SYMBOL))
DEF_GETTER_1(getEdgeById, Id, StorageEdge, StorageEdge())
DEF_GETTER_2(
getFullTextSearchLocations,
@@ -196,14 +196,14 @@ DEF_GETTER_7(
getGraphForTrail,
Id,
Id,
NodeType::TypeMask,
NodeKindMask,
Edge::TypeMask,
bool,
size_t,
bool,
std::shared_ptr<Graph>,
std::make_shared<Graph>())
DEF_GETTER_0(getAvailableNodeTypes, NodeType::TypeMask, 0);
DEF_GETTER_0(getAvailableNodeTypes, NodeKindMask, 0);
DEF_GETTER_0(getAvailableEdgeTypes, Edge::TypeMask, 0);
DEF_GETTER_2(getActiveTokenIdsForId, Id, Id*, std::vector<Id>, {})
DEF_GETTER_1(getNodeIdsForLocationIds, const std::vector<Id>&, std::vector<Id>, {})
src/lib/data/storage/StorageAccessProxy.h
+2 -2
View File
@@ -43,13 +43,13 @@ public:
std::shared_ptr<Graph> getGraphForTrail(
Id originId,
Id targetId,
NodeType::TypeMask nodeTypes,
NodeKindMask nodeTypes,
Edge::TypeMask edgeTypes,
bool nodeNonIndexed,
size_t depth,
bool directed) const override;
NodeType::TypeMask getAvailableNodeTypes() const override;
NodeKindMask getAvailableNodeTypes() const override;
Edge::TypeMask getAvailableEdgeTypes() const override;
std::vector<Id> getActiveTokenIdsForId(Id tokenId, Id* declarationId) const override;
src/lib/utility/messaging/type/activation/MessageActivateErrors.h
+1 -1
View File
@@ -31,7 +31,7 @@ public:
SearchMatch match;
match.name = match.text = file.fileName();
match.searchType = SearchMatch::SEARCH_TOKEN;
match.nodeType = NodeType::NODE_FILE;
match.nodeType = NodeType(NODE_FILE);
matches.push_back(match);
}
return matches;
src/lib/utility/messaging/type/activation/MessageActivateTokens.h
+1 -1
View File
@@ -48,7 +48,7 @@ public:
SearchMatch match;
match.name = match.text = L"aggregation"; // TODO: show aggregation source and target
match.searchType = SearchMatch::SEARCH_TOKEN;
match.nodeType = NodeType::NODE_TYPE;
match.nodeType = NodeType(NODE_TYPE);
return {match};
}
src/lib/utility/messaging/type/activation/MessageActivateTrail.h
+2 -2
View File
@@ -29,7 +29,7 @@ public:
MessageActivateTrail(
Id originId,
Id targetId,
NodeType::TypeMask nodeTypes,
NodeKindMask nodeTypes,
Edge::TypeMask edgeTypes,
bool nodeNonIndexed,
size_t depth,
@@ -60,7 +60,7 @@ public:
const Id originId;
const Id targetId;
const NodeType::TypeMask nodeTypes;
const NodeKindMask nodeTypes;
const Edge::TypeMask edgeTypes;
const bool nodeNonIndexed;
const size_t depth;
src/lib_gui/qt/element/search/QtAutocompletionList.cpp
+2 -3
View File
@@ -63,7 +63,7 @@ QVariant QtAutocompletionModel::data(const QModelIndex& index, int role) const
return indices;
}
case 5:
return match.nodeType.getType();
return match.nodeType.getKind();
default:
return QVariant();
}
@@ -137,8 +137,7 @@ void QtAutocompletionDelegate::paint(
QString subtext = index.sibling(index.row(), index.column() + 2).data().toString();
QString type = index.sibling(index.row(), index.column() + 3).data().toString();
QList<QVariant> indices = index.sibling(index.row(), index.column() + 4).data().toList();
NodeType nodeType = NodeType::intToType(
index.sibling(index.row(), index.column() + 5).data().toInt());
NodeType nodeType(intToNodeKind(index.sibling(index.row(), index.column() + 5).data().toInt()));
// define highlight colors
ColorScheme* scheme = ColorScheme::getInstance().get();
src/lib_gui/qt/graphics/graph/QtGraphNodeData.cpp
+1 -1
View File
@@ -88,7 +88,7 @@ void QtGraphNodeData::hoverEnterEvent(QGraphicsSceneHoverEvent* event)
if (!m_isInteractive)
{
TooltipInfo info;
info.title = NodeType::getReadableTypeWString(m_data->getType().getType());
info.title = getReadableNodeKindWString(m_data->getType().getKind());
info.offset = Vec2i(10, 20);
if (!m_data->isDefined())
src/lib_gui/qt/view/QtCustomTrailView.cpp
+30 -30
View File
@@ -190,33 +190,33 @@ QtCustomTrailView::QtCustomTrailView(ViewLayout* viewLayout)
std::vector<QString> nodeFilters;
std::vector<QColor> nodeColors;
std::vector<NodeType::Type> nodeTypes = {// NodeType::NODE_SYMBOL,
NodeType::NODE_TYPE,
NodeType::NODE_BUILTIN_TYPE,
// NodeType::NODE_MODULE,
// NodeType::NODE_NAMESPACE,
// NodeType::NODE_PACKAGE,
NodeType::NODE_CLASS,
NodeType::NODE_STRUCT,
NodeType::NODE_UNION,
NodeType::NODE_INTERFACE,
NodeType::NODE_TYPEDEF,
NodeType::NODE_TYPE_PARAMETER,
NodeType::NODE_ENUM,
NodeType::NODE_ENUM_CONSTANT,
NodeType::NODE_GLOBAL_VARIABLE,
NodeType::NODE_FIELD,
NodeType::NODE_FUNCTION,
NodeType::NODE_METHOD,
NodeType::NODE_FILE,
NodeType::NODE_MACRO,
NodeType::NODE_ANNOTATION};
const std::vector<NodeKind> nodeKinds = {// NODE_SYMBOL,
NODE_TYPE,
NODE_BUILTIN_TYPE,
// NODE_MODULE,
// NODE_NAMESPACE,
// NODE_PACKAGE,
NODE_CLASS,
NODE_STRUCT,
NODE_UNION,
NODE_INTERFACE,
NODE_TYPEDEF,
NODE_TYPE_PARAMETER,
NODE_ENUM,
NODE_ENUM_CONSTANT,
NODE_GLOBAL_VARIABLE,
NODE_FIELD,
NODE_FUNCTION,
NODE_METHOD,
NODE_FILE,
NODE_MACRO,
NODE_ANNOTATION};
for (NodeType::Type t: nodeTypes)
for (NodeKind t: nodeKinds)
{
nodeFilters.push_back(QString::fromStdString(NodeType::getReadableTypeString(t)));
nodeFilters.push_back(QString::fromStdString(getReadableNodeKindString(t)));
nodeColors.push_back(
QColor(scheme->getNodeTypeColor(t, "fill", ColorScheme::FOCUS).c_str()));
QColor(scheme->getNodeTypeColor(NodeType(t), "fill", ColorScheme::FOCUS).c_str()));
}
QVBoxLayout* filterLayout = addFilters(
@@ -316,7 +316,7 @@ QtCustomTrailView::QtCustomTrailView(ViewLayout* viewLayout)
}
}
NodeType::TypeMask nodeTypes = getCheckedNodeTypes();
NodeKindMask nodeTypes = getCheckedNodeTypes();
Edge::TypeMask edgeTypes = getCheckedEdgeTypes();
if (!nodeTypes)
@@ -368,7 +368,7 @@ void QtCustomTrailView::clearView()
});
}
void QtCustomTrailView::setAvailableNodeAndEdgeTypes(NodeType::TypeMask nodeTypes, Edge::TypeMask edgeTypes)
void QtCustomTrailView::setAvailableNodeAndEdgeTypes(NodeKindMask nodeTypes, Edge::TypeMask edgeTypes)
{
m_onQtThread([this, nodeTypes, edgeTypes]() {
for (QCheckBox* filter: m_nodeFilters)
@@ -379,7 +379,7 @@ void QtCustomTrailView::setAvailableNodeAndEdgeTypes(NodeType::TypeMask nodeType
}
bool enabled = nodeTypes &
NodeType::getTypeForReadableTypeString(filter->text().toStdWString());
getNodeKindForReadableNodeKindString(filter->text().toStdWString());
filter->setEnabled(enabled);
filter->setVisible(enabled);
}
@@ -578,14 +578,14 @@ QHBoxLayout* QtCustomTrailView::addCheckButtons(const std::vector<QCheckBox*>& c
return buttonLayout;
}
NodeType::TypeMask QtCustomTrailView::getCheckedNodeTypes() const
NodeKindMask QtCustomTrailView::getCheckedNodeTypes() const
{
NodeType::TypeMask nodeTypes = 0;
NodeKindMask nodeTypes = 0;
for (const QCheckBox* filter: m_nodeFilters)
{
if (filter->isEnabled() && filter->isChecked() && filter != m_nodeNonIndexed)
{
nodeTypes |= NodeType::getTypeForReadableTypeString(filter->text().toStdWString());
nodeTypes |= getNodeKindForReadableNodeKindString(filter->text().toStdWString());
}
}
return nodeTypes;
src/lib_gui/qt/view/QtCustomTrailView.h
+2 -2
View File
@@ -29,7 +29,7 @@ public:
// TrailView implementation
void clearView() override;
void setAvailableNodeAndEdgeTypes(NodeType::TypeMask nodeTypes, Edge::TypeMask edgeTypes) override;
void setAvailableNodeAndEdgeTypes(NodeKindMask nodeTypes, Edge::TypeMask edgeTypes) override;
void showView() override;
void hideView() override;
@@ -50,7 +50,7 @@ private:
size_t filtersInFirstColumn);
QHBoxLayout* addCheckButtons(const std::vector<QCheckBox*>& checkBoxes) const;
NodeType::TypeMask getCheckedNodeTypes() const;
NodeKindMask getCheckedNodeTypes() const;
Edge::TypeMask getCheckedEdgeTypes() const;
void setError(const QString& error);
src/test/GraphTestSuite.cpp
+36 -36
View File
@@ -144,7 +144,7 @@ TEST_CASE("nodes are nodes")
{
Node a(
1,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
@@ -156,12 +156,12 @@ TEST_CASE("edges are edges")
{
Node a(
1,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Node b(
2,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"B", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Edge e(3, Edge::EDGE_USAGE, &a, &b);
@@ -174,39 +174,39 @@ TEST_CASE("set type of node from constructor")
{
Node n(
1,
NodeType(NodeType::NODE_FUNCTION),
NodeType(NODE_FUNCTION),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
REQUIRE(NodeType(NodeType::NODE_FUNCTION) == n.getType());
REQUIRE(NodeType(NODE_FUNCTION) == n.getType());
}
TEST_CASE("set type of node from non indexed")
{
Node n(
2,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
n.setType(NodeType(NodeType::NODE_CLASS));
REQUIRE(NodeType(NodeType::NODE_CLASS) == n.getType());
n.setType(NodeType(NODE_CLASS));
REQUIRE(NodeType(NODE_CLASS) == n.getType());
}
TEST_CASE("can not change type of node after it was set")
{
Node n(
3,
NodeType(NodeType::NODE_NAMESPACE),
NodeType(NODE_NAMESPACE),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
n.setType(NodeType(NodeType::NODE_CLASS));
REQUIRE(NodeType(NodeType::NODE_CLASS) != n.getType());
n.setType(NodeType(NODE_CLASS));
REQUIRE(NodeType(NODE_CLASS) != n.getType());
}
TEST_CASE("node can be copied and keeps same id")
{
Node n(
4,
NodeType(NodeType::NODE_NAMESPACE),
NodeType(NODE_NAMESPACE),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Node n2(n);
@@ -221,23 +221,23 @@ TEST_CASE("node type bit masking")
{
Node n(
1,
NodeType(NodeType::NODE_NAMESPACE),
NodeType(NODE_NAMESPACE),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
REQUIRE(n.isType(NodeType::NODE_FUNCTION | NodeType::NODE_NAMESPACE | NodeType::NODE_CLASS));
REQUIRE(!n.isType(NodeType::NODE_FUNCTION | NodeType::NODE_METHOD | NodeType::NODE_CLASS));
REQUIRE(n.isType(NODE_FUNCTION | NODE_NAMESPACE | NODE_CLASS));
REQUIRE(!n.isType(NODE_FUNCTION | NODE_METHOD | NODE_CLASS));
}
TEST_CASE("get type of edges")
{
Node a(
1,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Node b(
2,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"B", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Edge e(3, Edge::EDGE_USAGE, &a, &b);
@@ -249,12 +249,12 @@ TEST_CASE("edge can be copied and keeps same id")
{
Node a(
1,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Node b(
2,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"B", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Edge e(3, Edge::EDGE_USAGE, &a, &b);
@@ -269,12 +269,12 @@ TEST_CASE("edge type bit masking")
{
Node a(
1,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Node b(
2,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"B", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Edge e(3, Edge::EDGE_USAGE, &a, &b);
@@ -287,17 +287,17 @@ TEST_CASE("node finds child node")
{
Node a(
1,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Node b(
2,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"B", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Node c(
3,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"C", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Edge e(4, Edge::EDGE_MEMBER, &a, &b);
@@ -313,17 +313,17 @@ TEST_CASE("node can not find child node")
{
Node a(
1,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Node b(
2,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"B", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Node c(
3,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"C", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Edge e(4, Edge::EDGE_MEMBER, &a, &b);
@@ -338,17 +338,17 @@ TEST_CASE("node visits child nodes")
{
Node a(
1,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Node b(
2,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"B", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Node c(
3,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"C", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Edge e(4, Edge::EDGE_MEMBER, &a, &b);
@@ -367,12 +367,12 @@ TEST_CASE("graph saves nodes")
Graph graph;
Node* a = graph.createNode(
1,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Node* b = graph.createNode(
2,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"B", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
@@ -394,12 +394,12 @@ TEST_CASE("graph saves edges")
Node* a = graph.createNode(
1,
NodeType(NodeType::NODE_FUNCTION),
NodeType(NODE_FUNCTION),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
Node* b = graph.createNode(
2,
NodeType(NodeType::NODE_FUNCTION),
NodeType(NODE_FUNCTION),
NameHierarchy(L"B", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
@@ -418,12 +418,12 @@ TEST_CASE("graph removes nodes")
Node* a = graph.createNode(
1,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"A", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
graph.createNode(
2,
NodeType(NodeType::NODE_SYMBOL),
NodeType(NODE_SYMBOL),
NameHierarchy(L"B", NAME_DELIMITER_CXX),
DEFINITION_EXPLICIT);
src/test/RefreshInfoGeneratorTestSuite.cpp
+1 -1
View File
@@ -136,7 +136,7 @@ Id addFileToStorage(
const Id id =
storage
->addNode(StorageNodeData(
NodeType::NODE_FILE,
NODE_FILE,
NameHierarchy::serialize(NameHierarchy(filePath.wstr(), NAME_DELIMITER_FILE))))
.first;
storage->addFile(
src/test/StorageTestSuite.cpp
+6 -8
View File
@@ -63,7 +63,7 @@ TEST_CASE("storage saves file")
std::shared_ptr<IntermediateStorage> intermetiateStorage = std::make_shared<IntermediateStorage>();
Id id = intermetiateStorage
->addNode(StorageNodeData(
NodeType::typeToInt(NodeType::NODE_FILE),
nodeKindToInt(NODE_FILE),
NameHierarchy::serialize(NameHierarchy(filePath, NAME_DELIMITER_FILE))))
.first;
intermetiateStorage->addFile(StorageFile(id, filePath, L"someLanguage", "someTime", true, true));
@@ -82,14 +82,14 @@ TEST_CASE("storage saves node")
std::shared_ptr<IntermediateStorage> intermetiateStorage = std::make_shared<IntermediateStorage>();
intermetiateStorage->addNode(
StorageNodeData(NodeType::typeToInt(NodeType::NODE_TYPEDEF), NameHierarchy::serialize(a)));
StorageNodeData(nodeKindToInt(NODE_TYPEDEF), NameHierarchy::serialize(a)));
storage.inject(intermetiateStorage.get());
Id storedId = storage.getNodeIdForNameHierarchy(a);
REQUIRE(storedId != 0);
REQUIRE(storage.getNodeTypeForNodeWithId(storedId).getType() == NodeType::NODE_TYPEDEF);
REQUIRE(storage.getNodeTypeForNodeWithId(storedId).getKind() == NODE_TYPEDEF);
}
TEST_CASE("storage saves field as member")
@@ -102,14 +102,12 @@ TEST_CASE("storage saves field as member")
std::shared_ptr<IntermediateStorage> intermetiateStorage = std::make_shared<IntermediateStorage>();
Id aId = intermetiateStorage
->addNode(StorageNodeData(
NodeType::typeToInt(NodeType::NODE_STRUCT), NameHierarchy::serialize(a)))
->addNode(StorageNodeData(nodeKindToInt(NODE_STRUCT), NameHierarchy::serialize(a)))
.first;
intermetiateStorage->addSymbol(StorageSymbol(aId, DEFINITION_EXPLICIT));
Id bId = intermetiateStorage
->addNode(StorageNodeData(
NodeType::typeToInt(NodeType::NODE_FIELD), NameHierarchy::serialize(b)))
->addNode(StorageNodeData(nodeKindToInt(NODE_FIELD), NameHierarchy::serialize(b)))
.first;
intermetiateStorage->addSymbol(StorageSymbol(bId, DEFINITION_EXPLICIT));
intermetiateStorage->addEdge(StorageEdgeData(Edge::typeToInt(Edge::EDGE_MEMBER), aId, bId));
@@ -144,7 +142,7 @@ TEST_CASE("storage saves method static")
// Node* node = storage.getNodeWithId(id);
// TS_ASSERT(node);
// TS_ASSERT_EQUALS(node->getQualifiedNameWithSignature(), "isMethod");
// TS_ASSERT_EQUALS(node->getType(), NodeType::NODE_METHOD);
// TS_ASSERT_EQUALS(node->getType(), NODE_METHOD);
// TS_ASSERT(node->getComponent<TokenComponentStatic>());
}
src/test/helper/TestIntermediateStorage.h
+38 -38
View File
@@ -117,7 +117,7 @@ public:
{
nodesMap.emplace(node.id, node);
if (NodeType::intToType(node.type) == NodeType::NODE_FILE)
if (intToNodeKind(node.type) == NODE_FILE)
{
fileIdMap.insert(node.id);
}
@@ -345,41 +345,41 @@ public:
private:
std::wstring nodeTypeToString(int nodeType) const
{
switch (NodeType::intToType(nodeType))
switch (intToNodeKind(nodeType))
{
case NodeType::NODE_BUILTIN_TYPE:
case NODE_BUILTIN_TYPE:
return L"SYMBOL_BUILTIN_TYPE";
case NodeType::NODE_CLASS:
case NODE_CLASS:
return L"SYMBOL_CLASS";
case NodeType::NODE_ENUM:
case NODE_ENUM:
return L"SYMBOL_ENUM";
case NodeType::NODE_ENUM_CONSTANT:
case NODE_ENUM_CONSTANT:
return L"SYMBOL_ENUM_CONSTANT";
case NodeType::NODE_FIELD:
case NODE_FIELD:
return L"SYMBOL_FIELD";
case NodeType::NODE_FUNCTION:
case NODE_FUNCTION:
return L"SYMBOL_FUNCTION";
case NodeType::NODE_GLOBAL_VARIABLE:
case NODE_GLOBAL_VARIABLE:
return L"SYMBOL_GLOBAL_VARIABLE";
case NodeType::NODE_INTERFACE:
case NODE_INTERFACE:
return L"SYMBOL_INTERFACE";
case NodeType::NODE_MACRO:
case NODE_MACRO:
return L"SYMBOL_MACRO";
case NodeType::NODE_METHOD:
case NODE_METHOD:
return L"SYMBOL_METHOD";
case NodeType::NODE_MODULE:
case NODE_MODULE:
return L"SYMBOL_MODULE";
case NodeType::NODE_NAMESPACE:
case NODE_NAMESPACE:
return L"SYMBOL_NAMESPACE";
case NodeType::NODE_PACKAGE:
case NODE_PACKAGE:
return L"SYMBOL_PACKAGE";
case NodeType::NODE_STRUCT:
case NODE_STRUCT:
return L"SYMBOL_STRUCT";
case NodeType::NODE_TYPEDEF:
case NODE_TYPEDEF:
return L"SYMBOL_TYPEDEF";
case NodeType::NODE_TYPE_PARAMETER:
case NODE_TYPE_PARAMETER:
return L"SYMBOL_TYPE_PARAMETER";
case NodeType::NODE_UNION:
case NODE_UNION:
return L"SYMBOL_UNION";
default:
break;
@@ -421,43 +421,43 @@ private:
std::vector<std::wstring>* getBinForNodeType(int nodeType)
{
switch (NodeType::intToType(nodeType))
switch (intToNodeKind(nodeType))
{
case NodeType::NODE_PACKAGE:
case NODE_PACKAGE:
return &packages;
case NodeType::NODE_TYPEDEF:
case NODE_TYPEDEF:
return &typedefs;
case NodeType::NODE_BUILTIN_TYPE:
case NODE_BUILTIN_TYPE:
return &builtinTypes;
case NodeType::NODE_CLASS:
case NODE_CLASS:
return &classes;
case NodeType::NODE_UNION:
case NODE_UNION:
return &unions;
case NodeType::NODE_INTERFACE:
case NODE_INTERFACE:
return &interfaces;
case NodeType::NODE_ANNOTATION:
case NODE_ANNOTATION:
return &annotations;
case NodeType::NODE_ENUM:
case NODE_ENUM:
return &enums;
case NodeType::NODE_ENUM_CONSTANT:
case NODE_ENUM_CONSTANT:
return &enumConstants;
case NodeType::NODE_FUNCTION:
case NODE_FUNCTION:
return &functions;
case NodeType::NODE_FIELD:
case NODE_FIELD:
return &fields;
case NodeType::NODE_GLOBAL_VARIABLE:
case NODE_GLOBAL_VARIABLE:
return &globalVariables;
case NodeType::NODE_METHOD:
case NODE_METHOD:
return &methods;
case NodeType::NODE_MODULE:
case NODE_MODULE:
return &modules;
case NodeType::NODE_NAMESPACE:
case NODE_NAMESPACE:
return &namespaces;
case NodeType::NODE_STRUCT:
case NODE_STRUCT:
return &structs;
case NodeType::NODE_MACRO:
case NODE_MACRO:
return &macros;
case NodeType::NODE_TYPE_PARAMETER:
case NODE_TYPE_PARAMETER:
return &typeParameters;
default:
break;