From 90e17c58682fd9bd71bde3b0016896a30a8ca58f Mon Sep 17 00:00:00 2001 From: mlangkabel Date: Thu, 23 Nov 2017 17:05:15 +0100 Subject: [PATCH] src: converted NodeType to a class NodeType internally still uses the Type enum --- src/lib/CMakeLists.txt | 2 + .../controller/BookmarkController.cpp | 4 +- .../component/controller/GraphController.cpp | 170 ++++++------ .../component/controller/GraphController.h | 2 +- .../controller/UndoRedoController.cpp | 2 +- .../component/controller/helper/DummyNode.h | 4 +- src/lib/component/view/GraphViewStyle.cpp | 165 +++++------ src/lib/component/view/GraphViewStyle.h | 19 +- src/lib/component/view/GraphViewStyleImpl.h | 4 +- src/lib/data/NodeType.cpp | 260 ++++++++++++++++++ src/lib/data/NodeType.h | 76 +++++ src/lib/data/access/StorageAccess.h | 8 +- src/lib/data/access/StorageAccessProxy.cpp | 10 +- src/lib/data/access/StorageAccessProxy.h | 8 +- src/lib/data/graph/Edge.cpp | 2 +- src/lib/data/graph/Edge.h | 6 +- src/lib/data/graph/Graph.cpp | 2 +- src/lib/data/graph/Graph.h | 2 +- src/lib/data/graph/Node.cpp | 171 +----------- src/lib/data/graph/Node.h | 53 +--- src/lib/data/parser/ParserClientImpl.cpp | 54 ++-- src/lib/data/parser/ParserClientImpl.h | 6 +- src/lib/data/search/SearchIndex.cpp | 8 +- src/lib/data/search/SearchIndex.h | 10 +- src/lib/data/search/SearchMatch.cpp | 16 +- src/lib/data/search/SearchMatch.h | 4 +- src/lib/data/storage/PersistentStorage.cpp | 139 +++++----- src/lib/data/storage/PersistentStorage.h | 12 +- src/lib/settings/ColorScheme.cpp | 4 +- src/lib/settings/ColorScheme.h | 2 +- .../messaging/type/MessageActivateAll.h | 4 +- .../messaging/type/MessageActivateTrail.h | 4 +- .../utility/messaging/type/MessageSearch.h | 6 +- .../type/MessageSearchAutocomplete.h | 4 +- .../StorageTransformationAnonymousTypedef.cpp | 6 +- .../qt/element/QtAutocompletionList.cpp | 6 +- src/lib_gui/qt/element/QtHistoryList.cpp | 6 +- src/lib_gui/qt/element/QtSmartSearchBox.cpp | 14 +- src/lib_gui/qt/element/QtSmartSearchBox.h | 2 +- src/lib_gui/qt/view/QtGraphView.cpp | 18 +- src/lib_gui/qt/view/QtGraphViewStyleImpl.cpp | 4 +- src/lib_gui/qt/view/QtGraphViewStyleImpl.h | 4 +- .../qt/view/graphElements/QtGraphNode.cpp | 4 +- .../qt/view/graphElements/QtGraphNode.h | 2 +- .../view/graphElements/QtGraphNodeBundle.cpp | 8 +- .../qt/view/graphElements/QtGraphNodeBundle.h | 4 +- .../qt/view/graphElements/QtGraphNodeData.cpp | 2 +- .../graphElements/QtGraphNodeQualifier.cpp | 2 +- src/lib_gui/qt/window/QtMainWindow.cpp | 2 +- src/test/GraphTestSuite.h | 72 ++--- src/test/StorageTestSuite.h | 14 +- ...eTransformationAnonymousTypedefTestSuite.h | 22 +- 52 files changed, 779 insertions(+), 656 deletions(-) create mode 100644 src/lib/data/NodeType.cpp create mode 100644 src/lib/data/NodeType.h diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt index 39532963..ec0d113e 100644 --- a/src/lib/CMakeLists.txt +++ b/src/lib/CMakeLists.txt @@ -266,6 +266,8 @@ add_files( data/ErrorInfo.h data/HierarchyCache.cpp data/HierarchyCache.h + data/NodeType.cpp + data/NodeType.h data/TaskCleanStorage.cpp data/TaskCleanStorage.h data/TaskFinishParsing.cpp diff --git a/src/lib/component/controller/BookmarkController.cpp b/src/lib/component/controller/BookmarkController.cpp index 8bcca107..89592e40 100644 --- a/src/lib/component/controller/BookmarkController.cpp +++ b/src/lib/component/controller/BookmarkController.cpp @@ -500,10 +500,10 @@ std::vector BookmarkController::getActiveEdgeDisplayNames() const std::string BookmarkController::getNodeDisplayName(const Id nodeId) const { - Node::NodeType type = m_storageAccess->getNodeTypeForNodeWithId(nodeId); + NodeType type = m_storageAccess->getNodeTypeForNodeWithId(nodeId); NameHierarchy nameHierarchy = m_storageAccess->getNameHierarchyForNodeId(nodeId); - if (type == Node::NODE_FILE) + if (type.getType() == NodeType::NODE_FILE) { return FilePath(nameHierarchy.getQualifiedName()).fileName(); } diff --git a/src/lib/component/controller/GraphController.cpp b/src/lib/component/controller/GraphController.cpp index df5005c8..adca3763 100644 --- a/src/lib/component/controller/GraphController.cpp +++ b/src/lib/component/controller/GraphController.cpp @@ -488,7 +488,7 @@ void GraphController::createDummyGraphForTokenIds(const std::vector& tokenId { node->hasParent = false; - if (node->data->isType(Node::NODE_NAMESPACE | Node::NODE_PACKAGE)) + if (node->data->isType(NodeType::NODE_NAMESPACE | NodeType::NODE_PACKAGE)) { node->name = node->data->getFullName(); } @@ -546,7 +546,7 @@ std::vector> GraphController::createDummyNodeTopDown( m_dummyGraphNodes.emplace(result->data->getId(), result); nodes.push_back(result); - if (node->isType(Node::NODE_NAMESPACE)) + if (node->isType(NodeType::NODE_NAMESPACE)) { node->forEachChildNode( [&nodes, &ancestorId, this](Node* child) @@ -602,7 +602,7 @@ std::vector GraphController::getExpandedNodeIds() const { DummyNode* oldNode = p.second.get(); if (oldNode->expanded && !oldNode->autoExpanded && oldNode->isGraphNode() && - !oldNode->data->isType(Node::NODE_FUNCTION | Node::NODE_METHOD)) + !oldNode->data->isType(NodeType::NODE_FUNCTION | NodeType::NODE_METHOD)) { nodeIds.push_back(p.first); } @@ -763,7 +763,7 @@ void GraphController::setNodeVisibilityRecursiveTopDown(DummyNode* node, bool pa { node->visible = true; - if (node->isGraphNode() && node->data->getType() == Node::NODE_ENUM && !node->isExpanded()) + if (node->isGraphNode() && node->data->getType().getType() == NodeType::NODE_ENUM && !node->isExpanded()) { return; } @@ -891,7 +891,7 @@ void GraphController::bundleNodes() for (const std::shared_ptr& node : m_dummyNodes) { if (node->bundleInfo.isActive && ( - node->data->isType(Node::NODE_FILE | Node::NODE_MACRO) || + node->data->isType(NodeType::NODE_FILE | NodeType::NODE_MACRO) || node->data->findEdgeOfType(Edge::EDGE_INCLUDE | Edge::EDGE_MACRO_USAGE) != nullptr)) { fileOrMacroActive = true; @@ -907,7 +907,7 @@ void GraphController::bundleNodes() bundleNodesAndEdgesMatching( [](const DummyNode::BundleInfo& info, const Node* data) { - return data->isType(Node::NODE_FILE); + return data->isType(NodeType::NODE_FILE); }, 1, false, @@ -937,7 +937,7 @@ void GraphController::bundleNodes() bundleNodesAndEdgesMatching( [](const DummyNode::BundleInfo& info, const Node* data) { - return info.isDefined && info.isReferenced && data->isType(Node::NODE_BUILTIN_TYPE); + return info.isDefined && info.isReferenced && data->isType(NodeType::NODE_BUILTIN_TYPE); }, 3, false, @@ -1133,13 +1133,13 @@ std::shared_ptr GraphController::bundleNodesMatching( } void GraphController::bundleByType( - std::list>& nodes, Node::NodeType type, const std::string& name) + std::list>& nodes, NodeType::Type type, const std::string& name) { std::shared_ptr bundleNode = bundleNodesMatching( nodes, [&](const DummyNode* node) { - return node->visible && node->isGraphNode() && node->data->isType(type); + return node->visible && node->isGraphNode() && node->data->getType().getType() == type; }, name ); @@ -1164,33 +1164,33 @@ void GraphController::bundleNodesByType() nodes.push_back(oldNodes[i]); } - bundleByType(nodes, Node::NODE_FILE, "Files"); - bundleByType(nodes, Node::NODE_MACRO, "Macros"); + bundleByType(nodes, NodeType::NODE_FILE, "Files"); + bundleByType(nodes, NodeType::NODE_MACRO, "Macros"); - bundleByType(nodes, Node::NODE_NAMESPACE, "Namespaces"); - bundleByType(nodes, Node::NODE_PACKAGE, "Packages"); + bundleByType(nodes, NodeType::NODE_NAMESPACE, "Namespaces"); + bundleByType(nodes, NodeType::NODE_PACKAGE, "Packages"); - // bundleByType(nodes, Node::NODE_BUILTIN_TYPE, "Built-in Types"); - bundleByType(nodes, Node::NODE_CLASS, "Classes"); - bundleByType(nodes, Node::NODE_INTERFACE, "Interfaces"); - bundleByType(nodes, Node::NODE_STRUCT, "Structs"); + // bundleByType(nodes, NodeType::NODE_BUILTIN_TYPE, "Built-in Types"); + bundleByType(nodes, NodeType::NODE_CLASS, "Classes"); + bundleByType(nodes, NodeType::NODE_INTERFACE, "Interfaces"); + bundleByType(nodes, NodeType::NODE_STRUCT, "Structs"); - bundleByType(nodes, Node::NODE_FUNCTION, "Functions"); - bundleByType(nodes, Node::NODE_GLOBAL_VARIABLE, "Global Variables"); + bundleByType(nodes, NodeType::NODE_FUNCTION, "Functions"); + bundleByType(nodes, NodeType::NODE_GLOBAL_VARIABLE, "Global Variables"); - bundleByType(nodes, Node::NODE_TYPE, "Types"); - bundleByType(nodes, Node::NODE_TYPEDEF, "Typedefs"); - bundleByType(nodes, Node::NODE_ENUM, "Enums"); - bundleByType(nodes, Node::NODE_UNION, "Unions"); + bundleByType(nodes, NodeType::NODE_TYPE, "Types"); + bundleByType(nodes, NodeType::NODE_TYPEDEF, "Typedefs"); + bundleByType(nodes, NodeType::NODE_ENUM, "Enums"); + bundleByType(nodes, NodeType::NODE_UNION, "Unions"); // // should never be visible - // bundleByType(nodes, Node::NODE_METHOD, "Methods"); - // bundleByType(nodes, Node::NODE_FIELD, "Fields"); - // bundleByType(nodes, Node::NODE_ENUM_CONSTANT, "Enum Constants"); - // bundleByType(nodes, Node::NODE_TEMPLATE_PARAMETER_TYPE, "Template Parameter Types"); - // bundleByType(nodes, Node::NODE_TYPE_PARAMETER, "Type Parameters"); - // bundleByType(nodes, Node::NODE_NON_INDEXED, "Non-indexed Symbols"); + // bundleByType(nodes, NodeType::NODE_METHOD, "Methods"); + // bundleByType(nodes, NodeType::NODE_FIELD, "Fields"); + // bundleByType(nodes, NodeType::NODE_ENUM_CONSTANT, "Enum Constants"); + // bundleByType(nodes, NodeType::NODE_TEMPLATE_PARAMETER_TYPE, "Template Parameter Types"); + // bundleByType(nodes, NodeType::NODE_TYPE_PARAMETER, "Type Parameters"); + // bundleByType(nodes, NodeType::NODE_NON_INDEXED, "Non-indexed Symbols"); if (nodes.size()) { @@ -1229,7 +1229,7 @@ void GraphController::bundleNodesByType() if (anonymousBundle) { - anonymousBundle->bundledNodeType = Node::NODE_NAMESPACE; + anonymousBundle->bundledNodeType = NodeType::NODE_NAMESPACE; bundleNode->bundledNodeCount = bundleNode->getBundledNodeCount() + anonymousBundle->getBundledNodeCount(); bundleNode->bundledNodes.insert(anonymousBundle); } @@ -1312,7 +1312,7 @@ void GraphController::layoutNestingRecursive(DummyNode* node) const } else if (node->isBundleNode()) { - if (node->bundledNodeType != Node::NODE_NON_INDEXED) + if (node->bundledNodeType.getType() != NodeType::NODE_NON_INDEXED) { margins = GraphViewStyle::getMarginsForNodeType(node->bundledNodeType, false); } @@ -1345,7 +1345,7 @@ void GraphController::layoutNestingRecursive(DummyNode* node) const width = margins.charWidth * node->name.size(); - if (node->data->isType(Node::NODE_COLLAPSIBLE_TYPE) && node->data->getChildCount() > 0) + if (node->data->getType().isCollapsible() && node->data->getChildCount() > 0) { addExpandToggleNode(node); } @@ -1626,10 +1626,10 @@ void GraphController::handleMessage(MessageColorSchemeTest* message) std::shared_ptr graph = std::make_shared(); - std::function createNodes( - [&](Id id, Node::NodeType type, NameDelimiterType delimiter) + std::function createNodes( + [&](Id id, NodeType type, NameDelimiterType delimiter) { - std::string name = Node::getReadableTypeString(type); + std::string name = type.getReadableTypeString(); graph->createNode(id + 1, type, NameHierarchy(name, delimiter), true); graph->createNode(id + 2, type, NameHierarchy("focused " + name, delimiter), true); graph->createNode(id + 3, type, NameHierarchy("active " + name, delimiter), true); @@ -1640,17 +1640,17 @@ void GraphController::handleMessage(MessageColorSchemeTest* message) } ); - createNodes( 0, Node::NODE_FUNCTION, NAME_DELIMITER_CXX); - createNodes(10, Node::NODE_GLOBAL_VARIABLE, NAME_DELIMITER_CXX); - createNodes(20, Node::NODE_NON_INDEXED, NAME_DELIMITER_CXX); - createNodes(30, Node::NODE_TYPE, NAME_DELIMITER_CXX); - createNodes(40, Node::NODE_TYPEDEF, NAME_DELIMITER_CXX); - createNodes(50, Node::NODE_NAMESPACE, NAME_DELIMITER_CXX); - createNodes(60, Node::NODE_FILE, NAME_DELIMITER_FILE); - createNodes(70, Node::NODE_MACRO, NAME_DELIMITER_CXX); + createNodes( 0, NodeType::NODE_FUNCTION, NAME_DELIMITER_CXX); + createNodes(10, NodeType::NODE_GLOBAL_VARIABLE, NAME_DELIMITER_CXX); + createNodes(20, NodeType::NODE_NON_INDEXED, NAME_DELIMITER_CXX); + createNodes(30, NodeType::NODE_TYPE, NAME_DELIMITER_CXX); + createNodes(40, NodeType::NODE_TYPEDEF, NAME_DELIMITER_CXX); + createNodes(50, NodeType::NODE_NAMESPACE, NAME_DELIMITER_CXX); + createNodes(60, NodeType::NODE_FILE, NAME_DELIMITER_FILE); + createNodes(70, NodeType::NODE_MACRO, NAME_DELIMITER_CXX); - std::function createChild( - [&](Node* parent, Id id, Node::NodeType type, std::string name, AccessKind access) + std::function createChild( + [&](Node* parent, Id id, NodeType type, std::string name, AccessKind access) { Node* node = graph->createNode(id + 1000, type, NameHierarchy(name, NAME_DELIMITER_CXX), true); graph->createEdge(id + 10000, Edge::EDGE_MEMBER, parent, node); @@ -1667,9 +1667,9 @@ void GraphController::handleMessage(MessageColorSchemeTest* message) std::function createEnum( [&](Id id, std::string name) { - Node* enumNode = graph->createNode(id, Node::NODE_ENUM, - NameHierarchy(name + Node::getReadableTypeString(Node::NODE_ENUM), NAME_DELIMITER_CXX), true); - createChild(enumNode, id + 10, Node::NODE_ENUM_CONSTANT, name + Node::getReadableTypeString(Node::NODE_ENUM_CONSTANT), ACCESS_NONE); + Node* enumNode = graph->createNode(id, NodeType::NODE_ENUM, + NameHierarchy(name + NodeType(NodeType::NODE_ENUM).getReadableTypeString(), NAME_DELIMITER_CXX), true); + createChild(enumNode, id + 10, NodeType::NODE_ENUM_CONSTANT, name + NodeType(NodeType::NODE_ENUM_CONSTANT).getReadableTypeString(), ACCESS_NONE); } ); @@ -1681,27 +1681,27 @@ void GraphController::handleMessage(MessageColorSchemeTest* message) createEnum(105, "Non-indexed focused "); createEnum(106, "Non-indexed active "); - std::function createClass( - [&](Id id, Node::NodeType type, std::string name) + std::function createClass( + [&](Id id, NodeType type, std::string name) { - Node* classNode = graph->createNode(id, type, NameHierarchy(name + Node::getReadableTypeString(type), NAME_DELIMITER_CXX), true); + Node* classNode = graph->createNode(id, type, NameHierarchy(name + NodeType(type).getReadableTypeString(), NAME_DELIMITER_CXX), true); - if (type == Node::NODE_CLASS) + if (type.getType() == NodeType::NODE_CLASS) { - createChild(classNode, id, Node::NODE_TEMPLATE_PARAMETER_TYPE, name + "temp_param", ACCESS_TEMPLATE_PARAMETER); + createChild(classNode, id, NodeType::NODE_TEMPLATE_PARAMETER_TYPE, name + "temp_param", ACCESS_TEMPLATE_PARAMETER); } - createChild(classNode, id + 10, Node::NODE_METHOD, name + "method", ACCESS_PUBLIC); - if (type == Node::NODE_CLASS) + createChild(classNode, id + 10, NodeType::NODE_METHOD, name + "method", ACCESS_PUBLIC); + if (type.getType() == NodeType::NODE_CLASS) { - createChild(classNode, id + 30, Node::NODE_METHOD, name + "method", ACCESS_PROTECTED); + createChild(classNode, id + 30, NodeType::NODE_METHOD, name + "method", ACCESS_PROTECTED); } - createChild(classNode, id + 60, Node::NODE_FIELD, name + "field", ACCESS_PRIVATE); + createChild(classNode, id + 60, NodeType::NODE_FIELD, name + "field", ACCESS_PRIVATE); } ); - std::function createClasses( - [&](Id id, Node::NodeType type) + std::function createClasses( + [&](Id id, NodeType type) { createClass(id + 1, type, ""); createClass(id + 2, type, "focused "); @@ -1713,19 +1713,19 @@ void GraphController::handleMessage(MessageColorSchemeTest* message) } ); - createClasses(200, Node::NODE_STRUCT); - createClasses(300, Node::NODE_CLASS); + createClasses(200, NodeType::NODE_STRUCT); + createClasses(300, NodeType::NODE_CLASS); - std::function createEdge( - [&](Id id, Edge::EdgeType type, Node::NodeType origin, Node::NodeType target, std::string name) + std::function createEdge( + [&](Id id, Edge::EdgeType type, NodeType origin, NodeType target, std::string name) { Node* originNode; - if (origin == Node::NODE_METHOD) + if (origin.getType() == NodeType::NODE_METHOD) { - Node* classNode = graph->createNode(id + 101, Node::NODE_CLASS, - NameHierarchy(name + Node::getReadableTypeString(Node::NODE_CLASS), NAME_DELIMITER_CXX), true); - originNode = createChild(classNode, id + 111, Node::NODE_METHOD, name + Edge::getReadableTypeString(type), ACCESS_PUBLIC); + Node* classNode = graph->createNode(id + 101, NodeType::NODE_CLASS, + NameHierarchy(name + NodeType(NodeType::NODE_CLASS).getReadableTypeString(), NAME_DELIMITER_CXX), true); + originNode = createChild(classNode, id + 111, NodeType::NODE_METHOD, name + Edge::getReadableTypeString(type), ACCESS_PUBLIC); } else { @@ -1733,11 +1733,11 @@ void GraphController::handleMessage(MessageColorSchemeTest* message) } Node* targetNode; - if (target == Node::NODE_METHOD) + if (target.getType() == NodeType::NODE_METHOD) { - Node* classNode = graph->createNode(id + 201, Node::NODE_CLASS, - NameHierarchy(name + Node::getReadableTypeString(Node::NODE_CLASS), NAME_DELIMITER_CXX), true); - targetNode = createChild(classNode, id + 211, Node::NODE_METHOD, name + Edge::getReadableTypeString(type), ACCESS_PUBLIC); + Node* classNode = graph->createNode(id + 201, NodeType::NODE_CLASS, + NameHierarchy(name + NodeType(NodeType::NODE_CLASS).getReadableTypeString(), NAME_DELIMITER_CXX), true); + targetNode = createChild(classNode, id + 211, NodeType::NODE_METHOD, name + Edge::getReadableTypeString(type), ACCESS_PUBLIC); } else { @@ -1758,8 +1758,8 @@ void GraphController::handleMessage(MessageColorSchemeTest* message) } ); - std::function createEdges( - [&](Id id, Edge::EdgeType type, Node::NodeType origin, Node::NodeType target) + std::function createEdges( + [&](Id id, Edge::EdgeType type, NodeType origin, NodeType target) { createEdge(id, type, origin, target, ""); createEdge(id + 1000, type, origin, target, "focused "); @@ -1767,21 +1767,21 @@ void GraphController::handleMessage(MessageColorSchemeTest* message) } ); - createEdges( 100000, Edge::EDGE_CALL, Node::NODE_FUNCTION, Node::NODE_FUNCTION); - createEdges( 200000, Edge::EDGE_USAGE, Node::NODE_GLOBAL_VARIABLE, Node::NODE_GLOBAL_VARIABLE); - createEdges( 300000, Edge::EDGE_TYPE_USAGE, Node::NODE_FUNCTION, Node::NODE_TYPE); + createEdges( 100000, Edge::EDGE_CALL, NodeType::NODE_FUNCTION, NodeType::NODE_FUNCTION); + createEdges( 200000, Edge::EDGE_USAGE, NodeType::NODE_GLOBAL_VARIABLE, NodeType::NODE_GLOBAL_VARIABLE); + createEdges( 300000, Edge::EDGE_TYPE_USAGE, NodeType::NODE_FUNCTION, NodeType::NODE_TYPE); - createEdges( 400000, Edge::EDGE_AGGREGATION, Node::NODE_TYPE, Node::NODE_TYPE); - createEdges( 500000, Edge::EDGE_INCLUDE, Node::NODE_FILE, Node::NODE_FILE); - createEdges( 600000, Edge::EDGE_MACRO_USAGE, Node::NODE_MACRO, Node::NODE_MACRO); + createEdges( 400000, Edge::EDGE_AGGREGATION, NodeType::NODE_TYPE, NodeType::NODE_TYPE); + createEdges( 500000, Edge::EDGE_INCLUDE, NodeType::NODE_FILE, NodeType::NODE_FILE); + createEdges( 600000, Edge::EDGE_MACRO_USAGE, NodeType::NODE_MACRO, NodeType::NODE_MACRO); - createEdges( 700000, Edge::EDGE_INHERITANCE, Node::NODE_CLASS, Node::NODE_CLASS); - createEdges( 800000, Edge::EDGE_OVERRIDE, Node::NODE_METHOD, Node::NODE_METHOD); + createEdges( 700000, Edge::EDGE_INHERITANCE, NodeType::NODE_CLASS, NodeType::NODE_CLASS); + createEdges( 800000, Edge::EDGE_OVERRIDE, NodeType::NODE_METHOD, NodeType::NODE_METHOD); - createEdges( 900000, Edge::EDGE_TEMPLATE_ARGUMENT, Node::NODE_TYPE, Node::NODE_TYPE); - createEdges(1000000, Edge::EDGE_TEMPLATE_DEFAULT_ARGUMENT, Node::NODE_TYPE, Node::NODE_TYPE); - createEdges(1100000, Edge::EDGE_TEMPLATE_SPECIALIZATION, Node::NODE_TYPE, Node::NODE_TYPE); - createEdges(1200000, Edge::EDGE_TEMPLATE_MEMBER_SPECIALIZATION, Node::NODE_METHOD, Node::NODE_METHOD); + createEdges( 900000, Edge::EDGE_TEMPLATE_ARGUMENT, NodeType::NODE_TYPE, NodeType::NODE_TYPE); + createEdges(1000000, Edge::EDGE_TEMPLATE_DEFAULT_ARGUMENT, NodeType::NODE_TYPE, NodeType::NODE_TYPE); + createEdges(1100000, Edge::EDGE_TEMPLATE_SPECIALIZATION, NodeType::NODE_TYPE, NodeType::NODE_TYPE); + createEdges(1200000, Edge::EDGE_TEMPLATE_MEMBER_SPECIALIZATION, NodeType::NODE_METHOD, NodeType::NODE_METHOD); std::vector focusedTokenIds; std::vector activeTokenIds; diff --git a/src/lib/component/controller/GraphController.h b/src/lib/component/controller/GraphController.h index 58f4d5e5..9362c3f4 100644 --- a/src/lib/component/controller/GraphController.h +++ b/src/lib/component/controller/GraphController.h @@ -94,7 +94,7 @@ private: const std::string& name); std::shared_ptr bundleNodesMatching( std::list>& nodes, std::function matcher, const std::string& name); - void bundleByType(std::list>& nodes, Node::NodeType type, const std::string& name); + void bundleByType(std::list>& nodes, NodeType::Type type, const std::string& name); void bundleNodesByType(); void addCharacterIndex(); diff --git a/src/lib/component/controller/UndoRedoController.cpp b/src/lib/component/controller/UndoRedoController.cpp index 1ba979db..63a175df 100644 --- a/src/lib/component/controller/UndoRedoController.cpp +++ b/src/lib/component/controller/UndoRedoController.cpp @@ -615,7 +615,7 @@ SearchMatch UndoRedoController::getSearchMatchForMessage(MessageBase* message) c SearchMatch match; match.name = match.text = "aggregation"; // TODO: show aggregation source and target match.searchType = SearchMatch::SEARCH_TOKEN; - match.nodeType = Node::NODE_TYPE; + match.nodeType = NodeType::NODE_TYPE; return match; } } diff --git a/src/lib/component/controller/helper/DummyNode.h b/src/lib/component/controller/helper/DummyNode.h index b4dca3f0..e2934c1b 100644 --- a/src/lib/component/controller/helper/DummyNode.h +++ b/src/lib/component/controller/helper/DummyNode.h @@ -67,7 +67,7 @@ public: , bundleId(0) , layoutBucket(0, 0) , bundledNodeCount(0) - , bundledNodeType(Node::NODE_NON_INDEXED) + , bundledNodeType(NodeType::NODE_NON_INDEXED) , qualifierName(NAME_DELIMITER_UNKNOWN) , textNode(false) { @@ -376,7 +376,7 @@ public: // BundleNode BundledNodesSet bundledNodes; size_t bundledNodeCount; - Node::NodeType bundledNodeType; + NodeType bundledNodeType; // QualifierNode NameHierarchy qualifierName; diff --git a/src/lib/component/view/GraphViewStyle.cpp b/src/lib/component/view/GraphViewStyle.cpp index 4ec1c636..ab41e283 100644 --- a/src/lib/component/view/GraphViewStyle.cpp +++ b/src/lib/component/view/GraphViewStyle.cpp @@ -11,8 +11,8 @@ int GraphViewStyle::s_gridCellSize = 5; int GraphViewStyle::s_gridCellPadding = 10; -std::map GraphViewStyle::s_charWidths; -std::map GraphViewStyle::s_charHeights; +std::unordered_map GraphViewStyle::s_charWidths; +std::unordered_map GraphViewStyle::s_charHeights; std::shared_ptr GraphViewStyle::s_impl; @@ -145,13 +145,13 @@ void GraphViewStyle::loadStyleSettings() s_edgeColors.clear(); s_screenMatchColors.clear(); - s_gridCellPadding = getImpl()->getCharHeightForNodeType(Node::NODE_TYPE) - 8; + s_gridCellPadding = getImpl()->getCharHeightForNodeType(NodeType::NODE_TYPE) - 8; s_gridCellSize = s_gridCellPadding / 2; } -float GraphViewStyle::getCharWidthForNodeType(Node::NodeType type) +float GraphViewStyle::getCharWidthForNodeType(NodeType type) { - std::map::const_iterator it = s_charWidths.find(type); + std::unordered_map::const_iterator it = s_charWidths.find(type.getReadableTypeString()); if (it != s_charWidths.end()) { @@ -159,13 +159,13 @@ float GraphViewStyle::getCharWidthForNodeType(Node::NodeType type) } float charWidth = getImpl()->getCharWidthForNodeType(type); - s_charWidths.emplace(type, charWidth); + s_charWidths.emplace(type.getReadableTypeString(), charWidth); return charWidth; } -float GraphViewStyle::getCharHeightForNodeType(Node::NodeType type) +float GraphViewStyle::getCharHeightForNodeType(NodeType type) { - std::map::const_iterator it = s_charHeights.find(type); + std::unordered_map::const_iterator it = s_charHeights.find(type.getReadableTypeString()); if (it != s_charHeights.end()) { @@ -173,40 +173,13 @@ float GraphViewStyle::getCharHeightForNodeType(Node::NodeType type) } float charHeight = getImpl()->getCharHeightForNodeType(type); - s_charHeights.emplace(type, charHeight); + s_charHeights.emplace(type.getReadableTypeString(), charHeight); return charHeight; } -size_t GraphViewStyle::getFontSizeForNodeType(Node::NodeType type) +size_t GraphViewStyle::getFontSizeForNodeType(NodeType type) { - switch (type) - { - case Node::NODE_NAMESPACE: - case Node::NODE_PACKAGE: - return s_fontSize - 3; - - case Node::NODE_NON_INDEXED: - case Node::NODE_TYPE: - case Node::NODE_BUILTIN_TYPE: - case Node::NODE_STRUCT: - case Node::NODE_CLASS: - case Node::NODE_UNION: - case Node::NODE_INTERFACE: - case Node::NODE_ENUM: - case Node::NODE_TYPEDEF: - case Node::NODE_TEMPLATE_PARAMETER_TYPE: - case Node::NODE_TYPE_PARAMETER: - case Node::NODE_FILE: - case Node::NODE_MACRO: - return s_fontSize; - - case Node::NODE_FUNCTION: - case Node::NODE_METHOD: - case Node::NODE_GLOBAL_VARIABLE: - case Node::NODE_FIELD: - case Node::NODE_ENUM_CONSTANT: - return s_fontSize - 3; - } + return s_fontSize + type.getFontSizeOffset(); } size_t GraphViewStyle::getFontSizeOfAccessNode() @@ -234,7 +207,7 @@ size_t GraphViewStyle::getFontSizeOfTextNode() return s_fontSize + 5; } -std::string GraphViewStyle::getFontNameForNodeType(Node::NodeType type) +std::string GraphViewStyle::getFontNameForDataNode() { return s_fontName; } @@ -254,35 +227,35 @@ std::string GraphViewStyle::getFontNameOfTextNode() return "Fira Sans"; } -GraphViewStyle::NodeMargins GraphViewStyle::getMarginsForNodeType(Node::NodeType type, bool hasChildren) +GraphViewStyle::NodeMargins GraphViewStyle::getMarginsForNodeType(NodeType type, bool hasChildren) { NodeMargins margins; margins.spacingX = 6; margins.spacingY = 8; - switch (type) + switch (type.getType()) { - case Node::NODE_NAMESPACE: - case Node::NODE_PACKAGE: + case NodeType::NODE_NAMESPACE: + case NodeType::NODE_PACKAGE: margins.left = margins.right = 5; margins.top = margins.bottom = 3; margins.iconWidth = s_fontSize - 3; break; - case Node::NODE_ENUM: - case Node::NODE_TYPEDEF: - case Node::NODE_FILE: - case Node::NODE_MACRO: + case NodeType::NODE_ENUM: + case NodeType::NODE_TYPEDEF: + case NodeType::NODE_FILE: + case NodeType::NODE_MACRO: margins.iconWidth = s_fontSize + 11; - case Node::NODE_NON_INDEXED: - case Node::NODE_TYPE: - case Node::NODE_BUILTIN_TYPE: - case Node::NODE_STRUCT: - case Node::NODE_CLASS: - case Node::NODE_UNION: - case Node::NODE_INTERFACE: - case Node::NODE_TEMPLATE_PARAMETER_TYPE: - case Node::NODE_TYPE_PARAMETER: + case NodeType::NODE_NON_INDEXED: + 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_TEMPLATE_PARAMETER_TYPE: + case NodeType::NODE_TYPE_PARAMETER: if (hasChildren) { margins.left = margins.right = 10; @@ -296,11 +269,11 @@ GraphViewStyle::NodeMargins GraphViewStyle::getMarginsForNodeType(Node::NodeType } break; - case Node::NODE_FUNCTION: - case Node::NODE_METHOD: - case Node::NODE_GLOBAL_VARIABLE: - case Node::NODE_FIELD: - case Node::NODE_ENUM_CONSTANT: + case NodeType::NODE_FUNCTION: + case NodeType::NODE_METHOD: + case NodeType::NODE_GLOBAL_VARIABLE: + case NodeType::NODE_FIELD: + case NodeType::NODE_ENUM_CONSTANT: if (hasChildren) { margins.top = margins.bottom = 5; @@ -370,7 +343,7 @@ GraphViewStyle::NodeMargins GraphViewStyle::getMarginsOfExpandToggleNode() GraphViewStyle::NodeMargins GraphViewStyle::getMarginsOfBundleNode() { - return getMarginsForNodeType(Node::NODE_ENUM, false); + return getMarginsForNodeType(NodeType::NODE_ENUM, false); } GraphViewStyle::NodeMargins GraphViewStyle::getMarginsOfTextNode() @@ -385,13 +358,13 @@ GraphViewStyle::NodeMargins GraphViewStyle::getMarginsOfTextNode() } GraphViewStyle::NodeStyle GraphViewStyle::getStyleForNodeType( - Node::NodeType type, bool defined, bool isActive, bool isFocused, bool hasChildren, bool hasQualifier + NodeType type, bool defined, bool isActive, bool isFocused, bool hasChildren, bool hasQualifier ){ NodeStyle style; - style.color = getNodeColor(Node::getUnderscoredTypeString(type), isActive || isFocused); + style.color = getNodeColor(type.getUnderscoredTypeString(), isActive || isFocused); - style.fontName = getFontNameForNodeType(type); + style.fontName = getFontNameForDataNode(); style.fontSize = getFontSizeForNodeType(type); if (isActive || isFocused) @@ -408,28 +381,28 @@ GraphViewStyle::NodeStyle GraphViewStyle::getStyleForNodeType( style.borderWidth = 1; } - switch (type) + switch (type.getType()) { - case Node::NODE_NAMESPACE: - case Node::NODE_PACKAGE: + case NodeType::NODE_NAMESPACE: + case NodeType::NODE_PACKAGE: style.cornerRadius = 0; style.textOffset.x = 5; style.textOffset.y = 3; break; - case Node::NODE_NON_INDEXED: - case Node::NODE_TYPE: - case Node::NODE_BUILTIN_TYPE: - case Node::NODE_STRUCT: - case Node::NODE_CLASS: - case Node::NODE_UNION: - case Node::NODE_INTERFACE: - case Node::NODE_ENUM: - case Node::NODE_TYPEDEF: - case Node::NODE_TEMPLATE_PARAMETER_TYPE: - case Node::NODE_TYPE_PARAMETER: - case Node::NODE_FILE: - case Node::NODE_MACRO: + case NodeType::NODE_NON_INDEXED: + 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_ENUM: + case NodeType::NODE_TYPEDEF: + case NodeType::NODE_TEMPLATE_PARAMETER_TYPE: + case NodeType::NODE_TYPE_PARAMETER: + case NodeType::NODE_FILE: + case NodeType::NODE_MACRO: if (hasChildren) { style.cornerRadius = 20; @@ -444,11 +417,11 @@ GraphViewStyle::NodeStyle GraphViewStyle::getStyleForNodeType( } break; - case Node::NODE_FUNCTION: - case Node::NODE_METHOD: - case Node::NODE_GLOBAL_VARIABLE: - case Node::NODE_FIELD: - case Node::NODE_ENUM_CONSTANT: + case NodeType::NODE_FUNCTION: + case NodeType::NODE_METHOD: + case NodeType::NODE_GLOBAL_VARIABLE: + case NodeType::NODE_FIELD: + case NodeType::NODE_ENUM_CONSTANT: style.cornerRadius = 8; style.textOffset.x = 5; style.textOffset.y = 3; @@ -520,11 +493,11 @@ GraphViewStyle::NodeStyle GraphViewStyle::getStyleOfCountCircle() GraphViewStyle::NodeStyle GraphViewStyle::getStyleOfBundleNode(bool isFocused) { - NodeStyle style = getStyleForNodeType(Node::NODE_CLASS, true, false, isFocused, false, false); + NodeStyle style = getStyleForNodeType(NodeType::NODE_CLASS, true, false, isFocused, false, false); style.color = getNodeColor("bundle", isFocused); - addIcon(Node::NODE_ENUM, false, &style); + addIcon(NodeType::NODE_ENUM, false, &style); style.iconPath = ResourcePaths::getGuiPath().str() + "graph_view/images/bundle.png"; return style; @@ -737,28 +710,28 @@ const GraphViewStyle::NodeColor& GraphViewStyle::getScreenMatchColor(bool focus) return s_screenMatchColors.find(focus)->second; } -void GraphViewStyle::addIcon(Node::NodeType type, bool hasChildren, NodeStyle* style) +void GraphViewStyle::addIcon(NodeType type, bool hasChildren, NodeStyle* style) { - switch (type) + switch (type.getType()) { - case Node::NODE_NAMESPACE: - case Node::NODE_PACKAGE: + case NodeType::NODE_NAMESPACE: + case NodeType::NODE_PACKAGE: style->iconPath = ResourcePaths::getGuiPath().str() + "graph_view/images/namespace.png"; style->iconSize = s_fontSize - 4; style->iconOffset.x = -1; style->iconOffset.y = 5; return; - case Node::NODE_ENUM: + case NodeType::NODE_ENUM: style->iconPath = ResourcePaths::getGuiPath().str() + "graph_view/images/enum.png"; break; - case Node::NODE_TYPEDEF: + case NodeType::NODE_TYPEDEF: style->iconPath = ResourcePaths::getGuiPath().str() + "graph_view/images/typedef.png"; break; - case Node::NODE_MACRO: + case NodeType::NODE_MACRO: style->iconPath = ResourcePaths::getGuiPath().str() + "graph_view/images/macro.png"; break; - case Node::NODE_FILE: + case NodeType::NODE_FILE: style->iconPath = ResourcePaths::getGuiPath().str() + "graph_view/images/file.png"; break; default: diff --git a/src/lib/component/view/GraphViewStyle.h b/src/lib/component/view/GraphViewStyle.h index a22a08dd..595bc251 100644 --- a/src/lib/component/view/GraphViewStyle.h +++ b/src/lib/component/view/GraphViewStyle.h @@ -3,6 +3,7 @@ #include #include +#include #include "utility/math/Vector2.h" @@ -98,29 +99,29 @@ public: static void loadStyleSettings(); - static float getCharWidthForNodeType(Node::NodeType type); - static float getCharHeightForNodeType(Node::NodeType type); + static float getCharWidthForNodeType(NodeType type); + static float getCharHeightForNodeType(NodeType type); - static size_t getFontSizeForNodeType(Node::NodeType type); + static size_t getFontSizeForNodeType(NodeType type); static size_t getFontSizeOfAccessNode(); static size_t getFontSizeOfExpandToggleNode(); static size_t getFontSizeOfCountCircle(); static size_t getFontSizeOfQualifier(); static size_t getFontSizeOfTextNode(); - static std::string getFontNameForNodeType(Node::NodeType type); + static std::string getFontNameForDataNode(); static std::string getFontNameOfAccessNode(); static std::string getFontNameOfExpandToggleNode(); static std::string getFontNameOfTextNode(); - static NodeMargins getMarginsForNodeType(Node::NodeType type, bool hasChildren); + static NodeMargins getMarginsForNodeType(NodeType type, bool hasChildren); static NodeMargins getMarginsOfAccessNode(AccessKind access); static NodeMargins getMarginsOfExpandToggleNode(); static NodeMargins getMarginsOfBundleNode(); static NodeMargins getMarginsOfTextNode(); static NodeStyle getStyleForNodeType( - Node::NodeType type, bool defined, bool isActive, bool isFocused, bool hasChildren, bool hasQualifier); + NodeType type, bool defined, bool isActive, bool isFocused, bool hasChildren, bool hasQualifier); static NodeStyle getStyleOfAccessNode(); static NodeStyle getStyleOfExpandToggleNode(); static NodeStyle getStyleOfCountCircle(); @@ -144,10 +145,10 @@ public: static int s_gridCellPadding; private: - static void addIcon(Node::NodeType type, bool hasChildren, NodeStyle* style); + static void addIcon(NodeType type, bool hasChildren, NodeStyle* style); - static std::map s_charWidths; - static std::map s_charHeights; + static std::unordered_map s_charWidths; + static std::unordered_map s_charHeights; static std::shared_ptr s_impl; diff --git a/src/lib/component/view/GraphViewStyleImpl.h b/src/lib/component/view/GraphViewStyleImpl.h index e57a6421..492948db 100644 --- a/src/lib/component/view/GraphViewStyleImpl.h +++ b/src/lib/component/view/GraphViewStyleImpl.h @@ -7,8 +7,8 @@ class GraphViewStyleImpl { public: virtual ~GraphViewStyleImpl() { } - virtual float getCharWidthForNodeType(Node::NodeType type) = 0; - virtual float getCharHeightForNodeType(Node::NodeType type) = 0; + virtual float getCharWidthForNodeType(NodeType type) = 0; + virtual float getCharHeightForNodeType(NodeType type) = 0; virtual float getGraphViewZoomDifferenceForPlatform() = 0; }; diff --git a/src/lib/data/NodeType.cpp b/src/lib/data/NodeType.cpp new file mode 100644 index 00000000..c2c62588 --- /dev/null +++ b/src/lib/data/NodeType.cpp @@ -0,0 +1,260 @@ +#include "data/NodeType.h" + +#include "utility/utilityString.h" + +NodeType::NodeType(Type type) + : m_type(type) +{ +} + +bool NodeType::operator==(const NodeType& o) const +{ + return m_type == o.m_type; +} + +NodeType::Type NodeType::getType() const +{ + return m_type; +} + +bool NodeType::isFile() const +{ + const NodeType::TypeMask mask = + NodeType::NODE_FILE; + return ((m_type & mask) > 0); +} + +bool NodeType::isInheritable() const +{ + // what about java enums? + const NodeType::TypeMask mask = + NodeType::NODE_NON_INDEXED | + NodeType::NODE_BUILTIN_TYPE | + NodeType::NODE_TYPE | + NodeType::NODE_STRUCT | + NodeType::NODE_CLASS | + NodeType::NODE_INTERFACE; + + return ((m_type & mask) > 0); +} + +bool NodeType::isPackage() const +{ + const NodeType::TypeMask mask = + NodeType::NODE_NAMESPACE | + NodeType::NODE_PACKAGE; + return ((m_type & mask) > 0); +} + +bool NodeType::isCallable() const +{ + const NodeType::TypeMask mask = + NodeType::NODE_FUNCTION | + NodeType::NODE_METHOD; + return ((m_type & mask) > 0); +} + +bool NodeType::isUsable() const +{ + const NodeType::TypeMask mask = + NodeType::NODE_NON_INDEXED | + NodeType::NODE_BUILTIN_TYPE | + NodeType::NODE_STRUCT | + NodeType::NODE_CLASS | + NodeType::NODE_ENUM | + NodeType::NODE_UNION | + NodeType::NODE_INTERFACE | + NodeType::NODE_TYPEDEF; + return ((m_type & mask) > 0); +} + +bool NodeType::isPotentialMember() const +{ + const NodeType::TypeMask mask = + NodeType::NODE_METHOD | + NodeType::NODE_FIELD | + NodeType::NODE_CLASS | + NodeType::NODE_INTERFACE | + NodeType::NODE_STRUCT | + NodeType::NODE_UNION | + NodeType::NODE_TYPEDEF | + NodeType::NODE_ENUM; + + return ((m_type & mask) > 0); +} + +bool NodeType::isCollapsible() const +{ + const NodeType::TypeMask mask = + NodeType::NODE_NON_INDEXED | + NodeType::NODE_TYPE | + NodeType::NODE_BUILTIN_TYPE | + NodeType::NODE_CLASS | + NodeType::NODE_STRUCT | + NodeType::NODE_ENUM | + NodeType::NODE_UNION | + NodeType::NODE_INTERFACE; + return ((m_type & mask) > 0); +} + +bool NodeType::isVisibleAsParentInGraph() const +{ + return !isPackage(); +} + +int NodeType::getFontSizeOffset() const +{ + switch (m_type) + { + case NodeType::NODE_NAMESPACE: + case NodeType::NODE_PACKAGE: + return - 3; + + case NodeType::NODE_NON_INDEXED: + 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_ENUM: + case NodeType::NODE_TYPEDEF: + case NodeType::NODE_TEMPLATE_PARAMETER_TYPE: + case NodeType::NODE_TYPE_PARAMETER: + case NodeType::NODE_FILE: + case NodeType::NODE_MACRO: + return 0; + + case NodeType::NODE_FUNCTION: + case NodeType::NODE_METHOD: + case NodeType::NODE_GLOBAL_VARIABLE: + case NodeType::NODE_FIELD: + case NodeType::NODE_ENUM_CONSTANT: + return - 3; + } +} + +std::string NodeType::getUnderscoredTypeString() const +{ + return utility::replace(utility::replace(getReadableTypeString(), "-", "_"), " ", "_"); +} + +std::string NodeType::getReadableTypeString() const +{ + return utility::getReadableTypeString(m_type); +} + +int utility::nodeTypeToInt(NodeType::Type type) +{ + return type; +} + +NodeType::Type utility::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_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_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_TEMPLATE_PARAMETER_TYPE: + return NodeType::NODE_TEMPLATE_PARAMETER_TYPE; + 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_NON_INDEXED; +} + +std::string utility::getReadableTypeString(NodeType::Type type) +{ + switch (type) + { + case NodeType::NODE_NON_INDEXED: + return "non-indexed"; + case NodeType::NODE_BUILTIN_TYPE: + return "built-in type"; + case NodeType::NODE_TYPE: + return "type"; + 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_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_TEMPLATE_PARAMETER_TYPE: + return "template parameter type"; + 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 ""; +} + +NodeType::Type utility::getTypeForReadableTypeString(const std::string str) +{ + for (NodeType::TypeMask mask = 1; mask <= NodeType::NODE_MAX_VALUE; mask *= 2) + { + NodeType::Type type = intToType(mask); + if (getReadableTypeString(type) == str) + { + return type; + } + } + + return NodeType::NODE_NON_INDEXED; +} \ No newline at end of file diff --git a/src/lib/data/NodeType.h b/src/lib/data/NodeType.h new file mode 100644 index 00000000..0cb9c8f8 --- /dev/null +++ b/src/lib/data/NodeType.h @@ -0,0 +1,76 @@ +#ifndef NODE_TYPE_H +#define NODE_TYPE_H + +#include +#include +#include +#include + +#include "utility/types.h" + +class NodeType +{ +public: + typedef int NodeType::TypeMask; + enum Type : NodeType::TypeMask + { // make sure that the value of 0x0 is not used here because it doesn't work for bitmasking. + NODE_NON_INDEXED = 0x1, + NODE_TYPE = 0x2, + NODE_BUILTIN_TYPE = 0x4, + + NODE_NAMESPACE = 0x8, + NODE_PACKAGE = 0x10, + NODE_STRUCT = 0x20, + NODE_CLASS = 0x40, + NODE_INTERFACE = 0x80, + NODE_GLOBAL_VARIABLE = 0x100, + NODE_FIELD = 0x200, + NODE_FUNCTION = 0x400, + NODE_METHOD = 0x800, + + NODE_ENUM = 0x1000, + NODE_ENUM_CONSTANT = 0x2000, + NODE_TYPEDEF = 0x4000, + NODE_TEMPLATE_PARAMETER_TYPE = 0x8000, + NODE_TYPE_PARAMETER = 0x10000, + + NODE_FILE = 0x20000, + NODE_MACRO = 0x40000, + NODE_UNION = 0x80000, + + NODE_MAX_VALUE = NODE_UNION + }; + + NodeType(Type type); + + bool operator==(const NodeType& o) const; + + Type getType() const; + + bool isFile() const; + bool isInheritable() const; + bool isPackage() const; + bool isCallable() const; + bool isUsable() const; + bool isPotentialMember() const; + bool isCollapsible() const; + bool isVisibleAsParentInGraph() const; + + int getFontSizeOffset() const; + + std::string getUnderscoredTypeString() const; + std::string getReadableTypeString() const; + +private: + Type m_type; +}; + +namespace utility +{ + int nodeTypeToInt(NodeType::Type type); + NodeType::Type intToType(int value); + std::string getReadableTypeString(NodeType::Type type); + NodeType::Type getTypeForReadableTypeString(const std::string str); +} + +#endif // NODE_TYPE_H diff --git a/src/lib/data/access/StorageAccess.h b/src/lib/data/access/StorageAccess.h index 6e4f2c57..711dbb3a 100644 --- a/src/lib/data/access/StorageAccess.h +++ b/src/lib/data/access/StorageAccess.h @@ -40,7 +40,7 @@ public: virtual NameHierarchy getNameHierarchyForNodeId(Id id) const = 0; virtual std::vector getNameHierarchiesForNodeIds(const std::vector& nodeIds) const = 0; - virtual Node::NodeType getNodeTypeForNodeWithId(Id id) const = 0; + virtual NodeType getNodeTypeForNodeWithId(Id id) const = 0; virtual Id getIdForEdge( Edge::EdgeType type, const NameHierarchy& fromNameHierarchy, const NameHierarchy& toNameHierarchy) const = 0; @@ -48,15 +48,15 @@ public: virtual std::shared_ptr getFullTextSearchLocations( const std::string& searchTerm, bool caseSensitive) const = 0; - virtual std::vector getAutocompletionMatches(const std::string& query, Node::NodeTypeMask filter) const = 0; + virtual std::vector getAutocompletionMatches(const std::string& query, NodeType::TypeMask filter) const = 0; virtual std::vector getSearchMatchesForTokenIds(const std::vector& tokenIds) const = 0; virtual std::shared_ptr getGraphForAll() const = 0; - virtual std::shared_ptr getGraphForFilter(Node::NodeTypeMask filter) const = 0; + virtual std::shared_ptr getGraphForFilter(NodeType::TypeMask filter) const = 0; virtual std::shared_ptr getGraphForActiveTokenIds( const std::vector& tokenIds, const std::vector& expandedNodeIds, bool* isActiveNamespace = nullptr) const = 0; virtual std::shared_ptr getGraphForChildrenOfNodeId(Id nodeId) const = 0; - virtual std::shared_ptr getGraphForTrail(Id originId, Id targetId, Edge::EdgeTypeMask trailType, size_t depth) const = 0; + virtual std::shared_ptr getGraphForTrail(Id originId, Id targetId, Edge::TypeMask trailType, size_t depth) const = 0; virtual std::vector getActiveTokenIdsForId(Id tokenId, Id* declarationId) const = 0; virtual std::vector getNodeIdsForLocationIds(const std::vector& locationIds) const = 0; diff --git a/src/lib/data/access/StorageAccessProxy.cpp b/src/lib/data/access/StorageAccessProxy.cpp index 4fc4f186..ccb825ef 100644 --- a/src/lib/data/access/StorageAccessProxy.cpp +++ b/src/lib/data/access/StorageAccessProxy.cpp @@ -84,13 +84,13 @@ std::vector StorageAccessProxy::getNameHierarchiesForNodeIds(cons return std::vector(); } -Node::NodeType StorageAccessProxy::getNodeTypeForNodeWithId(Id id) const +NodeType StorageAccessProxy::getNodeTypeForNodeWithId(Id id) const { if (hasSubject()) { return m_subject->getNodeTypeForNodeWithId(id); } - return Node::NODE_NON_INDEXED; + return NodeType::NODE_NON_INDEXED; } Id StorageAccessProxy::getIdForEdge( @@ -125,7 +125,7 @@ std::shared_ptr StorageAccessProxy::getFullTextSearchL return std::make_shared(); } -std::vector StorageAccessProxy::getAutocompletionMatches(const std::string& query, Node::NodeTypeMask filter) const +std::vector StorageAccessProxy::getAutocompletionMatches(const std::string& query, NodeType::TypeMask filter) const { if (hasSubject()) { @@ -155,7 +155,7 @@ std::shared_ptr StorageAccessProxy::getGraphForAll() const return std::make_shared(); } -std::shared_ptr StorageAccessProxy::getGraphForFilter(Node::NodeTypeMask filter) const +std::shared_ptr StorageAccessProxy::getGraphForFilter(NodeType::TypeMask filter) const { if (hasSubject()) { @@ -186,7 +186,7 @@ std::shared_ptr StorageAccessProxy::getGraphForChildrenOfNodeId(Id nodeId return std::make_shared(); } -std::shared_ptr StorageAccessProxy::getGraphForTrail(Id originId, Id targetId, Edge::EdgeTypeMask trailType, size_t depth) const +std::shared_ptr StorageAccessProxy::getGraphForTrail(Id originId, Id targetId, Edge::TypeMask trailType, size_t depth) const { if (hasSubject()) { diff --git a/src/lib/data/access/StorageAccessProxy.h b/src/lib/data/access/StorageAccessProxy.h index 2d8e35b3..6b88c7f7 100644 --- a/src/lib/data/access/StorageAccessProxy.h +++ b/src/lib/data/access/StorageAccessProxy.h @@ -25,7 +25,7 @@ public: virtual NameHierarchy getNameHierarchyForNodeId(Id id) const; virtual std::vector getNameHierarchiesForNodeIds(const std::vector& nodeIds) const; - virtual Node::NodeType getNodeTypeForNodeWithId(Id id) const; + virtual NodeType getNodeTypeForNodeWithId(Id id) const; virtual Id getIdForEdge( Edge::EdgeType type, const NameHierarchy& fromNameHierarchy, const NameHierarchy& toNameHierarchy) const; @@ -33,15 +33,15 @@ public: virtual std::shared_ptr getFullTextSearchLocations( const std::string& searchTerm, bool caseSensitive) const; - virtual std::vector getAutocompletionMatches(const std::string& query, Node::NodeTypeMask filter) const; + virtual std::vector getAutocompletionMatches(const std::string& query, NodeType::TypeMask filter) const; virtual std::vector getSearchMatchesForTokenIds(const std::vector& tokenIds) const; virtual std::shared_ptr getGraphForAll() const; - virtual std::shared_ptr getGraphForFilter(Node::NodeTypeMask filter) const; + virtual std::shared_ptr getGraphForFilter(NodeType::TypeMask filter) const; virtual std::shared_ptr getGraphForActiveTokenIds( const std::vector& tokenIds, const std::vector& expandedNodeIds, bool* isActiveNamespace = nullptr) const; virtual std::shared_ptr getGraphForChildrenOfNodeId(Id nodeId) const; - virtual std::shared_ptr getGraphForTrail(Id originId, Id targetId, Edge::EdgeTypeMask trailType, size_t depth) const; + virtual std::shared_ptr getGraphForTrail(Id originId, Id targetId, Edge::TypeMask trailType, size_t depth) const; virtual std::vector getActiveTokenIdsForId(Id tokenId, Id* declarationId) const; virtual std::vector getNodeIdsForLocationIds(const std::vector& locationIds) const; diff --git a/src/lib/data/graph/Edge.cpp b/src/lib/data/graph/Edge.cpp index a903f68d..6b8db45a 100644 --- a/src/lib/data/graph/Edge.cpp +++ b/src/lib/data/graph/Edge.cpp @@ -89,7 +89,7 @@ Edge::EdgeType Edge::getType() const return m_type; } -bool Edge::isType(EdgeTypeMask mask) const +bool Edge::isType(TypeMask mask) const { return (m_type & mask) > 0; } diff --git a/src/lib/data/graph/Edge.h b/src/lib/data/graph/Edge.h index db123941..e72d0a46 100644 --- a/src/lib/data/graph/Edge.h +++ b/src/lib/data/graph/Edge.h @@ -14,8 +14,8 @@ class Edge : public Token { public: - typedef int EdgeTypeMask; - enum EdgeType : EdgeTypeMask + typedef int TypeMask; + enum EdgeType : TypeMask { EDGE_UNDEFINED = 0x0, EDGE_MEMBER = 0x1, @@ -43,7 +43,7 @@ public: virtual ~Edge(); EdgeType getType() const; - bool isType(EdgeTypeMask mask) const; + bool isType(TypeMask mask) const; Node* getFrom() const; Node* getTo() const; diff --git a/src/lib/data/graph/Graph.cpp b/src/lib/data/graph/Graph.cpp index 36767ceb..a1d755bf 100644 --- a/src/lib/data/graph/Graph.cpp +++ b/src/lib/data/graph/Graph.cpp @@ -41,7 +41,7 @@ void Graph::forEachToken(std::function func) const forEachEdge(func); } -Node* Graph::createNode(Id id, Node::NodeType type, NameHierarchy nameHierarchy, bool defined) +Node* Graph::createNode(Id id, NodeType type, NameHierarchy nameHierarchy, bool defined) { Node* n = getNodeById(id); if (n) diff --git a/src/lib/data/graph/Graph.h b/src/lib/data/graph/Graph.h index 4d46b0d5..4d353a28 100644 --- a/src/lib/data/graph/Graph.h +++ b/src/lib/data/graph/Graph.h @@ -27,7 +27,7 @@ public: void forEachEdge(std::function func) const; void forEachToken(std::function func) const; - Node* createNode(Id id, Node::NodeType type, NameHierarchy nameHierarchy, bool defined); + Node* createNode(Id id, NodeType type, NameHierarchy nameHierarchy, bool defined); Edge* createEdge(Id id, Edge::EdgeType type, Node* from, Node* to); size_t getNodeCount() const; diff --git a/src/lib/data/graph/Node.cpp b/src/lib/data/graph/Node.cpp index c3ef9b9e..d133ce69 100644 --- a/src/lib/data/graph/Node.cpp +++ b/src/lib/data/graph/Node.cpp @@ -11,143 +11,6 @@ #include "data/graph/token_component/TokenComponentStatic.h" #include "data/graph/token_component/TokenComponentFilePath.h" -const Node::NodeTypeMask Node::NODE_NOT_VISIBLE = - NODE_NAMESPACE | NODE_PACKAGE; - -const Node::NodeTypeMask Node::NODE_USEABLE_TYPE = - NODE_NON_INDEXED | NODE_BUILTIN_TYPE | NODE_STRUCT | NODE_CLASS | NODE_ENUM | NODE_UNION | NODE_INTERFACE | - NODE_TYPEDEF; - -const Node::NodeTypeMask Node::NODE_INHERITABLE_TYPE = - NODE_NON_INDEXED | NODE_BUILTIN_TYPE | NODE_TYPE | NODE_STRUCT | NODE_CLASS | NODE_INTERFACE; - -const Node::NodeTypeMask Node::NODE_MEMBER_TYPE = - NODE_METHOD | NODE_FIELD | NODE_CLASS | NODE_INTERFACE | NODE_STRUCT | NODE_UNION | NODE_TYPEDEF | NODE_ENUM; - -const Node::NodeTypeMask Node::NODE_COLLAPSIBLE_TYPE = - NODE_NON_INDEXED | NODE_TYPE | NODE_BUILTIN_TYPE | NODE_CLASS | NODE_STRUCT | NODE_ENUM | NODE_UNION | - NODE_INTERFACE; - -std::string Node::getUnderscoredTypeString(NodeType type) -{ - return utility::replace(utility::replace(getReadableTypeString(type), "-", "_"), " ", "_"); -} - -std::string Node::getReadableTypeString(NodeType type) -{ - switch (type) - { - case NODE_NON_INDEXED: - return "non-indexed"; - case NODE_BUILTIN_TYPE: - return "built-in type"; - case NODE_TYPE: - return "type"; - 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_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_TEMPLATE_PARAMETER_TYPE: - return "template parameter type"; - case NODE_TYPE_PARAMETER: - return "type parameter"; - case NODE_FILE: - return "file"; - case NODE_MACRO: - return "macro"; - case NODE_UNION: - return "union"; - } - - return ""; -} - -Node::NodeType Node::getTypeForReadableTypeString(const std::string str) -{ - for (Node::NodeTypeMask mask = 1; mask <= NODE_MAX_VALUE; mask *= 2) - { - Node::NodeType type = intToType(mask); - if (getReadableTypeString(type) == str) - { - return type; - } - } - - return NODE_NON_INDEXED; -} - -int Node::typeToInt(NodeType type) -{ - return type; -} - -Node::NodeType Node::intToType(int value) -{ - switch (value) - { - case NODE_TYPE: - return NODE_TYPE; - case NODE_BUILTIN_TYPE: - return NODE_BUILTIN_TYPE; - 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_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_TEMPLATE_PARAMETER_TYPE: - return NODE_TEMPLATE_PARAMETER_TYPE; - 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_NON_INDEXED; -} - Node::Node(Id id, NodeType type, NameHierarchy nameHierarchy, bool defined) : Token(id) , m_type(type) @@ -174,26 +37,26 @@ Node::~Node() { } -Node::NodeType Node::getType() const +NodeType Node::getType() const { return m_type; } void Node::setType(NodeType type) { - if (!isType(type | NODE_NON_INDEXED)) + if (!isType(type.getType() | NodeType::NODE_NON_INDEXED)) { LOG_WARNING( - "Cannot change NodeType after it was already set from " + getReadableTypeString() + " to " + getReadableTypeString(type) + "Cannot change NodeType after it was already set from " + getReadableTypeString() + " to " + type.getReadableTypeString() ); return; } m_type = type; } -bool Node::isType(NodeTypeMask mask) const +bool Node::isType(NodeType::TypeMask mask) const { - return (m_type & mask) > 0; + return (m_type.getType() & mask) > 0; } std::string Node::getName() const @@ -317,12 +180,12 @@ Edge* Node::findEdge(std::function func) const return nullptr; } -Edge* Node::findEdgeOfType(Edge::EdgeTypeMask mask) const +Edge* Node::findEdgeOfType(Edge::TypeMask mask) const { return findEdgeOfType(mask, [](Edge* e){ return true; }); } -Edge* Node::findEdgeOfType(Edge::EdgeTypeMask mask, std::function func) const +Edge* Node::findEdgeOfType(Edge::TypeMask mask, std::function func) const { auto it = find_if(m_edges.begin(), m_edges.end(), [mask, func](std::pair p) @@ -374,7 +237,7 @@ void Node::forEachEdge(std::function func) const ); } -void Node::forEachEdgeOfType(Edge::EdgeTypeMask mask, std::function func) const +void Node::forEachEdgeOfType(Edge::TypeMask mask, std::function func) const { for_each(m_edges.begin(), m_edges.end(), [mask, func](std::pair p) @@ -432,10 +295,6 @@ void Node::addComponentAbstraction(std::shared_ptr co // LOG_ERROR("TokenComponentAbstraction has been set before!"); return; } - else if (!isType(NODE_METHOD)) - { - LOG_ERROR("TokenComponentAbstraction can't be set on node of type: " + getReadableTypeString()); - } else { addComponent(component); @@ -449,10 +308,6 @@ void Node::addComponentConst(std::shared_ptr component) // LOG_ERROR("TokenComponentConst has been set before!"); return; } - else if (!isType(NODE_METHOD)) - { - LOG_ERROR("TokenComponentConst can't be set on node of type: " + getReadableTypeString()); - } else { addComponent(component); @@ -466,10 +321,6 @@ void Node::addComponentStatic(std::shared_ptr component) // LOG_ERROR("TokenComponentStatic has been set before!"); return; } - else if (!isType(NODE_GLOBAL_VARIABLE | NODE_FIELD | NODE_FUNCTION | NODE_METHOD)) - { - LOG_ERROR("TokenComponentStatic can't be set on node of type: " + getReadableTypeString()); - } else { addComponent(component); @@ -483,10 +334,6 @@ void Node::addComponentFilePath(std::shared_ptr componen // LOG_ERROR("TokenComponentFilePath has been set before!"); return; } - else if (!isType(NODE_FILE)) - { - LOG_ERROR("TokenComponentFilePath can't be set on node of type: " + getReadableTypeString()); - } else { addComponent(component); @@ -508,7 +355,7 @@ void Node::addComponentAccess(std::shared_ptr component) std::string Node::getReadableTypeString() const { - return getReadableTypeString(m_type); + return m_type.getReadableTypeString(); } std::string Node::getAsString() const diff --git a/src/lib/data/graph/Node.h b/src/lib/data/graph/Node.h index 0fa5f36b..1fcd313f 100644 --- a/src/lib/data/graph/Node.h +++ b/src/lib/data/graph/Node.h @@ -9,6 +9,7 @@ #include "data/graph/Edge.h" #include "data/graph/Token.h" #include "data/name/NameHierarchy.h" +#include "data/NodeType.h" class TokenComponentAbstraction; class TokenComponentAccess; @@ -21,56 +22,13 @@ class Node : public Token { public: - typedef int NodeTypeMask; - enum NodeType : NodeTypeMask - { // make sure that the value of 0x0 is not used here because it doesn't work for bitmasking. - NODE_NON_INDEXED = 0x1, - NODE_TYPE = 0x2, - NODE_BUILTIN_TYPE = 0x4, - - NODE_NAMESPACE = 0x8, - NODE_PACKAGE = 0x10, - NODE_STRUCT = 0x20, - NODE_CLASS = 0x40, - NODE_INTERFACE = 0x80, - NODE_GLOBAL_VARIABLE = 0x100, - NODE_FIELD = 0x200, - NODE_FUNCTION = 0x400, - NODE_METHOD = 0x800, - - NODE_ENUM = 0x1000, - NODE_ENUM_CONSTANT = 0x2000, - NODE_TYPEDEF = 0x4000, - NODE_TEMPLATE_PARAMETER_TYPE = 0x8000, - NODE_TYPE_PARAMETER = 0x10000, - - NODE_FILE = 0x20000, - NODE_MACRO = 0x40000, - NODE_UNION = 0x80000, - - NODE_MAX_VALUE = NODE_UNION - }; - - static std::string getUnderscoredTypeString(NodeType type); - static std::string getReadableTypeString(NodeType type); - static Node::NodeType getTypeForReadableTypeString(const std::string str); - - static int typeToInt(NodeType type); - static NodeType intToType(int value); - - static const NodeTypeMask NODE_NOT_VISIBLE; - static const NodeTypeMask NODE_USEABLE_TYPE; - static const NodeTypeMask NODE_INHERITABLE_TYPE; - static const NodeTypeMask NODE_MEMBER_TYPE; - static const NodeTypeMask NODE_COLLAPSIBLE_TYPE; - Node(Id id, NodeType type, NameHierarchy nameHierarchy, bool defined); Node(const Node& other); virtual ~Node(); NodeType getType() const; void setType(NodeType type); - bool isType(NodeTypeMask mask) const; + bool isType(NodeType::TypeMask mask) const; std::string getName() const; std::string getFullName() const; @@ -98,12 +56,12 @@ public: Edge* getMemberEdge() const; Edge* findEdge(std::function func) const; - Edge* findEdgeOfType(Edge::EdgeTypeMask mask) const; - Edge* findEdgeOfType(Edge::EdgeTypeMask mask, std::function func) const; + Edge* findEdgeOfType(Edge::TypeMask mask) const; + Edge* findEdgeOfType(Edge::TypeMask mask, std::function func) const; Node* findChildNode(std::function func) const; void forEachEdge(std::function func) const; - void forEachEdgeOfType(Edge::EdgeTypeMask mask, std::function func) const; + void forEachEdgeOfType(Edge::TypeMask mask, std::function func) const; void forEachChildNode(std::function func) const; void forEachNodeRecursive(std::function func) const; @@ -116,7 +74,6 @@ public: void addComponentConst(std::shared_ptr component); void addComponentStatic(std::shared_ptr component); void addComponentFilePath(std::shared_ptr component); - void addComponentSignature(std::shared_ptr component); void addComponentAccess(std::shared_ptr component); // Logging. diff --git a/src/lib/data/parser/ParserClientImpl.cpp b/src/lib/data/parser/ParserClientImpl.cpp index 87a0e04b..fb41749b 100644 --- a/src/lib/data/parser/ParserClientImpl.cpp +++ b/src/lib/data/parser/ParserClientImpl.cpp @@ -69,7 +69,7 @@ void ParserClientImpl::recordReference( void ParserClientImpl::recordQualifierLocation(const NameHierarchy& qualifierName, const ParseLocation& location) { - Id nodeId = addNodeHierarchy(qualifierName, Node::NODE_NON_INDEXED); + Id nodeId = addNodeHierarchy(qualifierName, NodeType::NODE_NON_INDEXED); addSourceLocation(nodeId, location, locationTypeToInt(LOCATION_QUALIFIER)); } @@ -81,7 +81,7 @@ void ParserClientImpl::recordLocalSymbol(const std::string& name, const ParseLoc void ParserClientImpl::recordFile(const FileInfo& fileInfo) { - const Id nodeId = addNodeHierarchy(NameHierarchy(fileInfo.path.str(), NAME_DELIMITER_FILE), Node::NODE_FILE); + const Id nodeId = addNodeHierarchy(NameHierarchy(fileInfo.path.str(), NAME_DELIMITER_FILE), NodeType::NODE_FILE); addFile(nodeId, fileInfo.path, fileInfo.lastWriteTime.toString()); } @@ -99,48 +99,48 @@ void ParserClientImpl::doRecordError( } } -Node::NodeType ParserClientImpl::symbolKindToNodeType(SymbolKind symbolKind) const +NodeType ParserClientImpl::symbolKindToNodeType(SymbolKind symbolKind) const { switch (symbolKind) { case SYMBOL_BUILTIN_TYPE: - return Node::NODE_BUILTIN_TYPE; + return NodeType::NODE_BUILTIN_TYPE; case SYMBOL_CLASS: - return Node::NODE_CLASS; + return NodeType::NODE_CLASS; case SYMBOL_ENUM: - return Node::NODE_ENUM; + return NodeType::NODE_ENUM; case SYMBOL_ENUM_CONSTANT: - return Node::NODE_ENUM_CONSTANT; + return NodeType::NODE_ENUM_CONSTANT; case SYMBOL_FIELD: - return Node::NODE_FIELD; + return NodeType::NODE_FIELD; case SYMBOL_FUNCTION: - return Node::NODE_FUNCTION; + return NodeType::NODE_FUNCTION; case SYMBOL_GLOBAL_VARIABLE: - return Node::NODE_GLOBAL_VARIABLE; + return NodeType::NODE_GLOBAL_VARIABLE; case SYMBOL_INTERFACE: - return Node::NODE_INTERFACE; + return NodeType::NODE_INTERFACE; case SYMBOL_MACRO: - return Node::NODE_MACRO; + return NodeType::NODE_MACRO; case SYMBOL_METHOD: - return Node::NODE_METHOD; + return NodeType::NODE_METHOD; case SYMBOL_NAMESPACE: - return Node::NODE_NAMESPACE; + return NodeType::NODE_NAMESPACE; case SYMBOL_PACKAGE: - return Node::NODE_PACKAGE; + return NodeType::NODE_PACKAGE; case SYMBOL_STRUCT: - return Node::NODE_STRUCT; + return NodeType::NODE_STRUCT; case SYMBOL_TEMPLATE_PARAMETER: - return Node::NODE_TEMPLATE_PARAMETER_TYPE; + return NodeType::NODE_TEMPLATE_PARAMETER_TYPE; case SYMBOL_TYPEDEF: - return Node::NODE_TYPEDEF; + return NodeType::NODE_TYPEDEF; case SYMBOL_TYPE_PARAMETER: - return Node::NODE_TYPE_PARAMETER; + return NodeType::NODE_TYPE_PARAMETER; case SYMBOL_UNION: - return Node::NODE_UNION; + return NodeType::NODE_UNION; default: break; } - return Node::NODE_NON_INDEXED; + return NodeType::NODE_NON_INDEXED; } Edge::EdgeType ParserClientImpl::referenceKindToEdgeType(ReferenceKind referenceKind) const @@ -187,7 +187,7 @@ void ParserClientImpl::addAccess(Id nodeId, AccessKind access) } } -Id ParserClientImpl::addNodeHierarchy(NameHierarchy nameHierarchy, Node::NodeType nodeType) +Id ParserClientImpl::addNodeHierarchy(NameHierarchy nameHierarchy, NodeType nodeType) { if (nameHierarchy.size() == 0) { @@ -201,7 +201,7 @@ Id ParserClientImpl::addNodeHierarchy(NameHierarchy nameHierarchy, Node::NodeTyp { currentNameHierarchy.push(nameHierarchy[i]); const bool currentIsLastElement = (i == nameHierarchy.size() - 1); - const Node::NodeType currentType = (currentIsLastElement ? nodeType : Node::NODE_NON_INDEXED); // TODO: rename to unknown! + const NodeType currentType = (currentIsLastElement ? nodeType : NodeType::NODE_NON_INDEXED); // TODO: rename to unknown! Id nodeId = addNode(currentType, currentNameHierarchy); @@ -215,14 +215,14 @@ Id ParserClientImpl::addNodeHierarchy(NameHierarchy nameHierarchy, Node::NodeTyp return parentNodeId; } -Id ParserClientImpl::addNode(Node::NodeType nodeType, NameHierarchy nameHierarchy) +Id ParserClientImpl::addNode(NodeType nodeType, NameHierarchy nameHierarchy) { if (!m_storage) { return 0; } - return m_storage->addNode(StorageNodeData(Node::typeToInt(nodeType), NameHierarchy::serialize(nameHierarchy))); + return m_storage->addNode(StorageNodeData(utility::nodeTypeToInt(nodeType.getType()), NameHierarchy::serialize(nameHierarchy))); } void ParserClientImpl::addFile(Id id, const FilePath& filePath, const std::string& modificationTime) @@ -292,7 +292,7 @@ void ParserClientImpl::addSourceLocation(Id elementId, const ParseLocation& loca } Id sourceLocationId = m_storage->addSourceLocation(StorageSourceLocationData( - addNodeHierarchy(NameHierarchy(location.filePath.str(), NAME_DELIMITER_FILE), Node::NODE_FILE), + addNodeHierarchy(NameHierarchy(location.filePath.str(), NAME_DELIMITER_FILE), NodeType::NODE_FILE), location.startLineNumber, location.startColumnNumber, location.endLineNumber, @@ -324,7 +324,7 @@ void ParserClientImpl::addCommentLocation(const ParseLocation& location) } m_storage->addCommentLocation(StorageCommentLocationData( - addNodeHierarchy(NameHierarchy(location.filePath.str(), NAME_DELIMITER_FILE), Node::NODE_FILE), + addNodeHierarchy(NameHierarchy(location.filePath.str(), NAME_DELIMITER_FILE), NodeType::NODE_FILE), location.startLineNumber, location.startColumnNumber, location.endLineNumber, diff --git a/src/lib/data/parser/ParserClientImpl.h b/src/lib/data/parser/ParserClientImpl.h index 63bbb2e9..07fb05d2 100644 --- a/src/lib/data/parser/ParserClientImpl.h +++ b/src/lib/data/parser/ParserClientImpl.h @@ -47,12 +47,12 @@ private: virtual void doRecordError(const ParseLocation& location, const std::string& message, const std::string& commandline, bool fatal, bool indexed) override; - Node::NodeType symbolKindToNodeType(SymbolKind symbolType) const; + NodeType symbolKindToNodeType(SymbolKind symbolType) const; Edge::EdgeType referenceKindToEdgeType(ReferenceKind referenceKind) const; void addAccess(Id nodeId, AccessKind access); - Id addNodeHierarchy(NameHierarchy nameHierarchy, Node::NodeType nodeType = Node::NODE_NON_INDEXED); + Id addNodeHierarchy(NameHierarchy nameHierarchy, NodeType nodeType = NodeType::NODE_NON_INDEXED); - Id addNode(Node::NodeType nodeType, NameHierarchy nameHierarchy); + Id addNode(NodeType nodeType, NameHierarchy nameHierarchy); void addFile(Id id, const FilePath& filePath, const std::string& modificationTime); void addSymbol(Id id, DefinitionKind definitionKind); Id addEdge(int type, Id sourceId, Id targetId); diff --git a/src/lib/data/search/SearchIndex.cpp b/src/lib/data/search/SearchIndex.cpp index 52c57942..aa2e3a91 100644 --- a/src/lib/data/search/SearchIndex.cpp +++ b/src/lib/data/search/SearchIndex.cpp @@ -16,7 +16,7 @@ SearchIndex::~SearchIndex() { } -void SearchIndex::addNode(Id id, const std::string& name, Node::NodeTypeMask type) +void SearchIndex::addNode(Id id, const std::string& name, NodeType::TypeMask type) { SearchNode* currentNode = m_root; @@ -100,7 +100,7 @@ void SearchIndex::clear() } std::vector SearchIndex::search( - const std::string& query, Node::NodeTypeMask filter, size_t maxResultCount, size_t maxBestScoredResultsLength) const + const std::string& query, NodeType::TypeMask filter, size_t maxResultCount, size_t maxBestScoredResultsLength) const { // find paths containing query SearchPath startPath; @@ -147,7 +147,7 @@ void SearchIndex::populateEdgeGate(SearchEdge* e) } void SearchIndex::searchRecursive( - const SearchPath& path, const std::string& remainingQuery, Node::NodeTypeMask filter, + const SearchPath& path, const std::string& remainingQuery, NodeType::TypeMask filter, std::vector* results) const { if (remainingQuery.size() == 0 && (!filter || (path.node->mask & filter))) @@ -197,7 +197,7 @@ void SearchIndex::searchRecursive( } std::multiset SearchIndex::createScoredResults( - const std::vector& paths, Node::NodeTypeMask filter, size_t maxResultCount) const + const std::vector& paths, NodeType::TypeMask filter, size_t maxResultCount) const { // score and order initial paths std::multimap> scoredPaths; diff --git a/src/lib/data/search/SearchIndex.h b/src/lib/data/search/SearchIndex.h index 02d3b428..f6951b7c 100644 --- a/src/lib/data/search/SearchIndex.h +++ b/src/lib/data/search/SearchIndex.h @@ -30,13 +30,13 @@ public: SearchIndex(); virtual ~SearchIndex(); - void addNode(Id id, const std::string& name, Node::NodeTypeMask type = 0); + void addNode(Id id, const std::string& name, NodeType::TypeMask type = 0); void finishSetup(); void clear(); // maxResultCount == 0 means "no restriction". std::vector search( - const std::string& query, Node::NodeTypeMask filter, size_t maxResultCount, size_t maxBestScoredResultsLength = 0) const; + const std::string& query, NodeType::TypeMask filter, size_t maxResultCount, size_t maxBestScoredResultsLength = 0) const; private: struct SearchEdge; @@ -44,7 +44,7 @@ private: struct SearchNode { std::set elementIds; - Node::NodeTypeMask mask = 0; + NodeType::TypeMask mask = 0; std::map edges; }; @@ -63,11 +63,11 @@ private: }; void populateEdgeGate(SearchEdge* e); - void searchRecursive(const SearchPath& path, const std::string& remainingQuery, Node::NodeTypeMask filter, + void searchRecursive(const SearchPath& path, const std::string& remainingQuery, NodeType::TypeMask filter, std::vector* results) const; std::multiset createScoredResults( - const std::vector& paths, Node::NodeTypeMask filter, size_t maxResultCount) const; + const std::vector& paths, NodeType::TypeMask filter, size_t maxResultCount) const; static SearchResult bestScoredResult( SearchResult result, std::map* scoresCache, size_t maxBestScoredResultsLength); diff --git a/src/lib/data/search/SearchMatch.cpp b/src/lib/data/search/SearchMatch.cpp index b311d677..7bc3073d 100644 --- a/src/lib/data/search/SearchMatch.cpp +++ b/src/lib/data/search/SearchMatch.cpp @@ -56,20 +56,20 @@ SearchMatch SearchMatch::createCommand(CommandType type) return match; } -std::vector SearchMatch::createCommandsForFilter(Node::NodeTypeMask filter) +std::vector SearchMatch::createCommandsForFilter(NodeType::TypeMask filter) { std::vector matches; - for (Node::NodeTypeMask type = 1; type <= filter; type *= 2) + for (NodeType::TypeMask type = 1; type <= filter; type *= 2) { if (type & filter) { SearchMatch match; - match.name = Node::getReadableTypeString(Node::intToType(type)); + match.name = NodeType(utility::intToType(type)).getReadableTypeString(); match.text = match.name; match.typeName = "filter"; match.searchType = SEARCH_COMMAND; - match.nodeType = Node::intToType(type); + match.nodeType = NodeType(utility::intToType(type)); matches.push_back(match); } } @@ -96,7 +96,7 @@ std::string SearchMatch::getCommandName(CommandType type) SearchMatch::SearchMatch() : typeName("") - , nodeType(Node::NODE_NON_INDEXED) + , nodeType(NodeType::NODE_NON_INDEXED) , searchType(SEARCH_NONE) , hasChildren(false) { @@ -106,7 +106,7 @@ SearchMatch::SearchMatch(const std::string& query) : name(query) , text(query) , typeName("") - , nodeType(Node::NODE_NON_INDEXED) + , nodeType(NodeType::NODE_NON_INDEXED) , searchType(SEARCH_NONE) , hasChildren(false) { @@ -224,7 +224,7 @@ void SearchMatch::print(std::ostream& ostream) const std::string SearchMatch::getFullName() const { - if (searchType == SEARCH_TOKEN && nodeType == Node::NODE_FILE) + if (searchType == SEARCH_TOKEN && nodeType.getType() == NodeType::NODE_FILE) { return text; } @@ -234,7 +234,7 @@ std::string SearchMatch::getFullName() const std::string SearchMatch::getNodeTypeAsUnderscoredString() const { - return Node::getUnderscoredTypeString(nodeType); + return nodeType.getUnderscoredTypeString(); } std::string SearchMatch::getSearchTypeName() const diff --git a/src/lib/data/search/SearchMatch.h b/src/lib/data/search/SearchMatch.h index eb7237fb..bf54f06d 100644 --- a/src/lib/data/search/SearchMatch.h +++ b/src/lib/data/search/SearchMatch.h @@ -34,7 +34,7 @@ struct SearchMatch static std::string searchMatchesToString(const std::vector& matches); static SearchMatch createCommand(CommandType type); - static std::vector createCommandsForFilter(Node::NodeTypeMask filter); + static std::vector createCommandsForFilter(NodeType::TypeMask filter); static std::string getCommandName(CommandType type); static const char FULLTEXT_SEARCH_CHARACTER = '?'; @@ -67,7 +67,7 @@ struct SearchMatch std::string typeName; - Node::NodeType nodeType; + NodeType nodeType; SearchType searchType; std::vector indices; diff --git a/src/lib/data/storage/PersistentStorage.cpp b/src/lib/data/storage/PersistentStorage.cpp index 68b0cdf3..078a6a92 100644 --- a/src/lib/data/storage/PersistentStorage.cpp +++ b/src/lib/data/storage/PersistentStorage.cpp @@ -32,26 +32,26 @@ PersistentStorage::PersistentStorage(const FilePath& dbPath, const FilePath& boo m_commandIndex.addNode(0, SearchMatch::getCommandName(SearchMatch::COMMAND_ALL)); m_commandIndex.addNode(0, SearchMatch::getCommandName(SearchMatch::COMMAND_ERROR)); - // m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_NON_INDEXED)); - // m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_TYPE)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_BUILTIN_TYPE)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_NAMESPACE)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_PACKAGE)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_STRUCT)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_CLASS)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_INTERFACE)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_GLOBAL_VARIABLE)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_FIELD)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_FUNCTION)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_METHOD)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_ENUM)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_ENUM_CONSTANT)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_TYPEDEF)); - // m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_TEMPLATE_PARAMETER_TYPE)); - // m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_TYPE_PARAMETER)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_FILE)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_MACRO)); - m_commandIndex.addNode(0, Node::getReadableTypeString(Node::NODE_UNION)); + // m_commandIndex.addNode(0, NodeType(NodeType::NODE_NON_INDEXED).getReadableTypeString()); + // m_commandIndex.addNode(0, NodeType(NodeType::NODE_TYPE).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_BUILTIN_TYPE).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_NAMESPACE).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_PACKAGE).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_STRUCT).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_CLASS).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_INTERFACE).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_GLOBAL_VARIABLE).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_FIELD).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_FUNCTION).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_METHOD).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_ENUM).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_ENUM_CONSTANT).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_TYPEDEF).getReadableTypeString()); + // m_commandIndex.addNode(0, NodeType(NodeType::NODE_TEMPLATE_PARAMETER_TYPE).getReadableTypeString()); + // m_commandIndex.addNode(0, NodeType(NodeType::NODE_TYPE_PARAMETER).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_FILE).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_MACRO).getReadableTypeString()); + m_commandIndex.addNode(0, NodeType(NodeType::NODE_UNION).getReadableTypeString()); // m_commandIndex.addNode(0, SearchMatch::getCommandName(SearchMatch::COMMAND_COLOR_SCHEME_TEST)); @@ -440,9 +440,9 @@ std::vector PersistentStorage::getNameHierarchiesForNodeIds(const return nameHierarchies; } -Node::NodeType PersistentStorage::getNodeTypeForNodeWithId(Id nodeId) const +NodeType PersistentStorage::getNodeTypeForNodeWithId(Id nodeId) const { - return Node::intToType(m_sqliteIndexStorage.getFirstById(nodeId).type); + return utility::intToType(m_sqliteIndexStorage.getFirstById(nodeId).type); } Id PersistentStorage::getIdForEdge( @@ -558,7 +558,7 @@ std::shared_ptr PersistentStorage::getFullTextSearchLo return collection; } -std::vector PersistentStorage::getAutocompletionMatches(const std::string& query, Node::NodeTypeMask filter) const +std::vector PersistentStorage::getAutocompletionMatches(const std::string& query, NodeType::TypeMask filter) const { TRACE(); @@ -569,12 +569,12 @@ std::vector PersistentStorage::getAutocompletionMatches(const std:: // create SearchMatches std::vector matches; - if (!filter || (filter & ~Node::NODE_FILE)) + if (!filter || (filter & ~NodeType::NODE_FILE)) { utility::append(matches, getAutocompletionSymbolMatches(query, filter, maxResultsCount, maxBestScoredResultsLength)); } - if (!filter || (filter & Node::NODE_FILE)) + if (!filter || (filter & NodeType::NODE_FILE)) { utility::append(matches, getAutocompletionFileMatches(query, maxResultsCount)); } @@ -606,7 +606,7 @@ std::vector PersistentStorage::getAutocompletionMatches(const std:: } std::vector PersistentStorage::getAutocompletionSymbolMatches( - const std::string& query, Node::NodeTypeMask filter, size_t maxResultsCount, size_t maxBestScoredResultsLength) const + const std::string& query, NodeType::TypeMask filter, size_t maxResultsCount, size_t maxBestScoredResultsLength) const { // search in indices std::vector results = @@ -674,12 +674,12 @@ std::vector PersistentStorage::getAutocompletionSymbolMatches( match.indices = result.indices; match.score = result.score; - match.nodeType = Node::intToType(firstNode->type); - match.typeName = Node::getReadableTypeString(match.nodeType); + match.nodeType = utility::intToType(firstNode->type); + match.typeName = match.nodeType.getReadableTypeString(); match.searchType = SearchMatch::SEARCH_TOKEN; if (storageSymbolMap.find(firstNode->id) == storageSymbolMap.end() && - match.nodeType != Node::NODE_NON_INDEXED) + match.nodeType.getType() != NodeType::NODE_NON_INDEXED) { match.typeName = "non-indexed " + match.typeName; } @@ -692,7 +692,7 @@ std::vector PersistentStorage::getAutocompletionSymbolMatches( std::vector PersistentStorage::getAutocompletionFileMatches(const std::string& query, size_t maxResultsCount) const { - std::vector results = m_fileIndex.search(query, Node::NODE_FILE, maxResultsCount, 100); + std::vector results = m_fileIndex.search(query, NodeType::NODE_FILE, maxResultsCount, 100); // create SearchMatches std::vector matches; @@ -712,8 +712,8 @@ std::vector PersistentStorage::getAutocompletionFileMatches(const s match.indices = result.indices; match.score = result.score; - match.nodeType = Node::NODE_FILE; - match.typeName = Node::getReadableTypeString(match.nodeType); + match.nodeType = NodeType::NODE_FILE; + match.typeName = match.nodeType.getReadableTypeString(); match.searchType = SearchMatch::SEARCH_TOKEN; @@ -724,7 +724,7 @@ std::vector PersistentStorage::getAutocompletionFileMatches(const s } std::vector PersistentStorage::getAutocompletionCommandMatches( - const std::string& query, Node::NodeTypeMask filter) const + const std::string& query, NodeType::TypeMask filter) const { // search in indices std::vector results = m_commandIndex.search(query, 0, 0); @@ -748,11 +748,11 @@ std::vector PersistentStorage::getAutocompletionCommandMatches( if (match.getCommandType() == SearchMatch::COMMAND_NODE_FILTER) { - match.nodeType = Node::getTypeForReadableTypeString(match.name); + match.nodeType = utility::getTypeForReadableTypeString(match.name); match.typeName = "filter"; } - if (!filter || (match.getCommandType() == SearchMatch::COMMAND_NODE_FILTER && !(filter & match.nodeType))) + if (!filter || (match.getCommandType() == SearchMatch::COMMAND_NODE_FILTER && !(filter & match.nodeType.getType()))) { matches.push_back(match); } @@ -791,12 +791,12 @@ std::vector PersistentStorage::getSearchMatchesForTokenIds(const st match.text = nameHierarchy.getRawName(); match.tokenIds.push_back(elementId); - match.nodeType = Node::intToType(node.type); + match.nodeType = utility::intToType(node.type); match.searchType = SearchMatch::SEARCH_TOKEN; match.delimiter = nameHierarchy.getDelimiter(); - if (match.nodeType == Node::NODE_FILE) + if (match.nodeType.getType() == NodeType::NODE_FILE) { match.text = FilePath(match.text).fileName(); } @@ -819,7 +819,7 @@ std::shared_ptr PersistentStorage::getGraphForAll() const auto it = m_symbolDefinitionKinds.find(node.id); if (it != m_symbolDefinitionKinds.end() && it->second == DEFINITION_EXPLICIT && ( - Node::intToType(node.type) & (Node::NODE_NAMESPACE | Node::NODE_PACKAGE) || + utility::intToType(node.type) & (NodeType::NODE_NAMESPACE | NodeType::NODE_PACKAGE) || !m_hierarchyCache.isChildOfVisibleNodeOrInvisible(node.id) ) ){ @@ -837,7 +837,7 @@ std::shared_ptr PersistentStorage::getGraphForAll() const return graph; } -std::shared_ptr PersistentStorage::getGraphForFilter(Node::NodeTypeMask filter) const +std::shared_ptr PersistentStorage::getGraphForFilter(NodeType::TypeMask filter) const { TRACE(); @@ -846,7 +846,7 @@ std::shared_ptr PersistentStorage::getGraphForFilter(Node::NodeTypeMask f std::vector tokenIds; for (StorageNode& node: m_sqliteIndexStorage.getAll()) { - if ((filter & Node::intToType(node.type))) + if ((filter & utility::intToType(node.type))) { auto it = m_symbolDefinitionKinds.find(node.id); if (it != m_symbolDefinitionKinds.end() && it->second == DEFINITION_EXPLICIT) @@ -856,7 +856,7 @@ std::shared_ptr PersistentStorage::getGraphForFilter(Node::NodeTypeMask f } } - if (!filter || (filter & Node::NODE_FILE)) + if (!filter || (filter & NodeType::NODE_FILE)) { for (const auto& p : m_fileNodePaths) { @@ -890,8 +890,8 @@ std::shared_ptr PersistentStorage::getGraphForActiveTokenIds( if (node.id > 0) { - Node::NodeType nodeType = Node::intToType(node.type); - if (nodeType & (Node::NODE_NAMESPACE | Node::NODE_PACKAGE)) + NodeType nodeType = utility::intToType(node.type); + if (nodeType.getType() & (NodeType::NODE_NAMESPACE | NodeType::NODE_PACKAGE)) { ids.clear(); m_hierarchyCache.addFirstChildIdsForNodeId(elementId, &ids, &edgeIds); @@ -904,7 +904,7 @@ std::shared_ptr PersistentStorage::getGraphForActiveTokenIds( m_hierarchyCache.addFirstChildIdsForNodeId(elementId, &nodeIds, &edgeIds); // don't expand active node if it has more than 20 child nodes - if (nodeIds.size() > 20 && nodeType & Node::NODE_COLLAPSIBLE_TYPE) + if (nodeIds.size() > 20 && nodeType.isCollapsible()) { nodeIds.clear(); } @@ -921,7 +921,7 @@ std::shared_ptr PersistentStorage::getGraphForActiveTokenIds( continue; } - if ((nodeType & Node::NODE_USEABLE_TYPE) && (edgeType & Edge::EDGE_TYPE_USAGE) && + if (nodeType.isUsable() && (edgeType & Edge::EDGE_TYPE_USAGE) && m_hierarchyCache.isChildOfVisibleNodeOrInvisible(edge.sourceNodeId) && (m_hierarchyCache.getLastVisibleParentNodeId(edge.targetNodeId) != m_hierarchyCache.getLastVisibleParentNodeId(edge.sourceNodeId))) @@ -1046,7 +1046,7 @@ std::shared_ptr PersistentStorage::getGraphForChildrenOfNodeId(Id nodeId) } std::shared_ptr PersistentStorage::getGraphForTrail( - Id originId, Id targetId, Edge::EdgeTypeMask trailType, size_t depth) const + Id originId, Id targetId, Edge::TypeMask trailType, size_t depth) const { TRACE(); @@ -1212,7 +1212,7 @@ std::shared_ptr PersistentStorage::getSourceLocationsF if (path.empty() && m_symbolDefinitionKinds.find(tokenId) == m_symbolDefinitionKinds.end()) { StorageNode fileNode = m_sqliteIndexStorage.getNodeById(tokenId); - if (Node::intToType(fileNode.type) == Node::NODE_FILE) + if (utility::intToType(fileNode.type) == NodeType::NODE_FILE) { path = FilePath(NameHierarchy::deserialize(fileNode.serializedName).getQualifiedName()); } @@ -1705,8 +1705,8 @@ TooltipInfo PersistentStorage::getTooltipInfoForTokenIds(const std::vector& return info; } - Node::NodeType type = Node::intToType(node.type); - info.title = Node::getReadableTypeString(type); + NodeType type = utility::intToType(node.type); + info.title = type.getReadableTypeString(); DefinitionKind defKind = DEFINITION_NONE; StorageSymbol symbol = m_sqliteIndexStorage.getFirstById(node.id); @@ -1715,7 +1715,7 @@ TooltipInfo PersistentStorage::getTooltipInfoForTokenIds(const std::vector& defKind = intToDefinitionKind(symbol.definitionKind); } - if (type & Node::NODE_MEMBER_TYPE) + if (type.isPotentialMember()) { StorageComponentAccess access = m_sqliteIndexStorage.getComponentAccessByNodeId(node.id); if (access.nodeId != 0) @@ -1724,7 +1724,7 @@ TooltipInfo PersistentStorage::getTooltipInfoForTokenIds(const std::vector& } } - if (type == Node::NODE_FILE && m_fileNodePaths.find(node.id) != m_fileNodePaths.end()) + if (type.getType() == NodeType::NODE_FILE && m_fileNodePaths.find(node.id) != m_fileNodePaths.end()) { bool complete = false; auto it = m_fileNodeComplete.find(node.id); @@ -1738,7 +1738,7 @@ TooltipInfo PersistentStorage::getTooltipInfoForTokenIds(const std::vector& info.title = "incomplete " + info.title; } } - else if (defKind == DEFINITION_NONE && type != Node::NODE_NON_INDEXED) + else if (defKind == DEFINITION_NONE && type.getType() != NodeType::NODE_NON_INDEXED) { info.title = "non-indexed " + info.title; } @@ -1781,7 +1781,7 @@ TooltipSnippet PersistentStorage::getTooltipSnippetForNode(const StorageNode& no snippet.locationFile = std::make_shared( FilePath(nameHierarchy.getDelimiter() == NAME_DELIMITER_JAVA ? "main.java" : "main.cpp"), true, true); - if (Node::intToType(node.type) & (Node::NODE_FUNCTION | Node::NODE_METHOD | Node::NODE_FIELD | Node::NODE_GLOBAL_VARIABLE)) + if (utility::intToType(node.type) & (NodeType::NODE_FUNCTION | NodeType::NODE_METHOD | NodeType::NODE_FIELD | NodeType::NODE_GLOBAL_VARIABLE)) { snippet.code = utility::breakSignature( nameHierarchy.getSignature().getPrefix(), @@ -1892,7 +1892,7 @@ TooltipInfo PersistentStorage::getTooltipInfoForSourceLocationIdsAndLocalSymbolI snippet.locationFile->addSourceLocation( LOCATION_TOKEN, 0, std::vector(1, node.id), 1, 1, 1, snippet.code.size()); - if (Node::intToType(node.type) & (Node::NODE_METHOD | Node::NODE_FUNCTION)) + if (utility::intToType(node.type) & (NodeType::NODE_METHOD | NodeType::NODE_FUNCTION)) { snippet.code += "()"; } @@ -2170,8 +2170,8 @@ void PersistentStorage::addNodesToGraph(const std::vector& newNodeIds, Graph for (const StorageNode& storageNode : m_sqliteIndexStorage.getAllByIds(nodeIds)) { - const Node::NodeType type = Node::intToType(storageNode.type); - if (type == Node::NODE_FILE) + const NodeType type(utility::intToType(storageNode.type)); + if (type.getType() == NodeType::NODE_FILE) { const FilePath filePath(NameHierarchy::deserialize(storageNode.serializedName).getRawName()); @@ -2184,7 +2184,7 @@ void PersistentStorage::addNodesToGraph(const std::vector& newNodeIds, Graph Node* node = graph->createNode( storageNode.id, - Node::NODE_FILE, + type, NameHierarchy(filePath.fileName(), NAME_DELIMITER_FILE), defined ); @@ -2452,7 +2452,7 @@ void PersistentStorage::addInheritanceChainsToGraph(const std::vector& activ for (Id nodeId : visibleParentIds) { Node* node = graph->getNodeById(nodeId); - if (node && node->isType(Node::NODE_INHERITABLE_TYPE)) + if (node && node->getType().isInheritable()) { activeNodeIdsSet.insert(node->getId()); } @@ -2463,7 +2463,7 @@ void PersistentStorage::addInheritanceChainsToGraph(const std::vector& activ graph->forEachNode( [&nodeIdsSet, &activeNodeIdsSet](Node* node) { - if (node->isType(Node::NODE_INHERITABLE_TYPE) && activeNodeIdsSet.find(node->getId()) == activeNodeIdsSet.end()) + if (node->getType().isInheritable() && activeNodeIdsSet.find(node->getId()) == activeNodeIdsSet.end()) { nodeIdsSet.insert(node->getId()); } @@ -2536,8 +2536,8 @@ void PersistentStorage::buildSearchIndex() for (StorageNode& node : m_sqliteIndexStorage.getAll()) { - Node::NodeType type = Node::intToType(node.type); - if (type == Node::NODE_FILE) + NodeType::Type type = utility::intToType(node.type); + if (type == NodeType::NODE_FILE) { auto it = m_fileNodePaths.find(node.id); if (it != m_fileNodePaths.end()) @@ -2549,7 +2549,7 @@ void PersistentStorage::buildSearchIndex() filePath = filePath.relativeTo(dbPath); } - m_fileIndex.addNode(node.id, filePath.str(), type); + m_fileIndex.addNode(node.id, filePath.str(), node.type); } } else @@ -2570,7 +2570,7 @@ void PersistentStorage::buildSearchIndex() name = utility::replaceBetween(name, '<', '>', ".."); } - m_symbolIndex.addNode(node.id, name, type); + m_symbolIndex.addNode(node.id, name, node.type); } } } @@ -2676,15 +2676,22 @@ void PersistentStorage::buildHierarchyCache() std::vector sourceNodes = m_sqliteIndexStorage.getAllByIds(sourceNodeIds); - std::map sourceNodeTypeMap; + std::map sourceNodeTypeMap; for (const StorageNode& node : sourceNodes) { - sourceNodeTypeMap.emplace(node.id, Node::intToType(node.type)); + sourceNodeTypeMap.emplace(node.id, utility::intToType(node.type)); } for (const StorageEdge& edge : memberEdges) { - bool sourceIsVisible = !(sourceNodeTypeMap[edge.sourceNodeId] & Node::NODE_NOT_VISIBLE); + bool sourceIsVisible = true; + { + std::map::const_iterator it = sourceNodeTypeMap.find(edge.sourceNodeId); + if (it != sourceNodeTypeMap.end()) + { + sourceIsVisible = it->second.isVisibleAsParentInGraph(); + } + } bool sourceIsImplicit = false; auto it = m_symbolDefinitionKinds.find(edge.sourceNodeId); diff --git a/src/lib/data/storage/PersistentStorage.h b/src/lib/data/storage/PersistentStorage.h index e35ffc63..17eae026 100644 --- a/src/lib/data/storage/PersistentStorage.h +++ b/src/lib/data/storage/PersistentStorage.h @@ -77,7 +77,7 @@ public: virtual NameHierarchy getNameHierarchyForNodeId(Id nodeId) const; virtual std::vector getNameHierarchiesForNodeIds(const std::vector& nodeIds) const; - virtual Node::NodeType getNodeTypeForNodeWithId(Id nodeId) const; + virtual NodeType getNodeTypeForNodeWithId(Id nodeId) const; virtual Id getIdForEdge( Edge::EdgeType type, const NameHierarchy& fromNameHierarchy, const NameHierarchy& toNameHierarchy) const; @@ -86,19 +86,19 @@ public: virtual std::shared_ptr getFullTextSearchLocations( const std::string& searchTerm, bool caseSensitive) const; - virtual std::vector getAutocompletionMatches(const std::string& query, Node::NodeTypeMask filter) const; + virtual std::vector getAutocompletionMatches(const std::string& query, NodeType::TypeMask filter) const; std::vector getAutocompletionSymbolMatches( - const std::string& query, Node::NodeTypeMask filter, size_t maxResultsCount, size_t maxBestScoredResultsLength) const; + const std::string& query, NodeType::TypeMask filter, size_t maxResultsCount, size_t maxBestScoredResultsLength) const; std::vector getAutocompletionFileMatches(const std::string& query, size_t maxResultsCount) const; - std::vector getAutocompletionCommandMatches(const std::string& query, Node::NodeTypeMask filter) const; + std::vector getAutocompletionCommandMatches(const std::string& query, NodeType::TypeMask filter) const; virtual std::vector getSearchMatchesForTokenIds(const std::vector& elementIds) const; virtual std::shared_ptr getGraphForAll() const; - virtual std::shared_ptr getGraphForFilter(Node::NodeTypeMask filter) const; + virtual std::shared_ptr getGraphForFilter(NodeType::TypeMask filter) const; virtual std::shared_ptr getGraphForActiveTokenIds( const std::vector& tokenIds, const std::vector& expandedNodeIds, bool* isActiveNamespace = nullptr) const; virtual std::shared_ptr getGraphForChildrenOfNodeId(Id nodeId) const; - virtual std::shared_ptr getGraphForTrail(Id originId, Id targetId, Edge::EdgeTypeMask trailType, size_t depth) const; + virtual std::shared_ptr getGraphForTrail(Id originId, Id targetId, Edge::TypeMask trailType, size_t depth) const; virtual std::vector getActiveTokenIdsForId(Id tokenId, Id* declarationId) const; virtual std::vector getNodeIdsForLocationIds(const std::vector& locationIds) const; diff --git a/src/lib/settings/ColorScheme.cpp b/src/lib/settings/ColorScheme.cpp index 18d3700b..9604ca7d 100644 --- a/src/lib/settings/ColorScheme.cpp +++ b/src/lib/settings/ColorScheme.cpp @@ -26,9 +26,9 @@ std::string ColorScheme::getColor(const std::string& key, const std::string& def return getValue(key, defaultColor); } -std::string ColorScheme::getNodeTypeColor(Node::NodeType type, const std::string& key, ColorState state) const +std::string ColorScheme::getNodeTypeColor(NodeType type, const std::string& key, ColorState state) const { - return getNodeTypeColor(Node::getUnderscoredTypeString(type), key, state); + return getNodeTypeColor(type.getUnderscoredTypeString(), key, state); } std::string ColorScheme::getNodeTypeColor(const std::string& typeStr, const std::string& key, ColorState state) const diff --git a/src/lib/settings/ColorScheme.h b/src/lib/settings/ColorScheme.h index f846ab30..237be017 100644 --- a/src/lib/settings/ColorScheme.h +++ b/src/lib/settings/ColorScheme.h @@ -22,7 +22,7 @@ public: std::string getColor(const std::string& key) const; std::string getColor(const std::string& key, const std::string& defaultColor) const; - std::string getNodeTypeColor(Node::NodeType type, const std::string& key, ColorState state) const; + std::string getNodeTypeColor(NodeType type, const std::string& key, ColorState state) const; std::string getNodeTypeColor(const std::string& typeStr, const std::string& key, ColorState state) const; std::string getEdgeTypeColor(Edge::EdgeType type, ColorState state) const; diff --git a/src/lib/utility/messaging/type/MessageActivateAll.h b/src/lib/utility/messaging/type/MessageActivateAll.h index 70f5a5ac..b0d56030 100644 --- a/src/lib/utility/messaging/type/MessageActivateAll.h +++ b/src/lib/utility/messaging/type/MessageActivateAll.h @@ -8,7 +8,7 @@ class MessageActivateAll : public Message { public: - MessageActivateAll(Node::NodeTypeMask filter = 0) + MessageActivateAll(NodeType::TypeMask filter = 0) : filter(filter) { setIsParallel(true); @@ -19,7 +19,7 @@ public: return "MessageActivateAll"; } - Node::NodeTypeMask filter; + NodeType::TypeMask filter; }; #endif // MESSAGE_ACTIVATE_ALL_H diff --git a/src/lib/utility/messaging/type/MessageActivateTrail.h b/src/lib/utility/messaging/type/MessageActivateTrail.h index 4ea1189c..d3c6d08f 100644 --- a/src/lib/utility/messaging/type/MessageActivateTrail.h +++ b/src/lib/utility/messaging/type/MessageActivateTrail.h @@ -8,7 +8,7 @@ class MessageActivateTrail : public Message { public: - MessageActivateTrail(Id originId, Id targetId, Edge::EdgeTypeMask trailType, size_t depth, bool horizontalLayout) + MessageActivateTrail(Id originId, Id targetId, Edge::TypeMask trailType, size_t depth, bool horizontalLayout) : originId(originId) , targetId(targetId) , trailType(trailType) @@ -24,7 +24,7 @@ public: const Id originId; const Id targetId; - const Edge::EdgeTypeMask trailType; + const Edge::TypeMask trailType; const size_t depth; const bool horizontalLayout; }; diff --git a/src/lib/utility/messaging/type/MessageSearch.h b/src/lib/utility/messaging/type/MessageSearch.h index 341a79df..9fa9c074 100644 --- a/src/lib/utility/messaging/type/MessageSearch.h +++ b/src/lib/utility/messaging/type/MessageSearch.h @@ -9,7 +9,7 @@ class MessageSearch : public Message { public: - MessageSearch(const std::vector& matches, Node::NodeTypeMask filter = 0) + MessageSearch(const std::vector& matches, NodeType::TypeMask filter = 0) : isFromSearch(true) , filter(filter) , m_matches(matches) @@ -28,7 +28,7 @@ public: for (size_t i = 0; i < m_matches.size(); i++) { ss << '@'; - if (m_matches[i].nodeType == Node::NODE_FILE) + if (m_matches[i].nodeType.getType() == NodeType::NODE_FILE) { ss << m_matches[i].subtext; } @@ -72,7 +72,7 @@ public: } bool isFromSearch; - Node::NodeTypeMask filter; + NodeType::TypeMask filter; private: const std::vector m_matches; diff --git a/src/lib/utility/messaging/type/MessageSearchAutocomplete.h b/src/lib/utility/messaging/type/MessageSearchAutocomplete.h index cb6b21dc..ce102d76 100644 --- a/src/lib/utility/messaging/type/MessageSearchAutocomplete.h +++ b/src/lib/utility/messaging/type/MessageSearchAutocomplete.h @@ -8,7 +8,7 @@ class MessageSearchAutocomplete : public Message { public: - MessageSearchAutocomplete(const std::string& query, Node::NodeTypeMask filter) + MessageSearchAutocomplete(const std::string& query, NodeType::TypeMask filter) : query(query) , filter(filter) { @@ -25,7 +25,7 @@ public: } const std::string query; - const Node::NodeTypeMask filter; + const NodeType::TypeMask filter; }; #endif // MESSAGE_SEARCH_AUTOCOMPLETE_H diff --git a/src/lib_cxx/data/storage/StorageTransformationAnonymousTypedef.cpp b/src/lib_cxx/data/storage/StorageTransformationAnonymousTypedef.cpp index 5a745dca..b407829a 100644 --- a/src/lib_cxx/data/storage/StorageTransformationAnonymousTypedef.cpp +++ b/src/lib_cxx/data/storage/StorageTransformationAnonymousTypedef.cpp @@ -30,12 +30,12 @@ void StorageTransformationAnonymousTypedef::transform(std::shared_ptr(node.id, node)); } - else if(nodeType & (Node::NODE_STRUCT | Node::NODE_CLASS | Node::NODE_ENUM | Node::NODE_UNION)) + else if(nodeType & (NodeType::NODE_STRUCT | NodeType::NODE_CLASS | NodeType::NODE_ENUM | NodeType::NODE_UNION)) { const NameHierarchy nameHierarchy = NameHierarchy::deserialize(node.serializedName); if (nameHierarchy.back() && utility::isPrefix("anonymous ", nameHierarchy.back()->getName())) diff --git a/src/lib_gui/qt/element/QtAutocompletionList.cpp b/src/lib_gui/qt/element/QtAutocompletionList.cpp index 300bad04..f16dfb33 100644 --- a/src/lib_gui/qt/element/QtAutocompletionList.cpp +++ b/src/lib_gui/qt/element/QtAutocompletionList.cpp @@ -64,7 +64,7 @@ QVariant QtAutocompletionModel::data(const QModelIndex &index, int role) const return indices; } case 5: - return match.nodeType; + return match.nodeType.getType(); default: return QVariant(); } @@ -140,7 +140,7 @@ void QtAutocompletionDelegate::paint(QPainter* painter, const QStyleOptionViewIt 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(); - Node::NodeType nodeType = static_cast(index.sibling(index.row(), index.column() + 5).data().toInt()); + NodeType nodeType = utility::intToType(index.sibling(index.row(), index.column() + 5).data().toInt()); // define highlight colors ColorScheme* scheme = ColorScheme::getInstance().get(); @@ -149,7 +149,7 @@ void QtAutocompletionDelegate::paint(QPainter* painter, const QStyleOptionViewIt if (type.size() && type != "command" && type != "filter") { - const GraphViewStyle::NodeColor& nodeColor = GraphViewStyle::getNodeColor(Node::getUnderscoredTypeString(nodeType), false); + const GraphViewStyle::NodeColor& nodeColor = GraphViewStyle::getNodeColor(nodeType.getUnderscoredTypeString(), false); fillColor = QColor(nodeColor.fill.c_str()); textColor = QColor(nodeColor.text.c_str()); } diff --git a/src/lib_gui/qt/element/QtHistoryList.cpp b/src/lib_gui/qt/element/QtHistoryList.cpp index f4dd80b3..023b10df 100644 --- a/src/lib_gui/qt/element/QtHistoryList.cpp +++ b/src/lib_gui/qt/element/QtHistoryList.cpp @@ -22,7 +22,7 @@ QtHistoryItem::QtHistoryItem(const SearchMatch& match, size_t index, bool isCurr layout->setContentsMargins(0, 0, 0, 0); layout->setAlignment(Qt::AlignTop); - std::string name = utility::elide(match.nodeType == Node::NODE_FILE ? match.text : match.name, utility::ELIDE_RIGHT, 100); + std::string name = utility::elide(match.nodeType.getType() == NodeType::NODE_FILE ? match.text : match.name, utility::ELIDE_RIGHT, 100); m_name = new QLabel(name.c_str(), this); m_name->setAttribute(Qt::WA_MacShowFocusRect, 0); @@ -43,8 +43,8 @@ QtHistoryItem::QtHistoryItem(const SearchMatch& match, size_t index, bool isCurr ColorScheme* scheme = ColorScheme::getInstance().get(); if (match.searchType == SearchMatch::SEARCH_TOKEN) { - m_indicatorColor = GraphViewStyle::getNodeColor(Node::getUnderscoredTypeString(match.nodeType), false).fill; - m_indicatorHoverColor = GraphViewStyle::getNodeColor(Node::getUnderscoredTypeString(match.nodeType), true).fill; + m_indicatorColor = GraphViewStyle::getNodeColor(match.nodeType.getUnderscoredTypeString(), false).fill; + m_indicatorHoverColor = GraphViewStyle::getNodeColor(match.nodeType.getUnderscoredTypeString(), true).fill; } else { diff --git a/src/lib_gui/qt/element/QtSmartSearchBox.cpp b/src/lib_gui/qt/element/QtSmartSearchBox.cpp index a02b0ae7..e47a2717 100644 --- a/src/lib_gui/qt/element/QtSmartSearchBox.cpp +++ b/src/lib_gui/qt/element/QtSmartSearchBox.cpp @@ -807,10 +807,10 @@ void QtSmartSearchBox::updateElements() if (match.searchType == SearchMatch::SEARCH_TOKEN) { - color = GraphViewStyle::getNodeColor(Node::getUnderscoredTypeString(match.nodeType), false).fill; - hoverColor = GraphViewStyle::getNodeColor(Node::getUnderscoredTypeString(match.nodeType), true).fill; - textColor = GraphViewStyle::getNodeColor(Node::getUnderscoredTypeString(match.nodeType), false).text; - textHoverColor = GraphViewStyle::getNodeColor(Node::getUnderscoredTypeString(match.nodeType), true).text; + color = GraphViewStyle::getNodeColor(match.nodeType.getUnderscoredTypeString(), false).fill; + hoverColor = GraphViewStyle::getNodeColor(match.nodeType.getUnderscoredTypeString(), true).fill; + textColor = GraphViewStyle::getNodeColor(match.nodeType.getUnderscoredTypeString(), false).text; + textHoverColor = GraphViewStyle::getNodeColor(match.nodeType.getUnderscoredTypeString(), true).text; } else { @@ -1040,15 +1040,15 @@ std::deque QtSmartSearchBox::getMatchesForInput(const std::string& return matches; } -Node::NodeTypeMask QtSmartSearchBox::getMatchFilter() const +NodeType::TypeMask QtSmartSearchBox::getMatchFilter() const { - Node::NodeTypeMask filter = 0; + NodeType::TypeMask filter = 0; for (const SearchMatch& match : m_matches) { if (match.isFilterCommand()) { - filter |= match.nodeType; + filter |= match.nodeType.getType(); } else { diff --git a/src/lib_gui/qt/element/QtSmartSearchBox.h b/src/lib_gui/qt/element/QtSmartSearchBox.h index 2d08692d..7c280547 100644 --- a/src/lib_gui/qt/element/QtSmartSearchBox.h +++ b/src/lib_gui/qt/element/QtSmartSearchBox.h @@ -99,7 +99,7 @@ private: std::deque getMatchesForInput(const std::string& text) const; - Node::NodeTypeMask getMatchFilter() const; + NodeType::TypeMask getMatchFilter() const; bool lastMatchIsNoFilter() const; bool m_allowTextChange; diff --git a/src/lib_gui/qt/view/QtGraphView.cpp b/src/lib_gui/qt/view/QtGraphView.cpp index dfa7a483..125e49a7 100644 --- a/src/lib_gui/qt/view/QtGraphView.cpp +++ b/src/lib_gui/qt/view/QtGraphView.cpp @@ -661,27 +661,27 @@ MessageActivateTrail QtGraphView::getMessageActivateTrail(bool forward) QtGraphNodeData* node = nullptr; if (m_oldActiveNode && (node = dynamic_cast(m_oldActiveNode))) { - Edge::EdgeTypeMask trailType; + Edge::TypeMask trailType; bool horizontalLayout = true; - switch (node->getData()->getType()) + switch (node->getData()->getType().getType()) { - case Node::NODE_NON_INDEXED: - case Node::NODE_CLASS: - case Node::NODE_STRUCT: - case Node::NODE_INTERFACE: + case NodeType::NODE_NON_INDEXED: + case NodeType::NODE_CLASS: + case NodeType::NODE_STRUCT: + case NodeType::NODE_INTERFACE: trailType = Edge::EDGE_INHERITANCE; horizontalLayout = false; break; - case Node::NODE_FUNCTION: - case Node::NODE_METHOD: + case NodeType::NODE_FUNCTION: + case NodeType::NODE_METHOD: trailType = Edge::EDGE_CALL | Edge::EDGE_OVERRIDE | Edge::EDGE_TEMPLATE_SPECIALIZATION | Edge::EDGE_TEMPLATE_MEMBER_SPECIALIZATION; horizontalLayout = true; break; - case Node::NODE_FILE: + case NodeType::NODE_FILE: trailType = Edge::EDGE_INCLUDE; horizontalLayout = true; break; diff --git a/src/lib_gui/qt/view/QtGraphViewStyleImpl.cpp b/src/lib_gui/qt/view/QtGraphViewStyleImpl.cpp index 868ab2ae..d32c2fb9 100644 --- a/src/lib_gui/qt/view/QtGraphViewStyleImpl.cpp +++ b/src/lib_gui/qt/view/QtGraphViewStyleImpl.cpp @@ -9,12 +9,12 @@ QtGraphViewStyleImpl::~QtGraphViewStyleImpl() { } -float QtGraphViewStyleImpl::getCharWidthForNodeType(Node::NodeType type) +float QtGraphViewStyleImpl::getCharWidthForNodeType(NodeType type) { return QFontMetrics(QtGraphNode::getFontForNodeType(type)).width("QtGraphNode::QtGraphNode::QtGraphNode") / 37.0f; } -float QtGraphViewStyleImpl::getCharHeightForNodeType(Node::NodeType type) +float QtGraphViewStyleImpl::getCharHeightForNodeType(NodeType type) { return QFontMetrics(QtGraphNode::getFontForNodeType(type)).height(); } diff --git a/src/lib_gui/qt/view/QtGraphViewStyleImpl.h b/src/lib_gui/qt/view/QtGraphViewStyleImpl.h index 71788d12..78642cd7 100644 --- a/src/lib_gui/qt/view/QtGraphViewStyleImpl.h +++ b/src/lib_gui/qt/view/QtGraphViewStyleImpl.h @@ -8,8 +8,8 @@ class QtGraphViewStyleImpl { public: virtual ~QtGraphViewStyleImpl(); - virtual float getCharWidthForNodeType(Node::NodeType type); - virtual float getCharHeightForNodeType(Node::NodeType type); + virtual float getCharWidthForNodeType(NodeType type); + virtual float getCharHeightForNodeType(NodeType type); virtual float getGraphViewZoomDifferenceForPlatform(); }; diff --git a/src/lib_gui/qt/view/graphElements/QtGraphNode.cpp b/src/lib_gui/qt/view/graphElements/QtGraphNode.cpp index beb4be32..943077a3 100644 --- a/src/lib_gui/qt/view/graphElements/QtGraphNode.cpp +++ b/src/lib_gui/qt/view/graphElements/QtGraphNode.cpp @@ -34,9 +34,9 @@ void QtGraphNode::hideNode() this->hide(); } -QFont QtGraphNode::getFontForNodeType(Node::NodeType type) +QFont QtGraphNode::getFontForNodeType(NodeType type) { - QFont font(GraphViewStyle::getFontNameForNodeType(type).c_str()); + QFont font(GraphViewStyle::getFontNameForDataNode().c_str()); font.setPixelSize(GraphViewStyle::getFontSizeForNodeType(type)); return font; } diff --git a/src/lib_gui/qt/view/graphElements/QtGraphNode.h b/src/lib_gui/qt/view/graphElements/QtGraphNode.h index d07c854f..3326558b 100644 --- a/src/lib_gui/qt/view/graphElements/QtGraphNode.h +++ b/src/lib_gui/qt/view/graphElements/QtGraphNode.h @@ -31,7 +31,7 @@ public slots: void hideNode(); public: - static QFont getFontForNodeType(Node::NodeType type); + static QFont getFontForNodeType(NodeType type); QtGraphNode(); virtual ~QtGraphNode(); diff --git a/src/lib_gui/qt/view/graphElements/QtGraphNodeBundle.cpp b/src/lib_gui/qt/view/graphElements/QtGraphNodeBundle.cpp index c293bc6d..664d5d01 100644 --- a/src/lib_gui/qt/view/graphElements/QtGraphNodeBundle.cpp +++ b/src/lib_gui/qt/view/graphElements/QtGraphNodeBundle.cpp @@ -9,7 +9,7 @@ #include "component/view/GraphViewStyle.h" #include "qt/graphics/QtCountCircleItem.h" -QtGraphNodeBundle::QtGraphNodeBundle(Id tokenId, size_t nodeCount, Node::NodeType type, std::string name) +QtGraphNodeBundle::QtGraphNodeBundle(Id tokenId, size_t nodeCount, NodeType type, std::string name) : QtGraphNode() , m_tokenId(tokenId) , m_type(type) @@ -42,8 +42,8 @@ void QtGraphNodeBundle::onClick() { MessageGraphNodeBundleSplit( m_tokenId, - m_type != Node::NODE_NON_INDEXED && getName() != "Anonymous Namespaces", - m_type != Node::NODE_NON_INDEXED + m_type.getType() != NodeType::NODE_NON_INDEXED && getName() != "Anonymous Namespaces", + m_type.getType() != NodeType::NODE_NON_INDEXED ).dispatch(); } @@ -57,7 +57,7 @@ void QtGraphNodeBundle::moved(const Vec2i& oldPosition) void QtGraphNodeBundle::updateStyle() { GraphViewStyle::NodeStyle style; - if (m_type != Node::NODE_NON_INDEXED) + if (m_type.getType() != NodeType::NODE_NON_INDEXED) { style = GraphViewStyle::getStyleForNodeType(m_type, true, false, m_isHovering, false, false); } diff --git a/src/lib_gui/qt/view/graphElements/QtGraphNodeBundle.h b/src/lib_gui/qt/view/graphElements/QtGraphNodeBundle.h index 4f94bece..78b5d3cd 100644 --- a/src/lib_gui/qt/view/graphElements/QtGraphNodeBundle.h +++ b/src/lib_gui/qt/view/graphElements/QtGraphNodeBundle.h @@ -11,7 +11,7 @@ class QtGraphNodeBundle { Q_OBJECT public: - QtGraphNodeBundle(Id tokenId, size_t nodeCount, Node::NodeType type, std::string name); + QtGraphNodeBundle(Id tokenId, size_t nodeCount, NodeType type, std::string name); virtual ~QtGraphNodeBundle(); // QtGraphNode implementation @@ -29,7 +29,7 @@ protected: private: QtCountCircleItem* m_circle; Id m_tokenId; - Node::NodeType m_type; + NodeType m_type; }; #endif // QT_GRAPH_NODE_BUNDLE_H diff --git a/src/lib_gui/qt/view/graphElements/QtGraphNodeData.cpp b/src/lib_gui/qt/view/graphElements/QtGraphNodeData.cpp index 07d7fb21..ebf3326b 100644 --- a/src/lib_gui/qt/view/graphElements/QtGraphNodeData.cpp +++ b/src/lib_gui/qt/view/graphElements/QtGraphNodeData.cpp @@ -30,7 +30,7 @@ const Node* QtGraphNodeData::getData() const FilePath QtGraphNodeData::getFilePath() const { - if (m_data->isType(Node::NODE_FILE)) + if (m_data->getType().isFile()) { return m_data->getComponent()->getFilePath(); } diff --git a/src/lib_gui/qt/view/graphElements/QtGraphNodeQualifier.cpp b/src/lib_gui/qt/view/graphElements/QtGraphNodeQualifier.cpp index 809636d8..b15dc72a 100644 --- a/src/lib_gui/qt/view/graphElements/QtGraphNodeQualifier.cpp +++ b/src/lib_gui/qt/view/graphElements/QtGraphNodeQualifier.cpp @@ -21,7 +21,7 @@ QtGraphNodeQualifier::QtGraphNodeQualifier(const NameHierarchy& name) m_rightArrowSmall = new QGraphicsPolygonItem(this); QFont font; - font.setFamily(GraphViewStyle::getFontNameForNodeType(Node::NODE_NON_INDEXED).c_str()); + font.setFamily(GraphViewStyle::getFontNameForDataNode().c_str()); font.setPixelSize(GraphViewStyle::getFontSizeOfQualifier()); font.setWeight(QFont::Normal); diff --git a/src/lib_gui/qt/window/QtMainWindow.cpp b/src/lib_gui/qt/window/QtMainWindow.cpp index 63fb5221..2f43e0a4 100644 --- a/src/lib_gui/qt/window/QtMainWindow.cpp +++ b/src/lib_gui/qt/window/QtMainWindow.cpp @@ -867,7 +867,7 @@ void QtMainWindow::setupHistoryMenu() for (size_t i = 0; i < m_history.size(); i++) { SearchMatch& match = m_history[i]; - std::string name = utility::elide(match.nodeType == Node::NODE_FILE ? match.text : match.name, utility::ELIDE_RIGHT, 50); + std::string name = utility::elide(match.nodeType.getType() == NodeType::NODE_FILE ? match.text : match.name, utility::ELIDE_RIGHT, 50); QAction* action = new QAction(); action->setText(name.c_str()); diff --git a/src/test/GraphTestSuite.h b/src/test/GraphTestSuite.h index 9bc9c561..67c2b383 100644 --- a/src/test/GraphTestSuite.h +++ b/src/test/GraphTestSuite.h @@ -90,7 +90,7 @@ public: void test_nodes_are_nodes() { - Node a(1, Node::NODE_NON_INDEXED, NameHierarchy("A", NAME_DELIMITER_CXX), false); + Node a(1, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("A", NAME_DELIMITER_CXX), false); TS_ASSERT(a.isNode()); TS_ASSERT(!a.isEdge()); @@ -98,8 +98,8 @@ public: void test_edges_are_edges() { - Node a(1, Node::NODE_NON_INDEXED, NameHierarchy("A", NAME_DELIMITER_CXX), false); - Node b(2, Node::NODE_NON_INDEXED, NameHierarchy("B", NAME_DELIMITER_CXX), false); + Node a(1, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("A", NAME_DELIMITER_CXX), false); + Node b(2, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("B", NAME_DELIMITER_CXX), false); Edge e(3, Edge::EDGE_USAGE, &a, &b); TS_ASSERT(!e.isNode()); @@ -108,27 +108,27 @@ public: void test_set_type_of_node_from_constructor() { - Node n(1, Node::NODE_FUNCTION, NameHierarchy("A", NAME_DELIMITER_CXX), false); - TS_ASSERT_EQUALS(Node::NODE_FUNCTION, n.getType()); + Node n(1, NodeType(NodeType::NODE_FUNCTION), NameHierarchy("A", NAME_DELIMITER_CXX), false); + TS_ASSERT_EQUALS(NodeType(NodeType::NODE_FUNCTION), n.getType()); } void test_set_type_of_node_from_non_indexed() { - Node n(2, Node::NODE_NON_INDEXED, NameHierarchy("A", NAME_DELIMITER_CXX), false); - n.setType(Node::NODE_CLASS); - TS_ASSERT_EQUALS(Node::NODE_CLASS, n.getType()); + Node n(2, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("A", NAME_DELIMITER_CXX), false); + n.setType(NodeType(NodeType::NODE_CLASS)); + TS_ASSERT_EQUALS(NodeType(NodeType::NODE_CLASS), n.getType()); } void test_can_not_change_type_of_node_after_it_was_set() { - Node n(3, Node::NODE_NAMESPACE, NameHierarchy("A", NAME_DELIMITER_CXX), false); - n.setType(Node::NODE_CLASS); - TS_ASSERT_DIFFERS(Node::NODE_CLASS, n.getType()); + Node n(3, NodeType(NodeType::NODE_NAMESPACE), NameHierarchy("A", NAME_DELIMITER_CXX), false); + n.setType(NodeType(NodeType::NODE_CLASS)); + TS_ASSERT_DIFFERS(NodeType(NodeType::NODE_CLASS), n.getType()); } void test_node_can_be_copied_and_keeps_same_id() { - Node n(4, Node::NODE_NAMESPACE, NameHierarchy("A", NAME_DELIMITER_CXX), false); + Node n(4, NodeType(NodeType::NODE_NAMESPACE), NameHierarchy("A", NAME_DELIMITER_CXX), false); Node n2(n); TS_ASSERT_DIFFERS(&n, &n2); @@ -139,15 +139,15 @@ public: void test_node_type_bit_masking() { - Node n(1, Node::NODE_NAMESPACE, NameHierarchy("A", NAME_DELIMITER_CXX), false); - TS_ASSERT(n.isType(Node::NODE_FUNCTION | Node::NODE_NAMESPACE | Node::NODE_CLASS)); - TS_ASSERT(!n.isType(Node::NODE_FUNCTION | Node::NODE_METHOD | Node::NODE_CLASS)); + Node n(1, NodeType(NodeType::NODE_NAMESPACE), NameHierarchy("A", NAME_DELIMITER_CXX), false); + TS_ASSERT(n.isType(NodeType::NODE_FUNCTION | NodeType::NODE_NAMESPACE | NodeType::NODE_CLASS)); + TS_ASSERT(!n.isType(NodeType::NODE_FUNCTION | NodeType::NODE_METHOD | NodeType::NODE_CLASS)); } void test_get_type_of_edges() { - Node a(1, Node::NODE_NON_INDEXED, NameHierarchy("A", NAME_DELIMITER_CXX), false); - Node b(2, Node::NODE_NON_INDEXED, NameHierarchy("B", NAME_DELIMITER_CXX), false); + Node a(1, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("A", NAME_DELIMITER_CXX), false); + Node b(2, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("B", NAME_DELIMITER_CXX), false); Edge e(3, Edge::EDGE_USAGE, &a, &b); TS_ASSERT_EQUALS(Edge::EDGE_USAGE, e.getType()); @@ -155,8 +155,8 @@ public: void test_edge_can_be_copied_and_keeps_same_id() { - Node a(1, Node::NODE_NON_INDEXED, NameHierarchy("A", NAME_DELIMITER_CXX), false); - Node b(2, Node::NODE_NON_INDEXED, NameHierarchy("B", NAME_DELIMITER_CXX), false); + Node a(1, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("A", NAME_DELIMITER_CXX), false); + Node b(2, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("B", NAME_DELIMITER_CXX), false); Edge e(3, Edge::EDGE_USAGE, &a, &b); Edge e2(e, &a, &b); @@ -167,8 +167,8 @@ public: void test_edge_type_bit_masking() { - Node a(1, Node::NODE_NON_INDEXED, NameHierarchy("A", NAME_DELIMITER_CXX), false); - Node b(2, Node::NODE_NON_INDEXED, NameHierarchy("B", NAME_DELIMITER_CXX), false); + Node a(1, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("A", NAME_DELIMITER_CXX), false); + Node b(2, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("B", NAME_DELIMITER_CXX), false); Edge e(3, Edge::EDGE_USAGE, &a, &b); TS_ASSERT(e.isType(Edge::EDGE_MEMBER | Edge::EDGE_CALL | Edge::EDGE_USAGE)); @@ -177,9 +177,9 @@ public: void test_node_finds_child_node() { - Node a(1, Node::NODE_NON_INDEXED, NameHierarchy("A", NAME_DELIMITER_CXX), false); - Node b(2, Node::NODE_NON_INDEXED, NameHierarchy("B", NAME_DELIMITER_CXX), false); - Node c(3, Node::NODE_NON_INDEXED, NameHierarchy("C", NAME_DELIMITER_CXX), false); + Node a(1, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("A", NAME_DELIMITER_CXX), false); + Node b(2, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("B", NAME_DELIMITER_CXX), false); + Node c(3, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("C", NAME_DELIMITER_CXX), false); Edge e(4, Edge::EDGE_MEMBER, &a, &b); Edge e2(5, Edge::EDGE_MEMBER, &a, &c); @@ -196,9 +196,9 @@ public: void test_node_can_not_find_child_node() { - Node a(1, Node::NODE_NON_INDEXED, NameHierarchy("A", NAME_DELIMITER_CXX), false); - Node b(2, Node::NODE_NON_INDEXED, NameHierarchy("B", NAME_DELIMITER_CXX), false); - Node c(3, Node::NODE_NON_INDEXED, NameHierarchy("C", NAME_DELIMITER_CXX), false); + Node a(1, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("A", NAME_DELIMITER_CXX), false); + Node b(2, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("B", NAME_DELIMITER_CXX), false); + Node c(3, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("C", NAME_DELIMITER_CXX), false); Edge e(4, Edge::EDGE_MEMBER, &a, &b); Edge e2(5, Edge::EDGE_MEMBER, &a, &c); @@ -214,9 +214,9 @@ public: void test_node_visits_child_nodes() { - Node a(1, Node::NODE_NON_INDEXED, NameHierarchy("A", NAME_DELIMITER_CXX), false); - Node b(2, Node::NODE_NON_INDEXED, NameHierarchy("B", NAME_DELIMITER_CXX), false); - Node c(3, Node::NODE_NON_INDEXED, NameHierarchy("C", NAME_DELIMITER_CXX), false); + Node a(1, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("A", NAME_DELIMITER_CXX), false); + Node b(2, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("B", NAME_DELIMITER_CXX), false); + Node c(3, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("C", NAME_DELIMITER_CXX), false); Edge e(4, Edge::EDGE_MEMBER, &a, &b); Edge e2(5, Edge::EDGE_MEMBER, &a, &c); @@ -236,8 +236,8 @@ public: void test_graph_saves_nodes() { Graph graph; - Node* a = graph.createNode(1, Node::NODE_NON_INDEXED, NameHierarchy("A", NAME_DELIMITER_CXX), false); - Node* b = graph.createNode(2, Node::NODE_NON_INDEXED, NameHierarchy("B", NAME_DELIMITER_CXX), false); + Node* a = graph.createNode(1, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("A", NAME_DELIMITER_CXX), false); + Node* b = graph.createNode(2, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("B", NAME_DELIMITER_CXX), false); TS_ASSERT_EQUALS(2, graph.getNodeCount()); TS_ASSERT_EQUALS(0, graph.getEdgeCount()); @@ -255,8 +255,8 @@ public: { Graph graph; - Node* a = graph.createNode(1, Node::NODE_FUNCTION, NameHierarchy("A", NAME_DELIMITER_CXX), false); - Node* b = graph.createNode(2, Node::NODE_FUNCTION, NameHierarchy("B", NAME_DELIMITER_CXX), false); + Node* a = graph.createNode(1, NodeType(NodeType::NODE_FUNCTION), NameHierarchy("A", NAME_DELIMITER_CXX), false); + Node* b = graph.createNode(2, NodeType(NodeType::NODE_FUNCTION), NameHierarchy("B", NAME_DELIMITER_CXX), false); Edge* e = graph.createEdge(3, Edge::EDGE_CALL, a, b); @@ -271,8 +271,8 @@ public: { Graph graph; - Node* a = graph.createNode(1, Node::NODE_NON_INDEXED, NameHierarchy("A", NAME_DELIMITER_CXX), false); - graph.createNode(2, Node::NODE_NON_INDEXED, NameHierarchy("B", NAME_DELIMITER_CXX), false); + Node* a = graph.createNode(1, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("A", NAME_DELIMITER_CXX), false); + graph.createNode(2, NodeType(NodeType::NODE_NON_INDEXED), NameHierarchy("B", NAME_DELIMITER_CXX), false); TS_ASSERT_EQUALS(2, graph.getNodeCount()); TS_ASSERT_EQUALS(0, graph.getEdgeCount()); diff --git a/src/test/StorageTestSuite.h b/src/test/StorageTestSuite.h index ceed52bc..caa2379c 100644 --- a/src/test/StorageTestSuite.h +++ b/src/test/StorageTestSuite.h @@ -21,13 +21,13 @@ public: std::string filePath = "path/to/test.h"; std::shared_ptr intermetiateStorage = std::make_shared(); - Id id = intermetiateStorage->addNode(StorageNodeData(Node::typeToInt(Node::NODE_FILE), NameHierarchy::serialize(NameHierarchy(filePath, NAME_DELIMITER_FILE)))); + Id id = intermetiateStorage->addNode(StorageNodeData(utility::nodeTypeToInt(NodeType::NODE_FILE), NameHierarchy::serialize(NameHierarchy(filePath, NAME_DELIMITER_FILE)))); intermetiateStorage->addFile(StorageFile(id, filePath, "someTime", true)); storage.inject(intermetiateStorage.get()); TS_ASSERT_EQUALS(storage.getNameHierarchyForNodeId(id).getQualifiedName(), filePath); - TS_ASSERT_EQUALS(storage.getNodeTypeForNodeWithId(id), Node::NODE_FILE); + TS_ASSERT(storage.getNodeTypeForNodeWithId(id).isFile()); } void test_storage_saves_node() @@ -37,14 +37,14 @@ public: TestStorage storage; std::shared_ptr intermetiateStorage = std::make_shared(); - intermetiateStorage->addNode(StorageNodeData(Node::typeToInt(Node::NODE_TYPEDEF), NameHierarchy::serialize(a))); + intermetiateStorage->addNode(StorageNodeData(utility::nodeTypeToInt(NodeType::NODE_TYPEDEF), NameHierarchy::serialize(a))); storage.inject(intermetiateStorage.get()); Id storedId = storage.getNodeIdForNameHierarchy(a); TS_ASSERT(storedId != 0); - TS_ASSERT_EQUALS(storage.getNodeTypeForNodeWithId(storedId), Node::NODE_TYPEDEF); + TS_ASSERT_EQUALS(storage.getNodeTypeForNodeWithId(storedId).getType(), NodeType::NODE_TYPEDEF); } @@ -57,10 +57,10 @@ public: std::shared_ptr intermetiateStorage = std::make_shared(); - Id aId = intermetiateStorage->addNode(StorageNodeData(Node::typeToInt(Node::NODE_STRUCT), NameHierarchy::serialize(a))); + Id aId = intermetiateStorage->addNode(StorageNodeData(utility::nodeTypeToInt(NodeType::NODE_STRUCT), NameHierarchy::serialize(a))); intermetiateStorage->addSymbol(StorageSymbol(aId, DEFINITION_EXPLICIT)); - Id bId = intermetiateStorage->addNode(StorageNodeData(Node::typeToInt(Node::NODE_FIELD), NameHierarchy::serialize(b))); + Id bId = intermetiateStorage->addNode(StorageNodeData(utility::nodeTypeToInt(NodeType::NODE_FIELD), NameHierarchy::serialize(b))); intermetiateStorage->addSymbol(StorageSymbol(bId, DEFINITION_EXPLICIT)); intermetiateStorage->addEdge(StorageEdgeData(Edge::typeToInt(Edge::EDGE_MEMBER), aId, bId)); @@ -84,7 +84,7 @@ public: //Node* node = storage.getNodeWithId(id); //TS_ASSERT(node); //TS_ASSERT_EQUALS(node->getQualifiedNameWithSignature(), "isMethod"); - //TS_ASSERT_EQUALS(node->getType(), Node::NODE_METHOD); + //TS_ASSERT_EQUALS(node->getType(), NodeType::NODE_METHOD); //TS_ASSERT(node->getComponent()); } diff --git a/src/test/StorageTransformationAnonymousTypedefTestSuite.h b/src/test/StorageTransformationAnonymousTypedefTestSuite.h index 0ea2f39a..7dc305ae 100644 --- a/src/test/StorageTransformationAnonymousTypedefTestSuite.h +++ b/src/test/StorageTransformationAnonymousTypedefTestSuite.h @@ -12,8 +12,8 @@ public: { std::shared_ptr storage = std::make_shared(); - Id anonymousTypeId = storage->addNode(StorageNodeData(Node::typeToInt(Node::NODE_CLASS), NameHierarchy::serialize(NameHierarchy("anonymous class (input.cc<1:9>)", NAME_DELIMITER_CXX)))); - Id typedefId = storage->addNode(StorageNodeData(Node::typeToInt(Node::NODE_TYPEDEF), NameHierarchy::serialize(NameHierarchy("ClassTypedef", NAME_DELIMITER_CXX)))); + Id anonymousTypeId = storage->addNode(StorageNodeData(utility::nodeTypeToInt(NodeType::NODE_CLASS), NameHierarchy::serialize(NameHierarchy("anonymous class (input.cc<1:9>)", NAME_DELIMITER_CXX)))); + Id typedefId = storage->addNode(StorageNodeData(utility::nodeTypeToInt(NodeType::NODE_TYPEDEF), NameHierarchy::serialize(NameHierarchy("ClassTypedef", NAME_DELIMITER_CXX)))); storage->addEdge(StorageEdgeData(Edge::typeToInt(Edge::EDGE_TYPE_USAGE), typedefId, anonymousTypeId)); StorageTransformationAnonymousTypedef::transform(storage); @@ -35,8 +35,8 @@ public: { std::shared_ptr storage = std::make_shared(); - Id anonymousTypeId = storage->addNode(StorageNodeData(Node::typeToInt(Node::NODE_CLASS), NameHierarchy::serialize(NameHierarchy("anonymous class (input.cc<1:9>)", NAME_DELIMITER_CXX)))); - Id typedefId = storage->addNode(StorageNodeData(Node::typeToInt(Node::NODE_TYPEDEF), NameHierarchy::serialize(NameHierarchy("ClassTypedef", NAME_DELIMITER_CXX)))); + Id anonymousTypeId = storage->addNode(StorageNodeData(utility::nodeTypeToInt(NodeType::NODE_CLASS), NameHierarchy::serialize(NameHierarchy("anonymous class (input.cc<1:9>)", NAME_DELIMITER_CXX)))); + Id typedefId = storage->addNode(StorageNodeData(utility::nodeTypeToInt(NodeType::NODE_TYPEDEF), NameHierarchy::serialize(NameHierarchy("ClassTypedef", NAME_DELIMITER_CXX)))); storage->addEdge(StorageEdgeData(Edge::typeToInt(Edge::EDGE_TYPE_USAGE), typedefId, anonymousTypeId)); storage->addEdge(StorageEdgeData(Edge::typeToInt(Edge::EDGE_TYPE_USAGE), 42, typedefId)); @@ -69,8 +69,8 @@ public: { std::shared_ptr storage = std::make_shared(); - Id anonymousTypeId = storage->addNode(StorageNodeData(Node::typeToInt(Node::NODE_CLASS), NameHierarchy::serialize(NameHierarchy("anonymous class (input.cc<1:9>)", NAME_DELIMITER_CXX)))); - Id typedefId = storage->addNode(StorageNodeData(Node::typeToInt(Node::NODE_TYPEDEF), NameHierarchy::serialize(NameHierarchy("ClassTypedef", NAME_DELIMITER_CXX)))); + Id anonymousTypeId = storage->addNode(StorageNodeData(utility::nodeTypeToInt(NodeType::NODE_CLASS), NameHierarchy::serialize(NameHierarchy("anonymous class (input.cc<1:9>)", NAME_DELIMITER_CXX)))); + Id typedefId = storage->addNode(StorageNodeData(utility::nodeTypeToInt(NodeType::NODE_TYPEDEF), NameHierarchy::serialize(NameHierarchy("ClassTypedef", NAME_DELIMITER_CXX)))); storage->addEdge(StorageEdgeData(Edge::typeToInt(Edge::EDGE_TYPE_USAGE), typedefId, anonymousTypeId)); storage->addEdge(StorageEdgeData(Edge::typeToInt(Edge::EDGE_TYPE_USAGE), anonymousTypeId, 42)); @@ -103,12 +103,12 @@ public: { std::shared_ptr storage = std::make_shared(); - Id anonymousTypeId = storage->addNode(StorageNodeData(Node::typeToInt(Node::NODE_CLASS), NameHierarchy::serialize(NameHierarchy("anonymous class (input.cc<1:9>)", NAME_DELIMITER_CXX)))); - Id typedefId = storage->addNode(StorageNodeData(Node::typeToInt(Node::NODE_TYPEDEF), NameHierarchy::serialize(NameHierarchy("ClassTypedef", NAME_DELIMITER_CXX)))); + Id anonymousTypeId = storage->addNode(StorageNodeData(utility::nodeTypeToInt(NodeType::NODE_CLASS), NameHierarchy::serialize(NameHierarchy("anonymous class (input.cc<1:9>)", NAME_DELIMITER_CXX)))); + Id typedefId = storage->addNode(StorageNodeData(utility::nodeTypeToInt(NodeType::NODE_TYPEDEF), NameHierarchy::serialize(NameHierarchy("ClassTypedef", NAME_DELIMITER_CXX)))); storage->addEdge(StorageEdgeData(Edge::typeToInt(Edge::EDGE_TYPE_USAGE), typedefId, anonymousTypeId)); Id anonymousTypeMemberId = storage->addNode(StorageNodeData( - Node::typeToInt(Node::NODE_FIELD), + utility::nodeTypeToInt(NodeType::NODE_FIELD), NameHierarchy::serialize(NameHierarchy(utility::createVectorFromElements("anonymous class (input.cc<1:9>)", "field"), NAME_DELIMITER_CXX)) )); @@ -132,10 +132,10 @@ public: std::shared_ptr storage = std::make_shared(); Id typeId = storage->addNode(StorageNodeData( - Node::typeToInt(Node::NODE_CLASS), + utility::nodeTypeToInt(NodeType::NODE_CLASS), NameHierarchy::serialize(NameHierarchy(utility::createVectorFromElements("anonymous namespace (input.cc<1:9>)", "Type"), NAME_DELIMITER_CXX)) )); - Id typedefId = storage->addNode(StorageNodeData(Node::typeToInt(Node::NODE_TYPEDEF), NameHierarchy::serialize(NameHierarchy("ClassTypedef", NAME_DELIMITER_CXX)))); + Id typedefId = storage->addNode(StorageNodeData(utility::nodeTypeToInt(NodeType::NODE_TYPEDEF), NameHierarchy::serialize(NameHierarchy("ClassTypedef", NAME_DELIMITER_CXX)))); storage->addEdge(StorageEdgeData(Edge::typeToInt(Edge::EDGE_TYPE_USAGE), typedefId, typeId)); StorageTransformationAnonymousTypedef::transform(storage);