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

src: converted NodeType to a class

Browse Source 
NodeType internally still uses the Type enum
This commit is contained in:
mlangkabel
2017-11-23 17:05:15 +01:00
parent c512992e2c
commit 90e17c5868
52 changed files with 779 additions and 656 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib/CMakeLists.txt
+2
View File
@@ -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
src/lib/component/controller/BookmarkController.cpp
+2 -2
View File
@@ -500,10 +500,10 @@ std::vector<std::string> 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();
}
src/lib/component/controller/GraphController.cpp
+85 -85
View File
@@ -488,7 +488,7 @@ void GraphController::createDummyGraphForTokenIds(const std::vector<Id>& 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<std::shared_ptr<DummyNode>> 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<Id> 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<DummyNode>& 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<DummyNode> GraphController::bundleNodesMatching(
}
void GraphController::bundleByType(
std::list<std::shared_ptr<DummyNode>>& nodes, Node::NodeType type, const std::string& name)
std::list<std::shared_ptr<DummyNode>>& nodes, NodeType::Type type, const std::string& name)
{
std::shared_ptr<DummyNode> 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> graph = std::make_shared<Graph>();
std::function<void(Id, Node::NodeType, NameDelimiterType)> createNodes(
[&](Id id, Node::NodeType type, NameDelimiterType delimiter)
std::function<void(Id, NodeType, NameDelimiterType)> 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<Node*(Node*, Id, Node::NodeType, std::string, AccessKind)> createChild(
[&](Node* parent, Id id, Node::NodeType type, std::string name, AccessKind access)
std::function<Node*(Node*, Id, NodeType, std::string, AccessKind)> 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<void(Id, std::string)> 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<void(Id, Node::NodeType, std::string)> createClass(
[&](Id id, Node::NodeType type, std::string name)
std::function<void(Id, NodeType, std::string)> 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<void(Id, Node::NodeType)> createClasses(
[&](Id id, Node::NodeType type)
std::function<void(Id, NodeType)> 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<void(Id, Edge::EdgeType, Node::NodeType, Node::NodeType, std::string)> createEdge(
[&](Id id, Edge::EdgeType type, Node::NodeType origin, Node::NodeType target, std::string name)
std::function<void(Id, Edge::EdgeType, NodeType, NodeType, std::string)> 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<void(Id, Edge::EdgeType, Node::NodeType, Node::NodeType)> createEdges(
[&](Id id, Edge::EdgeType type, Node::NodeType origin, Node::NodeType target)
std::function<void(Id, Edge::EdgeType, NodeType, NodeType)> 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<Id> focusedTokenIds;
std::vector<Id> activeTokenIds;
src/lib/component/controller/GraphController.h
+1 -1
View File
@@ -94,7 +94,7 @@ private:
const std::string& name);
std::shared_ptr<DummyNode> bundleNodesMatching(
std::list<std::shared_ptr<DummyNode>>& nodes, std::function<bool(const DummyNode*)> matcher, const std::string& name);
void bundleByType(std::list<std::shared_ptr<DummyNode>>& nodes, Node::NodeType type, const std::string& name);
void bundleByType(std::list<std::shared_ptr<DummyNode>>& nodes, NodeType::Type type, const std::string& name);
void bundleNodesByType();
void addCharacterIndex();
src/lib/component/controller/UndoRedoController.cpp
+1 -1
View File
@@ -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;
}
}
src/lib/component/controller/helper/DummyNode.h
+2 -2
View File
@@ -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;
src/lib/component/view/GraphViewStyle.cpp
+69 -96
View File
@@ -11,8 +11,8 @@
int GraphViewStyle::s_gridCellSize = 5;
int GraphViewStyle::s_gridCellPadding = 10;
std::map<Node::NodeType, float> GraphViewStyle::s_charWidths;
std::map<Node::NodeType, float> GraphViewStyle::s_charHeights;
std::unordered_map<std::string, float> GraphViewStyle::s_charWidths;
std::unordered_map<std::string, float> GraphViewStyle::s_charHeights;
std::shared_ptr<GraphViewStyleImpl> 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<Node::NodeType, float>::const_iterator it = s_charWidths.find(type);
std::unordered_map<std::string, float>::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<Node::NodeType, float>::const_iterator it = s_charHeights.find(type);
std::unordered_map<std::string, float>::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:
src/lib/component/view/GraphViewStyle.h
+10 -9
View File
@@ -3,6 +3,7 @@
#include <map>
#include <memory>
#include <unordered_map>
#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<Node::NodeType, float> s_charWidths;
static std::map<Node::NodeType, float> s_charHeights;
static std::unordered_map<std::string, float> s_charWidths;
static std::unordered_map<std::string, float> s_charHeights;
static std::shared_ptr<GraphViewStyleImpl> s_impl;
src/lib/component/view/GraphViewStyleImpl.h
+2 -2
View File
@@ -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;
};
src/lib/data/NodeType.cpp
+260
View File
@@ -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;
}
src/lib/data/NodeType.h
+76
View File
@@ -0,0 +1,76 @@
#ifndef NODE_TYPE_H
#define NODE_TYPE_H
#include <map>
#include <memory>
#include <set>
#include <vector>
#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
src/lib/data/access/StorageAccess.h
+4 -4
View File
@@ -40,7 +40,7 @@ public:
virtual NameHierarchy getNameHierarchyForNodeId(Id id) const = 0;
virtual std::vector<NameHierarchy> getNameHierarchiesForNodeIds(const std::vector<Id>& 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<SourceLocationCollection> getFullTextSearchLocations(
const std::string& searchTerm, bool caseSensitive) const = 0;
virtual std::vector<SearchMatch> getAutocompletionMatches(const std::string& query, Node::NodeTypeMask filter) const = 0;
virtual std::vector<SearchMatch> getAutocompletionMatches(const std::string& query, NodeType::TypeMask filter) const = 0;
virtual std::vector<SearchMatch> getSearchMatchesForTokenIds(const std::vector<Id>& tokenIds) const = 0;
virtual std::shared_ptr<Graph> getGraphForAll() const = 0;
virtual std::shared_ptr<Graph> getGraphForFilter(Node::NodeTypeMask filter) const = 0;
virtual std::shared_ptr<Graph> getGraphForFilter(NodeType::TypeMask filter) const = 0;
virtual std::shared_ptr<Graph> getGraphForActiveTokenIds(
const std::vector<Id>& tokenIds, const std::vector<Id>& expandedNodeIds, bool* isActiveNamespace = nullptr) const = 0;
virtual std::shared_ptr<Graph> getGraphForChildrenOfNodeId(Id nodeId) const = 0;
virtual std::shared_ptr<Graph> getGraphForTrail(Id originId, Id targetId, Edge::EdgeTypeMask trailType, size_t depth) const = 0;
virtual std::shared_ptr<Graph> getGraphForTrail(Id originId, Id targetId, Edge::TypeMask trailType, size_t depth) const = 0;
virtual std::vector<Id> getActiveTokenIdsForId(Id tokenId, Id* declarationId) const = 0;
virtual std::vector<Id> getNodeIdsForLocationIds(const std::vector<Id>& locationIds) const = 0;
src/lib/data/access/StorageAccessProxy.cpp
+5 -5
View File
@@ -84,13 +84,13 @@ std::vector<NameHierarchy> StorageAccessProxy::getNameHierarchiesForNodeIds(cons
return std::vector<NameHierarchy>();
}
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<SourceLocationCollection> StorageAccessProxy::getFullTextSearchL
return std::make_shared<SourceLocationCollection>();
}
std::vector<SearchMatch> StorageAccessProxy::getAutocompletionMatches(const std::string& query, Node::NodeTypeMask filter) const
std::vector<SearchMatch> StorageAccessProxy::getAutocompletionMatches(const std::string& query, NodeType::TypeMask filter) const
{
if (hasSubject())
{
@@ -155,7 +155,7 @@ std::shared_ptr<Graph> StorageAccessProxy::getGraphForAll() const
return std::make_shared<Graph>();
}
std::shared_ptr<Graph> StorageAccessProxy::getGraphForFilter(Node::NodeTypeMask filter) const
std::shared_ptr<Graph> StorageAccessProxy::getGraphForFilter(NodeType::TypeMask filter) const
{
if (hasSubject())
{
@@ -186,7 +186,7 @@ std::shared_ptr<Graph> StorageAccessProxy::getGraphForChildrenOfNodeId(Id nodeId
return std::make_shared<Graph>();
}
std::shared_ptr<Graph> StorageAccessProxy::getGraphForTrail(Id originId, Id targetId, Edge::EdgeTypeMask trailType, size_t depth) const
std::shared_ptr<Graph> StorageAccessProxy::getGraphForTrail(Id originId, Id targetId, Edge::TypeMask trailType, size_t depth) const
{
if (hasSubject())
{
src/lib/data/access/StorageAccessProxy.h
+4 -4
View File
@@ -25,7 +25,7 @@ public:
virtual NameHierarchy getNameHierarchyForNodeId(Id id) const;
virtual std::vector<NameHierarchy> getNameHierarchiesForNodeIds(const std::vector<Id>& 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<SourceLocationCollection> getFullTextSearchLocations(
const std::string& searchTerm, bool caseSensitive) const;
virtual std::vector<SearchMatch> getAutocompletionMatches(const std::string& query, Node::NodeTypeMask filter) const;
virtual std::vector<SearchMatch> getAutocompletionMatches(const std::string& query, NodeType::TypeMask filter) const;
virtual std::vector<SearchMatch> getSearchMatchesForTokenIds(const std::vector<Id>& tokenIds) const;
virtual std::shared_ptr<Graph> getGraphForAll() const;
virtual std::shared_ptr<Graph> getGraphForFilter(Node::NodeTypeMask filter) const;
virtual std::shared_ptr<Graph> getGraphForFilter(NodeType::TypeMask filter) const;
virtual std::shared_ptr<Graph> getGraphForActiveTokenIds(
const std::vector<Id>& tokenIds, const std::vector<Id>& expandedNodeIds, bool* isActiveNamespace = nullptr) const;
virtual std::shared_ptr<Graph> getGraphForChildrenOfNodeId(Id nodeId) const;
virtual std::shared_ptr<Graph> getGraphForTrail(Id originId, Id targetId, Edge::EdgeTypeMask trailType, size_t depth) const;
virtual std::shared_ptr<Graph> getGraphForTrail(Id originId, Id targetId, Edge::TypeMask trailType, size_t depth) const;
virtual std::vector<Id> getActiveTokenIdsForId(Id tokenId, Id* declarationId) const;
virtual std::vector<Id> getNodeIdsForLocationIds(const std::vector<Id>& locationIds) const;
src/lib/data/graph/Edge.cpp
+1 -1
View File
@@ -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;
}
src/lib/data/graph/Edge.h
+3 -3
View File
@@ -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;
src/lib/data/graph/Graph.cpp
+1 -1
View File
@@ -41,7 +41,7 @@ void Graph::forEachToken(std::function<void(Token*)> 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)
src/lib/data/graph/Graph.h
+1 -1
View File
@@ -27,7 +27,7 @@ public:
void forEachEdge(std::function<void(Edge*)> func) const;
void forEachToken(std::function<void(Token*)> 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;
src/lib/data/graph/Node.cpp
+9 -162
View File
@@ -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<bool(Edge*)> 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<bool(Edge*)> func) const
Edge* Node::findEdgeOfType(Edge::TypeMask mask, std::function<bool(Edge*)> func) const
{
auto it = find_if(m_edges.begin(), m_edges.end(),
[mask, func](std::pair<Id, Edge*> p)
@@ -374,7 +237,7 @@ void Node::forEachEdge(std::function<void(Edge*)> func) const
);
}
void Node::forEachEdgeOfType(Edge::EdgeTypeMask mask, std::function<void(Edge*)> func) const
void Node::forEachEdgeOfType(Edge::TypeMask mask, std::function<void(Edge*)> func) const
{
for_each(m_edges.begin(), m_edges.end(),
[mask, func](std::pair<Id, Edge*> p)
@@ -432,10 +295,6 @@ void Node::addComponentAbstraction(std::shared_ptr<TokenComponentAbstraction> 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<TokenComponentConst> 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<TokenComponentStatic> 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<TokenComponentFilePath> 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<TokenComponentAccess> component)
std::string Node::getReadableTypeString() const
{
return getReadableTypeString(m_type);
return m_type.getReadableTypeString();
}
std::string Node::getAsString() const
src/lib/data/graph/Node.h
+5 -48
View File
@@ -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<bool(Edge*)> func) const;
Edge* findEdgeOfType(Edge::EdgeTypeMask mask) const;
Edge* findEdgeOfType(Edge::EdgeTypeMask mask, std::function<bool(Edge*)> func) const;
Edge* findEdgeOfType(Edge::TypeMask mask) const;
Edge* findEdgeOfType(Edge::TypeMask mask, std::function<bool(Edge*)> func) const;
Node* findChildNode(std::function<bool(Node*)> func) const;
void forEachEdge(std::function<void(Edge*)> func) const;
void forEachEdgeOfType(Edge::EdgeTypeMask mask, std::function<void(Edge*)> func) const;
void forEachEdgeOfType(Edge::TypeMask mask, std::function<void(Edge*)> func) const;
void forEachChildNode(std::function<void(Node*)> func) const;
void forEachNodeRecursive(std::function<void(const Node*)> func) const;
@@ -116,7 +74,6 @@ public:
void addComponentConst(std::shared_ptr<TokenComponentConst> component);
void addComponentStatic(std::shared_ptr<TokenComponentStatic> component);
void addComponentFilePath(std::shared_ptr<TokenComponentFilePath> component);
void addComponentSignature(std::shared_ptr<TokenComponentSignature> component);
void addComponentAccess(std::shared_ptr<TokenComponentAccess> component);
// Logging.
src/lib/data/parser/ParserClientImpl.cpp
+27 -27
View File
@@ -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,
src/lib/data/parser/ParserClientImpl.h
+3 -3
View File
@@ -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);
src/lib/data/search/SearchIndex.cpp
+4 -4
View File
@@ -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<SearchResult> 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<SearchIndex::SearchPath>* results) const
{
if (remainingQuery.size() == 0 && (!filter || (path.node->mask & filter)))
@@ -197,7 +197,7 @@ void SearchIndex::searchRecursive(
}
std::multiset<SearchResult> SearchIndex::createScoredResults(
const std::vector<SearchPath>& paths, Node::NodeTypeMask filter, size_t maxResultCount) const
const std::vector<SearchPath>& paths, NodeType::TypeMask filter, size_t maxResultCount) const
{
// score and order initial paths
std::multimap<int, SearchPath, std::greater<int>> scoredPaths;
src/lib/data/search/SearchIndex.h
+5 -5
View File
@@ -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<SearchResult> 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<Id> elementIds;
Node::NodeTypeMask mask = 0;
NodeType::TypeMask mask = 0;
std::map<char, SearchEdge*> 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<SearchIndex::SearchPath>* results) const;
std::multiset<SearchResult> createScoredResults(
const std::vector<SearchPath>& paths, Node::NodeTypeMask filter, size_t maxResultCount) const;
const std::vector<SearchPath>& paths, NodeType::TypeMask filter, size_t maxResultCount) const;
static SearchResult bestScoredResult(
SearchResult result, std::map<std::string, SearchResult>* scoresCache, size_t maxBestScoredResultsLength);
src/lib/data/search/SearchMatch.cpp
+8 -8
View File
@@ -56,20 +56,20 @@ SearchMatch SearchMatch::createCommand(CommandType type)
return match;
}
std::vector<SearchMatch> SearchMatch::createCommandsForFilter(Node::NodeTypeMask filter)
std::vector<SearchMatch> SearchMatch::createCommandsForFilter(NodeType::TypeMask filter)
{
std::vector<SearchMatch> 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
src/lib/data/search/SearchMatch.h
+2 -2
View File
@@ -34,7 +34,7 @@ struct SearchMatch
static std::string searchMatchesToString(const std::vector<SearchMatch>& matches);
static SearchMatch createCommand(CommandType type);
static std::vector<SearchMatch> createCommandsForFilter(Node::NodeTypeMask filter);
static std::vector<SearchMatch> 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<size_t> indices;
src/lib/data/storage/PersistentStorage.cpp
+73 -66
View File
@@ -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<NameHierarchy> PersistentStorage::getNameHierarchiesForNodeIds(const
return nameHierarchies;
}
Node::NodeType PersistentStorage::getNodeTypeForNodeWithId(Id nodeId) const
NodeType PersistentStorage::getNodeTypeForNodeWithId(Id nodeId) const
{
return Node::intToType(m_sqliteIndexStorage.getFirstById<StorageNode>(nodeId).type);
return utility::intToType(m_sqliteIndexStorage.getFirstById<StorageNode>(nodeId).type);
}
Id PersistentStorage::getIdForEdge(
@@ -558,7 +558,7 @@ std::shared_ptr<SourceLocationCollection> PersistentStorage::getFullTextSearchLo
return collection;
}
std::vector<SearchMatch> PersistentStorage::getAutocompletionMatches(const std::string& query, Node::NodeTypeMask filter) const
std::vector<SearchMatch> PersistentStorage::getAutocompletionMatches(const std::string& query, NodeType::TypeMask filter) const
{
TRACE();
@@ -569,12 +569,12 @@ std::vector<SearchMatch> PersistentStorage::getAutocompletionMatches(const std::
// create SearchMatches
std::vector<SearchMatch> 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<SearchMatch> PersistentStorage::getAutocompletionMatches(const std::
}
std::vector<SearchMatch> 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<SearchResult> results =
@@ -674,12 +674,12 @@ std::vector<SearchMatch> 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<SearchMatch> PersistentStorage::getAutocompletionSymbolMatches(
std::vector<SearchMatch> PersistentStorage::getAutocompletionFileMatches(const std::string& query, size_t maxResultsCount) const
{
std::vector<SearchResult> results = m_fileIndex.search(query, Node::NODE_FILE, maxResultsCount, 100);
std::vector<SearchResult> results = m_fileIndex.search(query, NodeType::NODE_FILE, maxResultsCount, 100);
// create SearchMatches
std::vector<SearchMatch> matches;
@@ -712,8 +712,8 @@ std::vector<SearchMatch> 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<SearchMatch> PersistentStorage::getAutocompletionFileMatches(const s
}
std::vector<SearchMatch> PersistentStorage::getAutocompletionCommandMatches(
const std::string& query, Node::NodeTypeMask filter) const
const std::string& query, NodeType::TypeMask filter) const
{
// search in indices
std::vector<SearchResult> results = m_commandIndex.search(query, 0, 0);
@@ -748,11 +748,11 @@ std::vector<SearchMatch> 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<SearchMatch> 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<Graph> 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<Graph> PersistentStorage::getGraphForAll() const
return graph;
}
std::shared_ptr<Graph> PersistentStorage::getGraphForFilter(Node::NodeTypeMask filter) const
std::shared_ptr<Graph> PersistentStorage::getGraphForFilter(NodeType::TypeMask filter) const
{
TRACE();
@@ -846,7 +846,7 @@ std::shared_ptr<Graph> PersistentStorage::getGraphForFilter(Node::NodeTypeMask f
std::vector<Id> tokenIds;
for (StorageNode& node: m_sqliteIndexStorage.getAll<StorageNode>())
{
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<Graph> 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<Graph> 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<Graph> 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<Graph> 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<Graph> PersistentStorage::getGraphForChildrenOfNodeId(Id nodeId)
}
std::shared_ptr<Graph> 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<SourceLocationCollection> 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<Id>&
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<StorageSymbol>(node.id);
@@ -1715,7 +1715,7 @@ TooltipInfo PersistentStorage::getTooltipInfoForTokenIds(const std::vector<Id>&
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<Id>&
}
}
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<Id>&
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<SourceLocationFile>(
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<Id>(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<Id>& newNodeIds, Graph
for (const StorageNode& storageNode : m_sqliteIndexStorage.getAllByIds<StorageNode>(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<Id>& 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<Id>& 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<Id>& 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<StorageNode>())
{
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<StorageNode> sourceNodes = m_sqliteIndexStorage.getAllByIds<StorageNode>(sourceNodeIds);
std::map<Id, Node::NodeType> sourceNodeTypeMap;
std::map<Id, NodeType> 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<Id, NodeType>::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);
src/lib/data/storage/PersistentStorage.h
+6 -6
View File
@@ -77,7 +77,7 @@ public:
virtual NameHierarchy getNameHierarchyForNodeId(Id nodeId) const;
virtual std::vector<NameHierarchy> getNameHierarchiesForNodeIds(const std::vector<Id>& 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<SourceLocationCollection> getFullTextSearchLocations(
const std::string& searchTerm, bool caseSensitive) const;
virtual std::vector<SearchMatch> getAutocompletionMatches(const std::string& query, Node::NodeTypeMask filter) const;
virtual std::vector<SearchMatch> getAutocompletionMatches(const std::string& query, NodeType::TypeMask filter) const;
std::vector<SearchMatch> 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<SearchMatch> getAutocompletionFileMatches(const std::string& query, size_t maxResultsCount) const;
std::vector<SearchMatch> getAutocompletionCommandMatches(const std::string& query, Node::NodeTypeMask filter) const;
std::vector<SearchMatch> getAutocompletionCommandMatches(const std::string& query, NodeType::TypeMask filter) const;
virtual std::vector<SearchMatch> getSearchMatchesForTokenIds(const std::vector<Id>& elementIds) const;
virtual std::shared_ptr<Graph> getGraphForAll() const;
virtual std::shared_ptr<Graph> getGraphForFilter(Node::NodeTypeMask filter) const;
virtual std::shared_ptr<Graph> getGraphForFilter(NodeType::TypeMask filter) const;
virtual std::shared_ptr<Graph> getGraphForActiveTokenIds(
const std::vector<Id>& tokenIds, const std::vector<Id>& expandedNodeIds, bool* isActiveNamespace = nullptr) const;
virtual std::shared_ptr<Graph> getGraphForChildrenOfNodeId(Id nodeId) const;
virtual std::shared_ptr<Graph> getGraphForTrail(Id originId, Id targetId, Edge::EdgeTypeMask trailType, size_t depth) const;
virtual std::shared_ptr<Graph> getGraphForTrail(Id originId, Id targetId, Edge::TypeMask trailType, size_t depth) const;
virtual std::vector<Id> getActiveTokenIdsForId(Id tokenId, Id* declarationId) const;
virtual std::vector<Id> getNodeIdsForLocationIds(const std::vector<Id>& locationIds) const;
src/lib/settings/ColorScheme.cpp
+2 -2
View File
@@ -26,9 +26,9 @@ std::string ColorScheme::getColor(const std::string& key, const std::string& def
return getValue<std::string>(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
src/lib/settings/ColorScheme.h
+1 -1
View File
@@ -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;
src/lib/utility/messaging/type/MessageActivateAll.h
+2 -2
View File
@@ -8,7 +8,7 @@ class MessageActivateAll
: public Message<MessageActivateAll>
{
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
src/lib/utility/messaging/type/MessageActivateTrail.h
+2 -2
View File
@@ -8,7 +8,7 @@ class MessageActivateTrail
: public Message<MessageActivateTrail>
{
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;
};
src/lib/utility/messaging/type/MessageSearch.h
+3 -3
View File
@@ -9,7 +9,7 @@ class MessageSearch
: public Message<MessageSearch>
{
public:
MessageSearch(const std::vector<SearchMatch>& matches, Node::NodeTypeMask filter = 0)
MessageSearch(const std::vector<SearchMatch>& 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<SearchMatch> m_matches;
src/lib/utility/messaging/type/MessageSearchAutocomplete.h
+2 -2
View File
@@ -8,7 +8,7 @@ class MessageSearchAutocomplete
: public Message<MessageSearchAutocomplete>
{
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
src/lib_cxx/data/storage/StorageTransformationAnonymousTypedef.cpp
+3 -3
View File
@@ -30,12 +30,12 @@ void StorageTransformationAnonymousTypedef::transform(std::shared_ptr<Intermedia
for (const StorageNode& node : nodes)
{
const Node::NodeType nodeType = Node::intToType(node.type);
if (nodeType & Node::NODE_TYPEDEF)
const NodeType::Type nodeType = utility::intToType(node.type);
if (nodeType & NodeType::NODE_TYPEDEF)
{
typedefNodes.insert(std::pair<Id, StorageNode>(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()))
src/lib_gui/qt/element/QtAutocompletionList.cpp
+3 -3
View File
@@ -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<QVariant> indices = index.sibling(index.row(), index.column() + 4).data().toList();
Node::NodeType nodeType = static_cast<Node::NodeType>(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());
}
src/lib_gui/qt/element/QtHistoryList.cpp
+3 -3
View File
@@ -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
{
src/lib_gui/qt/element/QtSmartSearchBox.cpp
+7 -7
View File
@@ -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<SearchMatch> 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
{
src/lib_gui/qt/element/QtSmartSearchBox.h
+1 -1
View File
@@ -99,7 +99,7 @@ private:
std::deque<SearchMatch> getMatchesForInput(const std::string& text) const;
Node::NodeTypeMask getMatchFilter() const;
NodeType::TypeMask getMatchFilter() const;
bool lastMatchIsNoFilter() const;
bool m_allowTextChange;
src/lib_gui/qt/view/QtGraphView.cpp
+9 -9
View File
@@ -661,27 +661,27 @@ MessageActivateTrail QtGraphView::getMessageActivateTrail(bool forward)
QtGraphNodeData* node = nullptr;
if (m_oldActiveNode && (node = dynamic_cast<QtGraphNodeData*>(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;
src/lib_gui/qt/view/QtGraphViewStyleImpl.cpp
+2 -2
View File
@@ -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();
}
src/lib_gui/qt/view/QtGraphViewStyleImpl.h
+2 -2
View File
@@ -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();
};
src/lib_gui/qt/view/graphElements/QtGraphNode.cpp
+2 -2
View File
@@ -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;
}
src/lib_gui/qt/view/graphElements/QtGraphNode.h
+1 -1
View File
@@ -31,7 +31,7 @@ public slots:
void hideNode();
public:
static QFont getFontForNodeType(Node::NodeType type);
static QFont getFontForNodeType(NodeType type);
QtGraphNode();
virtual ~QtGraphNode();
src/lib_gui/qt/view/graphElements/QtGraphNodeBundle.cpp
+4 -4
View File
@@ -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);
}
src/lib_gui/qt/view/graphElements/QtGraphNodeBundle.h
+2 -2
View File
@@ -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
src/lib_gui/qt/view/graphElements/QtGraphNodeData.cpp
+1 -1
View File
@@ -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<TokenComponentFilePath>()->getFilePath();
}
src/lib_gui/qt/view/graphElements/QtGraphNodeQualifier.cpp
+1 -1
View File
@@ -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);
src/lib_gui/qt/window/QtMainWindow.cpp
+1 -1
View File
@@ -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());
src/test/GraphTestSuite.h
+36 -36
View File
@@ -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());
src/test/StorageTestSuite.h
+7 -7
View File
@@ -21,13 +21,13 @@ public:
std::string filePath = "path/to/test.h";
std::shared_ptr<IntermediateStorage> intermetiateStorage = std::make_shared<IntermediateStorage>();
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<IntermediateStorage> intermetiateStorage = std::make_shared<IntermediateStorage>();
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<IntermediateStorage> intermetiateStorage = std::make_shared<IntermediateStorage>();
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<TokenComponentStatic>());
}
src/test/StorageTransformationAnonymousTypedefTestSuite.h
+11 -11
View File
@@ -12,8 +12,8 @@ public:
{
std::shared_ptr<IntermediateStorage> storage = std::make_shared<IntermediateStorage>();
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<IntermediateStorage> storage = std::make_shared<IntermediateStorage>();
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<IntermediateStorage> storage = std::make_shared<IntermediateStorage>();
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<IntermediateStorage> storage = std::make_shared<IntermediateStorage>();
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<std::string>("anonymous class (input.cc<1:9>)", "field"), NAME_DELIMITER_CXX))
));
@@ -132,10 +132,10 @@ public:
std::shared_ptr<IntermediateStorage> storage = std::make_shared<IntermediateStorage>();
Id typeId = storage->addNode(StorageNodeData(
Node::typeToInt(Node::NODE_CLASS),
utility::nodeTypeToInt(NodeType::NODE_CLASS),
NameHierarchy::serialize(NameHierarchy(utility::createVectorFromElements<std::string>("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);