doxygen tweak: graph.h

Author: polgreen

src/util/graph.h

@@ -19,9 +19,8 @@ Author: Daniel Kroening, [email protected]
 #include <list>
 #include <map>
 #include <queue>
-#include <stack>
-#include <vector>
 #include <set>
+#include <vector>
 
 #include "invariant.h"
 
@@ -256,13 +255,24 @@ class grapht
   void disconnect_unreachable(node_indext src);
   void disconnect_unreachable(const std::vector<node_indext> &src);
 
+  /// Run recursive depth-limited search on the graph, starting
+  /// from a vector of start nodes, to find the nodes reachable within n steps,
+  /// excluding the start node unless a self loop exists.
+  /// \param from: vector of node indices to start from
+  /// \param depth: depth limit
+  /// \return set of node indices of reachable nodes
   std::set<node_indext> depth_limited_search(
     const std::vector<node_indext> &from,
-    std::size_t steps) const;
+    std::size_t depth) const;
 
-  std::set<node_indext> depth_limited_search(
-    node_indext from,
-    std::size_t steps) const;
+  /// Run recursive depth-limited search on the graph, starting
+  /// from a vector of start nodes, to find the nodes reachable within n steps,
+  /// excluding the start node unless a self loop exists.
+  /// \param from: node index to start from
+  /// \param depth: depth limit
+  /// \return set of node indices of reachable nodes
+  std::set<node_indext>
+  depth_limited_search(node_indext from, std::size_t depth) const;
 
   void make_chordal();
 
@@ -287,6 +297,13 @@ class grapht
     std::function<void(const node_indext &)> f) const;
 
 protected:
+  /// Run recursive depth-limited search on the graph, starting
+  /// from a vector of start nodes, to find the nodes reachable within n steps,
+  /// excluding the start node unless a self loop exists.
+  /// \param from: node index to start from
+  /// \param depth: depth limit
+  /// \param result: set of nodes that have been visited so far.
+  /// Reachable nodes are inserted into this set
   void depth_limited_search(
     node_indext from,
     std::size_t depth,
@@ -598,51 +615,33 @@ std::vector<typename N::node_indext> grapht<N>::get_reachable(
   return result;
 }
 
-/// Run recursive depth-limited search on the graph, starting
-/// from a vector of start nodes, to find the nodes reachable within n steps,
-/// excluding the start node unless a self loop exists.
-/// \param from : vector of node indices to start from
-/// \param depth : depth limit
-/// \return set of node indices of reachable nodes
 template <class N>
-std::set<typename N::node_indext> grapht<N>::depth_limited_search(
-  const std::vector<node_indext> &from, size_t depth) const
+std::set<typename grapht<N>::node_indext> grapht<N>::depth_limited_search(
+  const std::vector<node_indext> &from,
+  size_t depth) const
 {
   std::set<node_indext> result;
   for(const node_indext src : from)
     depth_limited_search(src, depth, result);
   return result;
 }
 
-/// Run recursive depth-limited search on the graph, starting
-/// from a single start node, to find the nodes reachable within n steps,
-/// excluding the start node unless a self loop exists.
-/// \param from : index of node to start from
-/// \param depth : depth limit
-/// \return set of node indices of reachable nodes
 template <class N>
-std::set<typename N::node_indext> grapht<N>::depth_limited_search(
-  const node_indext from, size_t depth) const
+std::set<typename grapht<N>::node_indext>
+grapht<N>::depth_limited_search(const node_indext from, size_t depth) const
 {
   std::set<node_indext> result;
-    depth_limited_search(from, depth, result);
+  depth_limited_search(from, depth, result);
   return result;
 }
 
-/// Run recursive depth-limited search on the graph, starting
-/// from a single start node, to find the nodes reachable within n steps,
-/// excluding the start node unless a self loop exists.
-/// \param from : index of node to start from
-/// \param depth : depth limit
-/// \param result : set of node indices of nodes visited so far. Reachable
-/// nodes are added to this set
 template <class N>
 void grapht<N>::depth_limited_search(
   node_indext from,
   std::size_t depth,
   std::set<node_indext> &result) const
 {
-  if(depth==0)
+  if(depth == 0)
     return;
 
   for(const auto o : nodes[from].out)