metababel 0.0.3 → 0.0.5

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.5
 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-07-05 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: