roby 0.8.0 → 3.0.0

data/lib/roby/relations/events.rb

@@ -1,7 +0,0 @@
-module Roby::EventStructure
-    relation :Signal, :noinfo => true
-    relation :Forwarding, :noinfo => true
-    relation :CausalLink, :subsets => [Signal, Forwarding], :noinfo => true
-    relation :Precedence, :subsets => [CausalLink], :noinfo => true
-end
-

data/lib/roby/relations/executed_by.rb

@@ -1,208 +0,0 @@
-module Roby::TaskStructure
-    # This module defines model-level definition of execution agent, for
-    # instance to Roby::Task
-    module ModelLevelExecutionAgent
-	# The model of execution agent for this class
-	def execution_agent
-	    for klass in ancestors
-		if klass.instance_variable_defined?(:@execution_agent)
-		    return klass.instance_variable_get(:@execution_agent)
-		end
-	    end
-	    nil
-	end
-
-	# Defines a model of execution agent. Doing
-	#
-	#   TaskModel.executed_by ExecutionAgentModel
-	#
-	# is equivalent to
-	#
-	#   task = TaskModel.new
-	#   exec = <find a suitable ExecutionAgentModel instance in the plan or
-	#	   create a new one>
-	#   task.executed_by exec
-	#   
-	# for all instances of TaskModel. The actual job is done in the
-	# ExecutionAgentSpawn module
-	def executed_by(agent_model, arguments = Hash.new)
-	    @execution_agent = [agent_model, arguments]
-	end
-    end
-
-    # The execution_agent defines an agent (process or otherwise) a given
-    # task is executed by. It allows to define a class of these execution agent,
-    # so that the specific agents are managed externally (load-balancing, ...)
-    relation :ExecutionAgent, :parent_name => :executed_task, :child_name => :execution_agent, 
-	:noinfo => true, :distribute => false, :single_child => true do
-	
-	# When ExecutionAgent support is included in a model (for instance Roby::Task), add
-	# the model-level classes  
-        def self.included(klass) # :nodoc:
-	    klass.extend Roby::TaskStructure::ModelLevelExecutionAgent
-            super
-        end
-
-	# Defines a new execution agent for this task.
-        def executed_by(agent)
-	    return if execution_agent == agent
-	    if !agent.event(:start).controlable? && !agent.running?
-		raise ArgumentError, "the start event of #{self}'s execution agent #{agent} is not controlable"
-	    end
-	    # Check that agent defines the :ready event
-	    if !agent.has_event?(:ready)
-		raise ArgumentError, "execution agent tasks should define the :ready event"
-	    end
-	    
-	    old_agent = execution_agent
-	    if old_agent && old_agent != agent
-		Roby.debug "an agent is already defined for this task"
-		remove_execution_agent old_agent
-	    end
-
-	    unless old_agent
-		# If the task did have an agent already, these event handlers
-		# are already set up
-		if running?
-		    Roby::Distributed.update(self) do
-			agent.forward_to(:stop, self, :aborted)
-		    end
-		else
-		    on(:start) do
-			# The event handler will be called even if the
-			# execution agent has been removed. Check that there is
-			# actually an execution agent 
-			if execution_agent
-			    Roby::Distributed.update(self) do
-				execution_agent.forward_to(:stop, self, :aborted)
-			    end
-			end
-		    end
-		end
-
-		on(:stop) do 
-		    if execution_agent
-			Roby::Distributed.update(self) do
-			    execution_agent.event(:stop).remove_forwarding event(:aborted)
-			    remove_execution_agent execution_agent
-			end
-		    end
-		end
-	    end
-
-	    add_execution_agent(agent)
-        end
-
-    end
-
-    class ExecutionAgentSpawningFailed < Roby::LocalizedError
-	attr_reader :agent_model, :error
-	def initialize(task, agent_model, error)
-	    super(task)
-	    @agent_model, @error = agent_model, error
-	end
-    end
-    
-    # Add a suitable execution agent to +task+ if its model has a execution
-    # agent model (see ModelLevelExecutionAgent), either by reusing one
-    # that is already in the plan, or by creating a new one.
-    def ExecutionAgent.spawn(task)
-	agent_model, arguments = task.model.execution_agent
-	candidates = task.plan.find_tasks.
-	    with_model(agent_model).
-            with_arguments(arguments).
-	    self_owned.
-	    not_finished
-
-	agent = nil
-
-	if candidates.empty?
-	    begin
-		agent = agent_model.new(arguments)
-		agent.on(:stop) do
-		    agent.each_executed_task do |task|
-			if task.running?
-			    task.emit(:aborted, "execution agent #{self} failed") 
-			elsif task.pending?
-			    task.remove_execution_agent agent
-			    spawn(task)
-			end
-		    end
-		end
-	    rescue Exception => e
-		task.plan.engine.add_error(ExecutionAgentSpawningFailed.new(task, agent_model, e))
-	    end
-	else
-	    running, pending = candidates.partition { |t| t.running? }
-	    agent = if running.empty? then pending.first
-		    else running.first
-		    end
-	end
-	task.executed_by agent
-	agent
-    end
-
-    # This module is hooked in Roby::TaskEventGenerator to check that a task
-    # which is being started has a suitable execution agent, and to start it if
-    # it's not the case
-    module ExecutionAgentStart
-	def calling(context)
-	    super if defined? super
-	    return unless symbol == :start
-
-            agent = task.execution_agent
-            if !agent
-                if task.model.execution_agent
-                    raise CommandFailed.new(nil, self), "the model of #{task} requires an execution agent, but the task has none"
-                else
-                    return
-                end
-            end
-
-            # Check that the agent matches the model
-            agent_model, arguments = task.model.execution_agent
-            if agent_model
-                if !agent.fullfills?(agent_model, arguments)
-                    raise CommandFailed.new(nil, self), "the execution agent #{agent} does not match the required model #{agent_model}, #{arguments}"
-                end
-            end
-
-	    if agent.finished? || agent.finishing?
-		raise CommandFailed.new(nil, self), "task #{task} has an execution agent but it is dead"
-	    elsif !agent.event(:ready).happened? && !agent.depends_on?(task)
-		postpone(agent.event(:ready), "spawning execution agent #{agent} for #{self}") do
-		    if agent.pending?
-			agent.event(:ready).if_unreachable(true) do |reason|
-			    self.emit_failed "execution agent #{agent} failed to initialize: #{reason}"
-			end
-			agent.start!
-		    end
-		end
-	    end
-	end
-    end
-    Roby::TaskEventGenerator.include ExecutionAgentStart
-
-    # This module is included in Roby::Plan to automatically add execution agents
-    # to tasks that require it and are discovered in the executable plan.
-    module ExecutionAgentSpawn
-	# Hook into plan discovery to add execution agents to new tasks. 
-	# See ExecutionAgentSpawn.spawn
-	def added_tasks(tasks)
-	    # For now, settle on adding the execution agents only in the
-	    # main plan. Otherwise, it is possible that two transactions
-	    # will try to add two different agents
-	    #
-	    # Note that it would be solved by plan merging ...
-	    return unless executable?
-
-	    for task in tasks
-		if !task.execution_agent && task.model.execution_agent && task.self_owned?
-		    ExecutionAgent.spawn(task)
-		end
-	    end
-	end
-    end
-    Roby::Plan.include ExecutionAgentSpawn
-end
-

