metababel 0.1.0 → 1.0.2

data/template/source.c.erb

@@ -23,7 +23,11 @@ source_message_iterator_next(bt_self_message_iterator *self_message_iterator,
 
   /* 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);
+      (btx_message_iterator_t *)bt_self_message_iterator_get_data(
+          self_message_iterator);
+
+  // Avoid C++ crosses initialization warning
+  btx_source_status_t status;
 
   /* When you return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END, you must
    * not put any message into the message array */
@@ -32,16 +36,10 @@ source_message_iterator_next(bt_self_message_iterator *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(
+    btx_call_callbacks_initialize_processing(
         message_iterator_private_data->common_data,
-        &message_iterator_private_data->common_data->usr_data);
-    /* Call read callbacks */
-    btx_call_callbacks_read_params(
-        message_iterator_private_data->common_data,
-        message_iterator_private_data->common_data->usr_data,
-        message_iterator_private_data->common_data->btx_params);
+        message_iterator_private_data->common_data->usr_data);
 
     message_iterator_private_data->state = BTX_SOURCE_STATE_PROCESSING;
     return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
@@ -52,15 +50,14 @@ source_message_iterator_next(bt_self_message_iterator *self_message_iterator,
       return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
     }
 
-    btx_source_status_t status = BTX_SOURCE_END;
+    status = BTX_SOURCE_END;
 
     btx_call_callbacks_push_usr_messages(
         message_iterator_private_data->common_data,
         message_iterator_private_data->common_data->usr_data, &status);
     if (status == BTX_SOURCE_END) {
-
       /* Call Finalize user callback */
-      btx_call_callbacks_finalize_usr_data(
+      btx_call_callbacks_finalize_processing(
           message_iterator_private_data->common_data,
           message_iterator_private_data->common_data->usr_data);
       /* End of Stream */
@@ -92,15 +89,25 @@ source_initialize(bt_self_component_source *self_component_source,
                   bt_self_component_source_configuration *configuration,
                   const bt_value *params, void *initialize_method_data) {
   /* Allocate a private data structure */
-  common_data_t *common_data = calloc(1, sizeof(common_data_t));
-  common_data->btx_params = calloc(1, sizeof(btx_params_t));
+  common_data_t *common_data =
+      (common_data_t *)calloc(1, sizeof(common_data_t));
+  common_data->static_callbacks =
+      (static_callbacks_t *)calloc(1, sizeof(static_callbacks_t));
+  common_data->btx_params = (btx_params_t *)calloc(1, sizeof(btx_params_t));
   common_data->params = params;
-  // Read parameters
+
+  /* Read parameters */
   btx_populate_params(common_data);
   bt_value_get_ref(common_data->params);
 
   /* Register User Callbacks */
   btx_register_usr_callbacks((void *)common_data);
+  /* Call initialize_processing*/
+  btx_call_callbacks_initialize_component(common_data, &common_data->usr_data);
+  /* Call read callbacks */
+  btx_call_callbacks_read_params(common_data, common_data->usr_data,
+                                 common_data->btx_params);
+
   /* Upcast `self_component_source` to the `bt_self_component` type */
   bt_self_component *self_component =
       bt_self_component_source_as_self_component(self_component_source);
@@ -140,12 +147,12 @@ source_message_iterator_initialize(
     bt_self_component_port_output *self_port) {
   /* Allocate a private data structure */
   btx_message_iterator_t *message_iterator_private_data =
-      calloc(1, sizeof(btx_message_iterator_t));
+      (btx_message_iterator_t *)calloc(1, sizeof(btx_message_iterator_t));
 
   message_iterator_private_data->state = BTX_SOURCE_STATE_INITIALIZING;
 
   /* Retrieve the component's private data from its user data */
-  common_data_t *common_data = bt_self_component_get_data(
+  common_data_t *common_data = (common_data_t *)bt_self_component_get_data(
       bt_self_message_iterator_borrow_component(self_message_iterator));
 
   /* Save a link to the self_message_iterator */
@@ -162,9 +169,12 @@ source_message_iterator_initialize(
 }
 
 static void source_finalize(bt_self_component_source *self_component_source) {
-  common_data_t *common_data = bt_self_component_get_data(
+  common_data_t *common_data = (common_data_t *)bt_self_component_get_data(
       bt_self_component_source_as_self_component(self_component_source));
 
+  /* Finalize Component */
+  btx_call_callbacks_finalize_component(common_data, common_data->usr_data);
+
   btx_streams_put_ref(common_data->downstream_trace); // ??
   // We allocate it, we need to put ref
   bt_trace_put_ref(common_data->downstream_trace);
@@ -173,12 +183,14 @@ static void source_finalize(bt_self_component_source *self_component_source) {
   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);
+    utarray_free(current->callbacks->generic);
+    free(current->callbacks);
     free(current);
   }
 
   // We allocate it, we need to free it
   free(common_data->btx_params);
+  free(common_data->static_callbacks);
   bt_value_put_ref(common_data->params);
   free(common_data);
 }
@@ -187,7 +199,8 @@ static void source_message_iterator_finalize(
     bt_self_message_iterator *self_message_iterator) {
   /* 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);
+      (btx_message_iterator_t *)bt_self_message_iterator_get_data(
+          self_message_iterator);
 
   struct el *elt, *tmp;
   DL_FOREACH_SAFE(message_iterator_private_data->pool, elt, tmp) {

data/template/upstream.c.erb

@@ -7,151 +7,103 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
-<% 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) {
+<% dispatchers.each do |dispatcher| %>
+static void btx_dispatch_<%= dispatcher.name_sanitized %>(
+    callbacks_t *callbacks, common_data_t *common_data,
+    const bt_message *upstream_message) {
 
-  <% e.args.each do |s| %>
+  <% dispatcher.args.each do |s| %>
   <%= s.type %> <%= s.name %>;
   <% end %>
 
   <%# 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 %>
+  <% if not dispatcher.body.strip.empty? %>
+  const bt_event *<%= event_name %> =
+      bt_message_event_borrow_event_const(upstream_message);
+  <%= dispatcher.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);
+  <% if dispatcher.default_clock_class %>
+  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<%= ', _timestamp' if e.default_clock_class %><%= e.args.map{ |s| s.name }.join_with_prefix(", ") %>);
+  <%# event_class_name, only required when there is at least one matching callback for this event.  %>
+  <% if dispatcher.dispatch_types.map(&:args).flatten.any? { |arg| arg.name == '_event_class_name' } %>
+  const char *_event_class_name = "<%= dispatcher.name %>";
+  <% end %>
+
+  // Call registered matching callbacks
+  <% dispatcher.dispatch_types.each do |dispatch_type| %>
+  {
+    if (callbacks-><%= dispatch_type.id %>) {
+      void **_p = NULL;
+      while ((
+          _p = (void **)utarray_next(callbacks-><%= dispatch_type.id %>, _p))) {
+        (*((<%= dispatch_type.name_sanitized %>_callback_f **)(_p)))(
+            (void *)common_data,
+            common_data
+                ->usr_data<%= dispatch_type.args.map{ |a| a.name }.join_with_prefix(", ") %>);
+      }
+    }
   }
 
-  <% e.args_to_free.each do |s| %>
+  <% end %>
+  <% dispatcher.args_to_free.each do |s| %>
   <%= "free(#{s.name});" %>
   <% end %>
-
-  if (callbacks)
-    *is_callback_called = true;
 }
 
-void btx_register_callbacks_<%= e.name_sanitized %>(
-    void *btx_handle, <%= e.name_sanitized %>_callback_f *callback) {
+<% end %>
+<% dispatchers.each do |dispatcher| %>
+void btx_generic_register_callback_<%= dispatcher.name_sanitized %>(
+    void *btx_handle, const char *id, void *callback) {
   // Look-up our dispatcher
   name_to_dispatcher_t *s = NULL;
   name_to_dispatcher_t **name_to_dispatcher =
       &((common_data_t *)btx_handle)->name_to_dispatcher;
-  HASH_FIND_STR(*name_to_dispatcher, "<%= e.name %>", s);
+  HASH_FIND_STR(*name_to_dispatcher, "<%= dispatcher.name %>", s);
   if (!s) {
-    // We didn't find the dispatcher, so we need to:
-    // 1. Create it
+    // We didn't find the dispatcher, so we need to create it.
     s = (name_to_dispatcher_t *)malloc(sizeof(name_to_dispatcher_t));
-    s->name = "<%= e.name %>";
-    s->dispatcher = (void *)&btx_dispatch_<%= e.name_sanitized %>;
-    utarray_new(s->callbacks, &ut_ptr_icd);
+    s->name = "<%= dispatcher.name %>";
+    s->dispatcher = (void *)&btx_dispatch_<%= dispatcher.name_sanitized %>;
+    s->callbacks = (callbacks_t *)calloc(1, sizeof(callbacks_t));
     // 2. Register it
     HASH_ADD_KEYPTR(hh, *name_to_dispatcher, s->name, strlen(s->name), s);
   }
-  // Add the callbacks to the array
-  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) {
+  <% dispatcher.dispatch_types.each do |dispatch_type| %>
+  if (strcmp("<%= dispatch_type.id %>", id) == 0) {
+    // Add the callbacks to the array
+    if (!s->callbacks-><%= dispatch_type.id %>)
+      utarray_new(s->callbacks-><%= dispatch_type.id %>, &ut_ptr_icd);
+    utarray_push_back(s->callbacks-><%= dispatch_type.id %>, &callback);
+  }
 
-  <% 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 %>
+<% dispatch_types.each do |dispatch_type| %>
+void btx_register_callbacks_<%= dispatch_type.name_sanitized %>(
+    void *btx_handle,
+    <%= dispatch_type.name_sanitized %>_callback_f *callback) {
+  <% dispatch_type.matched_dispatchers.each do |dispatcher| %>
+  btx_generic_register_callback_<%= dispatcher.name_sanitized %>(
+      btx_handle, "<%= dispatch_type.id %>", (void *)callback);
+  <% end %>
+}
 
+<% 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);
+    <% dispatch_types.map(&:id).uniq.each do |name| %>
+    if (current->callbacks-><%= name %>)
+      utarray_free(current->callbacks-><%= name %>);
+    <% end %>
+    free(current->callbacks);
     free(current);
   }
 }

data/template/upstream.h.erb

@@ -5,47 +5,21 @@ extern "C" {
 #endif
 
 // Dispatcher
-typedef void(dispatcher_t)(UT_array *callbacks, common_data_t *common_data,
-                           const bt_message *upstream_message, bool *is_callback_called);
+typedef void(dispatcher_t)(callbacks_t *callbacks, common_data_t *common_data,
+                           const bt_message *upstream_message);
 
-<% event_class_dispatchers.each do |e| %>
-<%# The signature type of callbacks %>
-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 %>
-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(", ") %>);
+<% dispatch_types.each do |dispatch_type| %>
+typedef void <%= dispatch_type.name_sanitized %>_callback_f(
+    void *btx_handle,
+    void *
+        usr_data<%= dispatch_type.args.map{ |s| s.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_callbacks_<%= dispatch_type.name_sanitized %>(
+    void *btx_handle, <%= dispatch_type.name_sanitized %>_callback_f *callback);
 
-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);
+void btx_delete_dispatchers(common_data_t *common_data);
 
 #ifdef __cplusplus
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metababel
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Thomas Applencourt
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-16 00:00:00.000000000 Z
+date: 2023-11-07 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: 
@@ -23,7 +23,8 @@ files:
 - bin/metababel
 - lib/metababel.rb
 - lib/metababel/bt2_generator_utils.rb
-- lib/metababel/bt2_stream_classes_generator.rb
+- lib/metababel/bt2_matching_utils.rb
+- lib/metababel/bt2_trace_class_generator.rb
 - lib/metababel/bt2_values_generator.rb
 - lib/metababel/version.rb
 - template/component.c.erb
@@ -39,7 +40,8 @@ files:
 homepage: 
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths: