src.ctf.fs: remove ctf_fs_trace_destroy
[babeltrace.git] / src / plugins / ctf / fs-src / fs.cpp
index 8e781665c12adefa45a23daa9ec28cf934035eca..7f0de79bac0b643e82b5fc4505d3ba31d323687e 100644 (file)
@@ -35,15 +35,6 @@ struct tracer_info
     int64_t patch;
 };
 
-static void ctf_fs_msg_iter_data_destroy(struct ctf_fs_msg_iter_data *msg_iter_data)
-{
-    if (!msg_iter_data) {
-        return;
-    }
-
-    delete msg_iter_data;
-}
-
 static bt_message_iterator_class_next_method_status
 ctf_fs_iterator_next_one(struct ctf_fs_msg_iter_data *msg_iter_data, const bt_message **out_msg)
 {
@@ -176,8 +167,8 @@ ctf_fs_iterator_seek_beginning(bt_self_message_iterator *it)
 
 void ctf_fs_iterator_finalize(bt_self_message_iterator *it)
 {
-    ctf_fs_msg_iter_data_destroy(
-        (struct ctf_fs_msg_iter_data *) bt_self_message_iterator_get_data(it));
+    ctf_fs_msg_iter_data::UP {
+        (static_cast<ctf_fs_msg_iter_data *>(bt_self_message_iterator_get_data(it)))};
 }
 
 static bt_message_iterator_class_initialize_method_status
@@ -211,7 +202,7 @@ ctf_fs_iterator_init(bt_self_message_iterator *self_msg_iter,
             bt_self_component_port_output_as_self_component_port(self_port));
         BT_ASSERT(port_data);
 
-        ctf_fs_msg_iter_data *msg_iter_data = new ctf_fs_msg_iter_data {self_msg_iter};
+        auto msg_iter_data = bt2s::make_unique<ctf_fs_msg_iter_data>(self_msg_iter);
         msg_iter_data->ds_file_group = port_data->ds_file_group;
 
         medium_status = ctf_fs_ds_group_medops_data_create(msg_iter_data->ds_file_group,
@@ -247,8 +238,7 @@ ctf_fs_iterator_init(bt_self_message_iterator *self_msg_iter,
             bt_self_message_iterator_configuration_set_can_seek_forward(config, true);
         }
 
-        bt_self_message_iterator_set_data(self_msg_iter, msg_iter_data);
-        msg_iter_data = NULL;
+        bt_self_message_iterator_set_data(self_msg_iter, msg_iter_data.release());
 
         status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_OK;
         goto end;
@@ -257,7 +247,6 @@ error:
         bt_self_message_iterator_set_data(self_msg_iter, NULL);
 
 end:
-        ctf_fs_msg_iter_data_destroy(msg_iter_data);
         return status;
     } catch (const std::bad_alloc&) {
         return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
@@ -266,31 +255,6 @@ end:
     }
 }
 
-static void ctf_fs_trace_destroy(struct ctf_fs_trace *ctf_fs_trace)
-{
-    if (!ctf_fs_trace) {
-        return;
-    }
-
-    BT_TRACE_PUT_REF_AND_RESET(ctf_fs_trace->trace);
-
-    if (ctf_fs_trace->path) {
-        g_string_free(ctf_fs_trace->path, TRUE);
-    }
-
-    if (ctf_fs_trace->metadata) {
-        ctf_fs_metadata_fini(ctf_fs_trace->metadata);
-        delete ctf_fs_trace->metadata;
-    }
-
-    delete ctf_fs_trace;
-}
-
-void ctf_fs_trace_deleter::operator()(ctf_fs_trace * const trace) noexcept
-{
-    ctf_fs_trace_destroy(trace);
-}
-
 ctf_fs_component::UP ctf_fs_component_create(const bt2c::Logger& parentLogger)
 {
     return bt2s::make_unique<ctf_fs_component>(parentLogger);
@@ -322,7 +286,7 @@ bt2c::GCharUP ctf_fs_make_port_name(struct ctf_fs_ds_file_group *ds_file_group)
         bt_uuid_to_str(ds_file_group->ctf_fs_trace->metadata->tc->uuid, uuid_str);
         g_string_assign(name, uuid_str);
     } else {
-        g_string_assign(name, ds_file_group->ctf_fs_trace->path->str);
+        g_string_assign(name, ds_file_group->ctf_fs_trace->path.c_str());
     }
 
     /*
@@ -491,7 +455,7 @@ static int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, const
     int ret;
     ctf_fs_ds_file_info::UP ds_file_info;
     ctf_fs_ds_index::UP index;
-    struct ctf_msg_iter *msg_iter = NULL;
+    ctf_msg_iter_up msg_iter;
     struct ctf_stream_class *sc = NULL;
     struct ctf_msg_iter_packet_properties props;
 
@@ -507,18 +471,17 @@ static int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, const
 
     /* Create a temporary iterator to read the ds_file. */
     msg_iter = ctf_msg_iter_create(
-                   ctf_fs_trace->metadata->tc,
-                   bt_common_get_page_size(static_cast<int>(ctf_fs_trace->logger.level())) * 8,
-                   ctf_fs_ds_file_medops, ds_file.get(), nullptr, ctf_fs_trace->logger)
-                   .release();
+        ctf_fs_trace->metadata->tc,
+        bt_common_get_page_size(static_cast<int>(ctf_fs_trace->logger.level())) * 8,
+        ctf_fs_ds_file_medops, ds_file.get(), nullptr, ctf_fs_trace->logger);
     if (!msg_iter) {
         BT_CPPLOGE_STR_SPEC(ctf_fs_trace->logger, "Cannot create a CTF message iterator.");
         goto error;
     }
 
-    ctf_msg_iter_set_dry_run(msg_iter, true);
+    ctf_msg_iter_set_dry_run(msg_iter.get(), true);
 
-    ret = ctf_msg_iter_get_packet_properties(msg_iter, &props);
+    ret = ctf_msg_iter_get_packet_properties(msg_iter.get(), &props);
     if (ret) {
         BT_CPPLOGE_APPEND_CAUSE_SPEC(
             ctf_fs_trace->logger,
@@ -549,7 +512,7 @@ static int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, const
         goto error;
     }
 
-    index = ctf_fs_ds_file_build_index(ds_file.get(), ds_file_info.get(), msg_iter);
+    index = ctf_fs_ds_file_build_index(ds_file.get(), ds_file_info.get(), msg_iter.get());
     if (!index) {
         BT_CPPLOGE_APPEND_CAUSE_SPEC(ctf_fs_trace->logger, "Failed to index CTF stream file \'{}\'",
                                      ds_file->file->path);
@@ -617,10 +580,6 @@ error:
     ret = -1;
 
 end:
-    if (msg_iter) {
-        ctf_msg_iter_destroy(msg_iter);
-    }
-
     return ret;
 }
 
@@ -632,11 +591,11 @@ static int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace)
     GDir *dir = NULL;
 
     /* Check each file in the path directory, except specific ones */
-    dir = g_dir_open(ctf_fs_trace->path->str, 0, &error);
+    dir = g_dir_open(ctf_fs_trace->path.c_str(), 0, &error);
     if (!dir) {
         BT_CPPLOGE_APPEND_CAUSE_SPEC(ctf_fs_trace->logger,
-                                     "Cannot open directory `{}`: {} (code {})",
-                                     ctf_fs_trace->path->str, error->message, error->code);
+                                     "Cannot open directory `{}`: {} (code {})", ctf_fs_trace->path,
+                                     error->message, error->code);
         goto error;
     }
 
@@ -645,14 +604,14 @@ static int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace)
             /* Ignore the metadata stream. */
             BT_CPPLOGI_SPEC(ctf_fs_trace->logger,
                             "Ignoring metadata file `{}" G_DIR_SEPARATOR_S "{}`",
-                            ctf_fs_trace->path->str, basename);
+                            ctf_fs_trace->path, basename);
             continue;
         }
 
         if (basename[0] == '.') {
             BT_CPPLOGI_SPEC(ctf_fs_trace->logger,
-                            "Ignoring hidden file `{}" G_DIR_SEPARATOR_S "{}`",
-                            ctf_fs_trace->path->str, basename);
+                            "Ignoring hidden file `{}" G_DIR_SEPARATOR_S "{}`", ctf_fs_trace->path,
+                            basename);
             continue;
         }
 
@@ -662,12 +621,12 @@ static int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace)
             BT_CPPLOGE_APPEND_CAUSE_SPEC(
                 ctf_fs_trace->logger,
                 "Cannot create stream file object for file `{}" G_DIR_SEPARATOR_S "{}`",
-                ctf_fs_trace->path->str, basename);
+                ctf_fs_trace->path, basename);
             goto error;
         }
 
         /* Create full path string. */
-        file->path = fmt::format("{}" G_DIR_SEPARATOR_S "{}", ctf_fs_trace->path->str, basename);
+        file->path = fmt::format("{}" G_DIR_SEPARATOR_S "{}", ctf_fs_trace->path, basename);
 
         if (!g_file_test(file->path.c_str(), G_FILE_TEST_IS_REGULAR)) {
             BT_CPPLOGI_SPEC(ctf_fs_trace->logger, "Ignoring non-regular file `{}`", file->path);
@@ -765,15 +724,10 @@ static ctf_fs_trace::UP ctf_fs_trace_create(const char *path, const char *name,
                                             const bt2c::Logger& parentLogger)
 {
     int ret;
-
     ctf_fs_trace::UP ctf_fs_trace {new struct ctf_fs_trace(parentLogger)};
-    ctf_fs_trace->path = g_string_new(path);
-    if (!ctf_fs_trace->path) {
-        goto error;
-    }
 
-    ctf_fs_trace->metadata = new ctf_fs_metadata;
-    ctf_fs_metadata_init(ctf_fs_trace->metadata);
+    ctf_fs_trace->path = path;
+    ctf_fs_trace->metadata = bt2s::make_unique<ctf_fs_metadata>();
 
     ret = ctf_fs_metadata_set_trace_class(selfComp, ctf_fs_trace.get(), clkClsCfg);
     if (ret) {
@@ -781,19 +735,22 @@ static ctf_fs_trace::UP ctf_fs_trace_create(const char *path, const char *name,
     }
 
     if (ctf_fs_trace->metadata->trace_class) {
-        ctf_fs_trace->trace = bt_trace_create(ctf_fs_trace->metadata->trace_class);
-        if (!ctf_fs_trace->trace) {
+        bt_trace *trace = bt_trace_create(ctf_fs_trace->metadata->trace_class->libObjPtr());
+        if (!trace) {
             goto error;
         }
+
+        ctf_fs_trace->trace = bt2::Trace::Shared::createWithoutRef(trace);
     }
 
     if (ctf_fs_trace->trace) {
-        ret = ctf_trace_class_configure_ir_trace(ctf_fs_trace->metadata->tc, ctf_fs_trace->trace);
+        ret = ctf_trace_class_configure_ir_trace(ctf_fs_trace->metadata->tc,
+                                                 ctf_fs_trace->trace->libObjPtr());
         if (ret) {
             goto error;
         }
 
-        ret = set_trace_name(ctf_fs_trace->trace, name, ctf_fs_trace->logger);
+        ret = set_trace_name(ctf_fs_trace->trace->libObjPtr(), name, ctf_fs_trace->logger);
         if (ret) {
             goto error;
         }
@@ -1094,7 +1051,7 @@ static int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace,
                                              int64_t *ts_ns)
 {
     enum ctf_msg_iter_status iter_status = CTF_MSG_ITER_STATUS_OK;
-    struct ctf_msg_iter *msg_iter = NULL;
+    ctf_msg_iter_up msg_iter;
     int ret = 0;
 
     BT_ASSERT(ctf_fs_trace);
@@ -1113,10 +1070,9 @@ static int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace,
     BT_ASSERT(ctf_fs_trace->metadata->tc);
 
     msg_iter = ctf_msg_iter_create(
-                   ctf_fs_trace->metadata->tc,
-                   bt_common_get_page_size(static_cast<int>(ctf_fs_trace->logger.level())) * 8,
-                   ctf_fs_ds_file_medops, ds_file.get(), NULL, ctf_fs_trace->logger)
-                   .release();
+        ctf_fs_trace->metadata->tc,
+        bt_common_get_page_size(static_cast<int>(ctf_fs_trace->logger.level())) * 8,
+        ctf_fs_ds_file_medops, ds_file.get(), NULL, ctf_fs_trace->logger);
     if (!msg_iter) {
         /* ctf_msg_iter_create() logs errors. */
         ret = -1;
@@ -1127,10 +1083,10 @@ static int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace,
      * Turn on dry run mode to prevent the creation and usage of Babeltrace
      * library objects (bt_field, bt_message_*, etc.).
      */
-    ctf_msg_iter_set_dry_run(msg_iter, true);
+    ctf_msg_iter_set_dry_run(msg_iter.get(), true);
 
     /* Seek to the beginning of the target packet. */
-    iter_status = ctf_msg_iter_seek(msg_iter, index_entry->offset.bytes());
+    iter_status = ctf_msg_iter_seek(msg_iter.get(), index_entry->offset.bytes());
     if (iter_status) {
         /* ctf_msg_iter_seek() logs errors. */
         ret = -1;
@@ -1144,11 +1100,11 @@ static int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace,
          * the first event. To extract the first event's clock
          * snapshot.
          */
-        iter_status = ctf_msg_iter_curr_packet_first_event_clock_snapshot(msg_iter, cs);
+        iter_status = ctf_msg_iter_curr_packet_first_event_clock_snapshot(msg_iter.get(), cs);
         break;
     case LAST_EVENT:
         /* Decode the packet to extract the last event's clock snapshot. */
-        iter_status = ctf_msg_iter_curr_packet_last_event_clock_snapshot(msg_iter, cs);
+        iter_status = ctf_msg_iter_curr_packet_last_event_clock_snapshot(msg_iter.get(), cs);
         break;
     default:
         bt_common_abort();
@@ -1168,10 +1124,6 @@ static int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace,
     }
 
 end:
-    if (msg_iter) {
-        ctf_msg_iter_destroy(msg_iter);
-    }
-
     return ret;
 }
 
@@ -1697,7 +1649,7 @@ int ctf_fs_component_create_ctf_fs_trace(struct ctf_fs_component *ctf_fs,
                 BT_CPPLOGE_APPEND_CAUSE_SPEC(
                     ctf_fs->logger,
                     "Multiple traces given, but a trace does not have a UUID: path={}",
-                    this_trace->path->str);
+                    this_trace->path);
                 goto error;
             }
 
@@ -1712,8 +1664,8 @@ int ctf_fs_component_create_ctf_fs_trace(struct ctf_fs_component *ctf_fs,
                                              "Multiple traces given, but UUIDs don't match: "
                                              "first-trace-uuid={}, first-trace-path={}, "
                                              "trace-uuid={}, trace-path={}",
-                                             first_trace_uuid_str, first_trace->path->str,
-                                             this_trace_uuid_str, this_trace->path->str);
+                                             first_trace_uuid_str, first_trace->path,
+                                             this_trace_uuid_str, this_trace->path);
                 goto error;
             }
         }
@@ -1804,13 +1756,15 @@ static int create_streams_for_trace(struct ctf_fs_trace *ctf_fs_trace)
 
         if (ds_file_group->stream_id == UINT64_C(-1)) {
             /* No stream ID: use 0 */
-            stream = bt_stream_create_with_id(ds_file_group->sc->ir_sc, ctf_fs_trace->trace,
-                                              ctf_fs_trace->next_stream_id);
+            stream =
+                bt_stream_create_with_id(ds_file_group->sc->ir_sc, ctf_fs_trace->trace->libObjPtr(),
+                                         ctf_fs_trace->next_stream_id);
             ctf_fs_trace->next_stream_id++;
         } else {
             /* Specific stream ID */
-            stream = bt_stream_create_with_id(ds_file_group->sc->ir_sc, ctf_fs_trace->trace,
-                                              (uint64_t) ds_file_group->stream_id);
+            stream =
+                bt_stream_create_with_id(ds_file_group->sc->ir_sc, ctf_fs_trace->trace->libObjPtr(),
+                                         (uint64_t) ds_file_group->stream_id);
         }
 
         if (!stream) {
This page took 0.029413 seconds and 4 git commands to generate.