Skip to content

Commit 070abdd

Browse files
bpwilcoxbpwilcox
committed
move ParameterInfo to parameters.hpp and use in parameter map, update unit test
Signed-off-by: Brian Wilcox <[email protected]>
1 parent e6546c8 commit 070abdd

File tree

8 files changed

+73
-80
lines changed

8 files changed

+73
-80
lines changed

‎rclcpp/include/rclcpp/node_interfaces/node_parameters_interface.hpp‎

Lines changed: 0 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -33,16 +33,6 @@ namespace rclcpp
3333
namespace node_interfaces
3434
{
3535

36-
// Internal struct for holding useful info about parameters
37-
struct ParameterInfo
38-
{
39-
/// Current value of the parameter.
40-
rclcpp::ParameterValue value;
41-
42-
/// A description of the parameter
43-
rcl_interfaces::msg::ParameterDescriptor descriptor;
44-
};
45-
4636
struct OnSetParametersCallbackHandle
4737
{
4838
RCLCPP_SMART_PTR_DEFINITIONS(OnSetParametersCallbackHandle)

‎rclcpp/include/rclcpp/parameter.hpp‎

Lines changed: 10 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@
2222
#include <vector>
2323

2424
#include "rcl_interfaces/msg/parameter.hpp"
25+
#include "rcl_interfaces/msg/parameter_descriptor.hpp"
2526
#include "rclcpp/exceptions.hpp"
2627
#include "rclcpp/parameter_value.hpp"
2728
#include "rclcpp/visibility_control.hpp"
@@ -33,7 +34,15 @@ class Parameter;
3334

3435
namespace node_interfaces
3536
{
36-
struct ParameterInfo;
37+
// Internal struct for holding useful info about parameters
38+
struct ParameterInfo
39+
{
40+
/// Current value of the parameter.
41+
rclcpp::ParameterValue value;
42+
43+
/// A description of the parameter
44+
rcl_interfaces::msg::ParameterDescriptor descriptor;
45+
};
3746
} // namespace node_interfaces
3847

3948
namespace detail

‎rclcpp/include/rclcpp/parameter_map.hpp‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -34,8 +34,7 @@ namespace rclcpp
3434

3535
/// A map of fully qualified node names to a list of parameters
3636
using rcl_interfaces::msg::ParameterDescriptor;
37-
using ParameterAndDescriptor = std::unordered_map<std::string, std::pair<Parameter,
38-
ParameterDescriptor>>;
37+
using ParameterAndDescriptor = std::unordered_map<std::string, rclcpp::node_interfaces::ParameterInfo>;
3938
using ParameterMap = std::unordered_map<std::string, ParameterAndDescriptor>;
4039

4140
/// Convert parameters from rcl_yaml_param_parser into C++ class instances.

‎rclcpp/src/rclcpp/detail/resolve_parameter_overrides.cpp‎

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -60,11 +60,8 @@ rclcpp::detail::resolve_parameter_overrides(
6060
if (initial_map.count(node_name) > 0) {
6161
// Combine parameter yaml files, overwriting values in older ones
6262
for (const auto & param : initial_map.at(node_name)) {
63-
rclcpp::node_interfaces::ParameterInfo param_info;
64-
param_info.value = rclcpp::ParameterValue((param.second.first).get_value_message());
65-
param_info.descriptor = param.second.second;
66-
param_info.descriptor.dynamic_typing = true;
67-
result[(param.second.first).get_name()] = param_info;
63+
result[param.first] = param.second;
64+
result[param.first].descriptor.dynamic_typing = true;
6865
}
6966
}
7067
}

‎rclcpp/src/rclcpp/detail/resolve_parameter_overrides.hpp‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,6 @@
2121

2222
#include "rcl/arguments.h"
2323

24-
#include "rclcpp/node_interfaces/node_parameters_interface.hpp"
2524
#include "rclcpp/parameter.hpp"
2625
#include "rclcpp/parameter_value.hpp"
2726
#include "rclcpp/visibility_control.hpp"

‎rclcpp/src/rclcpp/parameter_client.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -308,7 +308,7 @@ AsyncParametersClient::load_parameters(
308308
(node_name == remote_name))
309309
{
310310
for (const auto & param : params.second) {
311-
parameters.push_back(param.second.first);
311+
parameters.push_back(rclcpp::Parameter(param.second));
312312
}
313313
}
314314
}

‎rclcpp/src/rclcpp/parameter_map.cpp‎

Lines changed: 5 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -64,7 +64,7 @@ rclcpp::parameter_map_from(const rcl_params_t * const c_params)
6464
throw InvalidParametersException(message);
6565
}
6666
const rcl_variant_t * const c_param_value = &(c_params_node->parameter_values[p]);
67-
params[c_param_name].first = Parameter(c_param_name, parameter_value_from(c_param_value));
67+
params[c_param_name].value = parameter_value_from(c_param_value);
6868
}
6969

