roby 0.8.0 → 3.0.0

data/ext/graph/undirected_graph.hh

@@ -1,421 +0,0 @@
-//  (C) Copyright Sylvain Joyeux 2006
-//
-// Original code from reverse_graph adaptor
-//  (C) Copyright David Abrahams 2000.
-//
-// 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 UNDIRECTED_GRAPH_HPP
-#define UNDIRECTED_GRAPH_HPP
-
-#include <boost/graph/adjacency_iterator.hpp>
-#include <boost/graph/properties.hpp>
-#include <boost/static_assert.hpp>
-#include "iterator_sequence.hh"
-#include <boost/iterator/transform_iterator.hpp>
-
-#include <boost/type_traits.hpp>
-
-namespace utilmm {
-    struct undirected_graph_tag { };
-
-    /** undirected_graph creates an undirected graph from a bidirectional graph. This can allow
-     * to use some undirected-graph-only algorithms on bidirectional graphs
-     */
-    template <class BidirectionalGraph, class GraphRef = const BidirectionalGraph&>
-    class undirected_graph {
-	typedef undirected_graph<BidirectionalGraph, GraphRef> Self;
-	typedef boost::graph_traits<BidirectionalGraph> Traits;
-
-	BOOST_STATIC_ASSERT(( boost::is_same<boost::bidirectional_tag, typename BidirectionalGraph::directed_category>::value ));
-
-     public:
-	typedef BidirectionalGraph base_type;
-
-	// Constructor
-	undirected_graph(GraphRef g) : m_g(g) {}
-
-	// Graph requirements
-	typedef typename Traits::vertex_descriptor vertex_descriptor;
-	typedef boost::undirected_tag directed_category;
-	typedef typename Traits::edge_parallel_category edge_parallel_category;
-	typedef typename Traits::traversal_category traversal_category;
-
-	// Add a 'reverse' flag to edge descriptors, so that source() and target() know what
-	// needs to be done
-	typedef std::pair<typename Traits::edge_descriptor, bool> edge_descriptor;
-	typedef edge_descriptor (*make_undirected_edge_descriptor)(typename Traits::edge_descriptor);
-
-	// Out edges do not need to be swapped
-	static edge_descriptor make_out_edge_descriptor(typename Traits::edge_descriptor e)
-	{ return make_pair(e, false); }
-	class base_out_edge_iterator : 
-	    public boost::transform_iterator<make_undirected_edge_descriptor, typename Traits::out_edge_iterator>
-	{
-	    typedef boost::transform_iterator<make_undirected_edge_descriptor, typename Traits::out_edge_iterator>
-		base_type;
-
-	public:
-	    base_out_edge_iterator() {}
-	    base_out_edge_iterator(typename Traits::out_edge_iterator e)
-		: base_type(e, make_out_edge_descriptor) {}
-	};
-
-	static edge_descriptor make_in_edge_descriptor(typename Traits::edge_descriptor e)
-	{ return make_pair(e, true); }
-	class base_in_edge_iterator : 
-	    public boost::transform_iterator<make_undirected_edge_descriptor, typename Traits::in_edge_iterator>
-	{
-	    typedef boost::transform_iterator<make_undirected_edge_descriptor, typename Traits::in_edge_iterator>
-		base_type;
-
-	public:
-	    base_in_edge_iterator() {}
-	    base_in_edge_iterator(typename Traits::in_edge_iterator e)
-		: base_type(e, make_in_edge_descriptor) {}
-	};
-
-	// Do not swap plain edge iterators
-	class edge_iterator : 
-	    public boost::transform_iterator<make_undirected_edge_descriptor, typename Traits::edge_iterator>
-	{
-	    typedef boost::transform_iterator<make_undirected_edge_descriptor, typename Traits::edge_iterator>
-		base_type;
-	public:
-	    edge_iterator() {}
-	    edge_iterator(typename Traits::edge_iterator e)
-		: base_type(e, make_out_edge_descriptor) {}
-	};
-
-	// IncidenceGraph requirements
-	typedef typename Traits::degree_size_type degree_size_type;
-	typedef iterator_sequence
-	    < base_in_edge_iterator
-	    , base_out_edge_iterator
-	    > in_edge_iterator;
-	typedef in_edge_iterator out_edge_iterator;
-
-	// AdjacencyGraph requirements
-	typedef iterator_sequence
-	    < typename Traits::adjacency_iterator
-	    , typename BidirectionalGraph::inv_adjacency_iterator
-	    > adjacency_iterator;
-	typedef adjacency_iterator inv_adjacency_iterator;
-
-	// VertexListGraph requirements
-	typedef typename Traits::vertex_iterator vertex_iterator;
-
-	// EdgeListGraph requirements
-	typedef typename Traits::edge_iterator   edge_iterator;
-	typedef typename Traits::vertices_size_type vertices_size_type;
-	typedef typename Traits::edges_size_type edges_size_type;
-
-	// More typedefs used by detail::edge_property_map, vertex_property_map
-	typedef typename BidirectionalGraph::edge_property_type
-	  edge_property_type;
-	typedef typename BidirectionalGraph::vertex_property_type
-	  vertex_property_type;
-	typedef undirected_graph_tag graph_tag;
-
-	static vertex_descriptor null_vertex()
-	{ return Traits::null_vertex(); }
-
-	// Bundled properties support
-        typename boost::graph::detail::bundled_result<BidirectionalGraph,
-                 edge_descriptor>::type&
-        operator[](edge_descriptor x)
-        { return m_g[x.first]; }
-
-        typename boost::graph::detail::bundled_result<BidirectionalGraph,
-                 edge_descriptor>::type const&
-        operator[](edge_descriptor x) const
-        { return m_g[x.first]; }
-
-
-
-        typename boost::graph::detail::bundled_result<BidirectionalGraph,
-                 vertex_descriptor>::type&
-        operator[](vertex_descriptor x)
-        { return m_g[x]; }
-
-        typename boost::graph::detail::bundled_result<BidirectionalGraph,
-                 vertex_descriptor>::type const&
-        operator[](vertex_descriptor x) const
-        { return m_g[x]; }
-
-
-	// would be private, but template friends aren't portable enough.
-     // private:
-	GraphRef m_g;
-    };
-
-    template <class BidirectionalGraph>
-    inline undirected_graph<BidirectionalGraph>
-    make_undirected_graph(const BidirectionalGraph& g)
-    {
-	return undirected_graph<BidirectionalGraph>(g);
-    }
-
-    template <class BidirectionalGraph>
-    inline undirected_graph<BidirectionalGraph, BidirectionalGraph&>
-    make_undirected_graph(BidirectionalGraph& g)
-    {
-	return undirected_graph<BidirectionalGraph, BidirectionalGraph&>(g);
-    }
-
-    template <class BidirectionalGraph, class GRef>
-    std::pair<typename undirected_graph<BidirectionalGraph>::vertex_iterator,
-	      typename undirected_graph<BidirectionalGraph>::vertex_iterator>
-    vertices(const undirected_graph<BidirectionalGraph,GRef>& g)
-    {
-	return vertices(g.m_g);
-    }
-
-    template <class BidirectionalGraph, class GRef>
-    std::pair<typename undirected_graph<BidirectionalGraph>::edge_iterator,
-	      typename undirected_graph<BidirectionalGraph>::edge_iterator>
-    edges(const undirected_graph<BidirectionalGraph,GRef>& g)
-    {
-	return edges(g.m_g);
-    }
-
-    template <class BidirectionalGraph, class GRef>
-    inline std::pair<typename undirected_graph<BidirectionalGraph,GRef>::out_edge_iterator,
-		     typename undirected_graph<BidirectionalGraph,GRef>::out_edge_iterator>
-    out_edges(const typename BidirectionalGraph::vertex_descriptor u,
-	      const undirected_graph<BidirectionalGraph,GRef>& g)
-    {
-	std::pair<typename BidirectionalGraph::out_edge_iterator,
-		  typename BidirectionalGraph::out_edge_iterator>
-		      out_edges = boost::out_edges(u, g.m_g);
-	std::pair<typename BidirectionalGraph::in_edge_iterator,
-		  typename BidirectionalGraph::in_edge_iterator> 
-		      in_edges = boost::in_edges(u, g.m_g);
-
-	typedef typename undirected_graph<BidirectionalGraph,GRef>::out_edge_iterator edge_iterator;
-	return make_pair(
-		edge_iterator(in_edges.first, in_edges.second, out_edges.first, out_edges.first),
-		edge_iterator(in_edges.second, in_edges.second, out_edges.second, out_edges.second));
-    }
-
-    template <class BidirectionalGraph, class GRef>
-    inline typename BidirectionalGraph::vertices_size_type
-    num_vertices(const undirected_graph<BidirectionalGraph,GRef>& g)
-    {
-	return num_vertices(g.m_g);
-    }
-
-    template <class BidirectionalGraph, class GRef>
-    inline typename undirected_graph<BidirectionalGraph>::edges_size_type
-    num_edges(const undirected_graph<BidirectionalGraph,GRef>& g)
-    {
-	return num_edges(g.m_g);
-    }
-
-    template <class BidirectionalGraph, class GRef>
-    inline typename BidirectionalGraph::degree_size_type
-    out_degree(const typename BidirectionalGraph::vertex_descriptor u,
-	       const undirected_graph<BidirectionalGraph,GRef>& g)
-    {
-	return in_degree(u, g.m_g) + out_degree(u, g.m_g);
-    }
-
-    template <class BidirectionalGraph, class GRef>
-    inline std::pair<typename BidirectionalGraph::edge_descriptor, bool>
-    edge(const typename BidirectionalGraph::vertex_descriptor u,
-	 const typename BidirectionalGraph::vertex_descriptor v,
-	 const undirected_graph<BidirectionalGraph,GRef>& g)
-    {
-	return edge(v, u, g.m_g);
-    }
-
-    template <class BidirectionalGraph, class GRef>
-    inline std::pair<typename BidirectionalGraph::out_edge_iterator,
-	typename BidirectionalGraph::out_edge_iterator>
-    in_edges(const typename BidirectionalGraph::vertex_descriptor u,
-	     const undirected_graph<BidirectionalGraph,GRef>& g)
-    { return out_edges(u, g); }
-
-    template <class BidirectionalGraph, class GRef>
-    inline std::pair<typename undirected_graph<BidirectionalGraph,GRef>::adjacency_iterator,
-		     typename undirected_graph<BidirectionalGraph,GRef>::adjacency_iterator>
-    adjacent_vertices(const typename BidirectionalGraph::vertex_descriptor u,
-		      const undirected_graph<BidirectionalGraph,GRef>& g)
-    {
-	std::pair<typename BidirectionalGraph::adjacency_iterator,
-		  typename BidirectionalGraph::adjacency_iterator> 
-		      adjacency = boost::adjacent_vertices(u, g.m_g);
-	std::pair<typename BidirectionalGraph::inv_adjacency_iterator,
-		  typename BidirectionalGraph::inv_adjacency_iterator>
-		      inv_adjacency = boost::inv_adjacent_vertices(u, g.m_g);
-
-	typedef typename undirected_graph<BidirectionalGraph,GRef>::adjacency_iterator adjacency_iterator;
-	return std::make_pair(
-		adjacency_iterator(adjacency.first, adjacency.second, inv_adjacency.first, inv_adjacency.first),
-		adjacency_iterator(adjacency.second, adjacency.second, inv_adjacency.second, inv_adjacency.second));
-    }
-
-    template <class BidirectionalGraph, class GRef>
-    inline typename BidirectionalGraph::degree_size_type
-    in_degree(const typename BidirectionalGraph::vertex_descriptor u,
-	      const undirected_graph<BidirectionalGraph,GRef>& g)
-    { return out_degree(u, g); }
-
-    template <class Edge, class BidirectionalGraph, class GRef>
-    inline typename boost::graph_traits<BidirectionalGraph>::vertex_descriptor
-    source(const Edge& e, const undirected_graph<BidirectionalGraph,GRef>& g)
-    {
-	if (e.second)
-	    return target(e.first, g.m_g);
-	else
-	    return source(e.first, g.m_g);
-    }
-
-    template <class Edge, class BidirectionalGraph, class GRef>
-    inline typename boost::graph_traits<BidirectionalGraph>::vertex_descriptor
-    target(const Edge& e, const undirected_graph<BidirectionalGraph,GRef>& g)
-    {
-	if (e.second)
-	    return source(e.first, g.m_g);
-	else
-	    return target(e.first, g.m_g);
-    }
-
-
-    namespace detail {
-
-      struct undirected_graph_vertex_property_selector {
-	template <class UndirectedGraph, class Property, class Tag>
-	struct bind_ {
-	  typedef typename UndirectedGraph::base_type Graph;
-	  typedef boost::property_map<Graph, Tag> PMap;
-	  typedef typename PMap::type type;
-	  typedef typename PMap::const_type const_type;
-	};
-      };
-
-      struct undirected_graph_edge_property_selector {
-	template <class UndirectedGraph, class Property, class Tag>
-	struct bind_ {
-	  typedef typename UndirectedGraph::base_type Graph;
-	  typedef boost::property_map<Graph, Tag> PMap;
-	  typedef typename PMap::type type;
-	  typedef typename PMap::const_type const_type;
-	};
-      };
-
-    } // namespace detail
-
-    /** This class adapts a property map on the edges of a graph to a property map
-     * on the edges of the corresponding undirected graph */
-    template<typename PropertyMap>
-    class undirected_property_map 
-    { 
-    public:
-	undirected_property_map(PropertyMap pmap)
-	    : m_map(pmap) {}
-
-	PropertyMap& map() { return m_map; }
-	PropertyMap const& map() const { return m_map; }
-
-    private:
-	PropertyMap m_map;
-    };
-
-    template<typename PropertyMap, typename EdgeDescriptor, typename ValueType>
-    void put(undirected_property_map<PropertyMap>& map, 
-	    EdgeDescriptor e, ValueType value)
-    { put(map.map(), e.first, value); }
-    template<typename PropertyMap, typename EdgeDescriptor>
-    typename boost::property_traits<PropertyMap>::value_type
-	get(undirected_property_map<PropertyMap> const& map, 
-	    EdgeDescriptor e)
-    { return get(map.map(), e.first); }
-
-    template<typename PropertyMap>
-    undirected_property_map<PropertyMap> make_undirected_edge_map(PropertyMap pmap)
-    { return undirected_property_map<PropertyMap>(pmap); }
-
-
-} // namespace utilmm
-
-// Include specialization in the boost namespace
-namespace boost {
-    template<typename PropertyMap>
-    struct property_traits< utilmm::undirected_property_map<PropertyMap> >
-	: property_traits<PropertyMap> {};
-
-    template <>
-    struct vertex_property_selector<utilmm::undirected_graph_tag> {
-	typedef utilmm::detail::undirected_graph_vertex_property_selector type;
-    };
-
-    template <>
-    struct edge_property_selector<utilmm::undirected_graph_tag> {
-	typedef utilmm::detail::undirected_graph_edge_property_selector type;
-    };
-
-    namespace detail {
-	template<typename BidirGraph, typename GRef, typename Property>
-	struct get_property_map_type { };
-	template<typename BidirGraph, typename Property>
-	struct get_property_map_type<BidirGraph, const BidirGraph&, Property>
-	{ typedef typename property_map<BidirGraph, Property>::const_type type; };
-	template<typename BidirGraph, typename Property>
-	struct get_property_map_type<BidirGraph, BidirGraph&, Property>
-	{ typedef typename property_map<BidirGraph, Property>::type type; };
-    }
-
-    template <class BidirGraph, class GRef, class Property>
-    typename detail::get_property_map_type<BidirGraph, GRef, Property>::type
-    get(Property p, utilmm::undirected_graph<BidirGraph,GRef>& g)
-    {
-      return get(p, g.m_g);
-    }
-
-    template <class BidirGraph, class GRef, class Property>
-    typename detail::get_property_map_type<BidirGraph, GRef, Property>::type
-    get(Property p, const utilmm::undirected_graph<BidirGraph,GRef>& g)
-    {
-      return get(p, g.m_g);
-    }
-
-    template <class BidirectionalGraph, class GRef, class Property, class Key>
-    typename property_traits<
-      typename property_map<BidirectionalGraph, Property>::const_type
-    >::value_type
-    get(Property p, const utilmm::undirected_graph<BidirectionalGraph,GRef>& g, const Key& k)
-    {
-      return get(p, g.m_g, k);
-    }
-
-    template <class BidirectionalGraph, class GRef, class Property, class Key, class Value>
-    void
-    put(Property p, const utilmm::undirected_graph<BidirectionalGraph,GRef>& g, const Key& k,
-	const Value& val)
-    {
-      put(p, g.m_g, k, val);
-    }
-
-    template<typename BidirectionalGraph, typename GRef, typename Tag,
-	     typename Value>
-    inline void
-    set_property(const utilmm::undirected_graph<BidirectionalGraph,GRef>& g, Tag tag, 
-		 const Value& value)
-    {
-      set_property(g.m_g, tag, value);
-    }
-
-    template<typename BidirectionalGraph, typename GRef, typename Tag>
-    inline
-    typename graph_property<BidirectionalGraph, Tag>::type
-    get_property(const utilmm::undirected_graph<BidirectionalGraph,GRef>& g, Tag tag)
-    {
-      return get_property(g.m_g, tag);
-    }
-
-} // namespace boost
-
-#endif

data/lib/roby/app/scripts/generate/bookmarks.rb

@@ -1,162 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'roby/log/event_stream'
-STDOUT.sync = true
-
-class Roby::Log::EventMatcher
-    attr_reader :remote_ids
-    attr_reader :predicate_id
-    attr_reader :notifications
-    def initialize
-	@remote_ids = Hash.new
-	@notifications = Hash.new
-	@predicate_id = 0
-    end
-
-    def local_object(remote_id)
-	if remote_id.kind_of?(Roby::Distributed::RemoteID)
-	    unless obj = remote_ids[remote_id]
-		raise "no object for #{remote_id}: #{remote_ids.keys}"
-	    end
-	    obj
-	else
-	    remote_id
-	end
-    end
-
-    def filter(log)
-	while log.has_sample?
-	    log.read_and_decode.each_slice(4) do |m, sec, usec, args|
-		event(m, sec, usec, args)
-	    end
-	end
-    end
-
-    def event(m, sec, usec, args)
-	if m == :added_tasks || m == :added_events
-	    objects = args[1]
-	    for object in objects
-		for remote_id in object.remote_siblings.values
-		    remote_ids[remote_id] = object
-		end
-	    end
-
-	elsif m == :finalized_task || m == :finalized_event
-	    object = args[1]
-	    remote_ids.delete(object)
-	end
-
-	time = nil
-	if predicate_set = notifications[m]
-	    for p, callback in predicate_set
-		if p.call(args)
-		    time ||= Time.at(sec, usec)
-		    callback.call(time, args)
-		end
-	    end
-	end
-    end
-
-    def parse(expr, &block)
-	case expr
-	when /^(\w+)\((.*)\)$/
-	    method = :generator_fired
-	    task_model = Regexp.new($2)
-	    symbol = $1.to_sym
-	    predicate = lambda do |args|
-		generator = local_object(args[0])
-		if generator.respond_to?(:task) && generator.symbol == symbol
-		    task = local_object(generator.task)
-		    Regexp.new(task_model) === local_object(task).model.ancestors[0][0]
-		end
-	    end
-	end
-
-	if predicate
-	    notifications[method] ||= Array.new
-	    notifications[method] << [predicate, block]
-	end
-    end
-end
-
-config_path = ARGV[0]
-event_path  = ARGV[1]
-unless config_path && event_path
-    STDERR.puts <<-EOU
-Usage: scripts/generate/bookmarks config.yml event_set
-
-  This script generates a bookmark file suitable for roby-log replay based on a
-  log file and on a configuration file. The configuration file format is as
-  follows:
-
-    event_name:
-      - start_point
-      - end_point
-
-  where start_point and end_point are matching expressions. The following
-  expressions are recognized:
-
-    start(task_model)
-    ready(task_model)
-    stop(task_model
-
-  they trigger when, respectively, a task instance of the specified model is
-  started, its ready event has emitted and it stopped. 
-  
-  For instance, to get a 'localization_initialized' bookmark for a Localization
-  task, you would write the following configuration file:
-
-    localization_initialized:
-	- start(Localization)
-	- ready(Localization)
-
-    EOU
-
-    exit(1)
-
-end
-
-# Reverse the config file from a 'bookmark_name => event' into a 'event' =>
-# 'bookmark_name'
-config = YAML.load(File.open(ARGV[0]))
-bookmarks = Hash.new
-
-filter = Roby::Log::EventMatcher.new
-config.each do |name, (start_point, end_point)|
-    bookmarks[name] = []
-    filter.parse(start_point) do |time, args|
-	STDERR.puts "#{time.to_hms} starting point for #{name}"
-	bookmarks[name] << [time]
-    end
-    filter.parse(end_point) do |time, args|
-	if bookmarks[name].last && bookmarks[name].last[0] && !bookmarks[name].last[1]
-	    STDERR.puts "#{time.to_hms} end point for #{name}"
-	    bookmarks[name].last[1] = time
-	end
-    end
-end
-
-log = Roby::Log::EventStream.open(ARGV[1])
-filter.filter(log)
-
-bookmark_data = Hash.new
-bookmarks.each do |name, ranges|
-    if ranges.size == 1
-	bookmark_data[name] = ranges[0].map { |t| t }
-    else
-	ranges.each_with_index do |r, i|
-	    bookmark_data["#{name}-#{i}"] = r.map { |t| t }
-	end
-    end
-end
-
-bookmark_data = 
-
-bookmark_data.sort_by { |n, r| r[0] }.
-    each do |name, range|
-	puts "#{name}:"
-	range.each do |time|
-	    puts "  - \"#{time.to_hms}\""
-	end
-    end
-