metababel 0.1.0 → 1.0.2

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,31 @@ 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 =
-      bt_self_message_iterator_get_data(common_data->self_message_iterator);
-  btx_downstream_push_message(message_iterator_private_data, message);
+  btx_message_iterator_t *_message_iterator_private_data =
+      (btx_message_iterator_t *)bt_self_message_iterator_get_data(
+          common_data->self_message_iterator);
+  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

@@ -28,7 +28,8 @@ filter_message_iterator_next_finalizing(
     bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
 
   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);
 
   /* No more messages, we can stop the plugin, and transition to END  */
   if (!message_iterator_private_data->queue) {
@@ -55,7 +56,8 @@ filter_message_iterator_next_processing_sending(
     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);
+      (btx_message_iterator_t *)bt_self_message_iterator_get_data(
+          self_message_iterator);
 
   /* This should never append. When transitioning to sending,
      we check that we have some messages to send */
@@ -104,35 +106,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 +127,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);
@@ -182,7 +169,8 @@ filter_message_iterator_next_processing_reading(
     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);
+      (btx_message_iterator_t *)bt_self_message_iterator_get_data(
+          self_message_iterator);
 
   common_data_t *common_data = message_iterator_private_data->common_data;
 
@@ -244,7 +232,8 @@ filter_message_iterator_next_processing(
     bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
 
   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);
 
   switch (message_iterator_private_data->processing_state) {
   case BTX_FILTER_PROCESSING_STATE_READING:
@@ -272,21 +261,17 @@ filter_message_iterator_next_initializing(
 
   /* 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);
 
   /* 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);
 
   /* We need to transition to the processing state*/
   message_iterator_private_data->state = BTX_FILTER_STATE_PROCESSING;
@@ -313,7 +298,8 @@ filter_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);
 
   switch (message_iterator_private_data->state) {
   case BTX_FILTER_STATE_INITIALIZING:
@@ -354,15 +340,24 @@ filter_initialize(bt_self_component_filter *self_component_filter,
                   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 */
   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);
 
   /* Set the component's user data to our private data structure */
   bt_self_component_set_data(
@@ -401,7 +396,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,13 +431,13 @@ 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));
+      (btx_message_iterator_t *)calloc(1, sizeof(btx_message_iterator_t));
 
   /* 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 */
@@ -481,19 +477,22 @@ filter_message_iterator_initialize(
 }
 
 static void filter_finalize(bt_self_component_filter *self_component_filter) {
-  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_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);
 }
@@ -502,7 +501,8 @@ static void filter_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;

data/template/sink.c.erb

@@ -19,7 +19,7 @@ sink_consume(bt_self_component_sink *self_component_sink) {
 
   /* Retrieve our private data from the component's user data */
   /* This containt user data and the message iterator */
-  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_sink_as_self_component(self_component_sink));
 
   /* Consume a batch of messages from the upstream message iterator */
@@ -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);
@@ -102,19 +82,21 @@ sink_initialize(bt_self_component_sink *self_component_sink,
                 bt_self_component_sink_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
-  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(common_data, &common_data->usr_data);
   /* Call read callbacks */
   btx_call_callbacks_read_params(common_data, common_data->usr_data,
                                  common_data->btx_params);
@@ -137,19 +119,18 @@ sink_initialize(bt_self_component_sink *self_component_sink,
 }
 
 static void sink_finalize(bt_self_component_sink *self_component_sink) {
-  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_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 */
@@ -165,7 +146,7 @@ static void sink_finalize(bt_self_component_sink *self_component_sink) {
 static bt_component_class_sink_graph_is_configured_method_status
 sink_graph_is_configured(bt_self_component_sink *self_component_sink) {
   /* Retrieve our private data from the component's 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_component_sink_as_self_component(self_component_sink));
 
   /* Borrow our unique port */