7070
const rcl_node_params_descriptors_t * const c_param_descriptors_node =
@@ -78,10 +78,7 @@ rclcpp::parameter_map_from(const rcl_params_t * const c_params)
7878
}
7979
const rcl_param_descriptor_t * const c_param_descriptor =
8080
&(c_param_descriptors_node->parameter_descriptors[p]);
81-
if (params.count(std::string(c_param_name)) < 1) {
82-
params[c_param_name].first = Parameter(c_param_name);
83-
}
84-
params[c_param_name].second = parameter_descriptor_from(c_param_descriptor);
81+
params[c_param_name].descriptor = parameter_descriptor_from(c_param_descriptor);
8582
}
8683
}
8784
return parameters;
@@ -194,7 +191,9 @@ rclcpp::parameter_descriptor_from(const rcl_param_descriptor_t * const c_param_d
194191
i.step = *(c_param_descriptor->step_int);
195192
}
196193
p.integer_range.push_back(i);
197-
} else if (c_param_descriptor->min_value_double || c_param_descriptor->max_value_double || // NOLINT
194+
} else if (
195+
c_param_descriptor->min_value_double ||
196+
c_param_descriptor->max_value_double ||
198197
c_param_descriptor->step_double)
199198
{
200199
FloatingPointRange f;

‎rclcpp/test/rclcpp/test_parameter_map.cpp‎

Lines changed: 54 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -216,10 +216,10 @@ TEST(Test_parameter_map_from, bool_param_value)
216216

217217
rclcpp::ParameterMap map = rclcpp::parameter_map_from(c_params);
218218
const rclcpp::ParameterAndDescriptor & params = map.at("/foo");
219-
EXPECT_STREQ("true_bool", params.at("true_bool").first.get_name().c_str());
220-
EXPECT_TRUE(params.at("true_bool").first.get_value<bool>());
221-
EXPECT_STREQ("false_bool", params.at("false_bool").first.get_name().c_str());
222-
EXPECT_FALSE(params.at("false_bool").first.get_value<bool>());
219+
EXPECT_TRUE(params.count("true_bool"));
220+
EXPECT_TRUE(params.at("true_bool").value.get<bool>());
221+
EXPECT_TRUE(params.count("false_bool"));
222+
EXPECT_FALSE(params.at("false_bool").value.get<bool>());
223223

224224
c_params->params[0].parameter_values[0].bool_value = NULL;
225225
c_params->params[0].parameter_values[1].bool_value = NULL;
@@ -237,10 +237,10 @@ TEST(Test_parameter_map_from, integer_param_value)
237237

238238
rclcpp::ParameterMap map = rclcpp::parameter_map_from(c_params);
239239
const rclcpp::ParameterAndDescriptor & params = map.at("/bar");
240-
EXPECT_STREQ("positive.int", params.at("positive.int").first.get_name().c_str());
241-
EXPECT_EQ(42, params.at("positive.int").first.get_value<int64_t>());
242-
EXPECT_STREQ("negative.int", params.at("negative.int").first.get_name().c_str());
243-
EXPECT_EQ(-12345, params.at("negative.int").first.get_value<int64_t>());
240+
EXPECT_TRUE(params.count("positive.int"));
241+
EXPECT_EQ(42, params.at("positive.int").value.get<int64_t>());
242+
EXPECT_TRUE(params.count("negative.int"));
243+
EXPECT_EQ(-12345, params.at("negative.int").value.get<int64_t>());
244244

245245
c_params->params[0].parameter_values[0].integer_value = NULL;
246246
c_params->params[0].parameter_values[1].integer_value = NULL;
@@ -258,10 +258,10 @@ TEST(Test_parameter_map_from, double_param_value)
258258

259259
rclcpp::ParameterMap map = rclcpp::parameter_map_from(c_params);
260260
const rclcpp::ParameterAndDescriptor & params = map.at("/foo/bar");
261-
EXPECT_STREQ("positive.double", params.at("positive.double").first.get_name().c_str());
262-
EXPECT_DOUBLE_EQ(3.14, params.at("positive.double").first.get_value<double>());
263-
EXPECT_STREQ("negative.double", params.at("negative.double").first.get_name().c_str());
264-
EXPECT_DOUBLE_EQ(-2.718, params.at("negative.double").first.get_value<double>());
261+
EXPECT_TRUE(params.count("positive.double"));
262+
EXPECT_DOUBLE_EQ(3.14, params.at("positive.double").value.get<double>());
263+
EXPECT_TRUE(params.count("negative.double"));
264+
EXPECT_DOUBLE_EQ(-2.718, params.at("negative.double").value.get<double>());
265265

266266
c_params->params[0].parameter_values[0].double_value = NULL;
267267
c_params->params[0].parameter_values[1].double_value = NULL;
@@ -279,9 +279,9 @@ TEST(Test_parameter_map_from, string_param_value)
279279

280280
rclcpp::ParameterMap map = rclcpp::parameter_map_from(c_params);
281281
const rclcpp::ParameterAndDescriptor & params = map.at("/foo/bar");
282-
EXPECT_STREQ("string_param", params.at("string_param").first.get_name().c_str());
282+
EXPECT_TRUE(params.count("string_param"));
283283
EXPECT_STREQ(hello_world.c_str(),
284-
params.at("string_param").first.get_value<std::string>().c_str());
284+
params.at("string_param").value.get<std::string>().c_str());
285285

286286
c_params->params[0].parameter_values[0].string_value = NULL;
287287
delete[] c_hello_world;
@@ -311,9 +311,9 @@ TEST(Test_parameter_map_from, byte_array_param_value)
311311

312312
rclcpp::ParameterMap map = rclcpp::parameter_map_from(c_params);
313313
const rclcpp::ParameterAndDescriptor & params = map.at("/foobar");
314-
EXPECT_STREQ("byte_array_param", params.at("byte_array_param").first.get_name().c_str());
314+
EXPECT_TRUE(params.count("byte_array_param"));
315315
std::vector<uint8_t> byte_array =
316-
params.at("byte_array_param").first.get_value<std::vector<uint8_t>>();
316+
params.at("byte_array_param").value.get<std::vector<uint8_t>>();
317317
ASSERT_EQ(2u, byte_array.size());
318318
EXPECT_EQ(0xf0, byte_array.at(0));
319319
EXPECT_EQ(0xaa, byte_array.at(1));
@@ -333,8 +333,8 @@ TEST(Test_parameter_map_from, bool_array_param_value)
333333

334334
rclcpp::ParameterMap map = rclcpp::parameter_map_from(c_params);
335335
const rclcpp::ParameterAndDescriptor & params = map.at("/foo/bar/baz");
336-
EXPECT_STREQ("bool_array_param", params.at("bool_array_param").first.get_name().c_str());
337-
std::vector<bool> bool_array = params.at("bool_array_param").first.get_value<std::vector<bool>>();
336+
EXPECT_TRUE(params.count("bool_array_param"));
337+
std::vector<bool> bool_array = params.at("bool_array_param").value.get<std::vector<bool>>();
338338
ASSERT_EQ(2u, bool_array.size());
339339
EXPECT_TRUE(bool_array.at(0));
340340
EXPECT_FALSE(bool_array.at(1));
@@ -354,9 +354,9 @@ TEST(Test_parameter_map_from, integer_array_param_value)
354354

355355
rclcpp::ParameterMap map = rclcpp::parameter_map_from(c_params);
356356
const rclcpp::ParameterAndDescriptor & params = map.at("/foo");
357-
EXPECT_STREQ("integer_array_param", params.at("integer_array_param").first.get_name().c_str());
357+
EXPECT_TRUE(params.count("integer_array_param"));
358358
std::vector<int64_t> integer_array =
359-
params.at("integer_array_param").first.get_value<std::vector<int64_t>>();
359+
params.at("integer_array_param").value.get<std::vector<int64_t>>();
360360
ASSERT_EQ(2u, integer_array.size());
361361
EXPECT_EQ(42, integer_array.at(0));
362362
EXPECT_EQ(-12345, integer_array.at(1));
@@ -376,9 +376,9 @@ TEST(Test_parameter_map_from, double_array_param_value)
376376

377377
rclcpp::ParameterMap map = rclcpp::parameter_map_from(c_params);
378378
const rclcpp::ParameterAndDescriptor & params = map.at("/foo");
379-
EXPECT_STREQ("double_array_param", params.at("double_array_param").first.get_name().c_str());
379+
EXPECT_TRUE(params.count("double_array_param"));
380380
std::vector<double> double_array =
381-
params.at("double_array_param").first.get_value<std::vector<double>>();
381+
params.at("double_array_param").value.get<std::vector<double>>();
382382
ASSERT_EQ(2u, double_array.size());
383383
EXPECT_DOUBLE_EQ(3.14, double_array.at(0));
384384
EXPECT_DOUBLE_EQ(-2.718, double_array.at(1));
@@ -400,9 +400,9 @@ TEST(Test_parameter_map_from, string_array_param_value)
400400

401401
rclcpp::ParameterMap map = rclcpp::parameter_map_from(c_params);
402402
const rclcpp::ParameterAndDescriptor & params = map.at("/foo");
403-
EXPECT_STREQ("string_array_param", params.at("string_array_param").first.get_name().c_str());
403+
EXPECT_TRUE(params.count("string_array_param"));
404404
std::vector<std::string> string_array =
405-
params.at("string_array_param").first.get_value<std::vector<std::string>>();
405+
params.at("string_array_param").value.get<std::vector<std::string>>();
406406
ASSERT_EQ(2u, string_array.size());
407407
EXPECT_STREQ("Hello", string_array.at(0).c_str());
408408
EXPECT_STREQ("World", string_array.at(1).c_str());
@@ -434,19 +434,19 @@ TEST(Test_parameter_map_from, descriptor_integer_range)
434434

435435
rclcpp::ParameterMap map = rclcpp::parameter_map_from(c_params);
436436
const rclcpp::ParameterAndDescriptor & params = map.at("/foo");
437-
EXPECT_STREQ("bar", params.at("bar").second.name.c_str());
438-
EXPECT_STREQ("Integer Range Descriptor", params.at("bar").second.description.c_str());
439-
EXPECT_STREQ("Even numbers only", params.at("bar").second.additional_constraints.c_str());
440-
EXPECT_EQ(-1234, params.at("bar").second.integer_range[0].from_value);
441-
EXPECT_EQ(99, params.at("bar").second.integer_range[0].to_value);
442-
EXPECT_EQ(2U, params.at("bar").second.integer_range[0].step);
443-
EXPECT_STREQ("baz", params.at("baz").second.name.c_str());
444-
EXPECT_EQ(-1234, params.at("baz").second.integer_range[0].from_value);
445-
EXPECT_EQ(std::numeric_limits<int64_t>::max(), params.at("baz").second.integer_range[0].to_value);
446-
EXPECT_STREQ("foobar", params.at("foobar").second.name.c_str());
437+
EXPECT_TRUE(params.count("bar"));
438+
EXPECT_STREQ("Integer Range Descriptor", params.at("bar").descriptor.description.c_str());
439+
EXPECT_STREQ("Even numbers only", params.at("bar").descriptor.additional_constraints.c_str());
440+
EXPECT_EQ(-1234, params.at("bar").descriptor.integer_range[0].from_value);
441+
EXPECT_EQ(99, params.at("bar").descriptor.integer_range[0].to_value);
442+
EXPECT_EQ(2U, params.at("bar").descriptor.integer_range[0].step);
443+
EXPECT_TRUE(params.count("baz"));
444+
EXPECT_EQ(-1234, params.at("baz").descriptor.integer_range[0].from_value);
445+
EXPECT_EQ(std::numeric_limits<int64_t>::max(), params.at("baz").descriptor.integer_range[0].to_value);
446+
EXPECT_TRUE(params.count("foobar"));
447447
EXPECT_EQ(std::numeric_limits<int64_t>::min(), params.at(
448-
"foobar").second.integer_range[0].from_value);
449-
EXPECT_EQ(99, params.at("foobar").second.integer_range[0].to_value);
448+
"foobar").descriptor.integer_range[0].from_value);
449+
EXPECT_EQ(99, params.at("foobar").descriptor.integer_range[0].to_value);
450450

451451
c_params->descriptors[0].parameter_descriptors[0].name = NULL;
452452
c_params->descriptors[0].parameter_descriptors[0].min_value_int = NULL;
@@ -484,20 +484,20 @@ TEST(Test_parameter_map_from, descriptor_double_range)
484484

