metababel 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e44583997647f4d7d9e241dd5e066abc80586445283bd2846fa9fa453542de7
-  data.tar.gz: a89855eeb46c35a71325937679b30bc0ef3fe46317cc1239419980b13f43a1b5
+  metadata.gz: 4a06ce284438f35303ef476971d820bd7ae1c2370b58181ba36146821d4423f7
+  data.tar.gz: 534aff0d21827f367caa9295051d886be08e624a24775e9c3fbd19da7fef97dc
 SHA512:
-  metadata.gz: 8ece21929325026051ef4897d8f9871c19e5af621d963d1fcd8e57e8e481feb460e6fe3a02675eefb0bd44dc64505af329231ea22b52c54acbbfc7d9efcdaf2a
-  data.tar.gz: 62fd169ca6e45a414b71228c2b6fc763bd0d18dd83fcbc6266d1663bb7303a8aa608f56863b3bbea0154d5862e4b80f26adbdbd6401b11541a658e200c278704
+  metadata.gz: edac518ba0bbec6c560f1e763bbf9df96d40e9b666f6c54db2fda8c71a1f9676a880e79f97a0aeb6c311db4c2cf3f2870d1643ae2f3e17514ac9fa9123001f71
+  data.tar.gz: 484cf07cd9e6930c2a54fc562e79420ceeb7a5a6a931e90576084cb6a252af2526ac3fddb41bcc080bb6c9879c20f248094f7455b6fca93424873b92dca61828

data/bin/metababel

@@ -7,11 +7,22 @@ require 'metababel'
 require 'fileutils'
 
 def validate_model(yaml)
-  raise "Invalid Model #{yaml}" unless yaml[:stream_classes].all? do |d|
-                                         d.key?(:event_common_context_field_class) || d[:event_classes].all? do |d2|
-                                           d2.key?(:payload_field_class)
-                                         end
-                                       end
+  # Stream and event classes must have a 'name' as minimum requirement.
+  raise "Missing 'name' attr in model #{yaml}" unless yaml[:stream_classes].all? do |d|
+                                                        d.key?(:name) && d[:event_classes].all? do |d2|
+                                                          d2.key?(:name)
+                                                        end
+                                                      end
+
+  # Event class name must be unique
+  events = yaml[:stream_classes].flat_map { |sc|  sc[:event_classes] }.map { |e| e[:name] }
+  raise "Duplicated 'event' in model #{yaml}" unless events.length == events.uniq.length
+end
+
+class Array
+  def join_with_prefix(sep)
+    empty? ? '' : "#{sep}#{join(sep)}"
+  end
 end
 
 class Hash
@@ -33,7 +44,14 @@ class Hash
   end
 end
 
-EventInfo = Struct.new(:name, :args, :body, :index_stream_class, :index_event_class, :default_clock_class) do
+EventClassInfo = Struct.new(:name, :args, :body, :index_stream_class, :index_event_class, :default_clock_class,
+                            :args_to_free) do
+  def name_sanitized
+    name.gsub(/[^0-9A-Za-z-]/, '_')
+  end
+end
+
+StreamClassInfo = Struct.new(:name, :args, :body, :default_clock_class) do
   def name_sanitized
     name.gsub(/[^0-9A-Za-z-]/, '_')
   end
@@ -71,17 +89,28 @@ end
 # But we clean the white space empty line afterward \o/
 def wrote_event_dispatchers(folder, t)
   event_name = 'event'
-  event_dispatchers = t.map_event_classes_with_index do |e, index_stream_class, index_event_class, default_clock_class|
-    arg_variables = []
-    arg_variables << GeneratedArg.new("uint64_t", "timestamp") if default_clock_class
-
+  event_class_dispatchers = t.map_event_classes_with_index do |e, index_stream_class, index_event_class, default_clock_class|
+    arg_variables = {}
     body = Babeltrace2Gen.context(indent: 1) do
       e.get_getter(event: event_name, arg_variables: arg_variables)
     end
-    EventInfo.new(e.name, arg_variables, "\n" + body, index_stream_class, index_event_class)
+    EventClassInfo.new(e.name, arg_variables.fetch('outputs', []), body, index_stream_class, index_event_class, default_clock_class,
+                       arg_variables.fetch('outputs_allocated', []))
   end
 