data/lib/roby/relations/influence.rb

@@ -1,10 +0,0 @@
-module Roby
-    module TaskStructure
-	relation :Influence, :child_name => 'influenced_task', :noinfo => true, :weak => true do
-	    def influenced_by(task)
-		add_influenced_task(task)
-	    end
-	end
-    end
-end
-

data/lib/roby/relations/planned_by.rb

@@ -1,63 +0,0 @@
-module Roby::TaskStructure
-    relation :PlannedBy, :child_name => :planning_task, 
-	:parent_name => :planned_task, :noinfo => true, :single_child => true do
-
-	# The set of tasks which are planned by this one
-	def planned_tasks; parent_objects(PlannedBy) end
-	# Set +task+ as the planning task of +self+
-        def planned_by(task, options = {})
-	    if old = planning_task
-		if options[:replace]
-		    remove_planning_task(old)
-		else
-		    raise ArgumentError, "this task already has a planner"
-		end
-	    end
-	    add_planning_task(task)
-        end
-    end
-
-    # Returns a set of PlanningFailedError exceptions for all abstract tasks
-    # for which planning has failed
-    def PlannedBy.check_structure(plan)
-	result = []
-	Roby::TaskStructure::PlannedBy.each_edge do |planned_task, planning_task, _|
-	    next unless plan == planning_task.plan && planning_task.failed?
-	    next unless planned_task.pending? && !planned_task.executable? && planned_task.self_owned?
-	    result << Roby::PlanningFailedError.new(planned_task, planning_task)
-	end
-
-	result
-    end
-end
-
-module Roby
-    # This exception is raised when a task is abstract, and its planner failed:
-    # the system will therefore not have a suitable executable development for
-    # this task, and this is a failure
-    class PlanningFailedError < LocalizedError
-	# The planning task
-	attr_reader :planned_task
-
-	def initialize(planned_task, planning_task)
-	    @planned_task = planned_task
-	    super(planning_task.failure_event)
-	end
-        def pretty_print(pp)
-            pp.text "failed to plan "
-            planned_task.pretty_print(pp)
-            pp.breakable
-            pp.breakable
-            pp.text "the following planning task failed with the #{failure_point.symbol} event"
-            pp.breakable
-            failed_task.pretty_print(pp)
-            pp.breakable
-
-	    if failure_point.context
-                pp.breakable
-                failure_point.context.first.pretty_print(pp)
-	    end
-        end
-    end
-end
-

