roby 0.7.3 → 0.8.0

data/lib/roby/relations/hierarchy.rb

@@ -1,239 +0,0 @@
-require 'roby/task'
-require 'roby/control'
-require 'set'
-
-module Roby::TaskStructure
-    # Document-module: Hierarchy
-    relation :Hierarchy, :child_name => :child, :parent_name => :parent_task do
-	# True if +obj+ is a parent of this object in the hierarchy relation
-	# (+obj+ is realized by +self+)
-	def realizes?(obj);	parent_object?(obj, Hierarchy) end
-	# True if +obj+ is a child of this object in the hierarchy relation
-	def realized_by?(obj);  child_object?(obj, Hierarchy) end
-	# True if +obj+ can be reached through the Hierarchy relation by
-	# starting from this object
-	def depends_on?(obj)
-	    generated_subgraph(Hierarchy).include?(obj)
-	end
-	# The set of parent objects in the Hierarchy relation
-	def parents; parent_objects(Hierarchy) end
-	# The set of child objects in the Hierarchy relation
-	def children; child_objects(Hierarchy) end
-
-
-	# Adds +task+ as a child of +self+ in the Hierarchy relation. The
-	# following options are allowed:
-	#
-	# success:: the list of success events. The default is [:success]
-	# failure:: the list of failing events. The default is [:failed]
-	# model:: a <tt>[task_model, arguments]</tt> pair which defines the task model the parent is expecting. 
-	#   The default value is to get these parameters from +task+
-        #
-        # The +success+ set describes the events of the child task that are
-        # _required_ by the parent task. More specifically, the child task
-        # remains useful for the parent task as long as none of these events are
-        # emitted. By default, it is the +success+ event. Of course, an error
-        # condition is encountered when all events of +success+ become
-        # unreachable. In addition, the relation is removed if the
-        # +remove_when_done+ flag is set to true (false by default).
-        #
-        # The +failure+ set describes the events of the child task which are an
-        # error condition from the parent task point of view.
-        #
-        # In both error cases, a +ChildFailedError+ exception is raised.
-        def realized_by(task, options = {})
-            options = validate_options options, 
-		:model => [task.model, task.meaningful_arguments], 
-		:success => [:success], 
-		:failure => [:failed],
-		:remove_when_done => false
-
-	    options[:success] = Array[*options[:success]]
-	    options[:failure] = Array[*options[:failure]]
-
-	    # Validate failure and success event names
-	    options[:success].each { |ev| task.event(ev) }
-	    options[:failure].each { |ev| task.event(ev) }
-
-	    options[:model] = [options[:model], {}] unless Array === options[:model]
-	    required_model, required_args = *options[:model]
-	    if !task.fullfills?(required_model, required_args)
-		raise ArgumentError, "task #{task} does not fullfills the provided model #{options[:model]}"
-	    end
-
-	    add_child(task, options)
-            self
-        end
-
-	# Set up the event gathering needed by Hierarchy.check_structure
-	def added_child_object(child, relations, info) # :nodoc:
-	    super if defined? super
-	    if relations.include?(Hierarchy) && !respond_to?(:__getobj__) && !child.respond_to?(:__getobj__)
-		events = info[:success].map { |ev| child.event(ev) }
-		events.concat info[:failure].map { |ev| child.event(ev) }
-		Roby::EventGenerator.gather_events(Hierarchy.interesting_events, events)
-	    end
-	end
-
-	# Return the set of this task children for which the :start event has
-	# no parent in CausalLinks
-        def first_children
-	    result = ValueSet.new
-
-	    generated_subgraph(Hierarchy).each do |task|
-		next if task == self
-		if task.event(:start).root?(Roby::EventStructure::CausalLink)
-		    result << task
-		end
-	    end
-	    result
-        end
-
-	# The set of events that are needed by the parent tasks
-	def fullfilled_events
-	    needed = ValueSet.new
-	    each_parent_task do |parent|
-		needed.merge(parent[self, Hierarchy][:success])
-	    end
-	    needed
-	end
-
-	# Return [tags, arguments] where +tags+ is a list of task models which
-	# are required by the parent tasks of this task, and arguments the
-	# required arguments
-	#
-	# If there is a task class in the required models, it is always the
-	# first element of +tags+
-	def fullfilled_model
-	    model, tags, arguments = Roby::Task, [], {}
-
-	    each_parent_task do |parent|
-		m, a = parent[self, Hierarchy][:model]
-		if m.instance_of?(Roby::TaskModelTag)
-		    tags << m
-		elsif m.has_ancestor?(model)
-		    model = m
-		elsif !model.has_ancestor?(m)
-		    raise "inconsistency in fullfilled models: #{model} and #{m} are incompatible"
-		end
-		a.merge!(arguments) do |old, new| 
-		    if old != new
-			raise "inconsistency in fullfilled models: #{old} and #{new}"
-		    end
-		end
-	    end
-
-	    tags.unshift(model)
-	    [tags, arguments]
-	end
-
-	# Remove all children that have successfully finished
-	def remove_finished_children
-	    # We call #to_a to get a copy of children, since we will remove
-	    # children in the block. Note that we can't use #delete_if here
-	    # since #children is a relation enumerator (not the relation list
-	    # itself)
-	    children.to_a.each do |child|
-		success_events = self[child, Hierarchy][:success]
-		if success_events.any? { |ev| child.event(ev).happened? }
-		    remove_child(child)
-		end
-	    end
-	end
-    end
-
-    # Checks the structure of +plan+ w.r.t. the constraints of the hierarchy
-    # relations. It returns an array of ChildFailedError for all failed
-    # hierarchy relations
-    def Hierarchy.check_structure(plan)
-	result = []
-
-	events = Hierarchy.interesting_events
-	return result if events.empty? && failing_tasks.empty?
-
-	# Get the set of tasks for which a possible failure has been
-	# registered The tasks that are failing the hierarchy requirements
-	# are registered in Hierarchy.failing_tasks. The interesting_events
-	# set is cleared at cycle end (see below)
-	tasks = events.inject(failing_tasks) { |set, event| set << event.generator.task }
-	@failing_tasks = ValueSet.new
-	tasks.each do |child|
-	    # Check if the task has been removed from the plan
-	    next unless child.plan
-
-	    has_error = false
-	    child.each_parent_task do |parent|
-		next unless parent.self_owned?
-		next if parent.finished? || parent.finishing?
-
-		options = parent[child, Hierarchy]
-		success = options[:success]
-		failure = options[:failure]
-
-		if success.any? { |e| child.event(e).happened? }
-		    if options[:remove_when_done]
-			parent.remove_child child
-		    end
-		elsif failing_event = failure.find { |e| child.event(e).happened? }
-		    result << Roby::ChildFailedError.new(parent, child.event(failing_event).last)
-		    failing_tasks << child
-		end
-	    end
-	end
-
-	events.clear
-	result
-    end
-
-    class << Hierarchy
-	# The set of events that have been fired in this cycle and are involved in a Hierarchy relation
-	attribute(:interesting_events) { Array.new }
-
-	# The set of tasks that are currently failing 
-	attribute(:failing_tasks) { ValueSet.new }
-    end
-end
-
-module Roby
-    # This exception is raised when a {hierarchy relation}[classes/Roby/TaskStructure/Hierarchy.html] fails
-    class ChildFailedError < LocalizedError
-	# The parent in the relation
-	attr_reader :parent
-	# The child in the relation
-	def child; failed_task end
-	# The relation parameters (i.e. the hash given to #realized_by)
-	attr_reader :relation
-
-	# The event which is the cause of this error. This is either the task
-	# source of a failure event, or the reason why a positive event has
-	# become unreachable (if there is one)
-	def initialize(parent, event)
-	    super(event.task_sources.find { true })
-	    @parent = parent
-	    @relation = parent[child, TaskStructure::Hierarchy]
-	end
-
-	def pretty_print(pp) # :nodoc:
-            super
-            pp.breakable
-            pp.breakable
-            pp.text "The failed relation is"
-            pp.breakable
-            pp.nest(2) do
-                pp.text "  "
-                parent.pretty_print pp
-                pp.breakable
-                pp.text "realized_by "
-                child.pretty_print pp
-            end
-	end
-	def backtrace; [] end
-
-        # True if +obj+ is involved in this exception
-        def involved_plan_object?(obj)
-            super || obj == parent
-        end
-    end
-    Control.structure_checks << TaskStructure::Hierarchy.method(:check_structure)
-end
-

data/lib/roby/transactions/updates.rb

@@ -1,139 +0,0 @@
-module Roby
-    class SolverInvalidateTransaction
-	def self.finalized_plan_task(trsc, task); end
-	def self.finalized_plan_event(trsc, task); end
-
-	def self.adding_plan_relation(trsc, parent, child, relations, info)
-	end
-	def self.removing_plan_relation(trsc, parent, child, relations)
-	end
-    end
-
-    class SolverUpdateRelations
-	def self.finalized_plan_task(trsc, task)
-	end
-	def self.finalized_plan_event(trsc, task)
-	end
-
-	def self.adding_plan_relation(trsc, parent, child, relations, info)
-	    parent_proxy = trsc.wrap(parent)
-	    child_proxy  = trsc.wrap(child)
-	    for rel in relations
-		rel.link(parent_proxy, child_proxy, info)	   
-	    end
-	    trsc.invalid = false
-	end
-	def self.removing_plan_relation(trsc, parent, child, relations)
-	    parent_proxy = trsc.wrap(parent)
-	    child_proxy  = trsc.wrap(child)
-	    for rel in relations
-		rel.unlink(parent_proxy, child_proxy)
-	    end
-	    trsc.invalid = false
-	end
-    end
-
-    class SolverIgnoreUpdate
-	def finalized_plan_task(trsc, task)
-	    Roby.debug "#{trsc} is valid again"
-	    trsc.invalid = false
-	end
-	def finalized_plan_event(trsc, task)
-	    Roby.debug "#{trsc} is valid again"
-	    trsc.invalid = false
-	end
-
-	def adding_plan_relation(trsc, parent, child, relations, info)
-	    Roby.debug "#{trsc} is valid again"
-	    trsc.invalid = false
-	end
-	def removing_plan_relation(trsc, parent, child, relations)
-	    Roby.debug "#{trsc} is valid again"
-	    trsc.invalid = false
-	end
-    end
-    class Transaction
-	def finalized_plan_task(task)
-	    invalidate("task #{task} has been removed from the plan")
-	    discard_modifications(task)
-	    conflict_solver.finalized_plan_task(self, task)
-	end
-
-	def finalized_plan_event(event)
-	    invalidate("event #{event} has been removed from the plan")
-	    discard_modifications(event)
-	    conflict_solver.finalized_plan_event(self, event)
-	end
-
-	def adding_plan_relation(parent, child, relations, info)
-	    missing_relations = relations.find_all do |rel|
-		!parent.child_object?(child, rel)
-	    end
-	    unless missing_relations.empty?
-		invalidate("plan added a relation #{parent} -> #{child} in #{relations} with info #{info}")
-		conflict_solver.adding_plan_relation(self, parent, child, relations, info)
-	    end
-	end
-
-	def removing_plan_relation(parent, child, relations)
-	    present_relations = relations.find_all do |rel|
-		parent.child_object?(child, rel)
-	    end
-	    unless present_relations.empty?
-		invalidate("plan removed the #{parent} -> #{child} relation in #{relations}")
-		conflict_solver.removing_plan_relation(self, parent, child, relations)
-	    end
-	end
-    end
-
-    module Transactions
-	module PlanUpdates
-	    def self.finalized_object(plan, object) 
-		return unless object.root_object?
-		plan.transactions.each do |trsc|
-		    next unless trsc.proxying?
-
-		    if proxy = trsc.wrap(object, false)
-			yield(trsc, proxy)
-		    end
-		end
-	    end
-	    def finalized_event(event)
-		super if defined? super
-		PlanUpdates.finalized_object(self, event) { |trsc, proxy| trsc.finalized_plan_event(proxy) }
-	    end
-	    def finalized_task(task)
-		super if defined? super
-		PlanUpdates.finalized_object(self, task) { |trsc, proxy| trsc.finalized_plan_task(proxy) }
-	    end
-	end
-	Roby::Plan.include PlanUpdates
-
-	module PlanObjectUpdates
-	    def adding_child_object(child, relations, info)
-		super if defined? super
-		return if !plan
-
-		for trsc in plan.transactions
-		    next unless trsc.proxying?
-		    if (parent_proxy = trsc[self, false]) && (child_proxy = trsc[child, false])
-			trsc.adding_plan_relation(parent_proxy, child_proxy, relations, info) 
-		    end
-		end
-	    end
-	    def removing_child_object(child, relations)
-		super if defined? super
-		return if !plan
-
-		plan.transactions.each do |trsc|
-		    next unless trsc.proxying?
-		    if (parent_proxy = trsc[self, false]) && (child_proxy = trsc[child, false])
-			trsc.removing_plan_relation(parent_proxy, child_proxy, relations) 
-		    end
-		end
-	    end
-	end
-	Roby::PlanObject.include PlanObjectUpdates
-    end
-end
-

