metababel 0.1.0 → 1.0.1

data/template/component.h.erb

@@ -4,6 +4,9 @@
 #include "uthash.h"
 #include <babeltrace2/babeltrace.h>
 #include <stdbool.h>
+<% if options.key?(:usr_data_header) %>
+#include "<%= options[:usr_data_header] %>"
+<% end %>
 
 #ifdef __cplusplus
 extern "C" {
@@ -14,27 +17,35 @@ struct common_data_s;
 typedef struct common_data_s common_data_t;
 
 // Params
-// Avoid icx error: empty struct has size 0 in C, size 1 in C++ [-Werror,-Wextern-c-compat]
+// Avoid icx error: empty struct has size 0 in C, size 1 in C++
+// [-Werror,-Wextern-c-compat]
 struct btx_params_s {
-<% if params_declaration %>
+  <% if params_declaration %>
   <%= params_declaration %>
-<% else %>
-  int dummy;
-<% end %>
+  <% else %>
+  char _dummy;
+  <% end %>
 
 }; <%# Need empty line for nice code gen %>
 typedef struct btx_params_s btx_params_t;
 
 void btx_populate_params(common_data_t *common_data_t);
 
-<% if options.key?(:usr_data_header) %>
-#include "<%= options[:usr_data_header] %>"
-<% end %>
+struct callbacks_s {
+  <% callback_types.each do |c| %>
+  UT_array *<%= c %>;
+  <% end %>
+};
+typedef struct callbacks_s callbacks_t;
+
+<%# Forward Declaration %>
+struct static_callbacks_s;
+typedef struct static_callbacks_s static_callbacks_t;
 
 struct name_to_dispatcher_s {
   const char *name;
   void *dispatcher;
-  UT_array *callbacks;
+  callbacks_t *callbacks;
   UT_hash_handle hh;
 };
 typedef struct name_to_dispatcher_s name_to_dispatcher_t;
@@ -51,6 +62,10 @@ struct el {
 <% if options[:component_type] == 'SOURCE' %>
 struct common_data_s {
   name_to_dispatcher_t *name_to_dispatcher;
+  static_callbacks_t *static_callbacks;
+  <% unless options[:disable_callbaks].include?('on_downstream') %>
+  void *on_downstream_message_callback;
+  <% end %>
   void *usr_data;
   const bt_value *params;
   btx_params_t *btx_params;
@@ -89,7 +104,11 @@ 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;
+  static_callbacks_t *static_callbacks;
+  <% unless options[:disable_callbaks].include?('on_downstream') %>
+  void *on_downstream_message_callback;
+  <% end %>
+
   void *usr_data;
   const bt_value *params;
   btx_params_t *btx_params;
@@ -139,7 +158,8 @@ 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;
+  static_callbacks_t *static_callbacks;
+
   void *usr_data;
   const bt_value *params;
   btx_params_t *btx_params;
@@ -150,19 +170,25 @@ struct common_data_s {
 
 void btx_register_usr_callbacks(void *btx_handle);
 
-<% component_dispatchers.each do |e| %>
-<%# The signature type of callbacks %>
-typedef void
-<%= e.name_sanitized %>_callback_f(void *btx_handle,
-                                   <%= e.args.map{ |s| s.type }.join(", ") %>);
+<% static_callback_types.each do |e| %>
+typedef void <%= e.name_sanitized %>_static_callback_f(
+  <%= "void *btx_handle," unless e.no_btx_handle %>
+  <%= e.args.map{ |s| s.type }.join(", ") %>);
+
 <%# 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);
+    void *btx_handle, <%= e.name_sanitized %>_static_callback_f *callback);
 
 void btx_call_callbacks_<%= e.name_sanitized %>(
     common_data_t *common_data, <%= e.args.map{ |s| s.type }.join(", ") %>);
 <% end %>
 
+struct static_callbacks_s {
+  <% static_callback_types.each do |e| %>
+  <%= e.name_sanitized %>_static_callback_f *<%= e.name_sanitized %>;
+  <% end %>
+};
+
 #ifdef __cplusplus
 }
 #endif

data/template/downstream.c.erb

@@ -20,9 +20,9 @@ void btx_downstream_move_messages(
   }
 }
 
-void btx_downstream_push_message(
-    btx_message_iterator_t *message_iterator_private_data,
-    const bt_message *message) {
+static inline
+void _btx_push_message(btx_message_iterator_t *message_iterator_private_data,
+                  const bt_message *message) {
 
   struct el *elt;
   if (message_iterator_private_data->pool) {
@@ -35,11 +35,41 @@ void btx_downstream_push_message(
   DL_APPEND(message_iterator_private_data->queue, elt);
 }
 
+<% unless options[:disable_callbaks].include?('on_downstream') %>
+void btx_push_message(void *btx_handle, const bt_message *message) {
+  _btx_push_message((btx_message_iterator_t *)btx_handle, message);
+}
+
+void btx_register_on_downstream_message_callback(
+    void *btx_handle, on_downstream_message_callback_f *callback) {
+  ((common_data_t *)btx_handle)->on_downstream_message_callback =
+      (void *)callback;
+}
+<% end %>
+// Used internaly to push messages downstreams
+void btx_downstream_push_message(
+    btx_message_iterator_t *message_iterator_private_data,
+    const bt_message *message) {
+
+<% unless options[:disable_callbaks].include?('on_downstream') %>
+  on_downstream_message_callback_f *p =
+      (on_downstream_message_callback_f *)message_iterator_private_data
+          ->common_data->on_downstream_message_callback;
+  if (p) {
+    p(((void *)message_iterator_private_data),
+      message_iterator_private_data->common_data->usr_data, message);
+    return;
+  }
+<% end %>
+  _btx_push_message(message_iterator_private_data, message);
+}
+
+// Register callbacks
 bt_trace_class *
-btx_downstream_trace_class_create_rec(bt_self_component *self_component) {
-  bt_trace_class *trace_class;
+btx_downstream_trace_class_create_rec(bt_self_component *_self_component) {
+  bt_trace_class *_trace_class;
   <%= body_declarator_classes %>
-  return trace_class;
+  return _trace_class;
 }
 
 bt_trace *btx_downstream_trace_create_rec(bt_trace_class *trace_class) {
@@ -115,30 +145,30 @@ static void btx_set_message_<%= e.name_sanitized %>(
 
 void btx_push_message_<%= e.name_sanitized %>(
     void *
-        btx_handle<%= ', int64_t _timestamp' if e.default_clock_class %><%= e.args.map{ |s| "#{s.type} #{s.name}" }.join_with_prefix(", ") %>) {
+        btx_handle<%= e.args.map{ |s| "#{s.type} #{s.name}" }.join_with_prefix(", ") %>) {
 
   common_data_t *common_data = (common_data_t *)btx_handle;
 
-  bt_stream *stream = bt_trace_borrow_stream_by_index(
+  bt_stream *_stream = bt_trace_borrow_stream_by_index(
       common_data->downstream_trace, <%= e.index_stream_class %>);
-  bt_stream_class *stream_class = bt_stream_borrow_class(stream);
-  bt_event_class *event_class = bt_stream_class_borrow_event_class_by_index(
-      stream_class, <%= e.index_event_class %>);
+  bt_stream_class *_stream_class = bt_stream_borrow_class(_stream);
+  bt_event_class *_event_class = bt_stream_class_borrow_event_class_by_index(
+      _stream_class, <%= e.index_event_class %>);
   <% if !e.default_clock_class %>
-  bt_message *message = bt_message_event_create(
-      common_data->self_message_iterator, event_class, stream);
+  bt_message *_message = bt_message_event_create(
+      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);
+  bt_message *_message = bt_message_event_create_with_default_clock_snapshot(
+      common_data->self_message_iterator, _event_class, _stream, _timestamp);
   <% end %>
 
-  bt_event *downstream_event = bt_message_event_borrow_event(message);
+  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_with_prefix(", ") %>);
+      _downstream_event<%= e.args.map{ |s| s.name }.join_with_prefix(", ") %>);
 
-  btx_message_iterator_t *message_iterator_private_data =
+  btx_message_iterator_t *_message_iterator_private_data =
       bt_self_message_iterator_get_data(common_data->self_message_iterator);
-  btx_downstream_push_message(message_iterator_private_data, message);
+  btx_downstream_push_message(_message_iterator_private_data, _message);
 }
 <% end %>

data/template/downstream.h.erb

@@ -30,8 +30,18 @@ void btx_push_messages_stream_end(
 <% downstream_events.each do |e| %>
 void btx_push_message_<%= e.name_sanitized %>(
     void *
-        btx_handle<%= ', int64_t _timestamp' if e.default_clock_class %><%= e.args.map{ |s| "#{s.type} #{s.name}" }.join_with_prefix(", ") %>);
+        btx_handle<%= e.args.map{ |s| "#{s.type} #{s.name}" }.join_with_prefix(", ") %>);
 <% end %>
+
+<% unless options[:disable_callbaks].include?('on_downstream') %>
+void btx_push_message(void *btx_handle, const bt_message *message);
+
+typedef void on_downstream_message_callback_f(void *btx_handle, void *usr_data,
+                                              const bt_message *message);
+void btx_register_on_downstream_message_callback(
+    void *btx_handle, on_downstream_message_callback_f *callback);
+<% end %>
+
 #ifdef __cplusplus
 }
 #endif

data/template/filter.c.erb

@@ -104,35 +104,18 @@ static inline void filter_message_iterator_next_call_dispatchers(
   /* Borrow the event message's event and its class */
   const bt_event *event = bt_message_event_borrow_event_const(upstream_message);
   const bt_event_class *event_class = bt_event_borrow_class_const(event);
-  /* Lazy modified variable */
-  bool is_callback_called = false;
+
   /* Event dispatcher */
-  {
-    const char *class_name = bt_event_class_get_name(event_class);
-    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);
-  }
-  /* Matching Dispacher */
-  {
-    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;
-    if (stream_class_name)
-      HASH_FIND_STR(common_data->name_to_matching_dispatcher,
-                    stream_class_name, s);
-    if (s)
-      (*((dispatcher_t(*))(s->dispatcher)))(
-          s->callbacks, common_data, upstream_message, &is_callback_called);
-  }
-  /* Drop or push upstream message*/
-  if (is_callback_called) {
+  const char *class_name = bt_event_class_get_name(event_class);
+  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);
+    /* Drop message */
     bt_message_put_ref(upstream_message);
   } else {
+    /* Push upstream message to downstream */
     btx_downstream_push_message(message_iterator_private_data,
                                 upstream_message);
   }
@@ -142,10 +125,12 @@ static inline void
 filter_message_iterator_next_processing_reading_to_finalizing(
     bt_self_message_iterator *self_message_iterator,
     btx_message_iterator_t *message_iterator_private_data) {
+
   /* 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 */
   btx_push_messages_stream_end(self_message_iterator,
                                message_iterator_private_data);
@@ -279,14 +264,9 @@ filter_message_iterator_next_initializing(
                                      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);
 
   /* We need to transition to the processing state*/
   message_iterator_private_data->state = BTX_FILTER_STATE_PROCESSING;
@@ -355,14 +335,22 @@ filter_initialize(bt_self_component_filter *self_component_filter,
 
   /* Allocate a private data structure */
   common_data_t *common_data = calloc(1, sizeof(common_data_t));
+  common_data->static_callbacks = calloc(1, sizeof(static_callbacks_t));
   common_data->btx_params = calloc(1, sizeof(btx_params_t));
   common_data->params = params;
+
   /* 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((void *)common_data,
+                                          &common_data->usr_data);
+  /* Call read callbacks */
+  btx_call_callbacks_read_params(common_data, common_data->usr_data,
+                                 common_data->btx_params);
 
   /* Set the component's user data to our private data structure */
   bt_self_component_set_data(
@@ -401,7 +389,8 @@ filter_initialize(bt_self_component_filter *self_component_filter,
   /* Create message classes that will be used by the filter */
   bt_self_component *self_component =
       bt_self_component_filter_as_self_component(self_component_filter);
-  /* Create a `trace_class` and all the children's classes (stream and events) */
+  /* Create a `trace_class` and all the children's classes (stream and events)
+   */
   bt_trace_class *trace_class =
       btx_downstream_trace_class_create_rec(self_component);
   /* Instantiate a `downstream_trace` of `trace_class` and all the children
@@ -435,7 +424,7 @@ static bt_message_iterator_class_initialize_method_status
 filter_message_iterator_initialize(
     bt_self_message_iterator *self_message_iterator,
     bt_self_message_iterator_configuration *configuration,
-    bt_self_component_port_output *self_port) {
+    bt_self_component_port_output *self_port_output) {
   /* Allocate a private data structure */
   btx_message_iterator_t *message_iterator_private_data =
       calloc(1, sizeof(btx_message_iterator_t));
@@ -484,16 +473,19 @@ static void filter_finalize(bt_self_component_filter *self_component_filter) {
   common_data_t *common_data = bt_self_component_get_data(
       bt_self_component_filter_as_self_component(self_component_filter));
 
+  /* 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);
 
   /* 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);
+  free(common_data->static_callbacks);
   bt_value_put_ref(common_data->params);
   free(common_data);
 }

data/template/sink.c.erb

@@ -55,37 +55,17 @@ sink_consume(bt_self_component_sink *self_component_sink) {
     }
 
     /* Borrow the event message's event and its class */
-    const bt_event *event = bt_message_event_borrow_event_const(upstream_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 */
-    bool is_callback_called = false;
+    /* Event dispatcher */
     const char *class_name = bt_event_class_get_name(event_class);
-
-    {
-      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;
-      if (stream_class_name)
-        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);
-      }
+    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);
     }
 
     bt_message_put_ref(upstream_message);
@@ -103,18 +83,19 @@ sink_initialize(bt_self_component_sink *self_component_sink,
                 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->static_callbacks = calloc(1, sizeof(static_callbacks_t));
   common_data->btx_params = calloc(1, sizeof(btx_params_t));
   common_data->params = params;
-  // Read parameters
-  btx_populate_params(common_data);
 
+  /* 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 user callback */
-  btx_call_callbacks_initialize_usr_data(common_data, &common_data->usr_data);
+  /* Call initialize_processing*/
+  btx_call_callbacks_initialize_component((void *)common_data,
+                                          &common_data->usr_data);
   /* Call read callbacks */
   btx_call_callbacks_read_params(common_data, common_data->usr_data,
                                  common_data->btx_params);
@@ -140,16 +121,15 @@ static void sink_finalize(bt_self_component_sink *self_component_sink) {
   common_data_t *common_data = bt_self_component_get_data(
       bt_self_component_sink_as_self_component(self_component_sink));
 
-  /* Finalize User Data */
-  /* Call Finalize user callback */
-  btx_call_callbacks_finalize_usr_data(common_data, common_data->usr_data);
+  /* Finalize Component */
+  btx_call_callbacks_finalize_component(common_data, common_data->usr_data);
 
   // Delete name_to_dispatcher
   btx_delete_dispatchers(common_data);
-  btx_delete_matching_dispatchers(common_data);
 
   // 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 the allocated structure */

data/template/source.c.erb

@@ -32,16 +32,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(
-        message_iterator_private_data->common_data,
-        &message_iterator_private_data->common_data->usr_data);
-    /* Call read callbacks */
-    btx_call_callbacks_read_params(
+    btx_call_callbacks_initialize_processing(
         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;
@@ -58,9 +52,8 @@ source_message_iterator_next(bt_self_message_iterator *self_message_iterator,
         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 */
@@ -93,14 +86,23 @@ source_initialize(bt_self_component_source *self_component_source,
                   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->static_callbacks = calloc(1, sizeof(static_callbacks_t));
   common_data->btx_params = 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((void *)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);
@@ -165,6 +167,9 @@ static void source_finalize(bt_self_component_source *self_component_source) {
   common_data_t *common_data = 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 +178,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);
 }