roby 0.7.3 → 0.8.0

data/lib/roby/transactions.rb

@@ -1,8 +1,3 @@
-require 'roby/plan'
-require 'utilrb/value_set'
-require 'utilrb/kernel/swap'
-require 'roby/transactions/proxy'
-
 module Roby
     # Exception raised when someone tries do commit an invalid transaction
     class InvalidTransaction < RuntimeError; end
@@ -15,7 +10,8 @@ module Roby
 	
 	# A transaction is not an executable plan
 	def executable?; false end
-	def freezed?; @freezed end
+        attr_predicate :freezed
+        attr_predicate :committed
 
 	def do_wrap(object, do_include = false) # :nodoc:
 	    raise "transaction #{self} has been either committed or discarded. No modification allowed" if freezed?
@@ -23,7 +19,7 @@ module Roby
 	    proxy = proxy_objects[object] = Proxy.proxy_class(object).new(object, self)
 	    if do_include && object.root_object?
 		proxy.plan = self
-		discover(proxy)
+		add(proxy)
 	    end
 
 	    copy_object_relations(object, proxy)
@@ -38,7 +34,7 @@ module Roby
 	# This method copies on +proxy+ all relations of +object+ for which
 	# both ends of the relation are already in the transaction.
 	def copy_object_relations(object, proxy)
-	    Roby::Control.synchronize do
+	    Roby.synchronize do
 		# Create edges between the neighbours that are really in the transaction
 		object.each_relation do |rel|
 		    object.each_parent_object(rel) do |parent|
@@ -63,17 +59,19 @@ module Roby
 		elsif proxy = proxy_objects[object] then return proxy
 		end
 
+                if !object.plan && !object.finalized?
+                    object.plan = self
+                    add(object)
+                    return object
+                end
+
 		if create
-		    if !object.plan
-			object.plan = self
-			discover(object)
-			return object
-		    elsif object.plan == self.plan
+		    if object.plan == self.plan
 			wrapped = do_wrap(object, true)
 			if plan.mission?(object)
-			    insert(wrapped)
+			    add_mission(wrapped)
 			elsif plan.permanent?(object)
-			    permanent(wrapped)
+			    add_permanent(wrapped)
 			end
 			return wrapped
 		    else
@@ -81,41 +79,20 @@ module Roby
 		    end
 		end
 		nil
-	    elsif object.respond_to?(:each) 
+	    elsif object.respond_to?(:to_ary) 
 		object.map { |o| wrap(o, create) }
+            elsif object.respond_to?(:each)
+                raise ArgumentError, "don't know how to wrap containers of class #{objects.class}"
 	    else
 		raise TypeError, "don't know how to wrap #{object || 'nil'} of type #{object.class.ancestors}"
 	    end
 	end
 	alias :[] :wrap
 
-	# Remove +proxy+ from this transaction. While #remove_object is also
-	# removing the object from the plan itself, this method only removes it
-	# from the transaction, forgetting all modifications that have been
-	# done on +object+ in the transaction
-	def discard_modifications(object)
-	    object = may_unwrap(object)
-	    if object.respond_to?(:each_plan_child)
-		object.each_plan_child do |child|
-		    discard_modifications(child)
-		end
-	    end
-	    removed_objects.delete(object)
-	    discarded_tasks.delete(object)
-	    auto_tasks.delete(object)
-
-	    return unless proxy = proxy_objects.delete(object)
-	    proxy.clear_vertex
-
-	    missions.delete(proxy)
-	    known_tasks.delete(proxy)
-	    free_events.delete(proxy)
-	end
-
 	def restore_relation(proxy, relation)
 	    object = proxy.__getobj__
 
-	    Control.synchronize do
+	    Roby.synchronize do
 		proxy_children = proxy.child_objects(relation)
 		object.child_objects(relation).each do |object_child| 
 		    next unless proxy_child = wrap(object_child, false)
@@ -133,36 +110,56 @@ module Roby
 		end
 	    end
 
-	    discovered_objects.delete(proxy)
+	    added_objects.delete(proxy)
 	    proxy.discovered_relations.delete(relation)
 	    proxy.do_discover(relation, false)
 	end
 
-	alias :remove_plan_object :remove_object
+        # Removes an object from this transaction
+        #
+        # This does *not* remove the object from the underlying plan. Removing
+        # objects directly is (at best) dangerous, and should be handled by
+        # garbage collection.
 	def remove_object(object)
 	    raise "transaction #{self} has been either committed or discarded. No modification allowed" if freezed?
 
 	    object = may_unwrap(object)