485485
rclcpp::ParameterMap map = rclcpp::parameter_map_from(c_params);
486486
const rclcpp::ParameterAndDescriptor & params = map.at("/foo");
487-
EXPECT_STREQ("bar", params.at("bar").second.name.c_str());
488-
EXPECT_STREQ("Double Range Descriptor", params.at("bar").second.description.c_str());
489-
EXPECT_STREQ("Multiples of 5", params.at("bar").second.additional_constraints.c_str());
490-
EXPECT_DOUBLE_EQ(-1000.0, params.at("bar").second.floating_point_range[0].from_value);
491-
EXPECT_DOUBLE_EQ(500.0, params.at("bar").second.floating_point_range[0].to_value);
492-
EXPECT_DOUBLE_EQ(5.0, params.at("bar").second.floating_point_range[0].step);
493-
EXPECT_STREQ("baz", params.at("baz").second.name.c_str());
494-
EXPECT_DOUBLE_EQ(-1000.0, params.at("baz").second.floating_point_range[0].from_value);
487+
EXPECT_TRUE(params.count("bar"));
488+
EXPECT_STREQ("Double Range Descriptor", params.at("bar").descriptor.description.c_str());
489+
EXPECT_STREQ("Multiples of 5", params.at("bar").descriptor.additional_constraints.c_str());
490+
EXPECT_DOUBLE_EQ(-1000.0, params.at("bar").descriptor.floating_point_range[0].from_value);
491+
EXPECT_DOUBLE_EQ(500.0, params.at("bar").descriptor.floating_point_range[0].to_value);
492+
EXPECT_DOUBLE_EQ(5.0, params.at("bar").descriptor.floating_point_range[0].step);
493+
EXPECT_TRUE(params.count("baz"));
494+
EXPECT_DOUBLE_EQ(-1000.0, params.at("baz").descriptor.floating_point_range[0].from_value);
495495
EXPECT_DOUBLE_EQ(std::numeric_limits<double>::max(),
496-
params.at("baz").second.floating_point_range[0].to_value);
497-
EXPECT_STREQ("foobar", params.at("foobar").second.name.c_str());
496+
params.at("baz").descriptor.floating_point_range[0].to_value);
497+
EXPECT_TRUE(params.count("foobar"));
498498
EXPECT_DOUBLE_EQ(std::numeric_limits<double>::lowest(), params.at(
499-
"foobar").second.floating_point_range[0].from_value);
500-
EXPECT_DOUBLE_EQ(500.0, params.at("foobar").second.floating_point_range[0].to_value);
499+
"foobar").descriptor.floating_point_range[0].from_value);
500+
EXPECT_DOUBLE_EQ(500.0, params.at("foobar").descriptor.floating_point_range[0].to_value);
501501

502502
c_params->descriptors[0].parameter_descriptors[0].name = NULL;
503503
c_params->descriptors[0].parameter_descriptors[0].min_value_double = NULL;
@@ -548,12 +548,12 @@ TEST(Test_parameter_map_from, descriptor_read_only)
548548

549549
rclcpp::ParameterMap map = rclcpp::parameter_map_from(c_params);
550550
const rclcpp::ParameterAndDescriptor & params = map.at("/foo");
551-
EXPECT_STREQ("bar", params.at("bar").second.name.c_str());
552-
EXPECT_STREQ("read-only param", params.at("bar").second.description.c_str());
553-
EXPECT_TRUE(params.at("bar").second.read_only);
554-
EXPECT_STREQ("baz", params.at("baz").second.name.c_str());
555-
EXPECT_STREQ("not read-only", params.at("baz").second.description.c_str());
556-
EXPECT_FALSE(params.at("baz").second.read_only);
551+
EXPECT_TRUE(params.count("bar"));
552+
EXPECT_STREQ("read-only param", params.at("bar").descriptor.description.c_str());
553+
EXPECT_TRUE(params.at("bar").descriptor.read_only);
554+
EXPECT_TRUE(params.count("baz"));
555+
EXPECT_STREQ("not read-only", params.at("baz").descriptor.description.c_str());
556+
EXPECT_FALSE(params.at("baz").descriptor.read_only);
557557

558558

559559
c_params->descriptors[0].parameter_descriptors[0].name = NULL;

0 commit comments

Comments
 (0)