data/lib/roby/state/information.rb

@@ -1,55 +0,0 @@
-module Distributions
-    class Gaussian
-	attr_reader :mean, :dev
-	def initialize(mean, dev)
-	    @mean, @dev = mean, dev
-	end
-    end
-end
-
-module Roby
-    # A TimeDistribution object describes the evolution of a 
-    # value object w.r.t. time. Time can be described by absolute
-    # values using Time objects or w.r.t. the plan by using 
-    # EventGenerator objects
-    class TimeDistribution
-	attr_reader :info
-	def initialize(info)
-	    @info = info
-	    @timepoints = Array.new
-	end
-
-	# Set the predicted value of the distribution at +event+
-	def set_value(event, value)
-	    @timepoints << [event, :set_value, value]
-	end
-
-	# Set a decay function which is valid from +event+
-	def set_decay(event, decay)
-	    @timepoints << [event, :set_decay, decay]
-	end
-
-	# Set the knowledge value for the distribution at +event+
-	# For now, the only valid values are 0 (nothing known) 
-	# and 1 (perfectly known)
-	def set_knowledge(event, value = 1.0)
-	    @timepoints << [event, :set_knowledge, value]
-	end
-    end
-
-    class Task < PlanObject
-	inherited_enumerable(:needed_information) { Array.new }
-	inherited_enumerable(:improved_information) { Array.new }
-	
-	# This task is influenced by the information contained in +info+
-	def self.needs(info); needed_information << info end
-	def self.needs?(info); enum_for(:each_needed_information).any? { |i| info === i } end
-	def needs?(info); self.model.needs?(info) end
-
-	# This task will improve the information contained in +info+
-	def self.improves(info); improved_information << info end
-	def self.improves?(info); enum_for(:each_improved_information).any? { |i| info === i } end
-	def improves?(info); self.model.improves?(info) end
-    end
-end
-

data/lib/roby/state/state.rb