-	    proxy = proxy_objects[object] || object
-
-	    # removing the proxy may trigger some discovery (event relations
-	    # for instance, if proxy is a task). Do it first, or #discover
-	    # will be called and the modifications of internal structures
-	    # nulled (like #removed_objects) ...
-	    remove_plan_object(proxy)
-	    proxy_objects.delete(object)
-
-	    if object.plan == self.plan
-		# +object+ is new in the transaction
-		removed_objects.insert(object)
-	    end
+            proxy  = proxy_objects.delete(object)
+            if (proxy || object).plan != self
+                raise InternalError, "inconsistency"
+            end
+
+            if proxy
+                discarded_tasks.delete(object)
+                auto_tasks.delete(object)
+                if proxy.respond_to?(:each_plan_child)
+                    proxy.each_plan_child(true) do |child_proxy|
+                        auto_tasks.delete(child_proxy)
+                    end
+                end
+            end
+
+            proxy ||= object
+            if proxy.root_object?
+                super(proxy)
+            end
+            self
 	end
 
-	def may_wrap(object, create = true)
-	    (wrap(object, create) || object) rescue object 
+	def may_wrap(objects, create = true)
+            if objects.respond_to?(:to_ary)
+                objects.map { |obj| may_wrap(obj, create) }
+            elsif objects.respond_to?(:each)
+                raise ArgumentError, "don't know how to wrap containers of class #{objects.class}"
+            elsif objects.kind_of?(PlanObject)
+                wrap(objects, create)
+            else
+                objects
+            end
 	end
 	
-	# may_unwrap may return objects from transaction
+	# If +object+ is in this transaction, may_unwrap will return the
+        # underlying plan object. In all other cases, returns object.
 	def may_unwrap(object)
 	    if object.respond_to?(:plan) 
 		if object.plan == self && object.respond_to?(:__getobj__)
@@ -178,93 +175,94 @@ module Roby
 
 	# The list of discarded
 	attr_reader :discarded_tasks
-	# The list of removed tasks and events
-	attr_reader :removed_objects
 	# The list of permanent tasks that have been auto'ed
 	attr_reader :auto_tasks
 	# The plan this transaction applies on
 	attr_reader :plan
 	# The proxy objects built for this transaction
 	attr_reader :proxy_objects
-
-	attr_reader :conflict_solver
+        # The option hash given at initialization
 	attr_reader :options
 
-	def conflict_solver=(value)
-	    @conflict_solver = case value
-			       when :update
-				   SolverUpdateRelations
-			       when :invalidate
-				   SolverInvalidateTransaction
-			       when :ignore
-				   SolverIgnoreUpdate.new
-			       else value
-			       end
-	end
+        # The decision control object associated with this transaction. It is
+        # in general plan.control
+        def control; plan.control end
 
 	# Creates a new transaction which applies on +plan+
 	def initialize(plan, options = {})
-	    options = validate_options options, 
-		:conflict_solver => :invalidate
-
 	    @options = options
-	    self.conflict_solver = options[:conflict_solver]
 	    super()
 
-	    @plan = plan
+	    @plan   = plan
 
 	    @proxy_objects      = Hash.new
-	    @removed_objects    = ValueSet.new
 	    @discarded_tasks    = ValueSet.new
 	    @auto_tasks	        = ValueSet.new
 
-	    Roby::Control.synchronize do
+	    Roby.synchronize do
 		plan.transactions << self
 		plan.added_transaction(self)
 	    end
 	end
 
+        # Calls the given block in the execution thread of the engine of the
+        # underlying plan. If there is no engine attached to this plan, yields
+        # immediately.
+        #
+        # See Plan#execute and ExecutionEngine#execute
+        def execute(&block)
+            plan.execute(&block)
+        end
+
 	def discover_neighborhood(object)
-	    self[object]
-	    object.each_relation do |rel|
-		object.each_parent_object(rel) { |obj| self[obj] }
-		object.each_child_object(rel)  { |obj| self[obj] }
-	    end
+            stack  = object.transaction_stack
+            object = object.real_object
+            while stack.size > 1
+                plan = stack.pop
+                next_plan = stack.last
+
+                next_plan[object]
+                object.each_relation do |rel|
+                    object.each_parent_object(rel) { |obj| next_plan[obj] }
+                    object.each_child_object(rel)  { |obj| next_plan[obj] }
+                end
+                object = next_plan[object]
+            end
+            nil
 	end
 
 	def replace(from, to)
 	    # Make sure +from+, its events and all the related tasks and events
 	    # are in the transaction
-	    from = may_unwrap(from)
 	    discover_neighborhood(from)
 	    from.each_event do |ev|
 		discover_neighborhood(ev)
 	    end
 
-	    super(self[from], self[to])
+	    super(from, to)
 	end
 
-	def insert(t)
+	def add_mission(t)
 	    raise "transaction #{self} has been either committed or discarded. No modification allowed" if freezed?
 	    if proxy = self[t, false]
 		discarded_tasks.delete(may_unwrap(proxy))
 	    end
-	    super(self[t, true]) 
+	    super(t)
 	end
-	def permanent(t)
+	def add_permanent(t)
 	    raise "transaction #{self} has been either committed or discarded. No modification allowed" if freezed?
 	    if proxy = self[t, false]
 		auto_tasks.delete(may_unwrap(proxy))
 	    end
-	    super(self[t, true]) 
+	    super(t)
 	end
-	def discover(objects)
+	def add(objects)
 	    raise "transaction #{self} has been either committed or discarded. No modification allowed" if freezed?
-	    super(self[objects, true])
+	    super(objects)
 	    self
 	end
 
-	def auto(t)
+	def unmark_permanent(t)
 	    raise "transaction #{self} has been either committed or discarded. No modification allowed" if freezed?
 	    if proxy = self[t, false]
 		super(proxy)
@@ -276,7 +274,7 @@ module Roby
 	    end
 	end
 
-	def discard(t)
+	def unmark_mission(t)
 	    raise "transaction #{self} has been either committed or discarded. No modification allowed" if freezed?
 	    if proxy = self[t, false]
 		super(proxy)
@@ -328,12 +326,9 @@ module Roby
 	    check_valid_transaction
 	    freezed!
 
-	    Roby.execute do
-		auto_tasks.each      { |t| plan.auto(t) }
-		discarded_tasks.each { |t| plan.discard(t) }
-		removed_objects.each do |obj| 
-		    plan.remove_object(obj) if plan.include?(obj)
-		end
+	    plan.execute do
+		auto_tasks.each      { |t| plan.unmark_permanent(t) }
+		discarded_tasks.each { |t| plan.unmark_mission(t) }
 
 		discover_tasks  = ValueSet.new
 		discover_events  = ValueSet.new
@@ -351,8 +346,8 @@ module Roby
 		    if missions.include?(t) && t.self_owned?
 			missions.delete(t)
 			insert << unwrapped
-		    elsif keepalive.include?(t) && t.self_owned?
-			keepalive.delete(t)
+		    elsif permanent_tasks.include?(t) && t.self_owned?
+			permanent_tasks.delete(t)
 			permanent << unwrapped
 		    end
 
@@ -367,18 +362,22 @@ module Roby
 				    free_events.delete(ev)
 				    ev
 				end
+                    if permanent_events.include?(ev) && ev.self_owned?
+                        permanent_events.delete(ev)
+                        permanent << unwrapped
+                    end
 
 		    discover_events << unwrapped
 		end
 
-		new_tasks = plan.discover_task_set(discover_tasks)
+		new_tasks = plan.add_task_set(discover_tasks)
 		new_tasks.each do |task|
 		    if task.respond_to?(:commit_transaction)
 			task.commit_transaction
 		    end
 		end
 
-		new_events = plan.discover_event_set(discover_events)
+		new_events = plan.add_event_set(discover_events)
 		new_events.each do |event|
 		    if event.respond_to?(:commit_transaction)
 			event.commit_transaction
@@ -390,8 +389,8 @@ module Roby
 		proxy_objects.each_value { |proxy| proxy.commit_transaction }
 		proxy_objects.each_value { |proxy| proxy.clear_relations  }
 
-		insert.each    { |t| plan.insert(t) }
-		permanent.each { |t| plan.permanent(t) }
+		insert.each    { |t| plan.add_mission(t) }
+		permanent.each { |t| plan.add_permanent(t) }
 
 		proxies     = proxy_objects.dup
 		clear
@@ -402,6 +401,7 @@ module Roby
 		    Kernel.swap! proxy, forwarder
 		end
 
+                @committed = true
 		committed_transaction
 		plan.remove_transaction(self)
 		@plan = nil
@@ -439,7 +439,7 @@ module Roby
 	    clear
 
 	    discarded_transaction
-	    Roby.execute do
+	    plan.execute do
 		plan.remove_transaction(self)
 	    end
 	    @plan = nil
@@ -451,14 +451,57 @@ module Roby
 	end
 
 	def clear
-	    removed_objects.clear
 	    discarded_tasks.clear
 	    proxy_objects.each_value { |proxy| proxy.clear_relations }
 	    proxy_objects.clear
 	    super
 	end
+
+	def finalized_plan_task(task)
+            proxied_task = task.__getobj__
+
+	    invalidate("task #{task} has been removed from the plan")
+            discard_modifications(proxied_task)
+	    control.finalized_plan_task(self, task)
+	end
+
+	def finalized_plan_event(event)
+            proxied_event = event.__getobj__
+
+	    invalidate("event #{event} has been removed from the plan")
+            discard_modifications(proxied_event)
+	    control.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}")
+		control.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 a relation #{parent} -> #{child} in #{relations}")
+		control.removing_plan_relation(self, parent, child, relations)
+	    end
+	end
+
+        # Run a garbage collection pass in the transaction. This is 'static', as
+        # it does not care about the task's state: it will simply remove *from
+        # the transaction* any task that is not useful *in the context of the
+        # transaction*.
+        def static_garbage_collect
+            for t in unneeded_tasks
+                remove_object(t)
+            end
+        end
     end
 end
 
-require 'roby/transactions/updates'
-