roby 0.8.0 → 3.0.0

data/lib/roby/relations/directed_relation_support.rb

@@ -0,0 +1,268 @@
+module Roby
+    module Relations
+        # Base support for relations. It is mixed in objects on which a
+        # Relations::Space applies on, like Task for TaskStructure and EventGenerator
+        # for EventStructure.
+        #
+        # See also the definition of Relations::Graph#add_relation and
+        # Relations::Graph#remove_relation for the possibility to define hooks that
+        # get called when a new edge involving +self+ as a vertex gets added and
+        # removed 
+        module DirectedRelationSupport
+            attr_reader :relation_graphs
+
+            def relation_graph_for(rel)
+                relation_graphs.fetch(rel)
+            end
+
+            # Enumerate all relations that are relevant for this plan object
+            #
+            # Unlike {#each_relation_graph}, which enumerate only the graphs
+            # that include self, it enumerates all possible relations for self
+            #
+            # @yieldparam [Class<Graph>]
+            def each_relation
+                return enum_for(__method__) if !block_given?
+                relation_graphs.each do |k, g|
+                    yield(k) if k != g
+                end
+            end
+
+            # Enumerate the relation graphs that include this vertex
+            #
+            # @yieldparam [Graph]
+            def each_relation_graph
+                return enum_for(__method__) if !block_given?
+                relation_graphs.each do |k, g|
+                    yield(g) if g.has_vertex?(self) && (k == g)
+                end
+            end
+
+            # Enumerate the relation graphs that include this vertex and that
+            # are subgraphs of no other graphs
+            #
+            # @yieldparam [Graph]
+            def each_root_relation_graph
+                return enum_for(__method__) if !block_given?
+                each_relation_graph do |g|
+                    yield(g) if g.root_relation?
+                end
+            end
+
+            def root?(relation = nil)
+                if relation
+                    relation_graphs[relation].root?(self)
+                else
+                    each_relation_graph.all? { |g| g.root?(self) }
+                end
+            end
+
+            def leaf?(relation = nil)
+                if relation
+                    relation_graphs[relation].leaf?(self)
+                else
+                    each_relation_graph.all? { |g| g.leaf?(self) }
+                end
+            end
+
+            def child_object?(object, relation = nil)
+                relation_graphs[relation].has_edge?(self, object)
+            end
+
+            def parent_object?(object, relation = nil)
+                relation_graphs[relation].has_edge?(object, self)
+            end
+
+            def related_object?(object, relation = nil)
+                parent_object?(object, relation) || child_object?(object, relation)
+            end
+
+            def each_parent_object(graph, &block)
+                relation_graphs[graph].each_in_neighbour(self, &block)
+            end
+
+            def each_in_neighbour(graph, &block)
+                relation_graphs[graph].each_in_neighbour(self, &block)
+            end
+
+            def each_child_object(graph, &block)
+                relation_graphs[graph].each_out_neighbour(self, &block)
+            end
+
+            def each_out_neighbour(graph, &block)
+                relation_graphs[graph].each_out_neighbour(self, &block)
+            end
+
+            def sorted_relations
+                Relations.all_relations.
+                    find_all do |rel|
+                        (rel = relation_graphs.fetch(rel, nil)) && rel.has_vertex?(self)
+                    end
+            end
+
+            # Yields each relation this vertex is part of, starting with the most
+            # specialized relations
+            def each_relation_sorted(&block)
+                sorted_relations.each(&block)
+            end
+
+            # Removes +self+ from all the graphs it is included in.
+            def clear_vertex(remove_strong: true)
+                for rel in sorted_relations
+                    graph = relation_graphs[rel]
+                    if remove_strong || !graph.strong?
+                        if graph.remove_vertex(self)
+                            removed = true
+                        end
+                    end
+                end
+                removed
+            end
+            alias :clear_relations :clear_vertex
+
+            def enum_relations
+                Roby.warn_deprecated "DirectedRelationSupport#enum_relations is deprecated, use #each_relation instead"
+                each_relation
+            end
+
+            # The array of relations this object is part of
+            def relations; each_relation.to_a end
+
+            # Computes and returns the set of objects related with this one (parent
+            # or child). If +relation+ is given, enumerate only for this relation,
+            # otherwise enumerate for all relations.  If +result+ is given, it is a
+            # Set in which the related objects are added
+            def related_objects(relation = nil, result = Set.new)
+                if relation
+                    result.merge(parent_objects(relation))
+                    result.merge(child_objects(relation))
+                else
+                    each_root_relation_graph do |g|
+                        result.merge(g.in_neighbours(self))
+                        result.merge(g.out_neighbours(self))
+                    end
+                end
+                result
+            end
+
+            def enum_parent_objects(relation)
+                Roby.warn_deprecated "#enum_parent_objects is deprecated, use #parent_objects or #each_parent_object instead"
+                parent_objects(relation)
+            end
+
+            def parent_objects(relation)
+                relation_graphs[relation].in_neighbours(self)
+            end
+
+            def enum_child_objects(relation)
+                Roby.warn_deprecated "#enum_child_objects is deprecated, use #parent_objects or #each_parent_object instead"
+                child_objects(relation)
+            end
+
+            def child_objects(relation)
+                relation_graphs[relation].out_neighbours(self)
+            end
+
+            # Add a new child object in the +relation+ relation. This calls
+            # * #adding_child_object on +self+ and #adding_parent_object on +child+
+            #   just before the relation is added
+            # * #added_child_object on +self+ and #added_parent_object on +child+
+            #   just after
+            def add_child_object(child, relation, info = nil)
+                relation_graphs[relation].add_relation(self, child, info)
+            end
+
+            # Add a new parent object in the +relation+ relation
+            # * #adding_child_object on +parent+ and #adding_parent_object on
+            #   +self+ just before the relation is added
+            # * #added_child_object on +parent+ and #added_child_object on +self+
+            #   just after
+            def add_parent_object(parent, relation, info = nil)
+                relation_graphs[parent].add_child_object(self, relation, info)
+            end
+
+            # Remove all edges in which +self+ is the source and +child+ the
+            # target. If +relation+ is given, it removes only the edge in that
+            # relation graph.
+            def remove_child_object(child, relation = nil)
+                if !relation
+                    for rel in sorted_relations
+                        rel.remove_relation(self, child)
+                    end
+                else
+                    relation_graphs[relation].remove_relation(self, child)
+                end
+            end
+
+            # Remove all edges in which +self+ is the source. If +relation+
+            # is given, it removes only the edges in that relation graph.
+            def remove_children(relation = nil)
+                if !relation
+                    for rel in sorted_relations
+                        remove_children(rel)
+                    end
+                    return
+                end
+
+                children = child_objects(relation).to_a
+                for child in children
+                    remove_child_object(child, relation)
+                end
+            end
+
+            # Remove all edges in which +child+ is the source and +self+ the
+            # target. If +relation+ is given, it removes only the edge in that
+            # relation graph.
+            def remove_parent_object(parent, relation = nil)
+                parent.remove_child_object(self, relation)
+            end
+
+            # Remove all edges in which +self+ is the target. If +relation+
+            # is given, it removes only the edges in that relation graph.
+            def remove_parents(relation = nil)
+                if !relation
+                    for rel in sorted_relations
+                        remove_parents(rel)
+                    end
+                    return
+                end
+
+                parents = parent_objects(relation).to_a
+                for parent in parents
+                    remove_parent_object(relation, parent)
+                end
+            end
+
+            # Remove all relations that point to or come from +to+ If +to+ is nil,
+            # it removes all edges in which +self+ is involved.
+            #
+            # If +relation+ is not nil, only edges of that relation graph are removed.
+            def remove_relations(relation = nil)
+                if !relation
+                    for rel in sorted_relations
+                        remove_relations(rel)
+                    end
+                    return
+                end
+                relation = relation_graphs[relation]
+                return if !relation.has_vertex?(self)
+
+                each_parent_object(relation).to_a.each do |parent|
+                    relation.remove_relation(parent, self)
+                end
+
+                each_child_object(relation).to_a.each do |child|
+                    relation.remove_relation(self, child)
+                end
+            end
+
+            def [](object, graph)
+                relation_graphs[graph].edge_info(self, object)
+            end
+
+            def []=(object, relation, value)
+                relation_graphs[relation].set_edge_info(self, object, value)
+            end
+        end
+    end
+end

data/lib/roby/relations/event_relation_graph.rb

@@ -0,0 +1,19 @@
+module Roby
+    module Relations
+        # Subclass of Relations::Space for events. Its main usage is to keep track of
+        # which tasks are related in a given relation through their events.
+        #
+        # I.e. if events 'a' and 'b' are parts of the tasks ta and tb, and 
+        #
+        #   a -> b
+        #
+        # in this relation graph, then 
+        #
+        #   relation.related_tasks?(ta, tb)
+        #
+        # will return true
+        class EventRelationGraph < Relations::Graph
+        end
+    end
+end
+

data/lib/roby/relations/fork_merge_visitor.rb

@@ -0,0 +1,154 @@
+module Roby
+    module Relations
+        # @api private
+        #
+        # A graph visitor which propagates a value through a subgraph of an
+        # acyclic graph, copying the value using #fork at graph forks, and
+        # merging them back with #merge when reaching a merge point
+        class ForkMergeVisitor < RGL::DFSVisitor
+            # The vertex from which we start visiting
+            attr_reader :origin
+
+            # The neighbours of this vertex that should be visited.
+            attr_reader :origin_neighbours
+
+            # A mapping from vertex to the propagated object for this vertex
+            attr_reader :vertex_to_object
+
+            # The pending merges, i.e. a collection of objects gathered so far
+            # at a merge point
+            attr_reader :pending_merges
+
+            # The in-degree of each node in the subgraph defined by {#origin}
+            # and {#origin_neighbours}
+            attr_reader :in_degree
+
+            # The out-degree of each node in the subgraph defined by {#origin}
+            # and {#origin_neighbours}
+            attr_reader :out_degree
+
+            # @param graph the directed graph we propagate the value in
+            # @param origin the vertex from which to propagate
+            # @param [#include?] origin_neighbours the neighbours of 'origin' to
+            #   propagate towards
+            # @param [#fork,#merge] object the object to propagate in the graph
+            def initialize(graph, object, origin, origin_neighbours = graph.out_neighbours(origin))
+                super(graph)
+                @origin = origin
+                @origin_neighbours = origin_neighbours
+
+                @vertex_to_object = Hash[origin => object]
+                @pending_merges = Hash.new { |h, k| h[k] = Array.new }
+
+                @in_degree, @out_degree = compute_in_out_degrees(origin, origin_neighbours)
+            end
+
+            def visit
+                graph.depth_first_visit(origin, self) {}
+            end
+
+            # A visitor that counts the in/out degree of vertices contained in a
+            # subgraph
+            class SubgraphDegreeCounter < RGL::DFSVisitor
+                attr_reader :out_degree
+                attr_reader :in_degree
+                def initialize(graph)
+                    @out_degree = Hash.new(0)
+                    @in_degree = Hash.new(0)
+                    super(graph)
+                end
+                def handle_tree_edge(u, v)
+                    out_degree[u] += 1
+                    in_degree[v] += 1
+                end
+                def handle_back_edge(u, v)
+                    out_degree[u] += 1
+                    in_degree[v] += 1
+                end
+                def handle_forward_edge(u, v)
+                    out_degree[u] += 1
+                    in_degree[v] += 1
+                end
+            end
+
+            # Computes the in and out degree of the subgraph starting at
+            # 'origin', following the out-edges of 'origin' that go towards
+            # 'origin_neighbours'
+            def compute_in_out_degrees(origin, origin_neighbours)
+                visitor = SubgraphDegreeCounter.new(graph)
+                origin_neighbours.each do |v|
+                    next if visitor.color_map[v] != :WHITE
+                    graph.depth_first_visit(v, visitor) { }
+                end
+                in_degree, out_degree = visitor.in_degree, visitor.out_degree
+
+                in_degree[origin] = 0
+                out_degree[origin] = origin_neighbours.size
+                origin_neighbours.each do |v|
+                    in_degree[v] += 1
+                end
+                return in_degree, out_degree
+            end
+
+            def follow_edge?(u, v)
+                if u == origin
+                    return if !origin_neighbours.include?(v)
+                end
+
+                degree = in_degree[v]
+                if degree == 1
+                    true
+                else
+                    (pending_merges[v].size + 1) == degree
+                end
+            end
+
+            def handle_forward_edge(u, v)
+                if u == origin
+                    return if !origin_neighbours.include?(v)
+                end
+
+                obj = vertex_to_object.fetch(u)
+                if obj
+                    if out_degree[u] > 1
+                        obj = fork_object(obj)
+                    end
+                    obj = propagate_object(u, v, obj)
+                end
+                if in_degree[v] > 1
+                    pending_merges[v] << obj
+                else
+                    vertex_to_object[v] = obj
+                end
+            end
+
+            def handle_tree_edge(u, v)
+                obj = vertex_to_object.fetch(u)
+                if obj
+                    if out_degree[u] > 1
+                        obj = fork_object(obj)
+                    end
+                    obj = propagate_object(u, v, obj)
+                end
+
+                if in_degree[v] > 1
+                    obj = (pending_merges.delete(v) << obj).compact.inject { |a, b| a.merge(b) }
+                end
+                vertex_to_object[v] = obj
+            end
+
+            def handle_back_edge(u, v)
+                raise "#handle_back_edge should never happen in a fork-merge traversal"
+            end
+
+            def propagate_object(u, v, obj)
+                obj
+            end
+
+            def fork_object(obj)
+                obj.fork
+            end
+        end
+    end
+end
+

data/lib/roby/relations/graph.rb

@@ -0,0 +1,533 @@
+module Roby
+    module Relations
+        # A relation graph
+        #
+        # Relation graphs extend the base graph class
+        # {BidirectionalDirectedAdjacencyGraph} by adding the ability to
+        # arrange the graphs in a hierarchy (where a 'child' is a subgraph of a
+        # 'parent'), and the modification methods {#add_relation} and
+        # {#remove_relation} that maintain consistency in the hierarchy.
+        # Moreover, it allows to set an {#observer} object that listens to graph
+        # modifications (Roby uses it to emit relation hooks on plan objects
+        # when included in a {ExecutablePlan}).
+        #
+        # Note that the underlying methods {#add_edge} and {#remove_edge}
+        # are still available in cases where the hooks should not be called
+        # *and* hierarchy consistency is maintained by other means (e.g. when
+        # copying a plan).
+        #
+        # Finally, it is possible for {#add_edge} to update an existing edge
+        # info. For this purpose, a subclass has to implement the {#merge_info}
+        # method which is called with the old and new info and should return the
+        # merged object. The default implementation raises ArgumentError
+        class Graph < BidirectionalDirectedAdjacencyGraph
+            extend Models::Graph
+
+            # True if this relation graph is a DAG
+            #
+            # This property is not enforced by the Graph class itself as in a
+            # lot of cases it would be too expensive. When used in Roby, it is
+            # either enforced by {ExecutablePlan} or when committing a
+            # transaction
+            attr_predicate :dag
+            # True if this relation should be seen by remote peers
+            attr_predicate :distribute
+            # If this relation is weak
+            #
+            # Weak relations are not considered during garbage collection
+            attr_predicate :weak
+            # If this relation is strong
+            #
+            # Strong relations mark parts of the plan that can't be exchanged
+            # bit-by-bit. I.e. {Plan#replace_task} will ignore those relations.
+            attr_predicate :strong
+
+            # If this relation embeds some additional information
+            attr_predicate :embeds_info?
+
+            # Whether edges in this relation should be copied on replacement or
+            # moved. The default is to move.
+            attr_predicate :copy_on_replace
+
+            # The relation parent (if any)
+            #
+            # @see superset_of recursive_subsets
+            attr_accessor :parent
+
+            # The set of graphs that are directly children of self in the graph
+            # hierarchy. They are subgraphs of self, but not all the existing
+            # subgraphs of self
+            #
+            # @see superset_of recursive_subsets
+            attr_reader   :subsets
+
+            # An object that is called for relation modifications
+            #
+            # The relation will call the following hooks.
+            #
+            # Addition/removal hooks are called once per modification in the
+            # relation hierarchy. They get a 'relations' array which is the list
+            # of relation IDs (i.e. graph classes, e.g.
+            # {TaskStructure::Dependency}) which are concerned with the
+            # modification. This array is sorted from the downmost in the
+            # relation hierarchy (i.e. the most specialized) up to the upmost
+            # (the biggest superset).
+            #
+            #    adding_edge(from, to, relations, info)
+            #    added_edge(from, to, relations, info)
+            #
+            # Before and after a new edge is added between two vertices in the
+            # graph. 'info' is the edge info that is set for the edge in the
+            # first element of 'relations' (the other relations get nil)
+            #
+            #    updating_edge(from, to, relation, info)
+            #    updated_edge(from, to, relation, info)
+            #
+            # Before and after the edge info is set on a given edge. 'relation'
+            # is a single relation ID.
+            #
+            #    removing_edge(from, to, relations)
+            #    removed_edge(from, to, relations)
+            #
+            # Before and after an edge has been removed.
+            attr_reader :observer
+
+            # Creates a relation graph with the given name and options. The
+            # following options are recognized:
+            # +dag+:: 
+            #   if the graph is a DAG. If true, add_relation will check that
+            #   no cycle is created
+            # +subsets+:: 
+            #   a set of Relations::Graph objects that are children of this one.
+            #   See #superset_of.
+            # +distributed+:: 
+            #   if this relation graph should be seen by remote hosts
+            def initialize(
+                observer: nil,
+                distribute: self.class.distribute?,
+                dag: self.class.dag?,
+                weak: self.class.weak?,
+                strong: self.class.strong?,
+                copy_on_replace: self.class.copy_on_replace?,
+                noinfo: !self.class.embeds_info?,
+                subsets: Set.new)
+
+                @observer = observer
+                @distribute = distribute
+                @dag     = dag
+                @weak    = weak
+                @strong  = strong
+                @copy_on_replace = copy_on_replace
+                @embeds_info = !noinfo
+
+                # If the relation is a single-child relation, it expects to have
+                # this ivar set
+                if respond_to?(:single_child_accessor)
+                    @single_child_accessor = "@#{self.class.child_name}"
+                end
+
+                @subsets = Set.new
+                subsets.each { |g| superset_of(g) }
+
+                super()
+            end
+
+            # Tests whether a vertex is reachable from this one
+            #
+            # This is at worst O(E), i.e. the number of vertices that are
+            # reachable from the source vertex.
+            #
+            # If you want to do a lot of these queries, or if you want to check
+            # for acyclicity, RGL offers better alternatives.
+            #
+            # @param [Object] u the origin vertex
+            # @param [Object] v the vertex whose reachability we want to test
+            #   from 'u'
+            def reachable?(u, v)
+                depth_first_visit(u) { |o| return true if o == v }
+                false
+            end
+
+            def to_s
+                "#{self.class.name}:#{object_id.to_s(16)}"
+            end
+
+            def inspect; to_s end
+
+            # Copy a subgraph of self into another graph
+            #
+            # This method allows to define a mapping of vertices from self
+            # (source set) into vertices of another graph (target set), and
+            # copies the edges that exist between the vertices of the source set
+            # to edges between the corresponding vertices of target set
+            #
+            # @param [Graph] graph the target graph
+            # @param [Hash<Object,Object>] a mapping from the subgraph vertices
+            #   in self to the corresponding vertices in the target graph
+            def copy_subgraph_to(graph, mappings)
+                mappings.each do |v, mapped_v|
+                    each_out_neighbour(v) do |child|
+                        if mapped_child = mappings[child]
+                            graph.add_edge(mapped_v, mapped_child,
+                                           edge_info(v, child))
+                        end
+                    end
+                end
+            end
+
+            def find_edge_difference(graph, mapping)
+                if graph.num_edges != num_edges
+                    return [:num_edges_differ]
+                end
+
+                each_edge do |parent, child|
+                    m_parent, m_child = mapping[parent], mapping[child]
+                    if !m_parent
+                        return [:missing_mapping, parent]
+                    elsif !m_child
+                        return [:missing_mapping, child]
+                    elsif !graph.has_vertex?(m_parent) || !graph.has_vertex?(m_child) || !graph.has_edge?(m_parent, m_child)
+                        return [:missing_edge, parent, child]
+                    elsif edge_info(parent, child) != graph.edge_info(m_parent, m_child)
+                        return [:differing_edge_info, parent, child]
+                    end
+                end
+                nil
+            end
+
+            # Moves a vertex relations onto another
+            #
+            # @param [Object] from the vertex whose relations are going to be
+            #   moved
+            # @param [Object] to the vertex on which the relations will be
+            #   added
+            # @param [Boolean] remove whether 'from' should be removed from the
+            #   graph after replacement
+            def replace_vertex(from, to, remove: true)
+                edges = Array.new
+                each_in_neighbour(from) do |parent|
+                    if parent != to
+                        add_edge(parent, to, edge_info(parent, from))
+                        edges << [parent, from]
+                    end
+                end
+                each_out_neighbour(from) do |child|
+                    if to != child
+                        add_edge(to, child, edge_info(from, child))
+                        edges << [from, child]
+                    end
+                end
+
+                edges.each do |parent, child|
+                    remove_relation(parent, child)
+                end
+
+                if remove
+                    remove_vertex(from)
+                end
+            end
+
+            # Add the vertices and edges of a graph in self
+            #
+            # @param [Graph] graph the graph whose relations should be added to
+            #   self
+            def merge!(graph)
+                merge(graph)
+                graph.clear
+            end
+
+            # @api private
+            #
+            # Updates the edge information of an existing info, or does nothing
+            # if the edge does not exist
+            #
+            # If the edge has a non-nil info already, the graph's #merge_info is
+            # called to merge the existing and new information. If #merge_info
+            # returns nil, the update is aborted
+            #
+            # @param from the edge parent object
+            # @param to the edge child object
+            # @param info the new edge info
+            # @return [Boolean] true if the edge existed and false otherwise
+            def try_updating_existing_edge_info(from, to, info)
+                return false if !has_edge?(from, to)
+
+                if !(old_info = edge_info(from, to)).nil?
+                    if old_info == info
+                        return true
+                    elsif !(info = merge_info(from, to, old_info, info))
+                        raise ArgumentError, "trying to change edge information in #{self} for #{from} => #{to}: old was #{old_info} and new is #{info}"
+                    end
+                end
+                set_edge_info(from, to, info)
+                true
+            end
+
+            # Add an edge between two objects
+            #
+            # Unlike {BidirectionalDirectedAdjacencyGraph#add_edge}, it will
+            # update the edge info (using {#merge_info}) if the edge already
+            # exists.
+            #
+            # @return true if a new edge was created
+            def add_edge(a, b, info)
+                if !try_updating_existing_edge_info(a, b, info)
+                    super
+                    true
+                end
+            end
+
+            # Add an edge between +from+ and +to+. The relation is added on all
+            # parent relation graphs as well. If #dag? is true on +self+ or on one
+            # of its parents, the method will raise {CycleFoundError} in case the new
+            # edge would create a cycle.
+            #
+            # If +from+ or +to+ define the following hooks:
+            #   adding_parent_object(parent, relations, info)
+            #   adding_child_object(child, relations, info)
+            #   added_parent_object(parent, relations, info)
+            #   added_child_object(child, relations, info)
+            #
+            # then these hooks get respectively called before and after having
+            # added the relation, where +relations+ is the set of
+            # Relations::Graph
+            # instances where the edge has been added. It can be either [+self+] if
+            # the edge does not already exist in it, or [+self+, +parent+,
+            # <tt>parent.parent</tt>, ...] if the parent, grandparent, ... graphs
+            # do not include the edge either.
+            def add_relation(from, to, info = nil)
+                # First check if we're trying to change the edge information
+                # rather than creating a new edge
+                if try_updating_existing_edge_info(from, to, info)
+                    return
+                end
+
+                new_relations = []
+                new_relations_ids = []
+                rel     = self
+                while rel
+                    if !rel.has_edge?(from, to)
+                        new_relations << rel
+                        new_relations_ids << rel.class
+                    end
+                    rel = rel.parent
+                end
+
+                if !new_relations.empty?
+                    if observer
+                        observer.adding_edge(from, to, new_relations_ids, info)
+                    end
+                    for rel in new_relations
+                        rel.add_edge(from, to, (info if self == rel))
+                    end
+                    if observer
+                        observer.added_edge(from, to, new_relations_ids, info)
+                    end
+                end
+            end
+
+            # Set the information of an object relation
+            def set_edge_info(from, to, info)
+                if observer
+                    observer.updating_edge_info(from, to, self.class, info)
+                end
+                super
+                if observer
+                    observer.updated_edge_info(from, to, self.class, info)
+                end
+            end
+
+            # Method used in {#add_relation} and {#add_edge} to merge existing
+            # information with new information
+            #
+            # It is safe to raise from within this method
+            #
+            # @return [nil,Object] if nil, the update is aborted. If non-nil,
+            #   it is the new information
+            def merge_info(from, to, old, new)
+                raise ArgumentError, "cannot update edge information in #{self}: #merge_info is not implemented"
+            end
+
+            alias :remove_vertex! :remove_vertex
+
+            def remove_vertex(object)
+                if !observer
+                    return super
+                end
+
+                rel = self
+                relations, relations_ids = [], []
+                while rel
+                    relations << rel
+                    relations_ids << rel.class
+                    rel = rel.parent
+                end
+
+                removed_relations = Array.new
+                in_neighbours(object).each { |parent| removed_relations << parent << object }
+                out_neighbours(object).each { |child| removed_relations << object << child }
+
+                removed_relations.each_slice(2) do |parent, child|
+                    observer.removing_edge(parent, child, relations_ids)
+                end
+                relations.each { |rel| rel.remove_vertex!(object) }
+                removed_relations.each_slice(2) do |parent, child|
+                    observer.removed_edge(parent, child, relations_ids)
+                end
+                !removed_relations.empty?
+            end
+
+            # Remove the relation between +from+ and +to+, in this graph and in its
+            # parent graphs as well.
+            #
+            # If +from+ or +to+ define the following hooks:
+            #   removing_child_object(child, relations)
+            #   removed_child_object(child, relations)
+            #
+            # then these hooks get respectively called once before and once after
+            # having removed the relation, where +relations+ is the set of
+            # Relations::Graph instances where the edge has been removed. It is always
+            # <tt>[self, parent, parent.parent, ...]</tt> up to the root relation
+            # which is a superset of +self+.
+            def remove_relation(from, to)
+                if !has_edge?(from, to)
+                    return
+                end
+
+                rel = self
+                relations, relations_ids = [], []
+                while rel
+                    relations << rel
+                    relations_ids << rel.class
+                    rel = rel.parent
+                end
+
+                if observer
+                    observer.removing_edge(from, to, relations_ids)
+                end
+                for rel in relations
+                    rel.remove_edge(from, to)
+                end
+                if observer
+                    observer.removed_edge(from, to, relations_ids)
+                end
+            end
+
+            # Compute the set of all graphs that are subsets of this one in the
+            # subset hierarchy
+            def recursive_subsets
+                result = Set.new
+                queue = subsets.to_a.dup
+                while !queue.empty?
+                    g = queue.shift
+                    result << g
+                    queue.concat(g.subsets.to_a)
+                end
+                result
+            end
+
+            # True if this relation does not have a parent
+            def root_relation?; !parent end
+
+            # Returns true if +relation+ is included in this relation (i.e. it is
+            # either the same relation or one of its children)
+            #
+            # See also #superset_of
+            def subset?(relation)
+                self.eql?(relation) || subsets.any? { |subrel| subrel.subset?(relation) }
+            end
+
+            # The root in this graph's hierarchy
+            def root_graph
+                g = self
+                while g.parent
+                    g = g.parent
+                end
+                g
+            end
+
+            # Tests the presence of an edge in this graph or in its supersets
+            #
+            # See #superset_of for a description of the parent mechanism
+            def has_edge_in_hierarchy?(source, target)
+                root_graph.has_edge?(source, target)
+            end
+
+            # Declare that +self+ is a superset of +relation+. Once this is done,
+            # the system manages two constraints:
+            # * new relations added with {#add_relation} are also added in self
+            # * a relation can only exist in one subset of self
+            #
+            # One single graph can be the superset of multiple subgraphs (these are
+            # stored in the {#subsets} attribute), but one graph can have only one
+            # parent {#parent}.
+            #
+            # This operation can be called only if the new subset is empty (no
+            # edges and no vertices)
+            #
+            # @param [Graph] relation the relation that should be added as a
+            #   subset of self
+            # @raise [ArgumentError] if 'relation' is not empty
+            def superset_of(relation)
+                if !relation.empty?
+                    raise ArgumentError, "cannot pass a non-empty graph to #superset_of"
+                end
+
+                relation.parent = self
+                subsets << relation
+            end
+
+            def remove(vertex)
+                Roby.warn_deprecated "Graph#remove is deprecated, use #remove_vertex instead"
+                remove_vertex(vertex)
+            end
+
+            def link(a, b, info)
+                Roby.warn_deprecated "Graph#link is deprecated, use #add_edge instead"
+                add_edge(a, b, info)
+            end
+
+            def linked?(parent, child)
+                Roby.warn_deprecated "Graph#linked? is deprecated, use #add_edge instead"
+                has_edge?(parent, child)
+            end
+
+            def unlink(parent, child)
+                Roby.warn_deprecated "Graph#unlink is deprecated, use #remove_edge instead"
+                remove_edge(parent, child)
+            end
+
+            def each_parent_vertex(object, &block)
+                Roby.warn_deprecated "#each_parent_vertex has been replaced by #each_in_neighbour"
+                each_in_neighbour(object, &block)
+            end
+
+            def each_child_vertex(object, &block)
+                Roby.warn_deprecated "#each_child_vertex has been replaced by #each_out_neighbour"
+                each_out_neighbour(object, &block)
+            end
+
+            def copy_to(target)
+                Roby.warn_deprecated "Graph#copy_to is deprecated, use #merge instead (WARN: a.copy_to(b) is b.merge(a) !"
+                target.merge(self)
+            end
+
+            def size
+                Roby.warn_deprecated "Graph#size is deprecated, use #num_vertices instead"
+                num_vertices
+            end
+
+            def include?(object)
+                Roby.warn_deprecated "Graph#include? is deprecated, use #has_vertex? instead"
+                has_vertex?(object)
+            end
+
+            # @deprecated use {#has_edge_in_hierarchy?}
+            def linked_in_hierarchy?(source, target)
+                Roby.warn_deprecated "#linked_in_hierarchy? is deprecated, use #has_edge_in_hierarchy? instead"
+                has_edge_in_hierarchy?(source, target)
+            end
+        end
+    end
+end
+