@@ -1,367 +0,0 @@
-module Roby
-    # ExtendedStruct objects are OpenStructs where attributes have a default
-    # class. They are used to build hierarchical data structure on-the-fly
-    #
-    # For instance
-    #	root = ExtendedStruct.new
-    #	root.child.value = 42
-    #
-    # However, you *cannot* check if a value is defined or not with
-    #	if (root.child)
-    #	    <do something>
-    #	end
-    #
-    # You'll have to test with respond_to? or #{name}?. The second one will
-    # return true only if the attribute is defined <b>and</b> it is not false
-    #	if (root.respond_to?(:child)
-    #	    <do something>
-    #	end
-    #
-    # == Handling of methods defined on parents
-    #
-    # Methods defined in Object or Kernel are automatically overriden if needed.
-    # For instance, if you're managing a (x, y, z) position using ExtendedStruct, 
-    # you will want YAML#y to *not* get in the way. The exceptions are the methods
-    # listed in NOT_OVERRIDABLE
-    #
-    class ExtendedStruct
-	include DRbUndumped
-
-	# +attach_to+ and +attach_name+
-	# are used so that
-	#   root = ExtendedStruct.new
-	#   root.bla
-	# does *not* add a +bla+ attribute to root, while the following constructs
-	#   root.bla.test = 20
-	#   bla = root.bla
-	#   bla.test = 20
-	# does
-	#
-	# Note, however that
-	#   bla = root.bla
-	#   root.bla = 10
-	#   bla.test = 20
-	#   
-	# will *not* make root.bla be the +bla+ object. And that
-	# 
-	#   bla = root.bla
-	#   root.stable!
-	#   bla.test = 20
-	#
-	# will not fail
-	def initialize(children_class = ExtendedStruct, attach_to = nil, attach_name = nil) # :nodoc
-	    clear
-            @attach_as = [attach_to, attach_name.to_s] if attach_to
-	    @children_class = children_class
-            @observers       = Hash.new { |h, k| h[k] = [] }
-        end
-
-	def clear
-	    @attach_as	     = nil
-            @stable          = false
-            @members         = Hash.new
-            @pending         = Hash.new
-            @filters         = Hash.new
-            @aliases         = Hash.new
-	end
-
-	def self._load(io)
-	    marshalled_members, aliases = Marshal.load(io)
-	    members = marshalled_members.inject({}) do |h, (n, mv)|
-		begin
-		    h[n] = Marshal.load(mv)
-		rescue Exception
-		    Roby::Distributed.warn "cannot load #{n} #{mv}: #{$!.message}"
-		end
-
-		h
-	    end
-
-	    result = ExtendedStruct.new
-	    result.instance_variable_set("@members", members)
-	    result.instance_variable_set("@aliases", aliases)
-	    result
-
-	rescue Exception
-	    Roby::Distributed.warn "cannot load #{members} #{io}: #{$!.message}"
-	    raise
-	end
-
-	def _dump(lvl = -1)
-	    marshalled_members = @members.map do |name, value|
-		[name, Marshal.dump(value)] rescue nil
-	    end
-	    marshalled_members.compact!
-	    Marshal.dump([marshalled_members, @aliases])
-	end
-
-	attr_reader :children_class
-
-	attr_reader :attach_as, :__parent_struct, :__parent_name
-        def attach # :nodoc:
-	    if @attach_as
-		@__parent_struct, @__parent_name = @attach_as
-		@attach_as = nil
-		__parent_struct.attach_child(__parent_name, self)
-	    end
-        end
-	def detach
-	    @attach_as = nil
-	end
-	def attach_child(name, obj)
-	    @members[name.to_s] = obj
-	end
-	protected :detach, :attach_as
-
-	# Call +block+ with the new value if +name+ changes
-	def on(name = nil, &block)
-	    name = name.to_s if name
-	    @observers[name] << block
-	end
-
-	# Converts this ExtendedStruct into a corresponding hash, where all
-	# keys are symbols. If +recursive+ is true, any member which responds
-	# to #to_hash will be converted as well
-	def to_hash(recursive = true)
-	    result = Hash.new
-	    @members.each do |k, v|
-		result[k.to_sym] = if recursive && v.respond_to?(:to_hash)
-				       v.to_hash
-				   else v
-				   end
-	    end
-	    result
-	end
-
-	# Iterates on all defined members of this object
-	def each_member(&block)
-	    @members.each(&block)
-	end
-        
-	# Update a set of values on this struct
-	# If a hash is given, it is an name => value hash of attribute
-	# values. A given block is yield with self, so that the construct
-	#
-	#   my.extendable.struct.very.deep.update do |deep|
-	#     <update deep>
-	#   end
-	#
-	# can be used 
-        def update(hash = nil)
-	    attach
-            hash.each { |k, v| send("#{k}=", v) } if hash
-            yield(self) if block_given?
-            self
-        end
-
-	def delete(name = nil)
-	    raise TypeError, "#{self} is stable" if stable?
-	    if name
-		name = name.to_s
-		if child = @members.delete(name)
-		    child.instance_variable_set(:@__parent_struct, nil)
-		    child.instance_variable_set(:@__parent_name, nil)
-		elsif child = @pending.delete(name)
-		    child.instance_variable_set(:@attach_as, nil)
-		elsif child = @aliases.delete(name)
-		    # nothing to do here
-		else
-		    raise ArgumentError, "no such child #{name}"
-		end
-
-		# and remove aliases that point to +name+
-		@aliases.delete_if { |_, pointed_to| pointed_to == name }
-	    else
-		if __parent_struct
-		    __parent_struct.delete(__parent_name)
-		elsif @attach_as
-		    @attach_as.first.delete(@attach_as.last)
-		else
-		    raise ArgumentError, "#{self} is attached to nothing"
-		end
-	    end
-	end
-
-	# Define a filter for the +name+ attribute on self. The given block
-	# is called when the attribute is written, and should return true if
-	# the new value if valid or false otherwise
-	def filter(name, &block)
-	    @filters[name.to_s] = block
-	end
-	
-	# If self is stable, it cannot be updated. That is, calling a setter method
-	# raises NoMethodError
-        def stable?; @stable end
-
-	# Sets the stable attribute of +self+ to +is_stable+. If +recursive+ is true,
-	# set it on the child struct as well. 
-	#
-        def stable!(recursive = false, is_stable = true)
-            @stable = is_stable
-            if recursive
-                @members.each { |name, object| object.stable!(recursive, is_stable) if object.respond_to?(:stable!) }
-            end
-        end
-
-	def updated(name, value)
-	    if @observers.has_key?(name)
-		@observers[name].each { |b| b.call(value) }
-	    end
-	    @observers[nil].each { |b| b.call(value) }
-
-	    if __parent_struct
-		__parent_struct.updated(__parent_name, self)
-	    end
-	end
-
-	# Returns true if this object has no member
-	def empty?; @members.empty? end
-
-        if RUBY_VERSION >= "1.8.7"
-            def respond_to?(name, include_private = false) # :nodoc:
-                return true  if super
-                return __respond_to__(name)
-            end
-        else
-            def respond_to?(name) # :nodoc:
-                return true  if super
-                return __respond_to__(name)
-            end
-        end
-
-
-        # 1.8.7's #respond_to? takes two arguments, 1.8.6 only one. This is the
-        # common implementation for both version. #respond_to? is adapted (see
-        # above)
-        def __respond_to__(name) # :nodoc:
-            name = name.to_s
-	    return false if name =~ FORBIDDEN_NAMES_RX
-
-            if name =~ /=$/
-		!@stable
-            else
-                if @members.has_key?(name)
-		    true
-		else
-		    (alias_to = @aliases[name]) && respond_to?(alias_to)
-		end
-            end
-        end
-
-	def get(name, default_value)
-	    if respond_to?(name)
-		send(name.to_sym)
-	    else
-		default_value
-	    end
-	end
-
-	FORBIDDEN_NAMES=%w{marshal each enum to}.map { |str| "^#{str}_" }
-	FORBIDDEN_NAMES_RX = /(?:#{FORBIDDEN_NAMES.join("|")})/
-
-	NOT_OVERRIDABLE = %w{class} + instance_methods(false)
-	NOT_OVERRIDABLE_RX = /(?:#{NOT_OVERRIDABLE.join("|")})/
-
-        def method_missing(name, *args, &update) # :nodoc:
-	    name = name.to_s
-
-	    super(name.to_sym, *args, &update) if name =~ FORBIDDEN_NAMES_RX
-            if name =~ /(.+)=$/
-		# Setter
-		name = $1
-
-		value = *args
-                if stable?
-                    raise NoMethodError, "#{self} is stable"
-		elsif @filters.has_key?(name) && !@filters[name].call(value)
-		    raise ArgumentError, "value #{value} is not valid for #{name}"
-		elsif !@members.has_key?(name) && !@aliases.has_key?(name) && respond_to?(name)
-		    if NOT_OVERRIDABLE_RX =~ name
-			raise ArgumentError, "#{name} is already defined an cannot be overriden"
-		    end
-
-		    # Override it
-		    singleton_class.class_eval { private name }
-		end
-
-		attach
-
-
-		@aliases.delete(name)
-		pending = @pending.delete(name)
-
-		if pending && pending != value
-		    pending.detach
-		end
-
-		@members[name] = value
-		updated(name, value)
-                return value
-
-	    elsif name =~ /(.+)\?$/
-		# Test
-		name = $1
-		respond_to?(name) && send(name)
-
-            elsif args.empty? # getter
-		attach
-
-		if @members.has_key?(name)
-		    member = @members[name]
-		else
-		    if alias_to = @aliases[name]
-			return send(alias_to)
-		    elsif stable?
-			raise NoMethodError, "no such attribute #{name} (#{self} is stable)"
-		    else
-			member = children_class.new(children_class, self, name)
-			@pending[name] = member
-		    end
-		end
-
-                if update
-                    member.update(&update)
-		else
-                    member
-                end
-
-	    else
-		super(name.to_sym, *args, &update)
-            end
-        end
-
-	def alias(from, to)
-	    @aliases[to.to_s] = from.to_s
-	end
-    end
-
-    class StateSpace < ExtendedStruct
-	def initialize
-            @exported_fields = Set.new
-	    super
-	end
-
-	def _dump(lvl = -1)
-	    marshalled_members = @exported_fields.map do |name|
-		value = @members[name]
-		[name, Marshal.dump(value)] rescue nil
-	    end
-	    marshalled_members.compact!
-	    Marshal.dump([marshalled_members, @aliases])
-	end
-
-	def deep_copy
-	    exported_fields, @exported_fields = @exported_fields, Set.new
-	    Marshal.load(Marshal.dump(self))
-	ensure
-	    @exported_fields = exported_fiels
-	end
-
-	def testing?; Roby.app.testing? end
-	def simulation?; Roby.app.simulation? end
-	def export(*names)
-	    @exported_fields.merge names.map { |n| n.to_s }.to_set
-	end
-    end
-end
-