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

src: Removed unused color scheme test code

Browse Source
This commit is contained in:
Eberhard Graether
2017-11-26 19:04:38 +01:00
parent 7903ef9c1e
commit a9cd67659a
8 changed files with 1 additions and 307 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib/component/controller/GraphController.cpp
-265
View File
@@ -1773,268 +1773,3 @@ void GraphController::forEachDummyEdge(std::function<void(DummyEdge*)> func)
func(edge.get());
}
}
void GraphController::handleMessage(MessageColorSchemeTest* message)
{
// todo: add nodes: package, interface, type_parameter, builtin_type, union
// todo: add edges: EDGE_TYPE_ARGUMENT, EDGE_IMPORT
// todo: add access: TYPE_PARAMETER
clear();
std::shared_ptr<Graph> graph = std::make_shared<Graph>();
std::function<void(Id, NodeType, NameDelimiterType)> createNodes(
[&](Id id, NodeType type, NameDelimiterType delimiter)
{
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);
graph->createNode(id + 4, type, NameHierarchy("Non-indexed " + name, delimiter), true);
graph->createNode(id + 5, type, NameHierarchy("Non-indexed focused " + name, delimiter), true);
graph->createNode(id + 6, type, NameHierarchy("Non-indexed active " + name, delimiter), true);
}
);
createNodes( 0, NodeType::NODE_FUNCTION, NAME_DELIMITER_CXX);
createNodes(10, NodeType::NODE_GLOBAL_VARIABLE, NAME_DELIMITER_CXX);
createNodes(20, NodeType::NODE_SYMBOL, 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, 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);
if (access != ACCESS_NONE)
{
node->addComponentAccess(std::make_shared<TokenComponentAccess>(access));
}
return node;
}
);
std::function<void(Id, std::string)> createEnum(
[&](Id id, std::string name)
{
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);
}
);
createEnum(101, "");
createEnum(102, "focused ");
createEnum(103, "active ");
createEnum(104, "Non-indexed ");
createEnum(105, "Non-indexed focused ");
createEnum(106, "Non-indexed active ");
std::function<void(Id, NodeType, std::string)> createClass(
[&](Id id, NodeType type, std::string name)
{
Node* classNode = graph->createNode(id, type, NameHierarchy(name + NodeType(type).getReadableTypeString(), NAME_DELIMITER_CXX), true);
if (type.getType() == NodeType::NODE_CLASS)
{
createChild(classNode, id, NodeType::NODE_TEMPLATE_PARAMETER_TYPE, name + "temp_param", ACCESS_TEMPLATE_PARAMETER);
}
createChild(classNode, id + 10, NodeType::NODE_METHOD, name + "method", ACCESS_PUBLIC);
if (type.getType() == NodeType::NODE_CLASS)
{
createChild(classNode, id + 30, NodeType::NODE_METHOD, name + "method", ACCESS_PROTECTED);
}
createChild(classNode, id + 60, NodeType::NODE_FIELD, name + "field", ACCESS_PRIVATE);
}
);
std::function<void(Id, NodeType)> createClasses(
[&](Id id, NodeType type)
{
createClass(id + 1, type, "");
createClass(id + 2, type, "focused ");
createClass(id + 3, type, "active ");
createClass(id + 4, type, "Non-indexed ");
createClass(id + 5, type, "Non-indexed focused ");
createClass(id + 6, type, "Non-indexed active ");
}
);
createClasses(200, NodeType::NODE_STRUCT);
createClasses(300, NodeType::NODE_CLASS);
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.getType() == NodeType::NODE_METHOD)
{
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
{
originNode = graph->createNode(id + 1, origin, NameHierarchy(name + Edge::getReadableTypeString(type), NAME_DELIMITER_CXX), true);
}
Node* targetNode;
if (target.getType() == NodeType::NODE_METHOD)
{
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
{
targetNode = graph->createNode(id + 11, target, NameHierarchy(name + Edge::getReadableTypeString(type), NAME_DELIMITER_CXX), true);
}
Edge* edge = graph->createEdge(id, type, originNode, targetNode);
if (type == Edge::EDGE_AGGREGATION)
{
std::shared_ptr<TokenComponentAggregation> agg = std::make_shared<TokenComponentAggregation>();
for (Id i = 1; i < 11; i++)
{
agg->addAggregationId(i, true);
}
edge->addComponentAggregation(agg);
}
}
);
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 ");
createEdge(id + 2000, type, origin, target, "active ");
}
);
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, 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, NodeType::NODE_CLASS, NodeType::NODE_CLASS);
createEdges( 800000, Edge::EDGE_OVERRIDE, NodeType::NODE_METHOD, NodeType::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;
graph->forEachNode(
[&](Node* node)
{
Id id = node->getId();
if (id % 10 < 4)
{
node->setExplicit(true);
}
if (id % 10 == 2 || id % 10 == 5)
{
focusedTokenIds.push_back(id);
}
else if (id % 10 == 3 || id % 10 == 6)
{
activeTokenIds.push_back(id);
}
}
);
graph->forEachEdge(
[&](Edge* edge)
{
Id id = edge->getId();
if (id % 10000 == 1000)
{
focusedTokenIds.push_back(id);
}
else if (id % 10000 == 2000)
{
activeTokenIds.push_back(id);
}
}
);
createDummyGraph(graph);
for (size_t i = 0; i < 2; i++)
{
std::shared_ptr<DummyNode> bundleNode = std::make_shared<DummyNode>();
bundleNode->tokenId = 10000001 + i;
bundleNode->name = "bundle";
if (i == 1)
{
bundleNode->name = "focused bundle";
focusedTokenIds.push_back(bundleNode->tokenId);
}
bundleNode->bundledNodes.insert(std::make_shared<DummyNode>());
bundleNode->bundledNodeCount = 123;
m_dummyNodes.push_back(bundleNode);
}
forEachDummyNodeRecursive(
[](DummyNode* node)
{
node->visible = true;
if (node->subNodes.size())
{
node->expanded = true;
node->childVisible = true;
}
}
);
forEachDummyEdge(
[](DummyEdge* edge)
{
edge->visible = true;
edge->active = true;
}
);
setActive(activeTokenIds, true);
layoutNesting();
for (size_t i = 0; i < m_dummyNodes.size(); i++)
{
DummyNode* node = m_dummyNodes[i].get();
node->layoutBucket.x = i % 6 + 1;
node->layoutBucket.y = (i / 6) + 1;
}
BucketLayouter grid(Vec2i(0, 0));
grid.createBuckets(m_dummyNodes, std::vector<std::shared_ptr<DummyEdge>>());
grid.layoutBuckets();
buildGraph(message, false, true, false);
getView()->focusTokenIds(focusedTokenIds);
}