roby 0.7

data/ext/graph/graph.hh

@@ -0,0 +1,183 @@
+#ifndef RUBY_BGL_GRAPH_HH
+#define RUBY_BGL_GRAPH_HH
+
+#include <ruby.h>
+#include <boost/graph/adjacency_list.hpp>
+#include <set>
+#include <boost/tuple/tuple.hpp>
+
+extern VALUE bglModule;
+extern VALUE bglGraph;
+extern VALUE bglReverseGraph;
+extern VALUE bglUndirectedGraph;
+extern VALUE bglVertex;
+
+/**********************************************************************
+ * Definition of base C++ types
+ */
+
+struct EdgeProperty
+{
+    VALUE info;
+    boost::default_color_type color; // needed by some algorithms
+
+    EdgeProperty(VALUE info)
+	: info(info) { }
+};
+
+typedef boost::adjacency_list< boost::setS, boost::setS
+		      , boost::bidirectionalS, VALUE, EdgeProperty>	RubyGraph;
+typedef std::map<VALUE, RubyGraph::vertex_descriptor>	graph_map;
+
+inline RubyGraph& graph_wrapped(VALUE self)
+{
+    RubyGraph* object = 0;
+    Data_Get_Struct(self, RubyGraph, object);
+    return *object;
+}
+
+extern graph_map& vertex_descriptor_map(VALUE self);
+
+/* Return the vertex_descriptor of +self+ in +graph+. The boolean is true if
+ * +self+ is in graph, and false otherwise.
+ */
+inline std::pair<RubyGraph::vertex_descriptor, bool> 
+rb_to_vertex(VALUE vertex, VALUE graph)
+{
+    graph_map& descriptors = vertex_descriptor_map(vertex);
+    graph_map::iterator it = descriptors.find(graph);
+    if(it == descriptors.end())
+	return std::make_pair(static_cast<void*>(0), false);
+    else
+	return std::make_pair(it->second, true);
+}
+
+/* Returns a range for all descriptors of +self+
+ */
+inline std::pair<graph_map::iterator, graph_map::iterator> vertex_descriptors(VALUE self)
+{
+    graph_map& descriptors = vertex_descriptor_map(self);
+    return make_pair(descriptors.begin(), descriptors.end());
+}
+
+
+namespace details
+{
+    template<typename Graph, bool direct> struct vertex_range;
+
+    template<typename Graph>
+    struct vertex_range<Graph, true>
+    { 
+	typedef typename Graph::adjacency_iterator iterator;
+	typedef std::pair<iterator, iterator> range;
+
+	static range get(RubyGraph::vertex_descriptor v, Graph& graph) 
+	{ return adjacent_vertices(v, graph); }
+	static range get(RubyGraph::vertex_descriptor v, Graph const& graph) 
+	{ return adjacent_vertices(v, graph); }
+    };
+
+    template<typename Graph>
+    struct vertex_range<Graph, false>
+    { 
+	typedef typename Graph::inv_adjacency_iterator iterator;
+	typedef std::pair<iterator, iterator> range;
+
+	static range get(RubyGraph::vertex_descriptor v, Graph& graph) 
+	{ return inv_adjacent_vertices(v, graph); }
+	static range get(RubyGraph::vertex_descriptor v, Graph const& graph) 
+	{ return inv_adjacent_vertices(v, graph); }
+    };
+}
+
+/** Iterates on all vertices in the range */
+template <typename Range, typename F>
+static bool for_each_value(Range range, RubyGraph& graph, F f)
+{
+    typedef typename Range::first_type Iterator;
+    Iterator it, end;
+    for (boost::tie(it, end) = range; it != end; )
+    {
+	VALUE value = graph[*it];
+	++it;
+
+	if (!f(value))
+	    return false;
+    }
+    return true;
+}
+
+/** Iterates on each adjacent vertex of +v+ in +graph+ which are not yet in +already_seen+ */
+template <typename Graph, bool direct>
+static bool for_each_adjacent_uniq(RubyGraph::vertex_descriptor v, Graph const& graph, std::set<VALUE>& already_seen)
+{
+    typedef details::vertex_range<Graph, direct>	getter;
+    typedef typename getter::iterator		        Iterator;
+
+    Iterator it, end;
+    for (boost::tie(it, end) = details::vertex_range<Graph, direct>::get(v, graph); it != end; )
+    {
+	VALUE related_object = graph[*it];
+	bool inserted;
+	boost::tie(boost::tuples::ignore, inserted) = already_seen.insert(related_object);
+	++it;
+
+	if (inserted)
+	    rb_yield_values(1, related_object);
+    }
+    return true;
+}
+
+/* Iterates on all graphs +vertex+ is part of, calling f(RubyGraph&, vertex_descriptor). If the calling
+ * function returns false, stop iteration here */
+template<typename F>
+static bool for_each_graph(VALUE vertex, F f)
+{
+    graph_map::iterator graph, graph_end;
+    for (boost::tie(graph, graph_end) = vertex_descriptors(vertex); graph != graph_end;)
+    {
+	RubyGraph& g	    = graph_wrapped(graph->first);
+	RubyGraph::vertex_descriptor v = graph->second;
+	++graph;
+
+	if (!f(v, g))
+	    return false;
+    }
+    return true;
+}
+
+// Returns true if +v+ has either no child (if +direct+ is true) or no parents (if +direct+ is false)
+template<typename Graph, bool direct>
+bool vertex_has_adjacent_i(RubyGraph::vertex_descriptor v, Graph const& g)
+{
+    typedef typename details::vertex_range<Graph, direct> getter;
+    typename getter::iterator begin, end;
+    boost::tie(begin, end) = getter::get(v, g);
+    return begin == end;
+}
+
+template<bool direct>
+VALUE vertex_has_adjacent(int argc, VALUE* argv, VALUE self)
+{
+    VALUE graph = Qnil;
+    rb_scan_args(argc, argv, "01", &graph);
+
+    bool result;
+    if (NIL_P(graph))
+	result = for_each_graph(self, vertex_has_adjacent_i<RubyGraph, direct>);
+    else
+    {
+	RubyGraph::vertex_descriptor v; bool exists;
+	boost::tie(v, exists) = rb_to_vertex(self, graph);
+	if (! exists)
+	    return Qtrue;
+
+	RubyGraph& g = graph_wrapped(graph);
+	result = vertex_has_adjacent_i<RubyGraph, direct>(v, g);
+    }
+    return result ? Qtrue : Qfalse;
+}
+
+
+#endif
+

data/ext/graph/iterator_sequence.hh

@@ -0,0 +1,102 @@
+#ifndef UTILMM_ITERATOR_SEQUENCE_HPP
+#define UTILMM_ITERATOR_SEQUENCE_HPP
+
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace utilmm {
+    /**
+     * The iterator_sequence template takes two iterator ranges and iterates in the two ranges
+     * as if they were a single sequence. The only constraint is that both iterator types have
+     * the same value_type.
+     */
+    template<typename It1, typename It2>
+    class iterator_sequence : 
+	public boost::iterator_facade<
+	    iterator_sequence<It1, It2>,
+	    typename It1::value_type,
+	    typename boost::iterator_traversal<It1>::type,
+	    typename It1::reference >
+    {
+	typedef iterator_sequence<It1, It2> Self;
+
+    public:
+	/** Builds a new sequence
+	 * Note that for an iterator sequence (fb, fe) + (sb, se),
+	 * <ul>
+	 *  <li> the begin iterator is i_s(fb, fe, sb, sb)
+	 *  <li> the end iterator is i_s(fe, fe, se, se)
+	 * </ul>
+	 *
+	 * @param first the position in the first range
+	 * @param first_end the end of the first range
+	 * @param second_begin the beginning of the second range
+	 * @param second the position in the second range
+	 */
+	iterator_sequence(
+		It1 first, It1 first_end,
+		It2 second_begin, It2 second)
+	    : m_first(first), m_first_end(first_end)
+	    , m_second_begin(second_begin), m_second(second) {}
+	iterator_sequence() {}
+
+    private:
+	friend class boost::iterator_core_access;
+
+	It1 m_first, m_first_end;
+	It2 m_second_begin, m_second;
+
+	typename Self::reference dereference() const
+	{
+	    if (m_first == m_first_end)
+		return *m_second;
+	    else
+		return *m_first;
+	}
+	bool equal(Self x) const
+	{ return (x.m_first == m_first && x.m_second == m_second); }
+	void increment()
+	{
+	    if (m_first == m_first_end)
+		++m_second;
+	    else
+		++m_first;
+	}
+	void decrement()
+	{
+	    if (m_second == m_second_begin)
+		--m_first;
+	    else
+		--m_second;
+	}
+	void advance(typename Self::difference_type i)
+	{
+	    if (i > 0)
+	    {
+		typename Self::difference_type remains = m_first_end - m_first;
+		if (remains > i)
+		    m_first += i;
+		else
+		{
+		    m_first = m_first_end;
+		    m_second += i - remains;
+		}
+	    }
+	    else
+	    {
+		typename Self::difference_type remains = m_second_begin - m_second;
+		if (remains < i)
+		    m_second += i;
+		else
+		{
+		    m_second = m_second_begin;
+		    m_first += i - remains;
+		}
+	    }
+	}
+
+	typename Self::difference_type distance_to(Self x) const
+	{ return (x.m_first - m_first) + (x.m_second - m_second); }
+    };
+}
+#endif

