#pragma once
#include <wtf/FastMalloc.h>
#include <wtf/GraphNodeWorklist.h>
#include <wtf/Noncopyable.h>
#include <wtf/SingleRootGraph.h>
#include <wtf/SpanningTree.h>
#include <wtf/StdLibExtras.h>
namespace WTF {
template<typename Graph>
class BackwardsGraph {
WTF_MAKE_NONCOPYABLE(BackwardsGraph);
WTF_MAKE_FAST_ALLOCATED;
public:
using Node = SingleRootGraphNode<Graph>;
using Set = SingleRootGraphSet<Graph>;
template <typename T> using Map = SingleRootMap<T, Graph>;
typedef Vector<Node, 4> List;
BackwardsGraph(Graph& graph)
: m_graph(graph)
{
GraphNodeWorklist<typename Graph::Node, typename Graph::Set> worklist;
auto addRootSuccessor = [&] (typename Graph::Node node) {
if (worklist.push(node)) {
m_rootSuccessorList.append(node);
m_rootSuccessorSet.add(node);
while (typename Graph::Node node = worklist.pop())
worklist.pushAll(graph.predecessors(node));
}
};
{
SpanningTree<Graph> spanningTree(graph);
for (unsigned i = 0; i < graph.numNodes(); ++i) {
if (typename Graph::Node node = graph.node(i)) {
for (typename Graph::Node successor : graph.successors(node)) {
if (spanningTree.isDescendent(node, successor)) {
addRootSuccessor(node);
break;
}
}
}
}
}
for (unsigned i = 0; i < graph.numNodes(); ++i) {
if (typename Graph::Node node = graph.node(i)) {
if (!graph.successors(node).size())
addRootSuccessor(node);
}
}
for (unsigned i = graph.numNodes(); i--;) {
if (typename Graph::Node node = graph.node(i))
addRootSuccessor(node);
}
}
Node root() { return Node::root(); }
template<typename T>
Map<T> newMap() { return Map<T>(m_graph); }
List successors(const Node& node) const
{
if (node.isRoot())
return m_rootSuccessorList;
List result;
for (typename Graph::Node predecessor : m_graph.predecessors(node.node()))
result.append(predecessor);
return result;
}
List predecessors(const Node& node) const
{
if (node.isRoot())
return { };
List result;
if (m_rootSuccessorSet.contains(node.node()))
result.append(Node::root());
for (typename Graph::Node successor : m_graph.successors(node.node()))
result.append(successor);
return result;
}
unsigned index(const Node& node) const
{
if (node.isRoot())
return 0;
return m_graph.index(node.node()) + 1;
}
Node node(unsigned index) const
{
if (!index)
return Node::root();
return m_graph.node(index - 1);
}
unsigned numNodes() const
{
return m_graph.numNodes() + 1;
}
CString dump(Node node) const
{
StringPrintStream out;
if (!node)
out.print("<null>");
else if (node.isRoot())
out.print(Node::rootName());
else
out.print(m_graph.dump(node.node()));
return out.toCString();
}
void dump(PrintStream& out) const
{
for (unsigned i = 0; i < numNodes(); ++i) {
Node node = this->node(i);
if (!node)
continue;
out.print(dump(node), ":\n");
out.print(" Preds: ");
CommaPrinter comma;
for (Node predecessor : predecessors(node))
out.print(comma, dump(predecessor));
out.print("\n");
out.print(" Succs: ");
comma = CommaPrinter();
for (Node successor : successors(node))
out.print(comma, dump(successor));
out.print("\n");
}
}
private:
Graph& m_graph;
List m_rootSuccessorList;
typename Graph::Set m_rootSuccessorSet;
};
}
using WTF::BackwardsGraph;