src.ctf.fs: make ctf_fs_file_create return a unique_ptr
[babeltrace.git] / src / plugins / ctf / fs-src / data-stream-file.cpp
index 9f50f7ce584a4548cf932484210213c6d812810c..cea4a620cab624856e347998d716f5ae39ba782d 100644 (file)
@@ -12,6 +12,7 @@
 
 #include "compat/endian.h" /* IWYU pragma: keep  */
 #include "compat/mman.h"   /* IWYU: pragma keep  */
+#include "cpp-common/bt2s/make-unique.hpp"
 #include "cpp-common/vendor/fmt/format.h"
 
 #include "../common/src/msg-iter/msg-iter.hpp"
@@ -224,7 +225,7 @@ static bt_stream *medop_borrow_stream(bt_stream_class *stream_class, int64_t, vo
     bt_stream_class *ds_file_stream_class;
     bt_stream *stream = NULL;
 
-    ds_file_stream_class = bt_stream_borrow_class(ds_file->stream);
+    ds_file_stream_class = ds_file->stream->cls().libObjPtr();
 
     if (stream_class != ds_file_stream_class) {
         /*
@@ -234,7 +235,7 @@ static bt_stream *medop_borrow_stream(bt_stream_class *stream_class, int64_t, vo
         goto end;
     }
 
-    stream = ds_file->stream;
+    stream = ds_file->stream->libObjPtr();
 
 end:
     return stream;
@@ -358,7 +359,7 @@ static enum ctf_msg_iter_medium_status medop_group_switch_packet(void *void_data
     enum ctf_msg_iter_medium_status status;
 
     /* If we have gone through all index entries, we are done. */
-    if (data->next_index_entry_index >= data->ds_file_group->index->entries->len) {
+    if (data->next_index_entry_index >= data->ds_file_group->index->entries.size()) {
         status = CTF_MSG_ITER_MEDIUM_STATUS_EOF;
         goto end;
     }
@@ -367,8 +368,7 @@ static enum ctf_msg_iter_medium_status medop_group_switch_packet(void *void_data
      * Otherwise, look up the next index entry / packet and prepare it
      *  for reading.
      */
-    index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
-        data->ds_file_group->index->entries, data->next_index_entry_index);
+    index_entry = data->ds_file_group->index->entries[data->next_index_entry_index].get();
 
     status = ctf_fs_ds_group_medops_set_file(data, index_entry);
     if (status != CTF_MSG_ITER_MEDIUM_STATUS_OK) {
@@ -403,7 +403,7 @@ enum ctf_msg_iter_medium_status ctf_fs_ds_group_medops_data_create(
     BT_ASSERT(self_msg_iter);
     BT_ASSERT(ds_file_group);
     BT_ASSERT(ds_file_group->index);
-    BT_ASSERT(ds_file_group->index->entries->len > 0);
+    BT_ASSERT(!ds_file_group->index->entries.empty());
 
     ctf_fs_ds_group_medops_data *data = new ctf_fs_ds_group_medops_data {parentLogger};
     data->ds_file_group = ds_file_group;
@@ -437,15 +437,10 @@ struct ctf_msg_iter_medium_ops ctf_fs_ds_group_medops = {
     .borrow_stream = medop_group_borrow_stream,
 };
 
-static void ctf_fs_ds_index_entry_destroy(ctf_fs_ds_index_entry *entry)
+static ctf_fs_ds_index_entry::UP ctf_fs_ds_index_entry_create(const bt2c::DataLen offset,
+                                                              const bt2c::DataLen packetSize)
 {
-    delete entry;
-}
-
-static struct ctf_fs_ds_index_entry *ctf_fs_ds_index_entry_create(const bt2c::DataLen offset,
-                                                                  const bt2c::DataLen packetSize)
-{
-    ctf_fs_ds_index_entry *entry = new ctf_fs_ds_index_entry {offset, packetSize};
+    ctf_fs_ds_index_entry::UP entry = bt2s::make_unique<ctf_fs_ds_index_entry>(offset, packetSize);
 
     entry->packet_seq_num = UINT64_MAX;
 
@@ -459,9 +454,9 @@ static int convert_cycles_to_ns(struct ctf_clock_class *clock_class, uint64_t cy
                                                   clock_class->offset_cycles, ns);
 }
 
-static struct ctf_fs_ds_index *build_index_from_idx_file(struct ctf_fs_ds_file *ds_file,
-                                                         struct ctf_fs_ds_file_info *file_info,
-                                                         struct ctf_msg_iter *msg_iter)
+static ctf_fs_ds_index::UP build_index_from_idx_file(struct ctf_fs_ds_file *ds_file,
+                                                     struct ctf_fs_ds_file_info *file_info,
+                                                     struct ctf_msg_iter *msg_iter)
 {
     int ret;
     gchar *directory = NULL;
@@ -472,8 +467,9 @@ static struct ctf_fs_ds_index *build_index_from_idx_file(struct ctf_fs_ds_file *
     gsize filesize;
     const char *mmap_begin = NULL, *file_pos = NULL;
     const struct ctf_packet_index_file_hdr *header = NULL;
-    struct ctf_fs_ds_index *index = NULL;
-    struct ctf_fs_ds_index_entry *index_entry = NULL, *prev_index_entry = NULL;
+    ctf_fs_ds_index::UP index;
+    ctf_fs_ds_index_entry::UP index_entry;
+    ctf_fs_ds_index_entry *prev_index_entry = NULL;
     auto totalPacketsSize = bt2c::DataLen::fromBytes(0);
     size_t file_index_entry_size;
     size_t file_entry_count;
@@ -579,7 +575,7 @@ static struct ctf_fs_ds_index *build_index_from_idx_file(struct ctf_fs_ds_file *
         goto error;
     }
 
-    index = ctf_fs_ds_index_create(ds_file->logger);
+    index = ctf_fs_ds_index_create();
     if (!index) {
         goto error;
     }
@@ -613,7 +609,7 @@ static struct ctf_fs_ds_index *build_index_from_idx_file(struct ctf_fs_ds_file *
         }
 
         /* Set path to stream file. */
-        index_entry->path = file_info->path->str;
+        index_entry->path = file_info->path.c_str();
 
         index_entry->timestamp_begin = be64toh(file_index->timestamp_begin);
         index_entry->timestamp_end = be64toh(file_index->timestamp_end);
@@ -651,11 +647,9 @@ static struct ctf_fs_ds_index *build_index_from_idx_file(struct ctf_fs_ds_file *
         totalPacketsSize += packetSize;
         file_pos += file_index_entry_size;
 
-        prev_index_entry = index_entry;
+        prev_index_entry = index_entry.get();
 
-        /* Give ownership of `index_entry` to `index->entries`. */
-        g_ptr_array_add(index->entries, index_entry);
-        index_entry = NULL;
+        index->entries.emplace_back(std::move(index_entry));
     }
 
     /* Validate that the index addresses the complete stream. */
@@ -678,9 +672,7 @@ end:
     }
     return index;
 error:
-    ctf_fs_ds_index_destroy(index);
-    ctf_fs_ds_index_entry_destroy(index_entry);
-    index = NULL;
+    index.reset();
     goto end;
 }
 
@@ -729,18 +721,18 @@ end:
     return ret;
 }
 
-static struct ctf_fs_ds_index *build_index_from_stream_file(struct ctf_fs_ds_file *ds_file,
-                                                            struct ctf_fs_ds_file_info *file_info,
-                                                            struct ctf_msg_iter *msg_iter)
+static ctf_fs_ds_index::UP build_index_from_stream_file(struct ctf_fs_ds_file *ds_file,
+                                                        struct ctf_fs_ds_file_info *file_info,
+                                                        struct ctf_msg_iter *msg_iter)
 {
     int ret;
-    struct ctf_fs_ds_index *index = NULL;
+    ctf_fs_ds_index::UP index;
     enum ctf_msg_iter_status iter_status = CTF_MSG_ITER_STATUS_OK;
     auto currentPacketOffset = bt2c::DataLen::fromBytes(0);
 
     BT_CPPLOGI_SPEC(ds_file->logger, "Indexing stream file {}", ds_file->file->path->str);
 
-    index = ctf_fs_ds_index_create(ds_file->logger);
+    index = ctf_fs_ds_index_create();
     if (!index) {
         goto error;
     }
@@ -786,8 +778,7 @@ static struct ctf_fs_ds_index *build_index_from_stream_file(struct ctf_fs_ds_fil
             goto error;
         }
 
-        const auto index_entry =
-            ctf_fs_ds_index_entry_create(currentPacketOffset, currentPacketSize);
+        auto index_entry = ctf_fs_ds_index_entry_create(currentPacketOffset, currentPacketSize);
         if (!index_entry) {
             BT_CPPLOGE_APPEND_CAUSE_SPEC(ds_file->logger,
                                          "Failed to create a ctf_fs_ds_index_entry.");
@@ -795,15 +786,14 @@ static struct ctf_fs_ds_index *build_index_from_stream_file(struct ctf_fs_ds_fil
         }
 
         /* Set path to stream file. */
-        index_entry->path = file_info->path->str;
+        index_entry->path = file_info->path.c_str();
 
-        ret = init_index_entry(index_entry, ds_file, &props);
+        ret = init_index_entry(index_entry.get(), ds_file, &props);
         if (ret) {
-            ctf_fs_ds_index_entry_destroy(index_entry);
             goto error;
         }
 
-        g_ptr_array_add(index->entries, index_entry);
+        index->entries.emplace_back(std::move(index_entry));
 
         currentPacketOffset += currentPacketSize;
         BT_CPPLOGD_SPEC(ds_file->logger,
@@ -817,13 +807,13 @@ end:
     return index;
 
 error:
-    ctf_fs_ds_index_destroy(index);
-    index = NULL;
+    index.reset();
     goto end;
 }
 
-struct ctf_fs_ds_file *ctf_fs_ds_file_create(struct ctf_fs_trace *ctf_fs_trace, bt_stream *stream,
-                                             const char *path, const bt2c::Logger& parentLogger)
+struct ctf_fs_ds_file *ctf_fs_ds_file_create(struct ctf_fs_trace *ctf_fs_trace,
+                                             bt2::Stream::Shared stream, const char *path,
+                                             const bt2c::Logger& parentLogger)
 {
     int ret;
     size_t offset_align;
@@ -833,13 +823,12 @@ struct ctf_fs_ds_file *ctf_fs_ds_file_create(struct ctf_fs_trace *ctf_fs_trace,
         goto error;
     }
 
-    ds_file->file = ctf_fs_file_create(parentLogger);
+    ds_file->file = ctf_fs_file_create(parentLogger).release();
     if (!ds_file->file) {
         goto error;
     }
 
-    ds_file->stream = stream;
-    bt_stream_get_ref(ds_file->stream);
+    ds_file->stream = std::move(stream);
     ds_file->metadata = ctf_fs_trace->metadata;
     g_string_assign(ds_file->file->path, path);
     ret = ctf_fs_file_open(ds_file->file, "rb");
@@ -861,13 +850,11 @@ end:
     return ds_file;
 }
 
-struct ctf_fs_ds_index *ctf_fs_ds_file_build_index(struct ctf_fs_ds_file *ds_file,
-                                                   struct ctf_fs_ds_file_info *file_info,
-                                                   struct ctf_msg_iter *msg_iter)
+ctf_fs_ds_index::UP ctf_fs_ds_file_build_index(struct ctf_fs_ds_file *ds_file,
+                                               struct ctf_fs_ds_file_info *file_info,
+                                               struct ctf_msg_iter *msg_iter)
 {
-    struct ctf_fs_ds_index *index;
-
-    index = build_index_from_idx_file(ds_file, file_info, msg_iter);
+    auto index = build_index_from_idx_file(ds_file, file_info, msg_iter);
     if (index) {
         goto end;
     }
@@ -879,22 +866,9 @@ end:
     return index;
 }
 
-struct ctf_fs_ds_index *ctf_fs_ds_index_create(const bt2c::Logger& logger)
+ctf_fs_ds_index::UP ctf_fs_ds_index_create()
 {
-    ctf_fs_ds_index *index = new ctf_fs_ds_index;
-    index->entries = g_ptr_array_new_with_free_func((GDestroyNotify) ctf_fs_ds_index_entry_destroy);
-    if (!index->entries) {
-        BT_CPPLOGE_SPEC(logger, "Failed to allocate index entries.");
-        goto error;
-    }
-
-    goto end;
-
-error:
-    ctf_fs_ds_index_destroy(index);
-    index = NULL;
-end:
-    return index;
+    return bt2s::make_unique<ctf_fs_ds_index>();
 }
 
 void ctf_fs_ds_file_destroy(struct ctf_fs_ds_file *ds_file)
@@ -903,7 +877,6 @@ void ctf_fs_ds_file_destroy(struct ctf_fs_ds_file *ds_file)
         return;
     }
 
-    bt_stream_put_ref(ds_file->stream);
     (void) ds_file_munmap(ds_file);
 
     if (ds_file->file) {
@@ -913,94 +886,28 @@ void ctf_fs_ds_file_destroy(struct ctf_fs_ds_file *ds_file)
     delete ds_file;
 }
 
-void ctf_fs_ds_index_destroy(struct ctf_fs_ds_index *index)
-{
-    if (!index) {
-        return;
-    }
-
-    if (index->entries) {
-        g_ptr_array_free(index->entries, TRUE);
-    }
-
-    delete index;
-}
-
-void ctf_fs_ds_file_info_destroy(struct ctf_fs_ds_file_info *ds_file_info)
-{
-    if (!ds_file_info) {
-        return;
-    }
-
-    if (ds_file_info->path) {
-        g_string_free(ds_file_info->path, TRUE);
-    }
-
-    delete ds_file_info;
-}
-
-struct ctf_fs_ds_file_info *ctf_fs_ds_file_info_create(const char *path, int64_t begin_ns)
+ctf_fs_ds_file_info::UP ctf_fs_ds_file_info_create(const char *path, int64_t begin_ns)
 {
-    ctf_fs_ds_file_info *ds_file_info = new ctf_fs_ds_file_info;
-    ds_file_info->path = g_string_new(path);
-    if (!ds_file_info->path) {
-        ctf_fs_ds_file_info_destroy(ds_file_info);
-        ds_file_info = NULL;
-        goto end;
-    }
+    ctf_fs_ds_file_info::UP ds_file_info = bt2s::make_unique<ctf_fs_ds_file_info>();
 
+    ds_file_info->path = path;
     ds_file_info->begin_ns = begin_ns;
-
-end:
     return ds_file_info;
 }
 
-static void ctf_fs_ds_file_group_destroy(struct ctf_fs_ds_file_group *ds_file_group)
-{
-    if (!ds_file_group) {
-        return;
-    }
-
-    if (ds_file_group->ds_file_infos) {
-        g_ptr_array_free(ds_file_group->ds_file_infos, TRUE);
-    }
-
-    ctf_fs_ds_index_destroy(ds_file_group->index);
-
-    bt_stream_put_ref(ds_file_group->stream);
-    delete ds_file_group;
-}
-
-void ctf_fs_ds_file_group_deleter::operator()(ctf_fs_ds_file_group *group) noexcept
-{
-    ctf_fs_ds_file_group_destroy(group);
-}
-
 ctf_fs_ds_file_group::UP ctf_fs_ds_file_group_create(struct ctf_fs_trace *ctf_fs_trace,
                                                      struct ctf_stream_class *sc,
                                                      uint64_t stream_instance_id,
-                                                     struct ctf_fs_ds_index *index)
+                                                     ctf_fs_ds_index::UP index)
 {
     ctf_fs_ds_file_group::UP ds_file_group {new ctf_fs_ds_file_group};
 
-    ds_file_group->ds_file_infos =
-        g_ptr_array_new_with_free_func((GDestroyNotify) ctf_fs_ds_file_info_destroy);
-    if (!ds_file_group->ds_file_infos) {
-        goto error;
-    }
-
-    ds_file_group->index = index;
+    ds_file_group->index = std::move(index);
 
     ds_file_group->stream_id = stream_instance_id;
     BT_ASSERT(sc);
     ds_file_group->sc = sc;
     ds_file_group->ctf_fs_trace = ctf_fs_trace;
-    goto end;
 
-error:
-    ds_file_group.reset();
-    ctf_fs_ds_index_destroy(index);
-
-end:
     return ds_file_group;
 }
This page took 0.028732 seconds and 4 git commands to generate.