niklas/rcl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Support parameter overrides and remap rules flags on command line (#483)

Browse source 
* Support rcl_params_t copies.

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>

* Parse parameter overrides from command line.

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>

* Parameter overrides' tests passing.

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>

* Test rcl_yaml_node_struct_copy() function

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>

* Export rcl_yaml_param_parser as rcl dependency.

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>

* Zero initialize parameter overrides before rcl arguments copy.

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>

* Initialize local variables early enough.

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>

* Simplify rcl package.xml

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>

* Assert arguments sanity in rcl args parsing internal functions.

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>

* Extend rcl_yaml_param_parser tests to all parameter types.

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>

* Address peer review comments.

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>

* Support --remap/-r flags.

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>

* Please cpplint

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>
This commit is contained in:
Michel Hidalgo 2019-08-26 13:32:16 -03:00 • committed by GitHub
parent d07003847b
commit 6f989433bc
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 838 additions and 201 deletions
Download patch file Download diff file Expand all files Collapse all files

7
rcl_yaml_param_parser/include/rcl_yaml_param_parser/parser.h
View file

@ -32,6 +32,13 @@ RCL_YAML_PARAM_PARSER_PUBLIC
rcl_params_t * rcl_yaml_node_struct_init(
const rcutils_allocator_t allocator);
/// \brief Copy parameter structure
/// \param[in] params_st points to the parameter struct to be copied
/// \return a pointer to the copied param structure on success or NULL on failure
RCL_YAML_PARAM_PARSER_PUBLIC
rcl_params_t * rcl_yaml_node_struct_copy(
const rcl_params_t * params_st);
/// \brief Free parameter structure
/// \param[in] params_st points to the populated parameter struct
RCL_YAML_PARAM_PARSER_PUBLIC

184
rcl_yaml_param_parser/src/parser.c
View file

@ -393,6 +393,186 @@ rcl_params_t * rcl_yaml_node_struct_init(
return params_st;
}
///
/// Copy the rcl_params_t parameter structure
///
rcl_params_t * rcl_yaml_node_struct_copy(
const rcl_params_t * params_st)
{
RCUTILS_CHECK_ARGUMENT_FOR_NULL(params_st, NULL);
rcutils_allocator_t allocator = params_st->allocator;
rcl_params_t * out_params_st = rcl_yaml_node_struct_init(allocator);
if (NULL == out_params_st) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
return NULL;
}
rcutils_ret_t ret;
for (size_t node_idx = 0U; node_idx < params_st->num_nodes; ++node_idx) {
out_params_st->node_names[node_idx] =
rcutils_strdup(params_st->node_names[node_idx], allocator);
if (NULL == out_params_st->node_names[node_idx]) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
out_params_st->num_nodes++;
rcl_node_params_t * node_params_st = &(params_st->params[node_idx]);
rcl_node_params_t * out_node_params_st = &(out_params_st->params[node_idx]);
ret = node_params_init(out_node_params_st, allocator);
if (RCUTILS_RET_OK != ret) {
if (RCUTILS_RET_BAD_ALLOC == ret) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
}
goto fail;
}
for (size_t parameter_idx = 0U; parameter_idx < node_params_st->num_params; ++parameter_idx) {
out_node_params_st->parameter_names[parameter_idx] =
rcutils_strdup(node_params_st->parameter_names[parameter_idx], allocator);
if (NULL == out_node_params_st->parameter_names[parameter_idx]) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
out_node_params_st->num_params++;
rcl_variant_t * param_var = &(node_params_st->parameter_values[parameter_idx]);
rcl_variant_t * out_param_var = &(out_node_params_st->parameter_values[parameter_idx]);
if (NULL != param_var->bool_value) {
out_param_var->bool_value = allocator.allocate(sizeof(bool), allocator.state);
if (NULL == out_param_var->bool_value) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
*(out_param_var->bool_value) = *(param_var->bool_value);
} else if (NULL != param_var->integer_value) {
out_param_var->integer_value = allocator.allocate(sizeof(int64_t), allocator.state);
if (NULL == out_param_var->integer_value) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
*(out_param_var->integer_value) = *(param_var->integer_value);
} else if (NULL != param_var->double_value) {
out_param_var->double_value = allocator.allocate(sizeof(double), allocator.state);
if (NULL == out_param_var->double_value) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
*(out_param_var->double_value) = *(param_var->double_value);
} else if (NULL != param_var->string_value) {
out_param_var->string_value =
rcutils_strdup(param_var->string_value, allocator);
if (NULL == out_param_var->string_value) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
} else if (NULL != param_var->bool_array_value) {
out_param_var->bool_array_value =
allocator.allocate(sizeof(rcl_bool_array_t), allocator.state);
if (NULL == out_param_var->bool_array_value) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
if (0U != param_var->bool_array_value->size) {
out_param_var->bool_array_value->values = allocator.allocate(
sizeof(bool) * param_var->bool_array_value->size, allocator.state);
if (NULL == out_param_var->bool_array_value->values) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
memcpy(
out_param_var->bool_array_value->values,
param_var->bool_array_value->values,
sizeof(bool) * param_var->bool_array_value->size);
} else {
out_param_var->bool_array_value->values = NULL;
}
out_param_var->bool_array_value->size = param_var->bool_array_value->size;
} else if (NULL != param_var->integer_array_value) {
out_param_var->integer_array_value =
allocator.allocate(sizeof(rcl_int64_array_t), allocator.state);
if (NULL == out_param_var->integer_array_value) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
if (0U != param_var->integer_array_value->size) {
out_param_var->integer_array_value->values = allocator.allocate(
sizeof(int64_t) * param_var->integer_array_value->size, allocator.state);
if (NULL == out_param_var->integer_array_value->values) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
memcpy(
out_param_var->integer_array_value->values,
param_var->integer_array_value->values,
sizeof(int64_t) * param_var->integer_array_value->size);
} else {
out_param_var->integer_array_value->values = NULL;
}
out_param_var->integer_array_value->size = param_var->integer_array_value->size;
} else if (NULL != param_var->double_array_value) {
out_param_var->double_array_value =
allocator.allocate(sizeof(rcl_double_array_t), allocator.state);
if (NULL == out_param_var->double_array_value) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
if (0U != param_var->double_array_value->size) {
out_param_var->double_array_value->values = allocator.allocate(
sizeof(double) * param_var->double_array_value->size, allocator.state);
if (NULL == out_param_var->double_array_value->values) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
memcpy(
out_param_var->double_array_value->values,
param_var->double_array_value->values,
sizeof(double) * param_var->double_array_value->size);
} else {
out_param_var->double_array_value->values = NULL;
}
out_param_var->double_array_value->size = param_var->double_array_value->size;
} else if (NULL != param_var->string_array_value) {
out_param_var->string_array_value =
allocator.allocate(sizeof(rcutils_string_array_t), allocator.state);
if (NULL == param_var->string_array_value) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
*(out_param_var->string_array_value) = rcutils_get_zero_initialized_string_array();
ret = rcutils_string_array_init(
out_param_var->string_array_value,
param_var->string_array_value->size,
&(param_var->string_array_value->allocator));
if (RCUTILS_RET_OK != ret) {
if (RCUTILS_RET_BAD_ALLOC == ret) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
}
goto fail;
}
for (size_t str_idx = 0U; str_idx < param_var->string_array_value->size; ++str_idx) {
out_param_var->string_array_value->data[str_idx] = rcutils_strdup(
param_var->string_array_value->data[str_idx],
out_param_var->string_array_value->allocator);
if (NULL == out_param_var->string_array_value->data[str_idx]) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Error allocating mem");
goto fail;
}
}
} else {
/// Nothing to do to keep pclint happy
}
}
}
return out_params_st;
fail:
rcl_yaml_node_struct_fini(out_params_st);
return NULL;
}
///
/// Free param structure
/// NOTE: If there is an error, would recommend just to safely exit the process instead
@ -1574,6 +1754,10 @@ bool rcl_parse_yaml_value(
RCUTILS_CHECK_ARGUMENT_FOR_NULL(param_name, false);
RCUTILS_CHECK_ARGUMENT_FOR_NULL(yaml_value, false);
if (0U == strlen(node_name) || 0U == strlen(param_name) || 0U == strlen(yaml_value)) {
return false;
}
if (NULL == params_st) {
RCUTILS_SAFE_FWRITE_TO_STDERR("Pass an initialized parameter structure");
return false;

139
rcl_yaml_param_parser/test/test_parse_yaml.cpp
View file

@ -48,47 +48,112 @@ TEST(test_parser, correct_syntax) {
bool res = rcl_parse_yaml_file(path, params_hdl);
ASSERT_TRUE(res) << rcutils_get_error_string().str;
rcl_variant_t * param_value = rcl_yaml_node_struct_get("lidar_ns/lidar_1", "ports", params_hdl);
ASSERT_TRUE(NULL != param_value) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->integer_array_value);
ASSERT_EQ(3U, param_value->integer_array_value->size);
EXPECT_EQ(2438, param_value->integer_array_value->values[0]);
EXPECT_EQ(2439, param_value->integer_array_value->values[1]);
EXPECT_EQ(2440, param_value->integer_array_value->values[2]);
res = rcl_parse_yaml_value("lidar_ns/lidar_1", "ports", "[8080]", params_hdl);
EXPECT_TRUE(res) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->integer_array_value);
ASSERT_EQ(1U, param_value->integer_array_value->size);
EXPECT_EQ(8080, param_value->integer_array_value->values[0]);
rcl_params_t * copy_of_params_hdl = rcl_yaml_node_struct_copy(params_hdl);
ASSERT_TRUE(NULL != copy_of_params_hdl) << rcutils_get_error_string().str;
OSRF_TESTING_TOOLS_CPP_SCOPE_EXIT({
rcl_yaml_node_struct_fini(copy_of_params_hdl);
});
param_value = rcl_yaml_node_struct_get("lidar_ns/lidar_2", "is_back", params_hdl);
ASSERT_TRUE(NULL != param_value) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->bool_value);
EXPECT_FALSE(*param_value->bool_value);
res = rcl_parse_yaml_value("lidar_ns/lidar_2", "is_back", "true", params_hdl);
EXPECT_TRUE(res) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->bool_value);
EXPECT_TRUE(*param_value->bool_value);
rcl_params_t * params_hdl_set[] = {params_hdl, copy_of_params_hdl};
for (rcl_params_t * params : params_hdl_set) {
rcl_variant_t * param_value = rcl_yaml_node_struct_get("lidar_ns/lidar_2", "is_back", params);
ASSERT_TRUE(NULL != param_value) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->bool_value);
EXPECT_FALSE(*param_value->bool_value);
res = rcl_parse_yaml_value("lidar_ns/lidar_2", "is_back", "true", params);
EXPECT_TRUE(res) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->bool_value);
EXPECT_TRUE(*param_value->bool_value);
param_value = rcl_yaml_node_struct_get("camera", "cam_spec.angle", params_hdl);
ASSERT_TRUE(NULL != param_value) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->double_value);
EXPECT_DOUBLE_EQ(2.34, *param_value->double_value);
res = rcl_parse_yaml_value("camera", "cam_spec.angle", "2.2", params_hdl);
EXPECT_TRUE(res) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->double_value);
EXPECT_DOUBLE_EQ(2.2, *param_value->double_value);
param_value = rcl_yaml_node_struct_get("lidar_ns/lidar_2", "id", params);
ASSERT_TRUE(NULL != param_value) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->integer_value);
EXPECT_EQ(11, *param_value->integer_value);
res = rcl_parse_yaml_value("lidar_ns/lidar_2", "id", "12", params);
EXPECT_TRUE(res) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->integer_value);
EXPECT_EQ(12, *param_value->integer_value);
param_value = rcl_yaml_node_struct_get("intel", "arch", params_hdl);
ASSERT_TRUE(NULL != param_value) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->string_value);
EXPECT_STREQ("x86_64", param_value->string_value);
res = rcl_parse_yaml_value("intel", "arch", "x86", params_hdl);
EXPECT_TRUE(res) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->string_value);
EXPECT_STREQ("x86", param_value->string_value);
param_value = rcl_yaml_node_struct_get("camera", "cam_spec.angle", params);
ASSERT_TRUE(NULL != param_value) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->double_value);
EXPECT_DOUBLE_EQ(2.34, *param_value->double_value);
res = rcl_parse_yaml_value("camera", "cam_spec.angle", "2.2", params);
EXPECT_TRUE(res) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->double_value);
EXPECT_DOUBLE_EQ(2.2, *param_value->double_value);
rcl_yaml_node_struct_print(params_hdl);
param_value = rcl_yaml_node_struct_get("intel", "arch", params);
ASSERT_TRUE(NULL != param_value) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->string_value);
EXPECT_STREQ("x86_64", param_value->string_value);
res = rcl_parse_yaml_value("intel", "arch", "x86", params);
EXPECT_TRUE(res) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->string_value);
EXPECT_STREQ("x86", param_value->string_value);
param_value = rcl_yaml_node_struct_get("new_camera_ns/new_camera1", "is_cam_on", params);
ASSERT_TRUE(NULL != param_value) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->bool_array_value);
ASSERT_EQ(6U, param_value->bool_array_value->size);
EXPECT_TRUE(param_value->bool_array_value->values[0]);
EXPECT_TRUE(param_value->bool_array_value->values[1]);
EXPECT_FALSE(param_value->bool_array_value->values[2]);
EXPECT_TRUE(param_value->bool_array_value->values[3]);
EXPECT_FALSE(param_value->bool_array_value->values[4]);
EXPECT_FALSE(param_value->bool_array_value->values[5]);
res = rcl_parse_yaml_value("new_camera_ns/new_camera1", "is_cam_on", "[false, true]", params);
EXPECT_TRUE(res) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->bool_array_value);
ASSERT_EQ(2U, param_value->bool_array_value->size);
EXPECT_FALSE(param_value->bool_array_value->values[0]);
EXPECT_TRUE(param_value->bool_array_value->values[1]);
param_value = rcl_yaml_node_struct_get("lidar_ns/lidar_1", "ports", params);
ASSERT_TRUE(NULL != param_value) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->integer_array_value);
ASSERT_EQ(3U, param_value->integer_array_value->size);
EXPECT_EQ(2438, param_value->integer_array_value->values[0]);
EXPECT_EQ(2439, param_value->integer_array_value->values[1]);
EXPECT_EQ(2440, param_value->integer_array_value->values[2]);
res = rcl_parse_yaml_value("lidar_ns/lidar_1", "ports", "[8080]", params);
EXPECT_TRUE(res) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->integer_array_value);
ASSERT_EQ(1U, param_value->integer_array_value->size);
EXPECT_EQ(8080, param_value->integer_array_value->values[0]);
param_value = rcl_yaml_node_struct_get(
"lidar_ns/lidar_1", "driver1.bk_sensor_specs", params);
ASSERT_TRUE(NULL != param_value) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->double_array_value);
ASSERT_EQ(4U, param_value->double_array_value->size);
EXPECT_DOUBLE_EQ(12.1, param_value->double_array_value->values[0]);
EXPECT_DOUBLE_EQ(-2.3, param_value->double_array_value->values[1]);
EXPECT_DOUBLE_EQ(5.2, param_value->double_array_value->values[2]);
EXPECT_DOUBLE_EQ(9.0, param_value->double_array_value->values[3]);
res = rcl_parse_yaml_value("lidar_ns/lidar_1", "driver1.bk_sensor_specs", "[1.0]", params);
EXPECT_TRUE(res) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->double_array_value);
ASSERT_EQ(1U, param_value->double_array_value->size);
EXPECT_DOUBLE_EQ(1.0, param_value->double_array_value->values[0]);
param_value = rcl_yaml_node_struct_get("camera", "cam_spec.supported_brands", params);
ASSERT_TRUE(NULL != param_value) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value->string_array_value);
ASSERT_EQ(3U, param_value->string_array_value->size);
EXPECT_STREQ("Bosch", param_value->string_array_value->data[0]);
EXPECT_STREQ("Novatek", param_value->string_array_value->data[1]);
EXPECT_STREQ("Mobius", param_value->string_array_value->data[2]);
res = rcl_parse_yaml_value(
"camera", "cam_spec.supported_brands", "[Mobius]", params);
EXPECT_TRUE(res) << rcutils_get_error_string().str;
ASSERT_TRUE(NULL != param_value);
ASSERT_TRUE(NULL != param_value->string_array_value);
ASSERT_EQ(1U, param_value->string_array_value->size);
EXPECT_STREQ("Mobius", param_value->string_array_value->data[0]);
rcl_yaml_node_struct_print(params);
}
}
TEST(test_file_parser, string_array_with_quoted_number) {