roby 0.8.0 → 3.0.0

data/lib/roby/coordination/models/task_from_action.rb

@@ -0,0 +1,50 @@
+module Roby
+    module Coordination
+        module Models
+
+        # A representation of a state based on an action
+        class TaskFromAction < TaskWithDependencies
+            # The associated action
+            # @return [Roby::Actions::Action]
+            attr_accessor :action
+
+            def initialize(action)
+                @action = action
+                super(action.model.returned_type)
+            end
+
+            # Rebind this task to refer to a different action interface
+            def rebind(coordination_model)
+                result = super
+                result.action = action.rebind(coordination_model.action_interface)
+                result.model  = result.action.model.returned_type
+                result
+            end
+
+            # Generates a task for this state in the given plan and returns
+            # it
+            def instanciate(plan, variables = Hash.new)
+                arguments = action.arguments.map_value do |key, value|
+                    if value.respond_to?(:evaluate)
+                        value.evaluate(variables)
+                    else value
+                    end
+                end
+                action.as_plan(arguments)
+            end
+
+            # Returns the action's underlying coordination model if there is one
+            #
+            # @return [nil,Base]
+            def action_coordination_model
+                if action.model.respond_to?(:coordination_model)
+                    action.model.coordination_model
+                end
+            end
+
+            def to_s; "action(#{action})[#{model}]" end
+        end
+        end
+    end
+end
+

data/lib/roby/coordination/models/task_from_as_plan.rb

@@ -0,0 +1,33 @@
+module Roby
+    module Coordination
+        module Models
+            # Definition of a state from an object that responds to instanciate
+            class TaskFromAsPlan < TaskWithDependencies
+                # @return [#instanciate] the object that will be used to generate
+                #   the state's task when needed
+                attr_reader :instanciation_object
+
+                # @param [#instanciate] instanciation_object this object will be
+                #   used to generate the task that will perform the state's action.
+                #   It will be called with #instanciate(plan)
+                # @param [Model<Roby::Task>] task_model the model of the task
+                #   returned by the instanciation object
+                def initialize(instanciation_object, task_model)
+                    super(task_model)
+                    @instanciation_object = instanciation_object
+                end
+
+                # Called by the state machine implementation to create a Roby::Task
+                # instance that will perform the state's actions
+                def instanciate(plan, variables = Hash.new)
+                    plan.add(task = instanciation_object.as_plan)
+                    task
+                end
+
+                def to_s; "#{instanciation_object}[#{model}]" end
+            end
+        end
+    end
+end
+
+

data/lib/roby/coordination/models/task_from_instanciation_object.rb

@@ -0,0 +1,31 @@
+module Roby
+    module Coordination
+        module Models
+            # Definition of a state from an object that responds to instanciate
+            class TaskFromInstanciationObject < TaskWithDependencies
+                # @return [#instanciate] the object that will be used to generate
+                #   the state's task when needed
+                attr_reader :instanciation_object
+
+                # @param [#instanciate] instanciation_object this object will be
+                #   used to generate the task that will perform the state's action.
+                #   It will be called with #instanciate(plan)
+                # @param [Model<Roby::Task>] task_model the model of the task
+                #   returned by the instanciation object
+                def initialize(instanciation_object, task_model)
+                    super(task_model)
+                    @instanciation_object = instanciation_object
+                end
+
+                # Called by the state machine implementation to create a Roby::Task
+                # instance that will perform the state's actions
+                def instanciate(plan, variables = Hash.new)
+                    instanciation_object.instanciate(plan)
+                end
+
+                def to_s; "#{instanciation_object}[#{model}]" end
+            end
+        end
+    end
+end
+

data/lib/roby/coordination/models/task_from_variable.rb

@@ -0,0 +1,27 @@
+module Roby
+    module Coordination
+        module Models
+            # State whose instanciation object is provided through a state machine
+            # variable
+            class TaskFromVariable < TaskWithDependencies
+                attr_reader :variable_name
+                def initialize(variable_name, task_model)
+                    @variable_name = variable_name
+                    super(task_model)
+                end
+
+                def instanciate(plan, variables = Hash.new)
+                    obj = variables[variable_name]
+                    if !obj.respond_to?(:as_plan)
+                        raise ArgumentError, "expected variable #{variable_name} to contain an object that can generate tasks, found #{obj}"
+                    end
+                    obj.as_plan
+                end
+
+                def to_s; "var(#{variable_name})[#{task_model}]" end
+            end
+        end
+    end
+end
+
+

data/lib/roby/coordination/models/task_with_dependencies.rb

@@ -0,0 +1,48 @@
+module Roby
+    module Coordination
+        module Models
+            # Generic representation of an execution context task that can be
+            # instanciated 
+            class TaskWithDependencies < Task
+                # @return [Set<(Task,String)>] set of dependencies needed for this
+                #   task, as a (task,role) pair
+                attr_reader :dependencies
+
+                # (see Task#initialize)
+                def initialize(model)
+                    super
+                    @dependencies = Set.new
+                end
+
+                def initialize_copy(old)
+                    super
+                    @dependencies = @dependencies.dup
+                end
+
+                # Modify this task's internal structure to change relationships
+                # between tasks
+                def map_tasks(mapping)
+                    super
+                    @dependencies = dependencies.map do |task, role|
+                        [mapping[task] || task, role]
+                    end
+                end
+
+                def find_child_model(name)
+                    if d = dependencies.find { |_, role| role == name }
+                        d[0].model
+                    else super
+                    end
+                end
+
+                def depends_on(action, role: nil)
+                    if !action.kind_of?(Coordination::Models::Task)
+                        raise ArgumentError, "expected a task, got #{action}. You probably forgot to convert it using #task or #state"
+                    end
+                    dependencies << [action, role]
+                    self
+                end
+            end
+        end
+    end
+end

data/lib/roby/coordination/models/variable.rb

@@ -0,0 +1,32 @@
+module Roby
+    module Coordination
+        module Models
+            # Placeholder, in the execution contexts, for variables. It is
+            # used for instance to hold the arguments to the state machine during
+            # modelling, replaced by their values during instanciation
+            Variable = Struct.new :name do
+                include Tools::Calculus::Build
+                def evaluate(variables)
+                    if variables.has_key?(name)
+                        variables[name]
+                    else
+                        raise ArgumentError, "expected a value for #{arg}, got none"
+                    end
+                end
+
+                def to_s
+                    "var:#{name}"
+                end
+
+                def to_coordination_task(task_model = Roby::Task)
+                    TaskFromVariable.new(name, task_model)
+                end
+
+                def evaluate_delayed_argument(task)
+                    throw :no_value
+                end
+            end
+        end
+    end
+end
+

data/lib/roby/coordination/script.rb

