From 437f06d21b0adfd506ebd0a72ca5845c14395a95 Mon Sep 17 00:00:00 2001 From: Malte Langkabel Date: Fri, 14 Feb 2020 20:35:02 +0100 Subject: [PATCH] src: extract NoteType::Type to NodeKind (#925) --- src/lib/CMakeLists.txt | 2 + .../controller/CustomTrailController.cpp | 6 +- .../component/controller/GraphController.cpp | 193 +++++----- .../controller/UndoRedoController.cpp | 9 +- .../component/controller/helper/DummyNode.h | 2 +- src/lib/component/view/CustomTrailView.h | 2 +- src/lib/data/NodeKind.cpp | 126 +++++++ src/lib/data/NodeKind.h | 44 +++ src/lib/data/NodeType.cpp | 332 ++++++------------ src/lib/data/NodeType.h | 45 +-- src/lib/data/NodeTypeSet.cpp | 20 +- src/lib/data/graph/Node.cpp | 6 +- src/lib/data/graph/Node.h | 2 +- .../indexer/TaskExecuteCustomCommands.cpp | 2 +- src/lib/data/parser/ParserClientImpl.cpp | 47 ++- src/lib/data/parser/ParserClientImpl.h | 2 +- src/lib/data/search/SearchIndex.h | 2 +- src/lib/data/search/SearchMatch.cpp | 6 +- src/lib/data/storage/PersistentStorage.cpp | 65 ++-- src/lib/data/storage/PersistentStorage.h | 7 +- src/lib/data/storage/StorageAccess.h | 4 +- src/lib/data/storage/StorageAccessProxy.cpp | 6 +- src/lib/data/storage/StorageAccessProxy.h | 4 +- .../type/activation/MessageActivateErrors.h | 2 +- .../type/activation/MessageActivateTokens.h | 2 +- .../type/activation/MessageActivateTrail.h | 4 +- .../element/search/QtAutocompletionList.cpp | 5 +- .../qt/graphics/graph/QtGraphNodeData.cpp | 2 +- src/lib_gui/qt/view/QtCustomTrailView.cpp | 60 ++-- src/lib_gui/qt/view/QtCustomTrailView.h | 4 +- src/test/GraphTestSuite.cpp | 72 ++-- src/test/RefreshInfoGeneratorTestSuite.cpp | 2 +- src/test/StorageTestSuite.cpp | 14 +- src/test/helper/TestIntermediateStorage.h | 76 ++-- 34 files changed, 577 insertions(+), 600 deletions(-) create mode 100644 src/lib/data/NodeKind.cpp create mode 100644 src/lib/data/NodeKind.h diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt index 261dabeb..e08d2b40 100644 --- a/src/lib/CMakeLists.txt +++ b/src/lib/CMakeLists.txt @@ -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 diff --git a/src/lib/component/controller/CustomTrailController.cpp b/src/lib/component/controller/CustomTrailController.cpp index 43f20efb..7bd4d954 100644 --- a/src/lib/component/controller/CustomTrailController.cpp +++ b/src/lib/component/controller/CustomTrailController.cpp @@ -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); diff --git a/src/lib/component/controller/GraphController.cpp b/src/lib/component/controller/GraphController.cpp index c448a7d9..0ce3aec5 100644 --- a/src/lib/component/controller/GraphController.cpp +++ b/src/lib/component/controller/GraphController.cpp @@ -812,7 +812,7 @@ std::vector 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& 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 bundleInfoTree(NodeType::BundleInfo(L"Symbols")); std::shared_ptr 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> 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(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", Vec2i(x, y + dy * ++i)); - Node* genericParameterNode = addNode( - NodeType::NODE_TYPE_PARAMETER, L"ParameterType", Vec2i()); + NODE_TYPE, L"JavaGenericType", 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 aggregationComp = std::make_shared(); @@ -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(std::vector({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", - Vec2i(x, y + dy * ++i)); + NODE_FUNCTION, L"template_function", Vec2i(x, y + dy * ++i)); y += 20; Node* templateFunctionSpecializationNode = addNode( - NodeType::NODE_FUNCTION, + NODE_FUNCTION, L"template_function", Vec2i(x, y + dy * ++i), DEFINITION_IMPLICIT); @@ -2703,15 +2688,11 @@ void GraphController::createLegendGraph() templateFunctionNode); Node* templateNode = addNode( - NodeType::NODE_TYPE, L"TemplateType", Vec2i(x, y + dy * ++i)); + NODE_TYPE, L"TemplateType", Vec2i(x, y + dy * ++i)); y += 30; Node* templateSpecializationNode = addNode( - NodeType::NODE_TYPE, - L"TemplateType", - 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", 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", Vec2i(x, y + dy * ++i)); - Node* templateMethodNode = addNode(NodeType::NODE_METHOD, L"method", Vec2i()); + NODE_TYPE, L"TemplateType", 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", 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, diff --git a/src/lib/component/controller/UndoRedoController.cpp b/src/lib/component/controller/UndoRedoController.cpp index bb5ff4b1..cce14089 100644 --- a/src/lib/component/controller/UndoRedoController.cpp +++ b/src/lib/component/controller/UndoRedoController.cpp @@ -173,7 +173,8 @@ void UndoRedoController::handleMessage(MessageCodeShowDefinition* message) void UndoRedoController::handleMessage(MessageDeactivateEdge* message) { if (sameMessageTypeAsLast(message) && - static_cast(lastMessage())->scrollToDefinition == message->scrollToDefinition) + static_cast(lastMessage())->scrollToDefinition == + message->scrollToDefinition) { return; } @@ -493,15 +494,15 @@ void UndoRedoController::replayCommand(std::list::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); diff --git a/src/lib/component/controller/helper/DummyNode.h b/src/lib/component/controller/helper/DummyNode.h index ca9f08cd..0b33973e 100644 --- a/src/lib/component/controller/helper/DummyNode.h +++ b/src/lib/component/controller/helper/DummyNode.h @@ -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) diff --git a/src/lib/component/view/CustomTrailView.h b/src/lib/component/view/CustomTrailView.h index cab1bca3..d73f8cff 100644 --- a/src/lib/component/view/CustomTrailView.h +++ b/src/lib/component/view/CustomTrailView.h @@ -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; diff --git a/src/lib/data/NodeKind.cpp b/src/lib/data/NodeKind.cpp new file mode 100644 index 00000000..a01b252a --- /dev/null +++ b/src/lib/data/NodeKind.cpp @@ -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; +} diff --git a/src/lib/data/NodeKind.h b/src/lib/data/NodeKind.h new file mode 100644 index 00000000..541625e6 --- /dev/null +++ b/src/lib/data/NodeKind.h @@ -0,0 +1,44 @@ +#ifndef NODE_KIND_H +#define NODE_KIND_H + +#include + +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 diff --git a/src/lib/data/NodeType.cpp b/src/lib/data/NodeType.cpp index bcc01263..187d1854 100644 --- a/src/lib/data/NodeType.cpp +++ b/src/lib/data/NodeType.cpp @@ -3,155 +3,29 @@ #include "ResourcePaths.h" #include "utilityString.h" -std::vector 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 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::getOverviewBundleTree() const { - switch (m_type) + switch (m_kind) { - case NodeType::NODE_FILE: + case NODE_FILE: return Tree(BundleInfo(L"Files")); - case NodeType::NODE_MACRO: + case NODE_MACRO: return Tree(BundleInfo(L"Macros")); - case NodeType::NODE_NAMESPACE: + case NODE_NAMESPACE: { Tree tree(BundleInfo(L"Namespaces")); tree.children.push_back(Tree(BundleInfo( @@ -282,29 +147,29 @@ Tree NodeType::getOverviewBundleTree() const L"Anonymous Namespaces"))); return tree; } - case NodeType::NODE_MODULE: + case NODE_MODULE: return Tree(BundleInfo(L"Modules")); - case NodeType::NODE_PACKAGE: + case NODE_PACKAGE: return Tree(BundleInfo(L"Packages")); - case NodeType::NODE_CLASS: + case NODE_CLASS: return Tree(BundleInfo(L"Classes")); - case NodeType::NODE_INTERFACE: + case NODE_INTERFACE: return Tree(BundleInfo(L"Interfaces")); - case NodeType::NODE_ANNOTATION: + case NODE_ANNOTATION: return Tree(BundleInfo(L"Annotations")); - case NodeType::NODE_STRUCT: + case NODE_STRUCT: return Tree(BundleInfo(L"Structs")); - case NodeType::NODE_FUNCTION: + case NODE_FUNCTION: return Tree(BundleInfo(L"Functions")); - case NodeType::NODE_GLOBAL_VARIABLE: + case NODE_GLOBAL_VARIABLE: return Tree(BundleInfo(L"Global Variables")); - case NodeType::NODE_TYPE: + case NODE_TYPE: return Tree(BundleInfo(L"Types")); - case NodeType::NODE_TYPEDEF: + case NODE_TYPEDEF: return Tree(BundleInfo(L"Typedefs")); - case NodeType::NODE_ENUM: + case NODE_ENUM: return Tree(BundleInfo(L"Enums")); - case NodeType::NODE_UNION: + case NODE_UNION: return Tree(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 diff --git a/src/lib/data/NodeType.h b/src/lib/data/NodeType.h index 67726f7b..6694366c 100644 --- a/src/lib/data/NodeType.h +++ b/src/lib/data/NodeType.h @@ -8,42 +8,13 @@ #include #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 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 const overviewBundleNodeTypesOrdered; + private: - Type m_type; + NodeKind m_kind; }; #endif // NODE_TYPE_H diff --git a/src/lib/data/NodeTypeSet.cpp b/src/lib/data/NodeTypeSet.cpp index cd9e9754..6a5bb8c8 100644 --- a/src/lib/data/NodeTypeSet.cpp +++ b/src/lib/data/NodeTypeSet.cpp @@ -166,13 +166,13 @@ NodeTypeSet::MaskType NodeTypeSet::nodeTypeToMask(const NodeType& nodeType) } const std::vector 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)}; diff --git a/src/lib/data/graph/Node.cpp b/src/lib/data/graph/Node.cpp index 53e86f3a..a8ef7638 100644 --- a/src/lib/data/graph/Node.cpp +++ b/src/lib/data/graph/Node.cpp @@ -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 diff --git a/src/lib/data/graph/Node.h b/src/lib/data/graph/Node.h index 068aee7d..f3ec40ba 100644 --- a/src/lib/data/graph/Node.h +++ b/src/lib/data/graph/Node.h @@ -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; diff --git a/src/lib/data/indexer/TaskExecuteCustomCommands.cpp b/src/lib/data/indexer/TaskExecuteCustomCommands.cpp index a252f818..83a6b2b5 100644 --- a/src/lib/data/indexer/TaskExecuteCustomCommands.cpp +++ b/src/lib/data/indexer/TaskExecuteCustomCommands.cpp @@ -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; } diff --git a/src/lib/data/parser/ParserClientImpl.cpp b/src/lib/data/parser/ParserClientImpl.cpp index e2b3835b..5acc7d44 100644 --- a/src/lib/data/parser/ParserClientImpl.cpp +++ b/src/lib/data/parser/ParserClientImpl.cpp @@ -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 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; diff --git a/src/lib/data/parser/ParserClientImpl.h b/src/lib/data/parser/ParserClientImpl.h index 01d1de79..e637f5c7 100644 --- a/src/lib/data/parser/ParserClientImpl.h +++ b/src/lib/data/parser/ParserClientImpl.h @@ -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; diff --git a/src/lib/data/search/SearchIndex.h b/src/lib/data/search/SearchIndex.h index 69528749..05d76eca 100644 --- a/src/lib/data/search/SearchIndex.h +++ b/src/lib/data/search/SearchIndex.h @@ -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(); diff --git a/src/lib/data/search/SearchMatch.cpp b/src/lib/data/search/SearchMatch.cpp index 12404dcb..e8752342 100644 --- a/src/lib/data/search/SearchMatch.cpp +++ b/src/lib/data/search/SearchMatch.cpp @@ -44,7 +44,7 @@ std::wstring SearchMatch::searchMatchesToString(const std::vector& 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) { diff --git a/src/lib/data/storage/PersistentStorage.cpp b/src/lib/data/storage/PersistentStorage.cpp index 8a7027e0..c278ff44 100644 --- a/src/lib/data/storage/PersistentStorage.cpp +++ b/src/lib/data/storage/PersistentStorage.cpp @@ -573,7 +573,7 @@ std::map> PersistentStorage::getNodeIdToParentF NodeType PersistentStorage::getNodeTypeForNodeWithId(Id nodeId) const { - return NodeType::intToType(m_sqliteIndexStorage.getFirstById(nodeId).type); + return NodeType(intToNodeKind(m_sqliteIndexStorage.getFirstById(nodeId).type)); } StorageEdge PersistentStorage::getEdgeById(Id edgeId) const @@ -875,7 +875,7 @@ std::vector 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 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 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 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 PersistentStorage::getGraphForAll() const std::shared_ptr graph = std::make_shared(); const size_t sdk_size = m_symbolDefinitionKinds.size(); m_sqliteIndexStorage.forEach([&, 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 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 PersistentStorage::getGraphForNodeTypes(NodeTypeSet nodeT std::vector tokenIds; m_sqliteIndexStorage.forEach([&](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 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 PersistentStorage::getGraphForChildrenOfNodeId(Id nodeId) std::shared_ptr 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 PersistentStorage::getGraphForTrail( for (const StorageNode& node: m_sqliteIndexStorage.getAllByIds(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 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 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 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(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(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(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&& 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( sourceNodeIds, [&invisibleParentSourceNodeIds](StorageNode&& node) { - if (!NodeType(NodeType::intToType(node.type)).isVisibleAsParentInGraph()) + if (!NodeType(intToNodeKind(node.type)).isVisibleAsParentInGraph()) { invisibleParentSourceNodeIds.insert(node.id); } diff --git a/src/lib/data/storage/PersistentStorage.h b/src/lib/data/storage/PersistentStorage.h index 24ff8164..e8d315d1 100644 --- a/src/lib/data/storage/PersistentStorage.h +++ b/src/lib/data/storage/PersistentStorage.h @@ -133,13 +133,13 @@ public: std::shared_ptr 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 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& edgesToAggregate, Graph* graph) const; void addFileContentsToGraph(Id fileId, Graph* graph) const; diff --git a/src/lib/data/storage/StorageAccess.h b/src/lib/data/storage/StorageAccess.h index 236e0bdb..90439ace 100644 --- a/src/lib/data/storage/StorageAccess.h +++ b/src/lib/data/storage/StorageAccess.h @@ -67,13 +67,13 @@ public: virtual std::shared_ptr 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 getActiveTokenIdsForId(Id tokenId, Id* declarationId) const = 0; diff --git a/src/lib/data/storage/StorageAccessProxy.cpp b/src/lib/data/storage/StorageAccessProxy.cpp index 075eeec5..422ef05b 100644 --- a/src/lib/data/storage/StorageAccessProxy.cpp +++ b/src/lib/data/storage/StorageAccessProxy.cpp @@ -162,7 +162,7 @@ DEF_GETTER_1(getNameHierarchiesForNodeIds, const std::vector&, std::vector> NodeIdToParentFileMap; DEF_GETTER_1(getNodeIdToParentFileMap, const std::vector&, 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, std::make_shared()) -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, {}) DEF_GETTER_1(getNodeIdsForLocationIds, const std::vector&, std::vector, {}) diff --git a/src/lib/data/storage/StorageAccessProxy.h b/src/lib/data/storage/StorageAccessProxy.h index 74498d01..b2d47c0d 100644 --- a/src/lib/data/storage/StorageAccessProxy.h +++ b/src/lib/data/storage/StorageAccessProxy.h @@ -43,13 +43,13 @@ public: std::shared_ptr 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 getActiveTokenIdsForId(Id tokenId, Id* declarationId) const override; diff --git a/src/lib/utility/messaging/type/activation/MessageActivateErrors.h b/src/lib/utility/messaging/type/activation/MessageActivateErrors.h index 977edd94..ed7bbed1 100644 --- a/src/lib/utility/messaging/type/activation/MessageActivateErrors.h +++ b/src/lib/utility/messaging/type/activation/MessageActivateErrors.h @@ -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; diff --git a/src/lib/utility/messaging/type/activation/MessageActivateTokens.h b/src/lib/utility/messaging/type/activation/MessageActivateTokens.h index e941c99f..eb607366 100644 --- a/src/lib/utility/messaging/type/activation/MessageActivateTokens.h +++ b/src/lib/utility/messaging/type/activation/MessageActivateTokens.h @@ -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}; } diff --git a/src/lib/utility/messaging/type/activation/MessageActivateTrail.h b/src/lib/utility/messaging/type/activation/MessageActivateTrail.h index 3c127456..849701b1 100644 --- a/src/lib/utility/messaging/type/activation/MessageActivateTrail.h +++ b/src/lib/utility/messaging/type/activation/MessageActivateTrail.h @@ -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; diff --git a/src/lib_gui/qt/element/search/QtAutocompletionList.cpp b/src/lib_gui/qt/element/search/QtAutocompletionList.cpp index 22dc2ed0..059be344 100644 --- a/src/lib_gui/qt/element/search/QtAutocompletionList.cpp +++ b/src/lib_gui/qt/element/search/QtAutocompletionList.cpp @@ -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 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(); diff --git a/src/lib_gui/qt/graphics/graph/QtGraphNodeData.cpp b/src/lib_gui/qt/graphics/graph/QtGraphNodeData.cpp index d15d4f6b..7b14111f 100644 --- a/src/lib_gui/qt/graphics/graph/QtGraphNodeData.cpp +++ b/src/lib_gui/qt/graphics/graph/QtGraphNodeData.cpp @@ -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()) diff --git a/src/lib_gui/qt/view/QtCustomTrailView.cpp b/src/lib_gui/qt/view/QtCustomTrailView.cpp index e839cf5e..fd1b9ce8 100644 --- a/src/lib_gui/qt/view/QtCustomTrailView.cpp +++ b/src/lib_gui/qt/view/QtCustomTrailView.cpp @@ -190,33 +190,33 @@ QtCustomTrailView::QtCustomTrailView(ViewLayout* viewLayout) std::vector nodeFilters; std::vector nodeColors; - std::vector 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 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& 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; diff --git a/src/lib_gui/qt/view/QtCustomTrailView.h b/src/lib_gui/qt/view/QtCustomTrailView.h index 550df441..5ff19dea 100644 --- a/src/lib_gui/qt/view/QtCustomTrailView.h +++ b/src/lib_gui/qt/view/QtCustomTrailView.h @@ -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& checkBoxes) const; - NodeType::TypeMask getCheckedNodeTypes() const; + NodeKindMask getCheckedNodeTypes() const; Edge::TypeMask getCheckedEdgeTypes() const; void setError(const QString& error); diff --git a/src/test/GraphTestSuite.cpp b/src/test/GraphTestSuite.cpp index 04d652b7..423f56af 100644 --- a/src/test/GraphTestSuite.cpp +++ b/src/test/GraphTestSuite.cpp @@ -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); diff --git a/src/test/RefreshInfoGeneratorTestSuite.cpp b/src/test/RefreshInfoGeneratorTestSuite.cpp index 6ce37178..5ae16296 100644 --- a/src/test/RefreshInfoGeneratorTestSuite.cpp +++ b/src/test/RefreshInfoGeneratorTestSuite.cpp @@ -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( diff --git a/src/test/StorageTestSuite.cpp b/src/test/StorageTestSuite.cpp index fcdee1a1..f27b9dae 100644 --- a/src/test/StorageTestSuite.cpp +++ b/src/test/StorageTestSuite.cpp @@ -63,7 +63,7 @@ TEST_CASE("storage saves file") std::shared_ptr intermetiateStorage = std::make_shared(); 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 intermetiateStorage = std::make_shared(); 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 intermetiateStorage = std::make_shared(); 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()); } diff --git a/src/test/helper/TestIntermediateStorage.h b/src/test/helper/TestIntermediateStorage.h index 7d3e6831..518c364d 100644 --- a/src/test/helper/TestIntermediateStorage.h +++ b/src/test/helper/TestIntermediateStorage.h @@ -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* 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 ¯os; - case NodeType::NODE_TYPE_PARAMETER: + case NODE_TYPE_PARAMETER: return &typeParameters; default: break;