#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"
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) {
/*
goto end;
}
- stream = ds_file->stream;
+ stream = ds_file->stream->libObjPtr();
end:
return stream;
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;
}
* 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) {
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;
.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;
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;
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;
goto error;
}
- index = ctf_fs_ds_index_create(ds_file->logger);
+ index = ctf_fs_ds_index_create();
if (!index) {
goto error;
}
}
/* 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);
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. */
}
return index;
error:
- ctf_fs_ds_index_destroy(index);
- ctf_fs_ds_index_entry_destroy(index_entry);
- index = NULL;
+ index.reset();
goto 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;
}
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.");
}
/* 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,
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;
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");
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;
}
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)
return;
}
- bt_stream_put_ref(ds_file->stream);
(void) ds_file_munmap(ds_file);
if (ds_file->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;
}
projects / babeltrace.git / blobdiff