lttv/lttv/event.c

   1
   2
   3
   4 #include <lttv/event.h>
   5 #include <lttv/time.h>
   6 #include <babeltrace/ctf/events.h>
   7
   8 LttTime lttv_event_get_timestamp(LttvEvent *event)
   9 {
  10   return ltt_time_from_uint64(bt_ctf_get_timestamp(event->bt_event));
  11 }
  12
  13 //TODO ybrosseau find a way to return an error code
  14 unsigned long lttv_event_get_long_unsigned(LttvEvent *event, const char* field)
  15 {
  16         const struct definition *scope;
  17         unsigned long timestamp;
  18         unsigned long data;
  19         struct bt_ctf_event *ctf_event = event->bt_event;
  20
  21         timestamp = bt_ctf_get_timestamp(ctf_event);
  22         if (timestamp == -1ULL) {
  23                 return 0;
  24         }
  25         //scope = bt_ctf_get_top_level_scope(ctf_event, BT_STREAM_PACKET_CONTEXT);
  26         scope = bt_ctf_get_top_level_scope(ctf_event, BT_EVENT_FIELDS);
  27         if (bt_ctf_field_get_error()) {
  28                 return 0;
  29         }
  30         data = bt_ctf_get_uint64(bt_ctf_get_field(ctf_event, scope, field));
  31         if (bt_ctf_field_get_error()) {
  32                 return 0;
  33         } else {
  34                 return data;
  35         }
  36 }
  37
  38
  39 char* lttv_event_get_string(LttvEvent *event, const char* field)
  40 {
  41         const struct definition *scope;
  42         unsigned long timestamp;
  43         char* data;
  44         struct bt_ctf_event *ctf_event = event->bt_event;
  45
  46         timestamp = bt_ctf_get_timestamp(ctf_event);
  47         if (timestamp == -1ULL) {
  48                 printf("ERROR: lttv_event_get_string - cannot read timestamps");
  49                 return 0;
  50         }
  51         //scope = bt_ctf_get_top_level_scope(ctf_event, BT_STREAM_PACKET_CONTEXT);
  52         scope = bt_ctf_get_top_level_scope(ctf_event, BT_EVENT_FIELDS);
  53         if (bt_ctf_field_get_error()) {
  54                 printf("ERROR: lttv_event_get_string - cannot get field scope");
  55                 return 0;
  56         }
  57         data = bt_ctf_get_char_array(bt_ctf_get_field(ctf_event, scope, field));
  58         if (bt_ctf_field_get_error()) {
  59                 // Try get_string if we fail on char_array
  60                 // TODO ybrosseau: properly detect right type
  61                 data = bt_ctf_get_string(bt_ctf_get_field(ctf_event, scope, field));
  62                 if (bt_ctf_field_get_error()) {
  63
  64
  65                         printf("ERROR: lttv_event_get_string - cannot get field data %s", field);
  66
  67                         return 0;
  68                 } else {
  69                         return data;
  70                 }
  71
  72         } else {
  73                 return data;
  74         }
  75 }
  76 long lttv_event_get_long(LttvEvent *event, const char* field)
  77 {
  78         const struct definition *scope;
  79         unsigned long timestamp;
  80         long data;
  81         struct bt_ctf_event *ctf_event = event->bt_event;
  82
  83         timestamp = bt_ctf_get_timestamp(ctf_event);
  84         if (timestamp == -1ULL) {
  85                 return 0;
  86         }
  87         scope = bt_ctf_get_top_level_scope(ctf_event, BT_EVENT_FIELDS);
  88         if (bt_ctf_field_get_error()) {
  89                 return 0;
  90         }
  91         data = bt_ctf_get_int64(bt_ctf_get_field(ctf_event, scope, field));
  92         if (bt_ctf_field_get_error()) {
  93                 return 0;
  94         } else {
  95                 return data;
  96         }
  97 }
  98 /*
  99 unsigned int lttv_event_get_int_unsigned(LttvEvent *event, const char* field)
 100 {
 101         struct definition *scope;
 102         unsigned long timestamp;
 103         char* data;
 104         struct bt_ctf_event *ctf_event = event->bt_event;
 105
 106         timestamp = bt_ctf_get_timestamp(ctf_event);
 107         if (timestamp == -1ULL) {
 108                 return 0;
 109         }
 110         scope = bt_ctf_get_top_level_scope(ctf_event, BT_STREAM_PACKET_CONTEXT);
 111         if (bt_ctf_field_get_error()) {
 112                 return 0;
 113         }
 114         data = bt_ctf_get_char_array(bt_ctf_get_field(ctf_event, scope, field));
 115         if (bt_ctf_field_get_error()) {
 116                 return 0;
 117         } else {
 118                 return data;
 119         }
 120 }
 121 int lttv_event_get_int(LttvEvent *event, const char* field)
 122 {
 123         struct definition *scope;
 124         unsigned long timestamp;
 125         char* data;
 126         struct bt_ctf_event *ctf_event = event->bt_event;
 127
 128         timestamp = bt_ctf_get_timestamp(ctf_event);
 129         if (timestamp == -1ULL) {
 130                 return 0;
 131         }
 132         scope = bt_ctf_get_top_level_scope(ctf_event, BT_STREAM_PACKET_CONTEXT);
 133         if (bt_ctf_field_get_error()) {
 134                 return 0;
 135         }
 136         data = bt_ctf_get_char_array(bt_ctf_get_field(ctf_event, scope, field));
 137         if (bt_ctf_field_get_error()) {
 138                 return 0;
 139         } else {
 140                 return data;
 141         }
 142 }
 143 */