data/ext/graph/undirected_dfs.hh

@@ -0,0 +1,226 @@
+//=======================================================================
+// Copyright 2006 Sylvain Joyeux
+//   * added a terminator function to undirected_dfs_visit
+//   * specialize for use with undirected_graph<>
+//
+// Copyright 1997, 1998, 1999, 2000 University of Notre Dame.
+// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+//
+#ifndef UTILMM_GRAPH_UNDIRECTED_DFS_HPP
+#define UTILMM_GRAPH_UNDIRECTED_DFS_HPP
+
+#include <boost/graph/depth_first_search.hpp>
+#include <vector>
+
+namespace utilmm {
+  namespace detail {
+    using namespace boost;
+    struct nontruth2 {
+        template<class T, class T2>
+            bool operator()(const T&, const T2&) const { return false; }
+    };
+
+    template <typename IncidenceGraph, typename DFSVisitor, 
+              typename VertexColorMap, typename EdgeColorMap,
+	      typename TerminatorFunc>
+    void undir_dfv_impl_term
+      (const IncidenceGraph& g,
+       typename graph_traits<IncidenceGraph>::vertex_descriptor u, 
+       DFSVisitor& vis,
+       VertexColorMap vertex_color,
+       EdgeColorMap edge_color,
+       TerminatorFunc func = TerminatorFunc())
+    {
+      function_requires<IncidenceGraphConcept<IncidenceGraph> >();
+      function_requires<DFSVisitorConcept<DFSVisitor, IncidenceGraph> >();
+      typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
+      typedef typename graph_traits<IncidenceGraph>::edge_descriptor Edge;
+      function_requires<ReadWritePropertyMapConcept<VertexColorMap,Vertex> >();
+      function_requires<ReadWritePropertyMapConcept<EdgeColorMap,Edge> >();
+      typedef typename property_traits<VertexColorMap>::value_type ColorValue;
+      typedef typename property_traits<EdgeColorMap>::value_type EColorValue;
+      function_requires< ColorValueConcept<ColorValue> >();
+      function_requires< ColorValueConcept<EColorValue> >();
+      typedef color_traits<ColorValue> Color;
+      typedef color_traits<EColorValue> EColor;
+      typedef typename graph_traits<IncidenceGraph>::out_edge_iterator Iter;
+      typedef std::pair<Vertex, std::pair<Iter, Iter> > VertexInfo;
+
+      std::vector<VertexInfo> stack;
+
+      put(vertex_color, u, Color::gray());
+      vis.discover_vertex(u, g);
+
+      Iter ei, ei_end;
+      tie(ei, ei_end) = out_edges(u, g);
+      if (func(u, g))
+	  stack.push_back(std::make_pair(u, std::make_pair(ei_end, ei_end)));
+      else
+	  stack.push_back(std::make_pair(u, std::make_pair(ei, ei_end)));
+
+      while (!stack.empty()) {
+        VertexInfo& back = stack.back();
+        u = back.first;
+        tie(ei, ei_end) = back.second;
+        stack.pop_back();
+        while (ei != ei_end) {
+          Vertex v = target(*ei, g);
+          vis.examine_edge(*ei, g);
+          ColorValue v_color = get(vertex_color, v);
+          EColorValue uv_color = get(edge_color, *ei);
+          put(edge_color, *ei, EColor::black());
+          if (v_color == Color::white()) {
+            vis.tree_edge(*ei, g);
+            stack.push_back(std::make_pair(u, std::make_pair(++ei, ei_end)));
+            u = v;
+            put(vertex_color, u, Color::gray());
+            vis.discover_vertex(u, g);
+            tie(ei, ei_end) = out_edges(u, g);
+	    if (func(u, g))
+		ei = ei_end;
+          } else if (v_color == Color::gray()) {
+            if (uv_color == EColor::white()) vis.back_edge(*ei, g);
+            ++ei;
+          } else { // if (v_color == Color::black())
+            vis.forward_or_cross_edge(*ei, g);
+            ++ei;
+          }
+        }
+        put(vertex_color, u, Color::black());
+        vis.finish_vertex(u, g);
+      }
+    }
+  } // namespace detail
+
+  template <typename Graph, typename DFSVisitor, 
+            typename VertexColorMap, typename EdgeColorMap, 
+            typename Vertex>
+  void
+  undirected_dfs(const Graph& g, DFSVisitor vis, 
+                 VertexColorMap vertex_color, EdgeColorMap edge_color,
+                 Vertex start_vertex)
+  {
+    using namespace boost;
+    function_requires<DFSVisitorConcept<DFSVisitor, Graph> >();
+      function_requires<EdgeListGraphConcept<Graph> >();
+
+    typedef typename property_traits<VertexColorMap>::value_type ColorValue;
+    typedef color_traits<ColorValue> Color;
+
+    typename graph_traits<Graph>::vertex_iterator ui, ui_end;
+    for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
+      put(vertex_color, *ui, Color::white());   vis.initialize_vertex(*ui, g);
+    }
+    typename graph_traits<Graph>::edge_iterator ei, ei_end;
+    for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+      put(edge_color, *ei, Color::white());
+
+    if (start_vertex != *vertices(g).first){ vis.start_vertex(start_vertex, g);
+      detail::undir_dfv_impl_term(g, start_vertex, vis, vertex_color, edge_color, detail::nontruth2());
+    }
+
+    for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
+      ColorValue u_color = get(vertex_color, *ui);
+      if (u_color == Color::white()) {       vis.start_vertex(*ui, g);
+        detail::undir_dfv_impl_term(g, *ui, vis, vertex_color, edge_color, detail::nontruth2());
+      }
+    }
+  }
+
+  template <typename Graph, typename DFSVisitor, typename VertexColorMap,
+    typename EdgeColorMap>
+  void
+  undirected_dfs(const Graph& g, DFSVisitor vis, 
+                 VertexColorMap vertex_color, EdgeColorMap edge_color)
+  {
+    using namespace boost;
+    undirected_dfs(g, vis, vertex_color, edge_color, *vertices(g).first, detail::nontruth2());
+  }
+
+  namespace detail {
+    template <typename VertexColorMap>
+    struct udfs_dispatch {
+
+      template <typename Graph, typename Vertex, 
+                typename DFSVisitor, typename EdgeColorMap,
+                typename P, typename T, typename R>
+      static void
+      apply(const Graph& g, DFSVisitor vis, Vertex start_vertex,
+            const bgl_named_params<P, T, R>&,
+            EdgeColorMap edge_color,
+            VertexColorMap vertex_color)
+      {
+        undirected_dfs(g, vis, vertex_color, edge_color, start_vertex);
+      }
+    };
+
+    template <>
+    struct udfs_dispatch<boost::detail::error_property_not_found> {
+      template <typename Graph, typename Vertex, typename DFSVisitor,
+                typename EdgeColorMap,
+                typename P, typename T, typename R>
+      static void
+      apply(const Graph& g, DFSVisitor vis, Vertex start_vertex,
+            const bgl_named_params<P, T, R>& params,
+            EdgeColorMap edge_color,
+            boost::detail::error_property_not_found)
+      {
+        std::vector<default_color_type> color_vec(num_vertices(g));
+        default_color_type c = white_color; // avoid warning about un-init
+        undirected_dfs
+          (g, vis, make_iterator_property_map
+           (color_vec.begin(),
+            choose_const_pmap(get_param(params, vertex_index),
+                              g, vertex_index), c),
+           edge_color,
+           start_vertex);
+      }
+    };
+
+  } // namespace detail
+  
+
+  // Named Parameter Variant
+  template <typename Graph, typename P, typename T, typename R>
+  void
+  undirected_dfs(const Graph& g, 
+                 const boost::bgl_named_params<P, T, R>& params)
+  {
+    using namespace boost;
+    typedef typename property_value< bgl_named_params<P, T, R>, 
+      vertex_color_t>::type C;
+    detail::udfs_dispatch<C>::apply
+      (g,
+       choose_param(get_param(params, graph_visitor),
+                    make_dfs_visitor(null_visitor())),
+       choose_param(get_param(params, root_vertex_t()),
+                    *vertices(g).first),
+       params,
+       get_param(params, edge_color),
+       get_param(params, vertex_color)
+       );
+  }
+  
+
+  template <typename IncidenceGraph, typename DFSVisitor, 
+    typename VertexColorMap, typename EdgeColorMap,
+    typename TerminatorFunc>
+  void undirected_depth_first_visit
+    (const IncidenceGraph& g,
+     typename boost::graph_traits<IncidenceGraph>::vertex_descriptor u, 
+     DFSVisitor vis, VertexColorMap vertex_color, EdgeColorMap edge_color,
+     TerminatorFunc func = TerminatorFunc())
+  {
+    detail::undir_dfv_impl_term(g, u, vis, vertex_color, edge_color, func);
+  }
+
+
+} // namespace boost
+
+
+#endif