-  d = { event_dispatchers: event_dispatchers,
+  stream_classes_matching_dispatchers = t.stream_classes.map do |s|
+    arg_variables = {}
+    body = ''
+    if s.event_common_context_field_class
+      body = Babeltrace2Gen.context(indent: 1) do
+        s.get_getter(event: event_name, arg_variables: arg_variables)
+      end
+    end
+    StreamClassInfo.new(s.name, arg_variables.fetch('outputs', []), body, s.default_clock_class)
+  end
+
+  d = { event_class_dispatchers: event_class_dispatchers,
+        stream_classes_matching_dispatchers: stream_classes_matching_dispatchers,
         event_name: event_name }
 
   erb_render_and_save(d, 'upstream.h', folder)
@@ -91,13 +120,12 @@ end
 def wrote_creates(folder, t)
   event_name = 'event'
   downstream_events = t.map_event_classes_with_index do |e, index_stream_class, index_event_class, default_clock_class|
-    arg_variables = []
+    arg_variables = {}
     body = Babeltrace2Gen.context(indent: 1) do
       e.get_setter(event: event_name, arg_variables: arg_variables)
     end
-    arg_variables.insert(0,GeneratedArg.new("uint64_t", "timestamp")) if default_clock_class
-
-    EventInfo.new(e.name, arg_variables, "\n" + body, index_stream_class, index_event_class, default_clock_class)
+    EventClassInfo.new(e.name, arg_variables.fetch('outputs', []), "\n" + body, index_stream_class, index_event_class,
+                       default_clock_class)
   end
 
   body_declarator_classes = "\n" + Babeltrace2Gen.context(indent: 1) do
@@ -114,18 +142,18 @@ def wrote_creates(folder, t)
 end
 
 def wrote_component(options, d, folder)
-  component_dispatchers = [EventInfo.new('initialize_usr_data',
-                                         [GeneratedArg.new('void **', 'usr_data_p')]),
-                           EventInfo.new('finalize_usr_data',
-                                         [GeneratedArg.new('void *', 'usr_data')]),
-                           EventInfo.new('read_params',
-                                         [GeneratedArg.new('void *', 'usr_data'),
-                                          GeneratedArg.new('btx_params_t *', 'usr_params')])]
+  component_dispatchers = [EventClassInfo.new('initialize_usr_data',
+                                              [GeneratedArg.new('void **', 'usr_data_p')]),
+                           EventClassInfo.new('finalize_usr_data',
+                                              [GeneratedArg.new('void *', 'usr_data')]),
+                           EventClassInfo.new('read_params',
+                                              [GeneratedArg.new('void *', 'usr_data'),
+                                               GeneratedArg.new('btx_params_t *', 'usr_params')])]
 
   if options[:component_type] == 'SOURCE'
-    component_dispatchers << EventInfo.new('push_usr_messages',
-                                           [GeneratedArg.new('void *', 'usr_data'),
-                                            GeneratedArg.new('btx_source_status_t*', 'status')])
+    component_dispatchers << EventClassInfo.new('push_usr_messages',
+                                                [GeneratedArg.new('void *', 'usr_data'),
+                                                 GeneratedArg.new('btx_source_status_t*', 'status')])
   end
 
   d2 = { component_dispatchers: component_dispatchers,
@@ -187,8 +215,9 @@ OptionParser.new do |opts|
 end.parse!
 
 raise OptionParser::MissingArgument if options[:component_type].nil?
+
 options[:plugin_name] ||= "metababel_#{options[:component_type].downcase}"
-options[:component_name] ||= "btx"
+options[:component_name] ||= 'btx'
 
 # Babeltrace can be extended by plugins, which provide one or more component classes.
 base_folder = options[:folder] || "#{options[:component_type]}.#{options[:plugin_name]}.#{options[:component_name]}"
@@ -208,10 +237,10 @@ if options.key?(:params)
   d[:params_declaration] = c.get_struct_definition('params')
   d[:params_definition] = body
 else
-  d[:params_declaration] = "char _dummy;"
+  d[:params_declaration] = 'char _dummy;'
 end
 
-erb_render_and_save(d, "#{options[:component_type].downcase}.c", base_folder, out_name: "main.c")
+erb_render_and_save(d, "#{options[:component_type].downcase}.c", base_folder, out_name: 'main.c')
 erb_render_and_save({ options: options }, 'metababel.h', folder, prefix: '')
 
 wrote_component(options, d, folder)

data/lib/metababel/bt2_stream_classes_generator.rb

@@ -1,5 +1,14 @@
 require_relative 'bt2_generator_utils'
 
+module HashRefinements
+  refine Hash do
+    def fetch_append(key, item)
+      self[key] = fetch(key, []) << item
+      item
+    end
+  end
+end
+
 module Babeltrace2Gen
   class GeneratedArg < Struct.new(:type, :name)
   end
@@ -31,32 +40,22 @@ module Babeltrace2Gen
       is_a?(Babeltrace2Gen::BTMemberClass) ? self : @parent.rec_menber_class
     end
 
-    def find_field_class_path(path, variable)
-      path.scan(/\["(\w+)"\]|\[(\d+)\]/).each do |m|
-        # String
-        if m.first
-          pr "#{variable} = bt_field_class_structure_borrow_member_by_name(#{variable}, \"#{m.first}\");"
+    def resolve_path(path)
+      root, id = path.match(/^(PACKET_CONTEXT|EVENT_COMMON_CONTEXT|EVENT_SPECIFIC_CONTEXT|EVENT_PAYLOAD)\["?(.+)?"\]/).captures
+      field_class =
+        case root
+        when 'PACKET_CONTEXT'
+          rec_stream_class.packet_context_field_class
+        when 'EVENT_COMMON_CONTEXT'
+          rec_stream_class.event_common_context_field_class
+        when 'EVENT_SPECIFIC_CONTEXT'
+          rec_event_class.specific_context_field_class
+        when 'EVENT_PAYLOAD'
+          rec_event_class.payload_field_class
         else
-          pr "#{variable} = bt_field_class_structure_borrow_member_by_index(#{variable}, #{m.last});"
+          raise "invalid path #{path}"
         end
-      end
-    end
-
-    def find_field_class(path, variable)
-      m = path.match(/\A(PACKET_CONTEXT|EVENT_COMMON_CONTEXT|EVENT_SPECIFIC_CONTEXT|EVENT_PAYLOAD)(.*)/)
-      case m[1]
-      when 'PACKET_CONTEXT'
-        pr "#{variable} = #{rec_stream_class.packet_context_field_class.variable};"
-      when 'EVENT_COMMON_CONTEXT'
-        pr "#{variable} = #{rec_stream_class.event_common_context_field_class.variable};"
-      when 'EVENT_SPECIFIC_CONTEXT'
-        pr "#{variable} = #{rec_event_class.specific_context_field_class.varible};"
-      when 'EVENT_PAYLOAD'
-        pr "#{variable} = #{rec_event_class.payload_field_class.variable};"
-      else
-        raise "invalid path #{path}"
-      end
-      find_field_class_path(m[2], variable)
+      [field_class, id]
     end
   end
 
@@ -110,7 +109,8 @@ module Babeltrace2Gen
     include BTPrinter
     include BTLocator
     extend BTFromH
-    attr_reader :packet_context_field_class, :event_common_context_field_class, :event_classes, :default_clock_class, :id, :name
+    attr_reader :packet_context_field_class, :event_common_context_field_class, :event_classes, :default_clock_class,
+                :id, :name, :get_getter
 
     def initialize(parent:, name: nil, packet_context_field_class: nil, event_common_context_field_class: nil,
                    event_classes: [], id: nil, assigns_automatic_event_class_id: nil, assigns_automatic_stream_id: nil,
@@ -202,6 +202,21 @@ module Babeltrace2Gen
 
       pr "bt_stream_class_put_ref(#{variable});"
     end
+
+    # The getters code generated from event_common_context_field_class do not include
+    # the event variable name used by the getters. As we do not know the variable
+    # name that should be generated, we can not put it directly in the template,
+    # since, if the code generation generates another name we must update the
+    # template in addition.
+    def get_getter(event:, arg_variables:)
+      return unless event_common_context_field_class
+
+      field = "#{event}_cc_f"
+      scope do
+        pr "const bt_field *#{field} = bt_event_borrow_common_context_field_const(#{event});"
+        event_common_context_field_class.get_getter(variable: field, arg_variables: arg_variables)
+      end
+    end
   end
 
   class BTEventClass
@@ -223,7 +238,7 @@ module Babeltrace2Gen
     end
 
     def get_declarator(trace_class:, variable:, stream_class:)
-      # Store the variable name for instrocption purpose for LOCATION_PATH
+      # Store the variable name for instrospection purpose (PATH)
       @variable = variable
       if @id
         pr "#{variable} = bt_event_class_create_with_id(#{stream_class}, #{@id});"
@@ -243,14 +258,14 @@ module Babeltrace2Gen
         end
       end
 
-      if @payload_field_class
-        var_name = "#{variable}_p_fc"
-        scope do
-          pr "bt_field_class *#{var_name};"
-          @payload_field_class.get_declarator(trace_class: trace_class, variable: var_name)
-          pr "bt_event_class_set_payload_field_class(#{variable}, #{var_name});"
-          pr "bt_field_class_put_ref(#{var_name});"
-        end
+      return unless @payload_field_class
+
+      var_name = "#{variable}_p_fc"
+      scope do
+        pr "bt_field_class *#{var_name};"
+        @payload_field_class.get_declarator(trace_class: trace_class, variable: var_name)
+        pr "bt_event_class_set_payload_field_class(#{variable}, #{var_name});"
+        pr "bt_field_class_put_ref(#{var_name});"
       end
     end
 
@@ -271,12 +286,12 @@ module Babeltrace2Gen
         end
       end
 
-      if @payload_field_class
-        field = "#{event}_p_f"
-        scope do
-          pr "bt_field *#{field} = bt_event_borrow_payload_field(#{event});"
-          @payload_field_class.get_setter(variable: field, arg_variables: arg_variables)
-        end
+      return unless @payload_field_class
+
+      field = "#{event}_p_f"
+      scope do
+        pr "bt_field *#{field} = bt_event_borrow_payload_field(#{event});"
+        @payload_field_class.get_setter(variable: field, arg_variables: arg_variables)
       end
     end
 
@@ -297,12 +312,12 @@ module Babeltrace2Gen
         end
       end
 
-      if @payload_field_class
-        field = "#{event}_p_f"
-        scope do
-          pr "const bt_field *#{field} = bt_event_borrow_payload_field_const(#{event});"
-          @payload_field_class.get_getter(variable: field, arg_variables: arg_variables)
-        end
+      return unless @payload_field_class
+
+      field = "#{event}_p_f"
+      scope do
+        pr "const bt_field *#{field} = bt_event_borrow_payload_field_const(#{event});"
+        @payload_field_class.get_getter(variable: field, arg_variables: arg_variables)
       end
     end
   end
@@ -310,6 +325,7 @@ module Babeltrace2Gen
   class BTFieldClass
     include BTLocator
     include BTPrinter
+    using HashRefinements
 
     attr_accessor :cast_type
 
@@ -353,27 +369,32 @@ module Babeltrace2Gen
       raise NotImplementedError, self.class
     end
 
-    def bt_get_variable(_field, arg_variables)
-      if arg_variables.empty? || arg_variables.first.is_a?(GeneratedArg)
-        variable = rec_menber_class.name
-        type = @cast_type || self.class.instance_variable_get(:@bt_type)
-        arg_variables << GeneratedArg.new(type, variable)
-        variable
-      else
-        arg_variables.shift
-      end
+    def bt_get_variable(arg_variables, is_array: false)
+      internal = arg_variables.fetch('internal', [])
+      return internal.shift unless internal.empty?
+
+      type =
+        if is_array
+          "#{element_field_class.class.instance_variable_get(:@bt_type)}*"
+        else
+          self.class.instance_variable_get(:@bt_type)
+        end
+      var = GeneratedArg.new(@cast_type || type, rec_menber_class.name)
+
+      arg_variables.fetch_append('outputs_allocated', var) if is_array
+      arg_variables.fetch_append('outputs', var)
     end
 
     def get_getter(field:, arg_variables:)
       bt_func_get = self.class.instance_variable_get(:@bt_func) % 'get'
-      variable = bt_get_variable(field, arg_variables)
+      variable = bt_get_variable(arg_variables).name
       cast_func = @cast_type ? "(#{@cast_type})" : ''
       pr "#{variable} = #{cast_func}#{bt_func_get}(#{field});"
     end
 
     def get_setter(field:, arg_variables:)
       bt_func_get = self.class.instance_variable_get(:@bt_func) % 'set'
-      variable = bt_get_variable(field, arg_variables)
+      variable = bt_get_variable(arg_variables).name
       cast_func = @cast_type ? "(#{self.class.instance_variable_get(:@bt_type)})" : ''
       pr "#{bt_func_get}(#{field}, #{variable});"
     end
@@ -418,9 +439,9 @@ module Babeltrace2Gen
 
     def get_declarator(variable:)
       pr "bt_field_class_integer_set_field_value_range(#{variable}, #{@field_value_range});" if @field_value_range
-      if @preferred_display_base
-        pr "bt_field_class_integer_set_preferred_display_base(#{variable}, #{@preferred_display_base});"
-      end
+      return unless @preferred_display_base
+
+      pr "bt_field_class_integer_set_preferred_display_base(#{variable}, #{@preferred_display_base});"
     end
   end
 
@@ -546,13 +567,14 @@ module Babeltrace2Gen
     module WithLengthField
       attr_reader :length_field_path
     end
+    using HashRefinements
 
     def initialize(parent:, element_field_class:, length_field_path: nil)
       super(parent: parent, element_field_class: element_field_class)
-      if length_field_path
-        extend(WithLengthField)
-        @length_field_path = length_field_path
-      end
+      return unless length_field_path
+
+      extend(WithLengthField)
+      @length_field_path = length_field_path
     end
 
     def get_declarator(trace_class:, variable:)
@@ -563,13 +585,55 @@ module Babeltrace2Gen
         if @length_field_path
           element_field_class_variable_length = "#{element_field_class_variable}_length"
           pr "bt_field_class *#{element_field_class_variable_length};"
-          find_field_class(@length_field_path, element_field_class_variable_length)
+          scope do
+            element_field_class_variable_length_sm = "#{element_field_class_variable_length}_sm"
+            pr "bt_field_class_structure_member *#{element_field_class_variable_length_sm};"
+            field_class, id = resolve_path(@length_field_path)
+            id.scan(/(\w+)|(\d+)/).each do |name, index|
+              # String
+              if name
+                pr "#{element_field_class_variable_length_sm} = bt_field_class_structure_borrow_member_by_name(#{field_class.variable}, \"#{name}\");"
+              else
+                pr "#{element_field_class_variable_length_sm} = bt_field_class_structure_borrow_member_by_index(#{field_class.variable}, #{index});"
+              end
+            end
+            pr "#{element_field_class_variable_length} = bt_field_class_structure_member_borrow_field_class(#{element_field_class_variable_length_sm});"
+          end
           pr "#{variable} = bt_field_class_array_dynamic_create(#{trace_class}, #{element_field_class_variable}, #{element_field_class_variable_length});"
+          pr "bt_field_class_put_ref(#{element_field_class_variable});"
         else
           pr "#{variable} = bt_field_class_array_dynamic_create(#{trace_class}, #{element_field_class_variable}, NULL);"
         end
       end
     end
+
+    def get_setter(field:, arg_variables:)
+      field_class, id = resolve_path(@length_field_path)
+      length_field = field_class[id]
+      pr "bt_field_array_dynamic_set_length(#{field}, #{length_field.name});"
+      usr_var = bt_get_variable(arg_variables, is_array: true)
+      pr "for(uint64_t _i=0; _i < #{length_field.name} ; _i++)"
+      scope do
+        v = "#{field}_e"
+        pr "bt_field* #{v} = bt_field_array_borrow_element_field_by_index(#{field}, _i);"
+        arg_variables.fetch_append('internal', GeneratedArg.new('', "#{usr_var.name}[_i]"))
+        @element_field_class.get_setter(field: v, arg_variables: arg_variables)
+      end
+    end
+
+    def get_getter(field:, arg_variables:)
+      length = "#{field}_length"
+      pr "uint64_t #{length} = bt_field_array_get_length(#{field});"
+      usr_var = bt_get_variable(arg_variables, is_array: true)
+      pr "#{usr_var.name} = (#{usr_var.type}) malloc(#{length} * sizeof(#{usr_var.name}));"
+      pr "for(uint64_t _i=0; _i < #{length} ; _i++)"
+      scope do
+        v = "#{field}_e"
+        pr "const bt_field* #{v} = bt_field_array_borrow_element_field_by_index_const(#{field}, _i);"
+        arg_variables.fetch_append('internal', GeneratedArg.new('', "#{usr_var.name}[_i]"))
+        @element_field_class.get_getter(field: v, arg_variables: arg_variables)
+      end
+    end
   end
 
   class BTMemberClass
@@ -595,10 +659,12 @@ module Babeltrace2Gen
 
     def [](index)
       case index
-      when Integer
+      when ::Integer
         @members[index]
-      when String
+      when ::String
         @members.find { |m| m.name == index }
+      else
+        raise("Unknow Type (#{index.class}) for index: #{index}")
       end
     end
 

data/lib/metababel/bt2_values_generator.rb

@@ -28,10 +28,10 @@ module Babeltrace2Gen
 
     # Scalars are leafs, avoid recursion
     def self.from_h(model)
-      new(model[:name],model.fetch(:default_value,nil))
+      new(model[:name], model.fetch(:default_value, nil))
     end
 
-    def initialize(name,usr_default_value)
+    def initialize(name, usr_default_value)
       @name = name
       @usr_default_value = usr_default_value
     end
@@ -47,12 +47,12 @@ module Babeltrace2Gen
       pr "if (#{val} != NULL) {"
       pr "  if (!#{bt_type_is}(#{val})) {"
       pr "    fprintf(stderr,\"Bad value for command line argument '%s' the value must be '%s'. \\n\",\"#{@name}\",\"#{bt_type}\");"
-      pr "    exit(1);"
-      pr "  }"
+      pr '    exit(1);'
+      pr '  }'
       pr "  #{name} = #{cast_func}bt_value_#{bt_type}_get(#{val});"
-      pr "} else {"
+      pr '} else {'
       pr "  #{name} = #{cast_func}#{default_value};"
-      pr "}"
+      pr '}'
     end
   end
 
@@ -90,12 +90,13 @@ module Babeltrace2Gen
     @bt_return_type = 'bt_bool'
     @bt_default_value = 'BT_FALSE'
 
-    def initialize(name,usr_default_value)
+    def initialize(name, usr_default_value)
       bt_type = self.class.instance_variable_get(:@bt_type)
-      if !usr_default_value.nil? and !['BT_TRUE', 'BT_FALSE'].include? usr_default_value
+      if !usr_default_value.nil? and !%w[BT_TRUE BT_FALSE].include? usr_default_value
         raise "Bad default_value for '#{name}' in params.yaml, it must be #{bt_type} (BT_TRUE or BT_FALSE) but provided '#{usr_default_value}'."
       end
-      super(name,usr_default_value)
+
+      super(name, usr_default_value)
     end
   end
 
@@ -105,13 +106,14 @@ module Babeltrace2Gen
     @bt_return_type = 'const char*'
     @bt_default_value = 'NULL'
 
-    def initialize(name,usr_default_value)
+    def initialize(name, usr_default_value)
       bt_type = self.class.instance_variable_get(:@bt_type)
       # Every object that can be converted to string is being supported.
       if !usr_default_value.nil? and !usr_default_value.respond_to?(:to_s)
-          raise "Bad default_value for '#{name}' in params.yaml, it must be #{bt_type} but provided '#{usr_default_value}'." 
+        raise "Bad default_value for '#{name}' in params.yaml, it must be #{bt_type} but provided '#{usr_default_value}'."
       end
-      super(name,usr_default_value.to_s.inspect)
+
+      super(name, usr_default_value.to_s.inspect)
     end
   end
 
@@ -121,12 +123,13 @@ module Babeltrace2Gen
     @bt_return_type = 'uint64_t'
     @bt_default_value = '0'
 
-    def initialize(name,usr_default_value)
+    def initialize(name, usr_default_value)
       bt_type = self.class.instance_variable_get(:@bt_type)
-      if !usr_default_value.nil? and (!usr_default_value.kind_of? Integer or !usr_default_value.between?(0,2**64-1))
-          raise "Bad default_value for '#{name}' in params.yaml, it must be #{bt_type} and must be in [0,2^64-1], but provided '#{usr_default_value}'." 
+      if !usr_default_value.nil? and (!usr_default_value.is_a? Integer or !usr_default_value.between?(0, 2**64 - 1))
+        raise "Bad default_value for '#{name}' in params.yaml, it must be #{bt_type} and must be in [0,2^64-1], but provided '#{usr_default_value}'."
       end
-      super(name,usr_default_value)
+
+      super(name, usr_default_value)
     end
   end
 end

data/lib/metababel/version.rb

@@ -1,3 +1,3 @@
 module Metababel
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/template/component.c.erb

@@ -3,7 +3,6 @@
 #include <assert.h>
 #include <babeltrace2/babeltrace.h>
 #include <metababel/btx_component.h>
-#include <stdbool.h>
 // stdio needed because `params_definition` contain fprintf
 #include <stdio.h>
 

data/template/component.h.erb

@@ -3,6 +3,7 @@
 #include "utarray.h"
 #include "uthash.h"
 #include <babeltrace2/babeltrace.h>
+#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -83,6 +84,7 @@ typedef enum btx_source_status_e btx_source_status_t;
 <% elsif options[:component_type] == 'FILTER' %>
 struct common_data_s {
   name_to_dispatcher_t *name_to_dispatcher;
+  name_to_dispatcher_t *name_to_matching_dispatcher;
   void *usr_data;
   const bt_value *params;
   btx_params_t *btx_params;
@@ -132,6 +134,7 @@ typedef struct btx_message_iterator_s btx_message_iterator_t;
 <% elsif options[:component_type] == 'SINK' %>
 struct common_data_s {
   name_to_dispatcher_t *name_to_dispatcher;
+  name_to_dispatcher_t *name_to_matching_dispatcher;
   void *usr_data;
   const bt_value *params;
   btx_params_t *btx_params;

data/template/downstream.c.erb

@@ -108,14 +108,14 @@ void btx_push_messages_stream_end(
 
 <% downstream_events.each do |e| %>
 static void btx_set_message_<%= e.name_sanitized %>(
-    bt_event *<%= event_name %>,
-    <%= e.args.map{ |s| "#{s.type} #{s.name}" }.join(", ") %>) {
+    bt_event *
+        <%= event_name %><%= e.args.map{ |s| "#{s.type} #{s.name}" }.join_with_prefix(", ") %>) {
   <%= e.body %>
 }
 
 void btx_push_message_<%= e.name_sanitized %>(
-    void *btx_handle,
-    <%= e.args.map{ |s| "#{s.type} #{s.name}" }.join(", ") %>) {
+    void *
+        btx_handle<%= ', int64_t _timestamp' if e.default_clock_class %><%= e.args.map{ |s| "#{s.type} #{s.name}" }.join_with_prefix(", ") %>) {
 
   common_data_t *common_data = (common_data_t *)btx_handle;
 
@@ -129,13 +129,13 @@ void btx_push_message_<%= e.name_sanitized %>(
       common_data->self_message_iterator, event_class, stream);
   <% else %>
   bt_message *message = bt_message_event_create_with_default_clock_snapshot(
-      common_data->self_message_iterator, event_class, stream, timestamp);
+      common_data->self_message_iterator, event_class, stream, _timestamp);
   <% end %>
 
   bt_event *downstream_event = bt_message_event_borrow_event(message);
 
   btx_set_message_<%= e.name_sanitized %>(
-      downstream_event, <%= e.args.map{ |s| s.name }.join(", ") %>);
+      downstream_event<%= e.args.map{ |s| s.name }.join_with_prefix(", ") %>);
 
   btx_message_iterator_t *message_iterator_private_data =
       bt_self_message_iterator_get_data(common_data->self_message_iterator);

data/template/downstream.h.erb

@@ -29,8 +29,8 @@ void btx_push_messages_stream_end(
 
 <% downstream_events.each do |e| %>
 void btx_push_message_<%= e.name_sanitized %>(
-    void *btx_handle,
-    <%= e.args.map{ |s| "#{s.type} #{s.name}" }.join(", ") %>);
+    void *
+        btx_handle<%= ', int64_t _timestamp' if e.default_clock_class %><%= e.args.map{ |s| "#{s.type} #{s.name}" }.join_with_prefix(", ") %>);
 <% end %>
 #ifdef __cplusplus
 }

data/template/filter.c.erb

@@ -24,10 +24,15 @@ static inline bt_message_iterator_class_next_method_status
 filter_message_iterator_next_initializing(
     bt_self_message_iterator *self_message_iterator,
     bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
+
   /* Retrieve our private data from the message iterator's user data */
   btx_message_iterator_t *message_iterator_private_data =
       bt_self_message_iterator_get_data(self_message_iterator);
 
+  /* Begining of Stream */
+  btx_push_messages_stream_beginning(self_message_iterator,
+      message_iterator_private_data);
+
   /* Call Initialize user callback */
   btx_call_callbacks_initialize_usr_data(
       message_iterator_private_data->common_data,
@@ -100,6 +105,9 @@ filter_message_iterator_next_processing_reading(
       btx_call_callbacks_finalize_usr_data(
           message_iterator_private_data->common_data,
           message_iterator_private_data->common_data->usr_data);
+      /* End of Stream */
+      btx_push_messages_stream_end(self_message_iterator,
+                                   message_iterator_private_data);
       message_iterator_private_data->state = BTX_FILTER_STATE_FINALIZING;
       message_iterator_private_data->processing_state =
           BTX_FILTER_PROCESSING_STATE_FINISHED;
@@ -125,10 +133,12 @@ filter_message_iterator_next_processing_reading(
        upstream_i++) {
     /* Current message */
     const bt_message *upstream_message = upstream_messages[upstream_i];
-    /* Move as is if it's not an event message */
+    /* Forward all non event-messages downstream */
     if (bt_message_get_type(upstream_message) != BT_MESSAGE_TYPE_EVENT) {
-      bt_message_put_ref(upstream_message);
+      btx_downstream_push_message(message_iterator_private_data,
+                                  upstream_message);
       continue;
+
     }
     /* Borrow the event message's event and its class */
     const bt_event *event =
@@ -136,11 +146,35 @@ filter_message_iterator_next_processing_reading(
     const bt_event_class *event_class = bt_event_borrow_class_const(event);
 
     /* Call dispatcher or forward message downstream */
-    name_to_dispatcher_t *s = NULL;
+    bool is_callback_called = false;
     const char *class_name = bt_event_class_get_name(event_class);
-    HASH_FIND_STR(common_data->name_to_dispatcher, class_name, s);
-    if (s) {
-      (*((dispatcher_t(*))(s->dispatcher)))(s->callbacks, common_data, event);
+
+    {
+      name_to_dispatcher_t *s = NULL;
+      HASH_FIND_STR(common_data->name_to_dispatcher, class_name, s);
+      if (s) {
+        (*((dispatcher_t(*))(s->dispatcher)))(s->callbacks, common_data, upstream_message,
+                                              &is_callback_called);
+      }
+    }
+
+    {
+      const bt_stream_class *stream_class =
+          bt_event_class_borrow_stream_class_const(event_class);
+      const char *stream_class_name = bt_stream_class_get_name(stream_class);
+
+      name_to_dispatcher_t *s = NULL;
+      HASH_FIND_STR(common_data->name_to_matching_dispatcher, stream_class_name,
+                    s);
+      if (s) {
+        // is_callback_called will only be modified if at least one callback is
+        // called.
+        (*((dispatcher_t(*))(s->dispatcher)))(s->callbacks, common_data, upstream_message,
+                                              &is_callback_called);
+      }
+    }
+
+    if (is_callback_called) {
       /* The message have been consumed, we can discard it */
       bt_message_put_ref(upstream_message);
     } else {
@@ -379,13 +413,9 @@ static void filter_finalize(bt_self_component_filter *self_component_filter) {
   // We allocate it, we need to put ref
   bt_trace_put_ref(common_data->downstream_trace);
 
-  // Delete name_to_dispatcher
-  name_to_dispatcher_t *current, *tmp;
-  HASH_ITER(hh, common_data->name_to_dispatcher, current, tmp) {
-    HASH_DEL(common_data->name_to_dispatcher, current);
-    utarray_free(current->callbacks);
-    free(current);
-  }
+  // Delete name_to_dispatchers
+  btx_delete_dispatchers(common_data);
+  btx_delete_matching_dispatchers(common_data);
 
   // We allocate it, we need to free it
   free(common_data->btx_params);

data/template/sink.c.erb

@@ -48,24 +48,46 @@ sink_consume(bt_self_component_sink *self_component_sink) {
   }
   /* For each consumed message */
   for (uint64_t i = 0; i < message_count; i++) {
-    const bt_message *message = messages[i];
-    if (bt_message_get_type(message) != BT_MESSAGE_TYPE_EVENT) {
-      bt_message_put_ref(message);
+    const bt_message *upstream_message = messages[i];
+    if (bt_message_get_type(upstream_message) != BT_MESSAGE_TYPE_EVENT) {
+      bt_message_put_ref(upstream_message);
       continue;
     }
 
     /* Borrow the event message's event and its class */
-    const bt_event *event = bt_message_event_borrow_event_const(message);
+    const bt_event *event = bt_message_event_borrow_event_const(upstream_message);
     const bt_event_class *event_class = bt_event_borrow_class_const(event);
 
     /* Call dispatcher */
-    name_to_dispatcher_t *s = NULL;
+    bool is_callback_called = false;
     const char *class_name = bt_event_class_get_name(event_class);
-    HASH_FIND_STR(common_data->name_to_dispatcher, class_name, s);
-    if (s)
-      (*((dispatcher_t(*))(s->dispatcher)))(s->callbacks, common_data, event);
 
-    bt_message_put_ref(message);
+    {
+      name_to_dispatcher_t *s = NULL;
+      HASH_FIND_STR(common_data->name_to_dispatcher, class_name, s);
+      if (s) {
+        (*((dispatcher_t(*))(s->dispatcher)))(s->callbacks, common_data, upstream_message,
+                                              &is_callback_called);
+      }
+    }
+
+    {
+      const bt_stream_class *stream_class =
+          bt_event_class_borrow_stream_class_const(event_class);
+      const char *stream_class_name = bt_stream_class_get_name(stream_class);
+
+      name_to_dispatcher_t *s = NULL;
+      HASH_FIND_STR(common_data->name_to_matching_dispatcher, stream_class_name,
+                    s);
+      if (s) {
+        // is_callback_called will only be modified if at least one callback is
+        // called.
+        (*((dispatcher_t(*))(s->dispatcher)))(s->callbacks, common_data, upstream_message,
+                                              &is_callback_called);
+      }
+    }
+
+    bt_message_put_ref(upstream_message);
   }
 end:
   return status;
@@ -122,12 +144,8 @@ static void sink_finalize(bt_self_component_sink *self_component_sink) {
   btx_call_callbacks_finalize_usr_data(common_data, common_data->usr_data);
 
   // Delete name_to_dispatcher
-  name_to_dispatcher_t *current, *tmp;
-  HASH_ITER(hh, common_data->name_to_dispatcher, current, tmp) {
-    HASH_DEL(common_data->name_to_dispatcher, current);
-    utarray_free(current->callbacks);
-    free(current);
-  }
+  btx_delete_dispatchers(common_data);
+  btx_delete_matching_dispatchers(common_data);
 
   // We allocate it, we need to free it
   free(common_data->btx_params);

data/template/upstream.c.erb

@@ -4,24 +4,44 @@
 #include <babeltrace2/babeltrace.h>
 #include <metababel/btx_component.h>
 #include <metababel/btx_upstream.h>
+#include <stdbool.h>
+#include <stdlib.h>
 
-<% event_dispatchers.each do |e| %>
-static void
-btx_dispatch_<%= e.name_sanitized %>(UT_array *callbacks,
-                                     common_data_t *common_data,
-                                     const bt_event *<%= event_name %>) {
+<% event_class_dispatchers.each do |e| %>
+static void btx_dispatch_<%= e.name_sanitized %>(
+    UT_array *callbacks, common_data_t *common_data,
+    const bt_message *upstream_message, bool *is_callback_called) {
 
   <% e.args.each do |s| %>
   <%= s.type %> <%= s.name %>;
   <% end %>
-  <%= e.body %>
+
+  <%# Since now event is a variable, we need to check if the body will render variables that accesses it.  %>
+  <% if not e.body.empty? %>
+  const bt_event *<%= event_name %> = bt_message_event_borrow_event_const(upstream_message);
+  <%= "\n" + e.body %>
+  <% end %>
+
+  <% if e.default_clock_class %>
+  int64_t _timestamp;
+  const bt_clock_snapshot *clock_snapshot = bt_message_event_borrow_default_clock_snapshot_const(upstream_message);
+  bt_clock_snapshot_get_ns_from_origin(clock_snapshot, &_timestamp);
+  <% end %>
   // Call all the callbacks who where registered
   // Their type are declared in 'upstream.h'
   <%= e.name_sanitized %>_callback_f **p = NULL;
   while ((p = utarray_next(callbacks, p))) {
-    (*p)((void *)common_data, common_data->usr_data,
-         <%= e.args.map{ |s| s.name }.join(", ") %>);
+    (*p)((void *)common_data,
+         common_data
+             ->usr_data<%= ', _timestamp' if e.default_clock_class %><%= e.args.map{ |s| s.name }.join_with_prefix(", ") %>);
   }
+
+  <% e.args_to_free.each do |s| %>
+  <%= "free(#{s.name});" %>
+  <% end %>
+
+  if (callbacks)
+    *is_callback_called = true;
 }
 
 void btx_register_callbacks_<%= e.name_sanitized %>(
@@ -45,3 +65,93 @@ void btx_register_callbacks_<%= e.name_sanitized %>(
   utarray_push_back(s->callbacks, &callback);
 }
 <% end %>
+
+<% stream_classes_matching_dispatchers.each do |s| %>
+void btx_matching_dispatch_<%= s.name_sanitized %>(UT_array *callbacks,
+                                                   common_data_t *common_data,
+                                                   const bt_message *upstream_message,
+                                                   bool *is_callback_called) {
+
+  <% s.args.each do |a| %>
+  <%= a.type %> <%= a.name %>;
+  <% end %>
+  const bt_event *<%= event_name %> = bt_message_event_borrow_event_const(upstream_message);
+  <%= s.body %>
+  const bt_event_class *event_class = bt_event_borrow_class_const(<%= event_name %>);
+  const char *event_class_name = bt_event_class_get_name(event_class);
+
+  condition_to_callback_t **p = NULL;
+  while ((p = utarray_next(callbacks, p))) {
+    <%= s.name_sanitized %>_callback_condition_f *condition =
+        (<%= s.name_sanitized %>_callback_condition_f *)((*p)->condition);
+    <%= s.name_sanitized %>_conditioned_callback_f *callback =
+        (<%= s.name_sanitized %>_conditioned_callback_f *)((*p)->callback);
+    <% if s.default_clock_class %>
+    int64_t _timestamp;
+    const bt_clock_snapshot *clock_snapshot = bt_message_event_borrow_default_clock_snapshot_const(upstream_message);
+    bt_clock_snapshot_get_ns_from_origin(clock_snapshot, &_timestamp);
+    <% end %>
+    bool is_condition_met = false;
+    condition(
+        (void *)common_data, common_data->usr_data, event_class_name,
+        &is_condition_met<%= ', _timestamp' if s.default_clock_class %><%= s.args.map{ |a| a.name }.join_with_prefix(", ") %>);
+    if (is_condition_met) {
+      callback(
+          (void *)common_data, common_data->usr_data,
+          event_class_name<%= ', _timestamp' if s.default_clock_class %><%= s.args.map{ |a| a.name }.join_with_prefix(", ") %>);
+      *is_callback_called = true;
+    }
+  }
+}
+
+void btx_register_matching_callback_<%= s.name_sanitized %>(
+    void *btx_handle, <%= s.name_sanitized %>_callback_condition_f *condition,
+    <%= s.name_sanitized %>_conditioned_callback_f *callback) {
+  // Look-up our dispatcher
+  name_to_dispatcher_t *s = NULL;
+  name_to_dispatcher_t **name_to_matching_dispatcher =
+      &((common_data_t *)btx_handle)->name_to_matching_dispatcher;
+  HASH_FIND_STR(*name_to_matching_dispatcher, "<%= s.name_sanitized %>", s);
+  if (!s) {
+    // We didn't find the dispatcher, so we need to:
+    // 1. Create it
+    s = (name_to_dispatcher_t *)malloc(sizeof(name_to_dispatcher_t));
+    s->name = "<%= s.name_sanitized %>";
+    s->dispatcher = (void *)&btx_matching_dispatch_<%= s.name_sanitized %>;
+    utarray_new(s->callbacks, &ut_ptr_icd);
+    // 2. Register it
+    HASH_ADD_KEYPTR(hh, *name_to_matching_dispatcher, s->name, strlen(s->name),
+                    s);
+  }
+  // Add the callbacks to the array
+  condition_to_callback_t *m =
+      (condition_to_callback_t *)malloc(sizeof(condition_to_callback_t));
+  m->condition = (void *)condition;
+  m->callback = (void *)callback;
+  utarray_push_back(s->callbacks, &m);
+}
+<% end %>
+
+void btx_delete_dispatchers(common_data_t *common_data) {
+  name_to_dispatcher_t *current, *tmp;
+  HASH_ITER(hh, common_data->name_to_dispatcher, current, tmp) {
+    HASH_DEL(common_data->name_to_dispatcher, current);
+    utarray_free(current->callbacks);
+    free(current);
+  }
+}
+
+void btx_delete_matching_dispatchers(common_data_t *common_data) {
+  name_to_dispatcher_t *current, *tmp;
+  HASH_ITER(hh, common_data->name_to_matching_dispatcher, current, tmp) {
+    // Removes the item from the hash table.
+    HASH_DEL(common_data->name_to_matching_dispatcher, current);
+    // Deletes every condition, callback pair.
+    condition_to_callback_t **p = NULL;
+    while ((p = utarray_next(current->callbacks, p))) {
+      free(*p);
+    }
+    utarray_free(current->callbacks);
+    free(current);
+  }
+}

data/template/upstream.h.erb

@@ -6,17 +6,47 @@ extern "C" {
 
 // Dispatcher
 typedef void(dispatcher_t)(UT_array *callbacks, common_data_t *common_data,
-                           const bt_event *message);
+                           const bt_message *upstream_message, bool *is_callback_called);
 
-<% event_dispatchers.each do |e| %>
+<% event_class_dispatchers.each do |e| %>
 <%# The signature type of callbacks %>
-typedef void
-<%= e.name_sanitized %>_callback_f(void *btx_handle, void *usr_data,
-                                   <%= e.args.map{ |s| s.type }.join(", ") %>);
+typedef void <%= e.name_sanitized %>_callback_f(
+    void *btx_handle,
+    void *usr_data<%= ', int64_t _timestamp' if e.default_clock_class %><%= e.args.map{ |s| s.type }.join_with_prefix(", ") %>);
 <%# The Function who register the callbacks to the dispatcher %>
-extern void btx_register_callbacks_<%= e.name_sanitized %>(
+void btx_register_callbacks_<%= e.name_sanitized %>(
     void *btx_handle, <%= e.name_sanitized %>_callback_f *callback);
 <% end %>
+
+void btx_delete_dispatchers(common_data_t *common_data);
+
+// Matching dispatcher
+
+struct condition_to_callback_s {
+  void *condition;
+  void *callback;
+};
+typedef struct condition_to_callback_s condition_to_callback_t;
+
+<% stream_classes_matching_dispatchers.each do |s| %>
+<%# The signature type of condition callbacks %>
+typedef void <%= s.name_sanitized %>_callback_condition_f(
+    void *btx_handle, void *usr_data, const char *event_class_name,
+    bool *matched<%= ', int64_t _timestamp' if s.default_clock_class %><%= s.args.map{ |a| a.type }.join_with_prefix(", ") %>);
+
+<%# The signature type of callbacks to be called if the condition is met %>
+typedef void <%= s.name_sanitized %>_conditioned_callback_f(
+    void *btx_handle, void *usr_data,
+    const char *
+        event_class_name<%= ', int64_t _timestamp' if s.default_clock_class %><%= s.args.map{ |a| a.type }.join_with_prefix(", ") %>);
+
+void btx_register_matching_callback_<%= s.name_sanitized %>(
+    void *btx_handle, <%= s.name_sanitized %>_callback_condition_f *condition,
+    <%= s.name_sanitized %>_conditioned_callback_f *callback);
+<% end %>
+
+void btx_delete_matching_dispatchers(common_data_t *common_data);
+
 #ifdef __cplusplus
 }
 #endif

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metababel
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Thomas Applencourt
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-03 00:00:00.000000000 Z
+date: 2023-06-26 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: