src/ctf-writer/field-path.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   5  * Copyright 2016 Philippe Proulx <pproulx@efficios.com>
   6  *
   7  * Babeltrace CTF writer - Field path
   8  */
   9
  10 #define BT_LOG_TAG "CTF-WRITER/FIELD-PATH"
  11 #include "logging.h"
  12
  13 #include <glib.h>
  14 #include <inttypes.h>
  15 #include <limits.h>
  16 #include <stdint.h>
  17
  18 #include <babeltrace2-ctf-writer/field-types.h>
  19
  20 #include "common/assert.h"
  21
  22 #include "field-path.h"
  23 #include "field-types.h"
  24
  25 static
  26 void field_path_destroy(struct bt_ctf_object *obj)
  27 {
  28         struct bt_ctf_field_path *field_path = (struct bt_ctf_field_path *) obj;
  29
  30         BT_LOGD("Destroying field path: addr=%p", obj);
  31
  32         if (!field_path) {
  33                 return;
  34         }
  35
  36         if (field_path->indexes) {
  37                 g_array_free(field_path->indexes, TRUE);
  38         }
  39         g_free(field_path);
  40 }
  41
  42 struct bt_ctf_field_path *bt_ctf_field_path_create(void)
  43 {
  44         struct bt_ctf_field_path *field_path = NULL;
  45
  46         BT_LOGD_STR("Creating empty field path object.");
  47
  48         field_path = g_new0(struct bt_ctf_field_path, 1);
  49         if (!field_path) {
  50                 BT_LOGE_STR("Failed to allocate one field path.");
  51                 goto error;
  52         }
  53
  54         bt_ctf_object_init_shared(&field_path->base, field_path_destroy);
  55         field_path->root = BT_CTF_SCOPE_UNKNOWN;
  56         field_path->indexes = g_array_new(TRUE, FALSE, sizeof(int));
  57         if (!field_path->indexes) {
  58                 BT_LOGE_STR("Failed to allocate a GArray.");
  59                 goto error;
  60         }
  61
  62         BT_LOGD("Created empty field path object: addr=%p", field_path);
  63         return field_path;
  64
  65 error:
  66         BT_CTF_OBJECT_PUT_REF_AND_RESET(field_path);
  67         return NULL;
  68 }
  69
  70 void bt_ctf_field_path_clear(struct bt_ctf_field_path *field_path)
  71 {
  72         if (field_path->indexes->len > 0) {
  73                 g_array_remove_range(field_path->indexes, 0,
  74                         field_path->indexes->len);
  75         }
  76 }
  77
  78 struct bt_ctf_field_path *bt_ctf_field_path_copy(
  79                 struct bt_ctf_field_path *path)
  80 {
  81         struct bt_ctf_field_path *new_path;
  82
  83         BT_ASSERT_DBG(path);
  84         BT_LOGD("Copying field path: addr=%p, index-count=%u",
  85                 path, path->indexes->len);
  86         new_path = bt_ctf_field_path_create();
  87         if (!new_path) {
  88                 BT_LOGE_STR("Cannot create empty field path.");
  89                 goto end;
  90         }
  91
  92         new_path->root = path->root;
  93         g_array_insert_vals(new_path->indexes, 0,
  94                 path->indexes->data, path->indexes->len);
  95         BT_LOGD("Copied field path: original-addr=%p, copy-addr=%p",
  96                 path, new_path);
  97 end:
  98         return new_path;
  99 }
 100
 101 enum bt_ctf_scope bt_ctf_field_path_get_root_scope(
 102                 const struct bt_ctf_field_path *field_path)
 103 {
 104         enum bt_ctf_scope scope = BT_CTF_SCOPE_UNKNOWN;
 105
 106         if (!field_path) {
 107                 BT_LOGW_STR("Invalid parameter: field path is NULL.");
 108                 goto end;
 109         }
 110
 111         scope = field_path->root;
 112
 113 end:
 114         return scope;
 115 }
 116
 117 int64_t bt_ctf_field_path_get_index_count(
 118                 const struct bt_ctf_field_path *field_path)
 119 {
 120         int64_t count = (int64_t) -1;
 121
 122         if (!field_path) {
 123                 BT_LOGW_STR("Invalid parameter: field path is NULL.");
 124                 goto end;
 125         }
 126
 127         count = (int64_t) field_path->indexes->len;
 128
 129 end:
 130         return count;
 131 }
 132
 133 int bt_ctf_field_path_get_index(const struct bt_ctf_field_path *field_path,
 134                 uint64_t index)
 135 {
 136         int ret = INT_MIN;
 137
 138         if (!field_path) {
 139                 BT_LOGW_STR("Invalid parameter: field path is NULL.");
 140                 goto end;
 141         }
 142
 143         if (index >= field_path->indexes->len) {
 144                 BT_LOGW("Invalid parameter: index is out of bounds: "
 145                         "addr=%p, index=%" PRIu64 ", count=%u",
 146                         field_path, index, field_path->indexes->len);
 147                 goto end;
 148         }
 149
 150         ret = g_array_index(field_path->indexes, int, index);
 151
 152 end:
 153         return ret;
 154 }