data/test/relations/test_hierarchy.rb

@@ -1,158 +0,0 @@
-$LOAD_PATH.unshift File.expand_path('..', File.dirname(__FILE__))
-require 'roby/test/common'
-require 'roby/test/tasks/simple_task'
-
-class TC_RealizedBy < Test::Unit::TestCase
-    include Roby::Test
-
-    def test_definition
-	tag   = TaskModelTag.new
-	klass = Class.new(SimpleTask) do
-	    argument :id
-	    include tag
-	end
-	plan.discover(t1 = SimpleTask.new)
-
-	# Check validation of the model
-	child = nil
-	assert_nothing_raised { t1.realized_by((child = klass.new), :model => SimpleTask) }
-
-	assert_same(Hierarchy.interesting_events, EventGenerator.event_gathering[child.event(:success)].find { true })
-	assert_same(Hierarchy.interesting_events, EventGenerator.event_gathering[child.event(:failed)].find { true })
-	assert_equal([SimpleTask, {}], t1[child, Hierarchy][:model])
-
-	assert_nothing_raised { t1.realized_by klass.new, :model => [Roby::Task, {}] }
-	assert_nothing_raised { t1.realized_by klass.new, :model => tag }
-
-	plan.discover(simple_task = SimpleTask.new)
-	assert_raises(ArgumentError) { t1.realized_by simple_task, :model => [Class.new(Roby::Task), {}] }
-	assert_raises(ArgumentError) { t1.realized_by simple_task, :model => TaskModelTag.new }
-	
-	# Check validation of the arguments
-	plan.discover(model_task = klass.new)
-	assert_raises(ArgumentError) { t1.realized_by model_task, :model => [SimpleTask, {:id => 'bad'}] }
-
-	plan.discover(child = klass.new(:id => 'good'))
-	assert_raises(ArgumentError) { t1.realized_by child, :model => [klass, {:id => 'bad'}] }
-	assert_nothing_raised { t1.realized_by child, :model => [klass, {:id => 'good'}] }
-	assert_equal([klass, { :id => 'good' }], t1[child, TaskStructure::Hierarchy][:model])
-
-	# Check edge annotation
-	t2 = SimpleTask.new
-	t1.realized_by t2, :model => SimpleTask
-	assert_equal([SimpleTask, {}], t1[t2, TaskStructure::Hierarchy][:model])
-	t2 = klass.new(:id => 10)
-	t1.realized_by t2, :model => [klass, { :id => 10 }]
-    end
-
-    Hierarchy = TaskStructure::Hierarchy
-
-    def assert_children_failed(children, plan)
-	result = Hierarchy.check_structure(plan)
-	assert_equal(children.to_set, result.map { |e| e.failed_task }.to_set)
-    end
-
-    def test_failure_point
-	model = Class.new(SimpleTask) do
-	    event :specialized_failure, :command => true
-	    forward :specialized_failure => :failed
-	end
-	parent, child = prepare_plan :discover => 1, :tasks => 1, :model => model
-	parent.realized_by child
-
-	parent.start!
-	child.start!
-	child.specialized_failure!
-
-	error = Hierarchy.check_structure(plan).first.exception
-	assert_kind_of(ChildFailedError, error)
-	assert_equal(child.event(:specialized_failure).last, error.failure_point)
-	assert_equal(child.event(:specialized_failure).last, error.failed_event)
-
-	parent.stop!
-    end
-
-    def test_exception_printing
-        parent, child = prepare_plan :discover => 2, :model => SimpleTask
-        parent.realized_by child
-        parent.start!
-        child.start!
-        child.failed!
-
-	error = Hierarchy.check_structure(plan).first.exception
-	assert_kind_of(ChildFailedError, error)
-        assert_nothing_raised do
-            Roby.format_exception(error)
-        end
-
-        parent.stop!
-    end
-
-    def test_structure_checking
-	child_model = Class.new(SimpleTask) do
-	    event :first, :command => true
-	    event :second, :command => true
-	end
-
-	p1 = SimpleTask.new
-	child = child_model.new
-	plan.discover([p1, child])
-	p1.realized_by child
-	plan.insert(p1)
-
-	child.start!; p1.start!
-	assert_equal([], Hierarchy.check_structure(plan))
-	child.stop!
-	assert_equal([child.event(:failed).last], Hierarchy.interesting_events)
-	assert_children_failed([child], plan)
-
-	plan.clear
-	p1 = SimpleTask.new
-	child = child_model.new
-	plan.discover([p1, child])
-	p1.realized_by child, :success => [:second], :failure => [:first]
-	plan.insert(p1)
-	child.start! ; p1.start!
-	child.event(:first).emit(nil)
-	assert_children_failed([child], plan)
-
-	plan.clear
-	p1    = SimpleTask.new
-	child = child_model.new
-	plan.discover([p1, child])
-	p1.realized_by child, :success => [:first], :failure => [:second]
-	plan.insert(p1)
-	child.start! ; p1.start!
-	child.event(:first).emit(nil)
-	assert_children_failed([], plan)
-	child.event(:second).emit(nil)
-	assert_children_failed([], plan)
-    end
-
-    def test_fullfilled_model
-	tag = TaskModelTag.new
-	klass = Class.new(SimpleTask) do
-	    include tag
-	end
-
-	p1, p2, child = prepare_plan :discover => 3, :model => klass
-
-	p1.realized_by child, :model => SimpleTask
-	p2.realized_by child, :model => Roby::Task
-	assert_equal([[SimpleTask], {}], child.fullfilled_model)
-	p1.remove_child(child)
-	assert_equal([[Roby::Task], {}], child.fullfilled_model)
-	p1.realized_by child, :model => tag
-	assert_equal([[Roby::Task, tag], {}], child.fullfilled_model)
-    end
-
-    def test_first_children
-	p, c1, c2 = prepare_plan :discover => 3, :model => SimpleTask
-	p.realized_by c1
-	p.realized_by c2
-	assert_equal([c1, c2].to_value_set, p.first_children)
-
-	c1.on(:start, c2, :start)
-	assert_equal([c1].to_value_set, p.first_children)
-    end
-end