roby 0.7.3 → 0.8.0

data/lib/roby/log/console.rb

@@ -30,14 +30,16 @@ module Roby::Log
 	def arg_to_s(arg)
 	    case arg
 	    when Time then Time.at(arg - @reftime).to_hms
-	    when Array then arg.map(&method(:arg_to_s)).to_s
+	    when Array then arg.map { |v| arg_to_s(v) }.to_s
 	    when Hash then arg.map { |k, v| [arg_to_s(k), arg_to_s(v)].join(" => ") }.to_s
 	    else arg.to_s
 	    end
 	end
 
 
-	def display(m, time, *args) # :nodoc:
+        def logs_message?(m); true end
+        def close; end
+	def dump_method(m, time, *args) # :nodoc:
 	    @reftime ||= time
 
 	    args.map! { |a| arg_to_s(a) }
@@ -65,7 +67,7 @@ module Roby::Log
 	private :display
 
 	Roby::Log.each_hook do |klass, m|
-	    define_method(m) { |args| display(m, *args) }
+	    define_method(m) { |time, args| dump_method(m, time, args) }
 	end
     end
 end

data/lib/roby/log/data_stream.rb

@@ -46,6 +46,12 @@ module Roby::Log
 	    @decoders = []
 	end
 
+        def each_sample
+            while sample = read_and_decode
+                yield(sample)
+            end
+        end
+
 	def to_s; "#{name} [#{type}]" end
 	def open; end
 	def close; end
@@ -62,7 +68,9 @@ module Roby::Log
 	def read_all; end
 
 	def read_and_decode
-	    self.class.decode(read)
+            if raw = read
+                self.class.decode(raw)
+            end
 	end
 
 	# The [min, max] range of available samples. Initially
@@ -100,12 +108,21 @@ module Roby::Log
 	    super if defined? super
 	end
 
-	# Do a read - decode - feed cycle
-	def advance
-	    data = decode(read)
-	    decoders.each do |dec|
-		dec.process(data)
-	    end
+	# Do a read and decode the data
+        #
+        # It returns false if no decoders have found interesting updates in the
+        # decoded data, and true otherwise. The method relies on the decoder's
+        # #process method to return true/false when required.
+        #
+        # See DataDecoder#process
+        def advance
+	    if data = read_and_decode
+                !decoders.find_all do |dec|
+                    dec.process(data)
+                end.empty?
+            else
+                raise EOFError
+            end
 	end
 
 	def init(data)
@@ -115,13 +132,26 @@ module Roby::Log
 	    self.class.decode(data)
 	end
 
+        # Displays may have the ability to not display a per-cycle information,
+        # but to add information as it is coming over. This call asks them to
+        # remove the information integrated until now.
+        #
+        # It forwards the call to the decoders' #clear_integrated call. These
+        # methods should return true if a change has been needed on any of their
+        # display, and false otherwise.
 	def clear_integrated
-	    decoders.each do |decoder|
+	    !decoders.find_all do |decoder|
 		decoder.clear_integrated
-	    end
+	    end.empty?
 	end
 
 	# Update the displays
+        #
+        # It returns false if all decoders have reported that no display update
+        # was required, and true otherwise. The method relies on the decoder's
+        # #display method to return true/false when required.
+        #
+        # See DataDecoder#display
 	def display
 	    decoders.each do |decoder|
 		decoder.display
@@ -137,10 +167,16 @@ module Roby::Log
 	def hash; [name, type].hash end
     end
 
+    # In the data flow model we're using, a data decoder gets data from a
+    # DataStream object and builds a representation that can be used by
+    # displays.
     class DataDecoder
 	# The set of displays attached to this decoder
 	attr_reader :displays
+        # The decoder name
 	attr_reader :name
+
+        # The DataStream object we're getting our data from
 	attr_accessor :stream
 
 	def initialize(name)
@@ -148,24 +184,54 @@ module Roby::Log
 	    @displays = [] 
 	end
 
+        # Clear the stream data
 	def clear
 	    displays.each { |d| d.clear }
 	end
 
+        # Displays may have the ability to not display a per-cycle information,
+        # but to add information as it is coming over. This call asks them to
+        # remove the information integrated until now.
+        #
+        # It forwards the call to the displays' #clear_integrated call(if any). These
+        # methods should return true if a change has been needed on any of their
+        # display, and false otherwise.
 	def clear_integrated