@@ -0,0 +1,200 @@
+module Roby
+    module Coordination
+        # Common logic for script-based coordination models
+        module Script
+            DeadInstruction = Models::Script::DeadInstruction
+
+            class BlockExecute < ScriptInstruction
+                attr_reader :task
+
+                attr_reader :block
+
+                def initialize(block)
+                    @block = block
+                end
+
+                def new(task)
+                    @task = task
+                    self
+                end
+
+                def execute(script)
+                    script.root_task.instance_eval(&block)
+                    true
+                end
+            end
+
+            module Models
+                class PollUntil
+                    attr_reader :event, :block
+                    def initialize(event, block)
+                        @event, @block = event, block
+                    end
+
+                    def new(script)
+                        Script::PollUntil.new(script.root_task, script.instance_for(event), block)
+                    end
+                end
+            end
+
+            class PollUntil < ScriptInstruction
+                attr_reader :root_task, :event, :block
+                def initialize(root_task, event, block)
+                    @root_task, @event, @block = root_task, event, block
+                end
+
+                def cancel
+                    if @poll_handler_id
+                        root_task.remove_poll_handler(@poll_handler_id)
+                    end
+                    super
+                end
+
+                def execute(script)
+                    @poll_handler_id = root_task.poll do
+                        root_task.instance_eval(&block)
+                    end
+                    event = self.event.resolve
+                    event.on do |ev|
+                        if ev.generator == self.event.resolve && !disabled?
+                            cancel
+                            script.step
+                        end
+                    end
+
+                    if event.task != script.root_task
+                        script.root_task.depends_on event.task, success: event.symbol
+                    else
+                        event.when_unreachable(true) do |reason, generator|
+                            if !disabled?
+                                raise Script::DeadInstruction.new(script.root_task), "the 'until' condition of #{self} will never be reached: #{reason}"
+                            end
+                        end
+                    end
+
+                    false
+                end
+            end
+
+            # Exception generated when a timeout block has reached its specified
+            # limit, if the :event argument has not been set
+            class TimedOut < LocalizedError
+                attr_reader :instruction
+
+                def initialize(task, instruction)
+                    super(task)
+                    @instruction = instruction
+                end
+            end
+
+            class TimeoutStart < ScriptInstruction
+                attr_reader :model
+                attr_reader :event
+                attr_accessor :timeout_stop
+
+                def initialize(model, event)
+                    @model = model
+                    @event = event
+                end
+
+                def execute(script)
+                    script.root_task.execution_engine.delayed(model.seconds) do
+                        if !self.disabled?
+                            # Remove all instructions that are within the
+                            # timeout's scope
+                            if event
+                                event.resolve.emit
+                                script.jump_to(timeout_stop)
+                            else
+                                raise TimedOut.new(script.root_task, script.current_instruction), "#{script.current_instruction} timed out"
+                            end
+                        end
+                    end
+                    true
+                end
+            end
+
+            class TimeoutStop < ScriptInstruction
+                attr_reader :timeout_start
+
+                def initialize(timeout_start)
+                    @timeout_start = timeout_start
+                    timeout_start.timeout_stop = self
+                end
+
+                def execute(script)
+                    timeout_start.cancel
+                    true
+                end
+            end
+
+            attr_reader :current_instruction
+
+            attr_reader :instructions
+
+            def prepare
+                @instructions = Array.new
+                resolve_instructions
+                @current_instruction = nil
+
+                root_task.stop_event.on do |context|
+                    current_instruction.cancel if current_instruction
+                    instructions.each do |ins|
+                        ins.cancel
+                    end
+                end
+            end
+
+            def resolve_instructions
+                model.instructions.each do |ins|
+                    instructions << instance_for(ins)
+                end
+            end
+
+            def dependency_options_for(toplevel, task, roles)
+                options = super
+                if current_instruction.respond_to?(:task) && current_instruction.task == task
+                    options = options.merge(current_instruction.dependency_options)
+                end
+                options
+            end
+
+            def step
+                if current_instruction && !current_instruction.disabled?
+                    return
+                end
+
+                while @current_instruction = instructions.shift
+                    if !current_instruction.disabled?
+                        if !current_instruction.execute(self)
+                            break
+                        end
+                    end
+                end
+            rescue LocalizedError => e
+                raise e
+            rescue Exception => e
+                raise CodeError.new(e, root_task), e.message, e.backtrace
+            end
+
+            def jump_to(target)
+                # Verify that the jump is valid
+                if current_instruction != target && !instructions.find { |ins| ins == target }
+                    raise ArgumentError, "#{target} is not an instruction in #{self}"
+                end
+
+                if current_instruction != target
+                    current_instruction.cancel
+                end
+                while instructions.first != target
+                    instructions.shift
+                end
+                step
+            end
+
+            def finished?
+                instructions.empty? && !@current_instruction
+            end
+        end
+    end
+end

data/lib/roby/coordination/script_instruction.rb

@@ -0,0 +1,12 @@
+module Roby
+    module Coordination
+        class ScriptInstruction
+            attr_predicate :disabled?, true
+
+            def cancel
+                self.disabled = true
+            end
+        end
+    end
+end
+

data/lib/roby/coordination/task.rb

@@ -0,0 +1,45 @@
+module Roby
+    module Coordination
+            # Representation of a toplevel task in an execution context instance
+            class Task < TaskBase
+                # @return [nil,Roby::Task] the actual Roby task this is
+                #   representing
+                attr_reader :task
+
+                def initialize(execution_context, model)
+                    super(execution_context, model)
+                    @task  = nil
+                end
+
+                def root_task
+                    self
+                end
+
+                # Associate this coordination task to the given roby task
+                #
+                # This sets the next value returned by #resolve
+                #
+                # @param [Roby::Task] task
+                def bind(task)
+                    @task = task
+                end
+
+                # Resolves this to the actual task object
+                #
+                # @return [Roby::Task]
+                # @raise ResolvingUnboundObject
+                def resolve
+                    if task then task
+                    else raise ResolvingUnboundObject, "trying to resolve #{self}, which is not (yet) bound"
+                    end
+                end
+
+                def name
+                    model.name
+                end
+
+                def to_s; "Task[#{model.model}]" end
+            end
+    end
+end
+