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                 printf("ERROR: lttv_event_get_long_unsigned - invalid event\n");
  24                 return 0;
  25         }
  26         //scope = bt_ctf_get_top_level_scope(ctf_event, BT_STREAM_PACKET_CONTEXT);
  27         scope = bt_ctf_get_top_level_scope(ctf_event, BT_EVENT_FIELDS);
  28         if (bt_ctf_field_get_error()) {
  29                 printf("ERROR: lttv_event_get_long_unsigned - cannot get field scope\n");
  30                 return 0;
  31         }
  32         data = bt_ctf_get_uint64(bt_ctf_get_field(ctf_event, scope, field));
  33         if (bt_ctf_field_get_error()) {
  34                 printf("ERROR: lttv_event_get_long_unsigned - cannot get field data %s \n", field);
  35                 return 0;
  36         } else {
  37                 return data;
  38         }
  39 }
  40
  41
  42 char* lttv_event_get_string(LttvEvent *event, const char* field)
  43 {
  44         const struct definition *scope;
  45         unsigned long timestamp;
  46         char* data;
  47         struct bt_ctf_event *ctf_event = event->bt_event;
  48
  49         timestamp = bt_ctf_get_timestamp(ctf_event);
  50         if (timestamp == -1ULL) {
  51                 printf("ERROR: lttv_event_get_string - cannot read timestamps");
  52                 return 0;
  53         }
  54         //scope = bt_ctf_get_top_level_scope(ctf_event, BT_STREAM_PACKET_CONTEXT);
  55         scope = bt_ctf_get_top_level_scope(ctf_event, BT_EVENT_FIELDS);
  56         if (bt_ctf_field_get_error()) {
  57                 printf("ERROR: lttv_event_get_string - cannot get field scope");
  58                 return 0;
  59         }
  60         data = bt_ctf_get_char_array(bt_ctf_get_field(ctf_event, scope, field));
  61         if (bt_ctf_field_get_error()) {
  62                 // Try get_string if we fail on char_array
  63                 // TODO ybrosseau: properly detect right type
  64                 data = bt_ctf_get_string(bt_ctf_get_field(ctf_event, scope, field));
  65                 if (bt_ctf_field_get_error()) {
  66
  67
  68                         printf("ERROR: lttv_event_get_string - cannot get field data %s", field);
  69
  70                         return 0;
  71                 } else {
  72                         return data;
  73                 }
  74
  75         } else {
  76                 return data;
  77         }
  78 }
  79 long lttv_event_get_long(LttvEvent *event, const char* field)
  80 {
  81         const struct definition *scope;
  82         unsigned long timestamp;
  83         long data;
  84         struct bt_ctf_event *ctf_event = event->bt_event;
  85
  86         timestamp = bt_ctf_get_timestamp(ctf_event);
  87         if (timestamp == -1ULL) {
  88                 printf("ERROR: lttv_event_get_long - invalid event\n");
  89                 return 0;
  90         }
  91         scope = bt_ctf_get_top_level_scope(ctf_event, BT_EVENT_FIELDS);
  92         if (bt_ctf_field_get_error()) {
  93                 printf("ERROR: lttv_event_get_long - cannot get field scope\n");
  94                 return 0;
  95         }
  96         data = bt_ctf_get_int64(bt_ctf_get_field(ctf_event, scope, field));
  97         if (bt_ctf_field_get_error()) {
  98                 printf("ERROR: lttv_event_get_long - cannot get field data %s \n", field);
  99                 return 0;
 100         } else {
 101                 return data;
 102         }
 103 }
 104 /*
 105 unsigned int lttv_event_get_int_unsigned(LttvEvent *event, const char* field)
 106 {
 107         struct definition *scope;
 108         unsigned long timestamp;
 109         char* data;
 110         struct bt_ctf_event *ctf_event = event->bt_event;
 111
 112         timestamp = bt_ctf_get_timestamp(ctf_event);
 113         if (timestamp == -1ULL) {
 114                 return 0;
 115         }
 116         scope = bt_ctf_get_top_level_scope(ctf_event, BT_STREAM_PACKET_CONTEXT);
 117         if (bt_ctf_field_get_error()) {
 118                 return 0;
 119         }
 120         data = bt_ctf_get_char_array(bt_ctf_get_field(ctf_event, scope, field));
 121         if (bt_ctf_field_get_error()) {
 122                 return 0;
 123         } else {
 124                 return data;
 125         }
 126 }
 127 int lttv_event_get_int(LttvEvent *event, const char* field)
 128 {
 129         struct definition *scope;
 130         unsigned long timestamp;
 131         char* data;
 132         struct bt_ctf_event *ctf_event = event->bt_event;
 133
 134         timestamp = bt_ctf_get_timestamp(ctf_event);
 135         if (timestamp == -1ULL) {
 136                 return 0;
 137         }
 138         scope = bt_ctf_get_top_level_scope(ctf_event, BT_STREAM_PACKET_CONTEXT);
 139         if (bt_ctf_field_get_error()) {
 140                 return 0;
 141         }
 142         data = bt_ctf_get_char_array(bt_ctf_get_field(ctf_event, scope, field));
 143         if (bt_ctf_field_get_error()) {
 144                 return 0;
 145         } else {
 146                 return data;
 147         }
 148 }
 149 */