-	    displays.each do |display|
-		display.clear_integrated if display.respond_to?(:clear_integrated)
-	    end
+	    !displays.find_all do |display|
+                if display.respond_to?(:clear_integrated)
+                    display.clear_integrated 
+                end
+	    end.empty?
 	end
 
-	# Update the display to the current state of the decoder
+	# Updates the displays that are associated with this decoder. Returns
+        # true if one of the displays have been changed, and false otherwise.
+        #
+        # It relies on the display's #update method to return true if something
+        # has changed on the display and false otherwise.
 	def display
-	    displays.each do |display| 
+	    !displays.find_all do |display| 
 		display.update
-	    end
+	    end.empty?
 	end
     end
 
+    # This module gets mixed-in the display classes. It creates the necessary
+    # stream => decoder => display link, reusing (if possible) a decoder that
+    # already exists.
+    #
+    # One should use it that way:
+    #
+    # class Display
+    #   include DataDisplay
+    #   decoder DecoderClass
+    # end
+    #
+    # Then, one can do
+    #   display = Display.new
+    #   display.stream = data_stream
+    #
+    # and leave the rest to the DataDisplay implementation.
     module DataDisplay
 	module ClassExtension
 	    def decoder(new_type = nil)
@@ -177,11 +243,23 @@ module Roby::Log
 	    end
 	end
 
+        # The decoder object. That object gets data from a DataStream object and
+        # decodes it into the format required by the display.
+        #
+        # Examples: PlanRebuilder
 	attr_reader :decoder
 	attr_reader :main
+
+        # The configuration UI object. Usually a subclass of Qt::Widget
 	attr_accessor :config_ui
-	def splat?; true end
 
+
+	def splat? #:nodoc:
+            true
+        end
+
+        # Sets the data stream that this display listens to. It creates or gets
+        # the decoder that is necessary between the raw stream and the display
 	def stream=(data_stream)
 	    if decoder
 		clear

data/lib/roby/log/dot.rb

@@ -33,11 +33,11 @@ module Roby
 		trsc.to_dot(display, io, level + 1)
 	    end
 
-	    relations_to_dot(display, io, TaskStructure, known_tasks)
+	    relations_to_dot(display, io, Roby::Log::RelationsDisplay.all_task_relations, known_tasks)
 	end
 
-	def each_displayed_relation(display, space, objects)
-	    space.relations.each do |rel|
+	def each_displayed_relation(display, relations, objects)
+	    relations.each do |rel|
 		next unless display.relation_enabled?(rel)
 
 		objects.each do |from|
@@ -60,8 +60,8 @@ module Roby
 	    end
 	end
 
-	def relations_to_dot(display, io, space, objects)
-	    each_displayed_relation(display, space, objects) do |rel, from, to|
+	def relations_to_dot(display, io, all_relations, objects)
+	    each_displayed_relation(display, all_relations, objects) do |rel, from, to|
 		from_id, to_id = from.dot_id, to.dot_id
 		if from_id && to_id
 		    io << "  #{from_id} -> #{to_id}\n"
@@ -71,8 +71,8 @@ module Roby
 	    end
 	end
 
-	def layout_relations(positions, display, space, objects)
-	    each_displayed_relation(display, space, objects) do |rel, from, to|
+	def layout_relations(positions, display, all_relations, objects)
+	    each_displayed_relation(display, all_relations, objects) do |rel, from, to|
 		display.task_relation(from, to, rel, from[to, rel])
 	    end
 	end
@@ -114,7 +114,7 @@ module Roby
 	    transactions.each do |trsc|
 		trsc.apply_layout(bounding_rects, positions, display, max_depth)
 	    end
-	    layout_relations(positions, display, TaskStructure, known_tasks)
+	    layout_relations(positions, display, Roby::Log::RelationsDisplay.all_task_relations, known_tasks)
 	end
     end
 

data/lib/roby/log/event_stream.rb

@@ -17,7 +17,11 @@ module Roby
             attr_reader :start_cycle
 	    # A [min, max] array of the minimum and maximum times for this
 	    # stream
-	    def range; [start_time, logfile.range.last] end
+	    def range
+                if range = logfile.range
+                    [start_time, logfile.range.last]
+                end
+            end
 
 	    def initialize(basename, file = nil)
 		super(basename, "roby-events")
@@ -104,6 +108,10 @@ module Roby
 		    reinit!
 		end
 
+                if current_cycle >= index_data.size
+                    return
+                end
+
 		start_pos = index_data[current_cycle][:pos]
 		end_pos   = if index_data.size > current_cycle + 1
 				index_data[current_cycle + 1][:pos]
