* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
- * \author Dekel Tsur
+ * \author Dekel Tsur (original code)
+ * \author Richard Heck (re-implementation)
*
* Full author contact details are available in file CREDITS.
*/
#include "Graph.h"
#include "Format.h"
+#include "support/debug.h"
+#include "support/lassert.h"
+
#include <algorithm>
using namespace std;
Q_ = queue<int>();
- if (clear_visited)
- fill(visited_.begin(), visited_.end(), false);
- if (visited_[s] == false) {
+ if (clear_visited) {
+ vector<Vertex>::iterator it = vertices_.begin();
+ vector<Vertex>::iterator en = vertices_.end();
+ for (; it != en; ++it)
+ it->visited = false;
+ }
+ if (!vertices_[s].visited) {
Q_.push(s);
- visited_[s] = true;
+ vertices_[s].visited = true;
}
return true;
}
+void Graph::clearPaths()
+{
+ vector<Vertex>::iterator it = vertices_.begin();
+ vector<Vertex>::iterator en = vertices_.end();
+ for (; it != en; ++it)
+ it->path.clear();
+}
+
+
vector<int> const
Graph::getReachableTo(int target, bool clear_visited)
{
// Here's the logic, which is shared by the other routines.
// Q_ holds a list of nodes we have been able to reach (in this
- // case, reach backwards). It is initailized to the current node
+ // case, reach backwards). It is initialized to the current node
// by bfs_init, and then we recurse, adding the nodes we can reach
- // from the current node as we go.
+ // from the current node as we go. That makes it a breadth-first
+ // search.
while (!Q_.empty()) {
int const current = Q_.front();
Q_.pop();
if (current != target || formats.get(target).name() != "lyx")
result.push_back(current);
- vector<int>::iterator it = vertices_[current].in_vertices.begin();
- vector<int>::iterator end = vertices_[current].in_vertices.end();
+ vector<Arrow *>::iterator it = vertices_[current].in_arrows.begin();
+ vector<Arrow *>::iterator const end = vertices_[current].in_arrows.end();
for (; it != end; ++it) {
- if (!visited_[*it]) {
- visited_[*it] = true;
- Q_.push(*it);
+ const int cv = (*it)->from;
+ if (!vertices_[cv].visited) {
+ vertices_[cv].visited = true;
+ Q_.push(cv);
}
}
}
result.push_back(current);
}
- vector<OutEdge>::const_iterator cit =
+ vector<Arrow *>::const_iterator cit =
vertices_[current].out_arrows.begin();
- vector<OutEdge>::const_iterator end =
+ vector<Arrow *>::const_iterator end =
vertices_[current].out_arrows.end();
for (; cit != end; ++cit) {
- int const cv = cit->vertex;
- if (!visited_[cv]) {
- visited_[cv] = true;
+ int const cv = (*cit)->to;
+ if (!vertices_[cv].visited) {
+ vertices_[cv].visited = true;
Q_.push(cv);
}
}
if (current == to)
return true;
- vector<OutEdge>::const_iterator cit =
+ vector<Arrow *>::const_iterator cit =
vertices_[current].out_arrows.begin();
- vector<OutEdge>::const_iterator end =
+ vector<Arrow *>::const_iterator end =
vertices_[current].out_arrows.end();
for (; cit != end; ++cit) {
- int const cv = cit->vertex;
- if (!visited_[cv]) {
- visited_[cv] = true;
+ int const cv = (*cit)->to;
+ if (!vertices_[cv].visited) {
+ vertices_[cv].visited = true;
Q_.push(cv);
}
}
Graph::EdgePath const Graph::getPath(int from, int to)
{
- EdgePath path;
+ static const EdgePath path;
if (from == to)
return path;
if (to < 0 || !bfs_init(from))
return path;
- // pair<vertex, edge>
- vector<pair<int, int> > prev(vertices_.size());
-
- bool found = false;
+ clearPaths();
while (!Q_.empty()) {
int const current = Q_.front();
Q_.pop();
- vector<OutEdge>::const_iterator const beg =
+ vector<Arrow *>::const_iterator cit =
vertices_[current].out_arrows.begin();
- vector<OutEdge>::const_iterator cit = beg;
- vector<OutEdge>::const_iterator end =
+ vector<Arrow *>::const_iterator end =
vertices_[current].out_arrows.end();
for (; cit != end; ++cit) {
- int const cv = cit->vertex;
- if (!visited_[cv]) {
- visited_[cv] = true;
+ int const cv = (*cit)->to;
+ if (!vertices_[cv].visited) {
+ vertices_[cv].visited = true;
Q_.push(cv);
- // FIXME This will not do for finding multiple paths.
- // Perhaps we need a vector, or a set. We'll also want
- // to add this info, even if the node is visited, so
- // outside this conditional.
- prev[cv] = pair<int, int>(current, cit->edge);
+ // NOTE If we wanted to collect all the paths, then
+ // we just need to collect them here and not worry
+ // about "visited".
+ EdgePath lastpath = vertices_[(*cit)->from].path;
+ lastpath.push_back((*cit)->id);
+ vertices_[cv].path = lastpath;
}
if (cv == to) {
- found = true;
- break;
+ return vertices_[cv].path;
}
}
}
- if (!found)
- return path;
-
- while (to != from) {
- path.push_back(prev[to].second);
- to = prev[to].first;
- }
- reverse(path.begin(), path.end());
+ // failure
return path;
}
void Graph::init(int size)
{
vertices_ = vector<Vertex>(size);
- visited_.resize(size);
+ arrows_.clear();
numedges_ = 0;
}
void Graph::addEdge(int from, int to)
{
- vertices_[to].in_vertices.push_back(from);
- vertices_[from].out_arrows.push_back(OutEdge(to, numedges_++));
+ arrows_.push_back(Arrow(from, to, numedges_));
+ numedges_++;
+ Arrow * ar = &(arrows_.back());
+ vertices_[to].in_arrows.push_back(ar);
+ vertices_[from].out_arrows.push_back(ar);
}
-vector<Graph::Vertex> Graph::vertices_;
+// At present, we do not need this debugging code, but
+// I am going to leave it here in case we need it again.
+#if 0
+void Graph::dumpGraph() const
+{
+ vector<Vertex>::const_iterator it = vertices_.begin();
+ vector<Vertex>::const_iterator en = vertices_.end();
+ for (; it != en; ++it) {
+ LYXERR0("Next vertex...");
+ LYXERR0("In arrows...");
+ std::vector<Arrow *>::const_iterator iit = it->in_arrows.begin();
+ std::vector<Arrow *>::const_iterator ien = it->in_arrows.end();
+ for (; iit != ien; ++iit)
+ LYXERR0("From " << (*iit)->from << " to " << (*iit)->to);
+ LYXERR0("Out arrows...");
+ iit = it->out_arrows.begin();
+ ien = it->out_arrows.end();
+ for (; iit != ien; ++iit)
+ LYXERR0("From " << (*iit)->from << " to " << (*iit)->to);
+ }
+}
+#endif
} // namespace lyx