From: Simon Marchi Date: Tue, 12 Dec 2023 15:44:58 +0000 (+0000) Subject: src.ctf.fs: modernize read_src_fs_parameters X-Git-Url: https://git.efficios.com/?p=babeltrace.git;a=commitdiff_plain;h=c5a5a936663910e45158fe5f898ef5bb14c21624 src.ctf.fs: modernize read_src_fs_parameters - Change the input parameter `params` to be bt2::ConstMapValue. - Changethe return type to be of a new structure type containing all processed parameters, rather than using output parameters and rather than setting the clkClsCfg inside the ctf_fs object directly. - Change the type of the parameters of ctf_fs_component_create_ctf_fs_trace and other helper functions accordingly. Change-Id: I2ba5aca22f907ffcfbdd19c8d8077e17d0c47a71 Signed-off-by: Simon Marchi Reviewed-on: https://review.lttng.org/c/babeltrace/+/8421 Reviewed-by: Philippe Proulx Reviewed-on: https://review.lttng.org/c/babeltrace/+/12356 Tested-by: jenkins --- diff --git a/src/plugins/ctf/fs-src/fs.cpp b/src/plugins/ctf/fs-src/fs.cpp index e186a776..b028893a 100644 --- a/src/plugins/ctf/fs-src/fs.cpp +++ b/src/plugins/ctf/fs-src/fs.cpp @@ -1360,25 +1360,20 @@ static bool compare_ds_file_groups_by_first_path(const ctf_fs_ds_file_group::UP& } int ctf_fs_component_create_ctf_fs_trace(struct ctf_fs_component *ctf_fs, - const bt_value *paths_value, - const bt_value *trace_name_value, - bt_self_component *selfComp) + const bt2::ConstArrayValue pathsValue, + const char *traceName, bt_self_component *selfComp) { std::vector paths; - BT_ASSERT(bt_value_get_type(paths_value) == BT_VALUE_TYPE_ARRAY); - BT_ASSERT(!bt_value_array_is_empty(paths_value)); - - const char *trace_name = trace_name_value ? bt_value_string_get(trace_name_value) : NULL; + BT_ASSERT(!pathsValue.isEmpty()); /* * Create a sorted array of the paths, to make the execution of this * component deterministic. */ - for (std::uint64_t i = 0; i < bt_value_array_get_length(paths_value); i++) { - const bt_value *path_value = bt_value_array_borrow_element_by_index_const(paths_value, i); - const char *input = bt_value_string_get(path_value); - paths.emplace_back(input); + for (const auto pathValue : pathsValue) { + BT_ASSERT(pathValue.isString()); + paths.emplace_back(pathValue.asString().value().str()); } std::sort(paths.begin(), paths.end()); @@ -1386,7 +1381,7 @@ int ctf_fs_component_create_ctf_fs_trace(struct ctf_fs_component *ctf_fs, /* Create a separate ctf_fs_trace object for each path. */ std::vector traces; for (const auto& path : paths) { - int ret = ctf_fs_component_create_ctf_fs_trace_one_path(ctf_fs, path.c_str(), trace_name, + int ret = ctf_fs_component_create_ctf_fs_trace_one_path(ctf_fs, path.c_str(), traceName, traces, selfComp); if (ret) { return ret; @@ -1541,61 +1536,57 @@ static bt_param_validation_map_value_entry_descr fs_params_entries_descr[] = { bt_param_validation_value_descr::makeBool()}, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_END}; -bool read_src_fs_parameters(const bt_value *params, const bt_value **inputs, - const bt_value **trace_name, struct ctf_fs_component *ctf_fs) +ctf::src::fs::Parameters read_src_fs_parameters(const bt2::ConstMapValue params, + const bt2c::Logger& logger) { gchar *error = NULL; bt_param_validation_status validate_value_status = - bt_param_validation_validate(params, fs_params_entries_descr, &error); + bt_param_validation_validate(params.libObjPtr(), fs_params_entries_descr, &error); + if (validate_value_status != BT_PARAM_VALIDATION_STATUS_OK) { - BT_CPPLOGE_APPEND_CAUSE_SPEC(ctf_fs->logger, "{}", error); - g_free(error); - return false; + bt2c::GCharUP errorFreer {error}; + BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2c::Error, "{}", error); } - /* inputs parameter */ - *inputs = bt_value_map_borrow_entry_value_const(params, "inputs"); + ctf::src::fs::Parameters parameters {params["inputs"]->asArray()}; /* clock-class-offset-s parameter */ - const bt_value *value = bt_value_map_borrow_entry_value_const(params, "clock-class-offset-s"); - if (value) { - ctf_fs->clkClsCfg.offsetSec = bt_value_integer_signed_get(value); + if (const auto clockClassOffsetS = params["clock-class-offset-s"]) { + parameters.clkClsCfg.offsetSec = clockClassOffsetS->asSignedInteger().value(); } /* clock-class-offset-ns parameter */ - value = bt_value_map_borrow_entry_value_const(params, "clock-class-offset-ns"); - if (value) { - ctf_fs->clkClsCfg.offsetNanoSec = bt_value_integer_signed_get(value); + if (const auto clockClassOffsetNs = params["clock-class-offset-ns"]) { + parameters.clkClsCfg.offsetNanoSec = clockClassOffsetNs->asSignedInteger().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->clkClsCfg.forceOriginIsUnixEpoch = bt_value_bool_get(value); + if (const auto forceClockClassOriginUnixEpoch = params["force-clock-class-origin-unix-epoch"]) { + parameters.clkClsCfg.forceOriginIsUnixEpoch = + forceClockClassOriginUnixEpoch->asBool().value(); } /* trace-name parameter */ - *trace_name = bt_value_map_borrow_entry_value_const(params, "trace-name"); + if (const auto traceName = params["trace-name"]) { + parameters.traceName = traceName->asString().value().str(); + } - return true; + return parameters; } -static ctf_fs_component::UP ctf_fs_create(const bt_value *params, +static ctf_fs_component::UP ctf_fs_create(const bt2::ConstMapValue params, bt_self_component_source *self_comp_src) { - 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_component::UP ctf_fs = bt2s::make_unique( bt2c::Logger {bt2::SelfSourceComponent {self_comp_src}, "PLUGIN/SRC.CTF.FS/COMP"}); + const auto parameters = read_src_fs_parameters(params, ctf_fs->logger); - if (!read_src_fs_parameters(params, &inputs_value, &trace_name_value, ctf_fs.get())) { - return nullptr; - } + ctf_fs->clkClsCfg = parameters.clkClsCfg; - if (ctf_fs_component_create_ctf_fs_trace(ctf_fs.get(), inputs_value, trace_name_value, - self_comp)) { + if (ctf_fs_component_create_ctf_fs_trace( + ctf_fs.get(), parameters.inputs, + parameters.traceName ? parameters.traceName->c_str() : nullptr, self_comp)) { return nullptr; } @@ -1618,7 +1609,7 @@ bt_component_class_initialize_method_status ctf_fs_init(bt_self_component_source bt_component_class_initialize_method_status ret = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK; - ctf_fs_component::UP ctf_fs = ctf_fs_create(params, self_comp_src); + ctf_fs_component::UP ctf_fs = ctf_fs_create(bt2::ConstMapValue {params}, self_comp_src); if (!ctf_fs) { ret = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR; } diff --git a/src/plugins/ctf/fs-src/fs.hpp b/src/plugins/ctf/fs-src/fs.hpp index 6acbfc51..9add53da 100644 --- a/src/plugins/ctf/fs-src/fs.hpp +++ b/src/plugins/ctf/fs-src/fs.hpp @@ -158,27 +158,38 @@ ctf_fs_iterator_seek_beginning(bt_self_message_iterator *message_iterator); */ int ctf_fs_component_create_ctf_fs_trace(struct ctf_fs_component *ctf_fs, - const bt_value *paths_value, - const bt_value *trace_name_value, + bt2::ConstArrayValue pathsValue, const char *traceName, bt_self_component *selfComp); +namespace ctf { +namespace src { +namespace fs { + +/* `src.ctf.fs` parameters */ + +struct Parameters +{ + explicit Parameters(const bt2::ConstArrayValue inputsParam) noexcept : inputs {inputsParam} + { + } + + bt2::ConstArrayValue inputs; + bt2s::optional traceName; + ClkClsCfg clkClsCfg; +}; + +} /* namespace fs */ +} /* namespace src */ +} /* namespace ctf */ + /* * Read and validate parameters taken by the src.ctf.fs plugin. * - * - The mandatory `paths` parameter is returned in `*paths`. - * - The optional `clock-class-offset-s` and `clock-class-offset-ns`, if - * present, are recorded in the `ctf_fs` structure. - * - The optional `trace-name` parameter is returned in `*trace_name` if - * present, else `*trace_name` is set to NULL. - * - * `self_comp` and `self_comp_class` are used for logging, only one of them - * should be set. - * - * Return true on success, false if any parameter didn't pass validation. + * Throw if any parameter doesn't pass validation. */ -bool read_src_fs_parameters(const bt_value *params, const bt_value **paths, - const bt_value **trace_name, struct ctf_fs_component *ctf_fs); +ctf::src::fs::Parameters read_src_fs_parameters(bt2::ConstMapValue params, + const bt2c::Logger& logger); /* * Generate the port name to be used for a given data stream file group. diff --git a/src/plugins/ctf/fs-src/query.cpp b/src/plugins/ctf/fs-src/query.cpp index 729dc5ac..a7225dda 100644 --- a/src/plugins/ctf/fs-src/query.cpp +++ b/src/plugins/ctf/fs-src/query.cpp @@ -168,14 +168,13 @@ static void populate_trace_info(const struct ctf_fs_trace *trace, const bt2::Map bt2::Value::Shared trace_infos_query(const bt2::ConstMapValue params, const bt2c::Logger& logger) { ctf_fs_component ctf_fs {logger}; - const bt_value *inputs_value = NULL; - const bt_value *trace_name_value; + const auto parameters = read_src_fs_parameters(params, logger); - if (!read_src_fs_parameters(params.libObjPtr(), &inputs_value, &trace_name_value, &ctf_fs)) { - BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error, "Failed to read parameters"); - } + ctf_fs.clkClsCfg = parameters.clkClsCfg; - if (ctf_fs_component_create_ctf_fs_trace(&ctf_fs, inputs_value, trace_name_value, NULL)) { + if (ctf_fs_component_create_ctf_fs_trace( + &ctf_fs, parameters.inputs, + parameters.traceName ? parameters.traceName->c_str() : nullptr, nullptr)) { BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error, "Failed to create trace"); }