@@ -128,8 +136,10 @@ module Roby
 	    rescue EOFError
 	    end
 
-	    # Unmarshalls one cycle of data returned by #read and feeds
-	    # it to the decoders
+	    # Unmarshalls one cycle of data returned by #read
+            #
+            # In the case of the event stream, this is one array dumped with
+            # Marshal.dump
 	    def self.decode(data)
 		Marshal.load(data)
 	    end

data/lib/roby/log/file.rb

@@ -10,8 +10,10 @@ module Roby::Log
 	attr_reader :index_data
 	attr_reader :basename
 	def range
-	    [Time.at(*index_data.first[:start]), 
-		Time.at(*index_data.last[:start]) + index_data.last[:end]]
+            if !index_data.empty?
+                [Time.at(*index_data.first[:start]), 
+                    Time.at(*index_data.last[:start]) + index_data.last[:end]]
+            end
 	end
 
 	def initialize(file, allow_old_format = false, force_rebuild_index = false)
@@ -30,6 +32,14 @@ module Roby::Log
 		FileLogger.check_format(@event_io)
 	    end
 
+            @event_io.rewind
+            file_header = Marshal.load(@event_io)
+            if file_header[:plugins]
+                file_header[:plugins].each do |plugin_name|
+                    Roby.app.using plugin_name
+                end
+            end
+
 	    index_path = "#{basename}-index.log"
 	    if force_rebuild_index || !File.file?(index_path)
 		rebuild_index
@@ -88,8 +98,13 @@ module Roby::Log
                     return false
                 end
 
-                if cycle[-4] != :cycle_end ||
-                    cycle[-1].first != index
+                stats = cycle.last[0].dup
+                stats.delete(:state)
+                index = index.dup
+                index.delete(:state)
+                if stats != index
+                    STDERR.puts stats.inspect
+                    STDERR.puts index.inspect
                     return false
                 end
             end
@@ -127,7 +142,7 @@ module Roby::Log
 
     # A logger object which marshals all available events in two files. The
     # event log is the full log, the index log contains only the timings given
-    # to Control#cycle_end, along with the corresponding position in the event
+    # to ExecutionEngine#cycle_end, along with the corresponding position in the event
     # log file.
     #
     # You can use FileLogger.replay(io) to send the events back into the
@@ -151,19 +166,28 @@ module Roby::Log
 	# StringIO object on which we dump the data
 	attr_reader :dump_io
 
-	def initialize(basename)
+	def initialize(basename, options)
 	    @current_pos   = 0
 	    @dump_io	   = StringIO.new('', 'w')
 	    @current_cycle = Array.new
 	    @event_log = File.open("#{basename}-events.log", 'w')
 	    event_log.sync = true
-	    FileLogger.write_header(@event_log)
+	    FileLogger.write_header(@event_log, options)
 	    @index_log = File.open("#{basename}-index.log", 'w')
 	    index_log.sync = true
 	end
 
 	attr_accessor :stats_mode
 	def splat?; false end
+        def logs_message?(m)
+	    m == :cycle_end || !stats_mode
+        end
+
+        def close
+            dump_method(:cycle_end, Time.now, [])
+            @event_log.close
+            @index_log.close
+        end
 
 	def dump_method(m, time, args)
 	    if m == :cycle_end || !stats_mode
@@ -172,7 +196,7 @@ module Roby::Log
 	    if m == :cycle_end
 		info = args.first
 		info[:pos] = event_log.tell
-		info[:event_count] = current_cycle.size
+		info[:event_count] = current_cycle.size / 4
 		Marshal.dump(current_cycle, event_log)
 
 		dump_io.truncate(0)
@@ -184,13 +208,16 @@ module Roby::Log
 	    end
 
 	rescue 
-	    puts "failed to dump #{m}#{args}: #{$!.full_message}"
-	    args.each do |obj|
-		unless (Marshal.dump(obj) rescue nil)
-		    puts "there is a problem with"
-		    pp obj
+            current_cycle.each_slice(4) do |m, sec, usec, args|
+		unless (Marshal.dump(args) rescue nil)
+                    args.each do |obj|
+                        unless (Marshal.dump(obj) rescue nil)
+                            puts "cannot dump the following object in #{m}(#{args.join(", ")}):"
+                            pp obj
+                        end
+                    end
 		end
-	    end
+            end
 	end
 
 	Roby::Log.each_hook do |klass, m|
@@ -209,8 +236,6 @@ module Roby::Log
 	    loop do
 		cycle = Marshal.load(event_log)
 		info               = cycle.last.last
-		info[:pos]         = current_pos
-		info[:event_count] = cycle.size
 
 		dump_io.truncate(0)
 		dump_io.seek(0)
@@ -262,8 +287,8 @@ module Roby::Log
 	    end
 	end
 
-	def self.write_header(io)
-	    header = { :log_format => FORMAT_VERSION }
+	def self.write_header(io, options = Hash.new)
+	    header = { :log_format => FORMAT_VERSION }.merge(options)
 	    Marshal.dump(header, io)
 	end
 

data/lib/roby/log/gui/basic_display_ui.rb

@@ -0,0 +1,89 @@
+=begin
+** Form generated from reading ui file 'basic_display.ui'
+**
+** Created: Mon Jan 25 15:21:37 2010
+**      by: Qt User Interface Compiler version 4.5.3
+**
+** WARNING! All changes made in this file will be lost when recompiling ui file!
+=end
+
+class Ui_BasicDisplayConfig
+    attr_reader :gridLayout
+    attr_reader :gridLayout1
+    attr_reader :label
+    attr_reader :close
+    attr_reader :spacerItem
+    attr_reader :stream
+
+    def setupUi(basicDisplayConfig)
+    if basicDisplayConfig.objectName.nil?
+        basicDisplayConfig.objectName = "basicDisplayConfig"
+    end
+    basicDisplayConfig.resize(333, 77)
+    @gridLayout = Qt::GridLayout.new(basicDisplayConfig)
+    @gridLayout.spacing = 6
+    @gridLayout.margin = 9
+    @gridLayout.objectName = "gridLayout"
+    @gridLayout1 = Qt::GridLayout.new()
+    @gridLayout1.spacing = 6
+    @gridLayout1.margin = 0
+    @gridLayout1.objectName = "gridLayout1"
+    @label = Qt::Label.new(basicDisplayConfig)
+    @label.objectName = "label"
+    @sizePolicy = Qt::SizePolicy.new(1, 5)
+    @sizePolicy.setHorizontalStretch(0)
+    @sizePolicy.setVerticalStretch(0)
+    @sizePolicy.heightForWidth = @label.sizePolicy.hasHeightForWidth
+    @label.sizePolicy = @sizePolicy
+
+    @gridLayout1.addWidget(@label, 1, 0, 1, 1)
+
+    @close = Qt::PushButton.new(basicDisplayConfig)
+    @close.objectName = "close"
+
+    @gridLayout1.addWidget(@close, 0, 2, 1, 1)
+
+    @spacerItem = Qt::SpacerItem.new(161, 20, Qt::SizePolicy::Expanding, Qt::SizePolicy::Minimum)
+
+    @gridLayout1.addItem(@spacerItem, 0, 0, 1, 2)
+
+    @stream = Qt::ComboBox.new(basicDisplayConfig)
+    @stream.objectName = "stream"
+    @sizePolicy1 = Qt::SizePolicy.new(3, 0)
+    @sizePolicy1.setHorizontalStretch(0)
+    @sizePolicy1.setVerticalStretch(0)
+    @sizePolicy1.heightForWidth = @stream.sizePolicy.hasHeightForWidth
+    @stream.sizePolicy = @sizePolicy1
+
+    @gridLayout1.addWidget(@stream, 1, 1, 1, 2)
+
+
+    @gridLayout.addLayout(@gridLayout1, 0, 0, 1, 1)
+
+
+    retranslateUi(basicDisplayConfig)
+
+    Qt::MetaObject.connectSlotsByName(basicDisplayConfig)
+    end # setupUi
+
+    def setup_ui(basicDisplayConfig)
+        setupUi(basicDisplayConfig)
+    end
+
+    def retranslateUi(basicDisplayConfig)
+    basicDisplayConfig.windowTitle = Qt::Application.translate("BasicDisplayConfig", "Form", nil, Qt::Application::UnicodeUTF8)
+    @label.text = Qt::Application.translate("BasicDisplayConfig", "Data stream", nil, Qt::Application::UnicodeUTF8)
+    @close.text = Qt::Application.translate("BasicDisplayConfig", "Close", nil, Qt::Application::UnicodeUTF8)
+    end # retranslateUi
+
+    def retranslate_ui(basicDisplayConfig)
+        retranslateUi(basicDisplayConfig)
+    end
+
+end
+
+module Ui
+    class BasicDisplayConfig < Ui_BasicDisplayConfig
+    end
+end  # module Ui
+