delete ctf_fs_trace;
}
+void ctf_fs_trace_deleter::operator()(ctf_fs_trace * const trace) noexcept
+{
+ ctf_fs_trace_destroy(trace);
+}
+
void ctf_fs_destroy(struct ctf_fs_component *ctf_fs)
{
if (!ctf_fs) {
return;
}
- ctf_fs_trace_destroy(ctf_fs->trace);
-
if (ctf_fs->port_data) {
g_ptr_array_free(ctf_fs->port_data, TRUE);
}
delete ctf_fs;
}
+void ctf_fs_component_deleter::operator()(ctf_fs_component *comp)
+{
+ ctf_fs_destroy(comp);
+}
+
static void port_data_destroy(struct ctf_fs_port_data *port_data)
{
if (!port_data) {
ctf_fs_trace_destroy(trace);
}
-ctf_fs_component *ctf_fs_component_create(const bt2c::Logger& parentLogger)
+ctf_fs_component::UP ctf_fs_component_create(const bt2c::Logger& parentLogger)
{
- ctf_fs_component *ctf_fs = new ctf_fs_component {parentLogger};
+ ctf_fs_component::UP ctf_fs {new ctf_fs_component {parentLogger}};
+
ctf_fs->port_data = g_ptr_array_new_with_free_func(port_data_destroy_notifier);
if (!ctf_fs->port_data) {
goto error;
goto end;
error:
- ctf_fs_destroy(ctf_fs);
- ctf_fs = NULL;
+ ctf_fs.reset();
end:
return ctf_fs;
bt_self_component_source_as_self_component(component)));
}
-gchar *ctf_fs_make_port_name(struct ctf_fs_ds_file_group *ds_file_group)
+bt2c::GCharUP ctf_fs_make_port_name(struct ctf_fs_ds_file_group *ds_file_group)
{
GString *name = g_string_new(NULL);
g_string_append_printf(name, " | %s", ds_file_info->path->str);
}
- return g_string_free(name, FALSE);
+ return bt2c::GCharUP {g_string_free(name, FALSE)};
}
static int create_one_port_for_trace(struct ctf_fs_component *ctf_fs,
{
int ret = 0;
struct ctf_fs_port_data *port_data = NULL;
- gchar *port_name;
- port_name = ctf_fs_make_port_name(ds_file_group);
+ bt2c::GCharUP port_name = ctf_fs_make_port_name(ds_file_group);
if (!port_name) {
goto error;
}
- BT_CPPLOGI_SPEC(ctf_fs->logger, "Creating one port named `{}`", port_name);
+ BT_CPPLOGI_SPEC(ctf_fs->logger, "Creating one port named `{}`", port_name.get());
/* Create output port for this file */
port_data = new ctf_fs_port_data;
port_data->ctf_fs = ctf_fs;
port_data->ds_file_group = ds_file_group;
- ret = bt_self_component_source_add_output_port(self_comp_src, port_name, port_data, NULL);
+ ret = bt_self_component_source_add_output_port(self_comp_src, port_name.get(), port_data, NULL);
if (ret) {
goto error;
}
ret = -1;
end:
- g_free(port_name);
-
port_data_destroy(port_data);
return ret;
}
static bool ds_index_entries_equal(const struct ctf_fs_ds_index_entry *left,
const struct ctf_fs_ds_index_entry *right)
{
- if (left->packet_size != right->packet_size) {
+ if (left->packetSize != right->packetSize) {
return false;
}
}
static struct ctf_fs_trace *ctf_fs_trace_create(const char *path, const char *name,
- struct ctf_fs_metadata_config *metadata_config,
+ const ctf::src::ClkClsCfg& clkClsCfg,
bt_self_component *selfComp,
const bt2c::Logger& parentLogger)
{
goto error;
}
- ret = ctf_fs_metadata_set_trace_class(selfComp, ctf_fs_trace, metadata_config);
+ ret = ctf_fs_metadata_set_trace_class(selfComp, ctf_fs_trace, clkClsCfg);
if (ret) {
goto error;
}
goto end;
}
- ctf_fs_trace = ctf_fs_trace_create(norm_path->str, trace_name, &ctf_fs->metadata_config,
- selfComp, ctf_fs->logger);
+ ctf_fs_trace = ctf_fs_trace_create(norm_path->str, trace_name, ctf_fs->clkClsCfg, selfComp,
+ ctf_fs->logger);
if (!ctf_fs_trace) {
BT_CPPLOGE_APPEND_CAUSE_SPEC(ctf_fs->logger, "Cannot create trace for `{}`.",
norm_path->str);
ctf_msg_iter_set_dry_run(msg_iter, true);
/* Seek to the beginning of the target packet. */
- iter_status = ctf_msg_iter_seek(msg_iter, index_entry->offset);
+ iter_status = ctf_msg_iter_seek(msg_iter, index_entry->offset.bytes());
if (iter_status) {
/* ctf_msg_iter_seek() logs errors. */
ret = -1;
goto error;
}
- ctf_fs->trace = trace;
+ ctf_fs->trace.reset(trace);
} else {
/* Just one trace, it may or may not have a UUID, both are fine. */
- ctf_fs->trace = (ctf_fs_trace *) traces->pdata[0];
+ ctf_fs->trace.reset((ctf_fs_trace *) traces->pdata[0]);
traces->pdata[0] = NULL;
}
- ret = fix_packet_index_tracer_bugs(ctf_fs->trace);
+ ret = fix_packet_index_tracer_bugs(ctf_fs->trace.get());
if (ret) {
BT_CPPLOGE_APPEND_CAUSE_SPEC(ctf_fs->logger, "Failed to fix packet index tracer bugs.");
}
goto error;
}
- if (ds_file_group->sc->ir_sc) {
- BT_ASSERT(ctf_fs_trace->trace);
-
- if (ds_file_group->stream_id == UINT64_C(-1)) {
- /* No stream ID: use 0 */
- ds_file_group->stream = bt_stream_create_with_id(
- ds_file_group->sc->ir_sc, ctf_fs_trace->trace, ctf_fs_trace->next_stream_id);
- ctf_fs_trace->next_stream_id++;
- } else {
- /* Specific stream ID */
- ds_file_group->stream =
- bt_stream_create_with_id(ds_file_group->sc->ir_sc, ctf_fs_trace->trace,
- (uint64_t) ds_file_group->stream_id);
- }
+ BT_ASSERT(ds_file_group->sc->ir_sc);
+ BT_ASSERT(ctf_fs_trace->trace);
+
+ if (ds_file_group->stream_id == UINT64_C(-1)) {
+ /* No stream ID: use 0 */
+ ds_file_group->stream = bt_stream_create_with_id(
+ ds_file_group->sc->ir_sc, ctf_fs_trace->trace, ctf_fs_trace->next_stream_id);
+ ctf_fs_trace->next_stream_id++;
} else {
- ds_file_group->stream = NULL;
+ /* Specific stream ID */
+ ds_file_group->stream = bt_stream_create_with_id(
+ ds_file_group->sc->ir_sc, ctf_fs_trace->trace, (uint64_t) ds_file_group->stream_id);
}
if (!ds_file_group->stream) {
/* clock-class-offset-s parameter */
value = bt_value_map_borrow_entry_value_const(params, "clock-class-offset-s");
if (value) {
- ctf_fs->metadata_config.clock_class_offset_s = bt_value_integer_signed_get(value);
+ ctf_fs->clkClsCfg.offsetSec = bt_value_integer_signed_get(value);
}
/* clock-class-offset-ns parameter */
value = bt_value_map_borrow_entry_value_const(params, "clock-class-offset-ns");
if (value) {
- ctf_fs->metadata_config.clock_class_offset_ns = bt_value_integer_signed_get(value);
+ ctf_fs->clkClsCfg.offsetNanoSec = bt_value_integer_signed_get(value);
}
/* force-clock-class-origin-unix-epoch parameter */
value = bt_value_map_borrow_entry_value_const(params, "force-clock-class-origin-unix-epoch");
if (value) {
- ctf_fs->metadata_config.force_clock_class_origin_unix_epoch = bt_value_bool_get(value);
+ ctf_fs->clkClsCfg.forceOriginIsUnixEpoch = bt_value_bool_get(value);
}
/* trace-name parameter */
return ret;
}
-static struct ctf_fs_component *ctf_fs_create(const bt_value *params,
- bt_self_component_source *self_comp_src)
+static ctf_fs_component::UP ctf_fs_create(const bt_value *params,
+ bt_self_component_source *self_comp_src)
{
- struct ctf_fs_component *ctf_fs = NULL;
const bt_value *inputs_value;
const bt_value *trace_name_value;
bt_self_component *self_comp = bt_self_component_source_as_self_component(self_comp_src);
- ctf_fs = ctf_fs_component_create(
+ ctf_fs_component::UP ctf_fs = ctf_fs_component_create(
bt2c::Logger {bt2::SelfSourceComponent {self_comp_src}, "PLUGIN/SRC.CTF.FS/COMP"});
if (!ctf_fs) {
- goto error;
+ return nullptr;
}
- if (!read_src_fs_parameters(params, &inputs_value, &trace_name_value, ctf_fs)) {
- goto error;
+ if (!read_src_fs_parameters(params, &inputs_value, &trace_name_value, ctf_fs.get())) {
+ return nullptr;
}
- bt_self_component_set_data(self_comp, ctf_fs);
-
- if (ctf_fs_component_create_ctf_fs_trace(ctf_fs, inputs_value, trace_name_value, self_comp)) {
- goto error;
+ if (ctf_fs_component_create_ctf_fs_trace(ctf_fs.get(), inputs_value, trace_name_value,
+ self_comp)) {
+ return nullptr;
}
- if (create_streams_for_trace(ctf_fs->trace)) {
- goto error;
+ if (create_streams_for_trace(ctf_fs->trace.get())) {
+ return nullptr;
}
- if (create_ports_for_trace(ctf_fs, ctf_fs->trace, self_comp_src)) {
- goto error;
+ if (create_ports_for_trace(ctf_fs.get(), ctf_fs->trace.get(), self_comp_src)) {
+ return nullptr;
}
- goto end;
-
-error:
- ctf_fs_destroy(ctf_fs);
- ctf_fs = NULL;
- bt_self_component_set_data(self_comp, NULL);
-
-end:
return ctf_fs;
}
const bt_value *params, void *)
{
try {
- struct ctf_fs_component *ctf_fs;
bt_component_class_initialize_method_status ret =
BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
- ctf_fs = ctf_fs_create(params, self_comp_src);
+ ctf_fs_component::UP ctf_fs = ctf_fs_create(params, self_comp_src);
if (!ctf_fs) {
ret = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
}
+ bt_self_component_set_data(bt_self_component_source_as_self_component(self_comp_src),
+ ctf_fs.release());
return ret;
} catch (const std::bad_alloc&) {
return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
const bt_value **result)
{
try {
- bt_component_class_query_method_status status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
bt2c::Logger logger {bt2::SelfComponentClass {comp_class_src},
bt2::PrivateQueryExecutor {priv_query_exec},
"PLUGIN/SRC.CTF.FS/QUERY"};
+ bt2::ConstMapValue paramsObj(params);
+ bt2::Value::Shared resultObj;
if (strcmp(object, "metadata-info") == 0) {
- status = metadata_info_query(params, logger, result);
+ resultObj = metadata_info_query(paramsObj, logger);
} else if (strcmp(object, "babeltrace.trace-infos") == 0) {
- status = trace_infos_query(params, logger, result);
+ resultObj = trace_infos_query(paramsObj, logger);
} else if (!strcmp(object, "babeltrace.support-info")) {
- status = support_info_query(params, logger, result);
+ resultObj = support_info_query(paramsObj, logger);
} else {
BT_CPPLOGE_SPEC(logger, "Unknown query object `{}`", object);
- status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_UNKNOWN_OBJECT;
- goto end;
+ return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_UNKNOWN_OBJECT;
}
-end:
- return status;
+
+ *result = resultObj.release().libObjPtr();
+
+ return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
} catch (const std::bad_alloc&) {
return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
} catch (const bt2::Error&) {
projects / babeltrace.git / blobdiff