Add string array to lexical casts (#2333) (#2335)

(cherry picked from commit 4d3362d)

Co-authored-by: Jordan Palacios <[email protected]>

Author: mergify[bot]

hardware_interface/CMakeLists.txt

@@ -90,6 +90,10 @@ if(BUILD_TESTING)
   ament_add_gmock(test_helpers test/test_helpers.cpp)
   target_link_libraries(test_helpers hardware_interface)
 
+  # Test lexical casts methods
+  ament_add_gtest(test_lexical_casts test/test_lexical_casts.cpp)
+  target_link_libraries(test_lexical_casts hardware_interface)
+
   ament_add_gmock(test_component_interfaces test/test_component_interfaces.cpp)
   target_link_libraries(test_component_interfaces hardware_interface ros2_control_test_assets::ros2_control_test_assets)
 

hardware_interface/include/hardware_interface/lexical_casts.hpp

@@ -16,6 +16,7 @@
 #define HARDWARE_INTERFACE__LEXICAL_CASTS_HPP_
 
 #include <string>
+#include <vector>
 
 namespace hardware_interface
 {
@@ -29,6 +30,8 @@ double stod(const std::string & s);
 
 bool parse_bool(const std::string & bool_string);
 
+std::vector<std::string> parse_string_array(const std::string & string_array_string);
+
 }  // namespace hardware_interface
 
 #endif  // HARDWARE_INTERFACE__LEXICAL_CASTS_HPP_

hardware_interface/src/lexical_casts.cpp

@@ -15,6 +15,8 @@
 #include <locale>
 #include <optional>
 #include <sstream>
+#include <string>
+#include <vector>
 
 #include "hardware_interface/lexical_casts.hpp"
 
@@ -48,6 +50,7 @@ std::optional<double> stod(const std::string & s)
 #endif
 }
 }  // namespace impl
+
 double stod(const std::string & s)
 {
   if (const auto result = impl::stod(s))
@@ -56,8 +59,63 @@ double stod(const std::string & s)
   }
   throw std::invalid_argument("Failed converting string to real number");
 }
+
 bool parse_bool(const std::string & bool_string)
 {
   return bool_string == "true" || bool_string == "True";
 }
+
+std::vector<std::string> parse_string_array(const std::string & string_array_string)
+{
+  // Check string starts with '[' and ends with ']'
+  if (
+    string_array_string.empty() || string_array_string.front() != '[' ||
+    string_array_string.back() != ']')
+  {
+    throw std::invalid_argument("String must start with '[' and end with ']'");
+  }
+
+  // Check there are no "sub arrays"
+  if (
+    string_array_string.find("[") != 0u ||
+    string_array_string.find("]") != string_array_string.size() - 1u)
+  {
+    throw std::invalid_argument("String contains nested arrays");
+  }
+
+  // Check for empty array
+  if (string_array_string == "[]")
+  {
+    return {};
+  }
+
+  std::vector<std::string> result;
+  std::string current_string;
+  for (char c : string_array_string)
+  {
+    if (c == ',' || c == ']')
+    {
+      if (!current_string.empty())
+      {
+        result.push_back(current_string);
+        current_string.clear();
+      }
+      else
+      {
+        throw std::invalid_argument("Empty string found in array");
+      }
+    }
+    else if (c == '[' || c == ' ')
+    {
+      // Ignore opening brackets and spaces
+    }
+    else
+    {
+      current_string += c;  // Add character to current string
+    }
+  }
+
+  return result;
+}
+
 }  // namespace hardware_interface

hardware_interface/test/test_lexical_casts.cpp

@@ -0,0 +1,68 @@
+// Copyright 2025 PAL Robotics S.L.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <stdexcept>
+
+#include "gtest/gtest.h"
+
+#include "hardware_interface/lexical_casts.hpp"
+
+TEST(TestLexicalCasts, test_stod)
+{
+  using hardware_interface::stod;
+
+  ASSERT_THROW(stod(""), std::invalid_argument);
+  ASSERT_THROW(stod("abc"), std::invalid_argument);
+  ASSERT_THROW(stod("1.2.3"), std::invalid_argument);
+  ASSERT_EQ(stod("1.2"), 1.2);
+  ASSERT_EQ(stod("-1.2"), -1.2);
+  ASSERT_EQ(stod("1.0"), 1.0);
+}
+
+TEST(TestLexicalCasts, test_parse_bool)
+{
+  using hardware_interface::parse_bool;
+
+  ASSERT_TRUE(parse_bool("true"));
+  ASSERT_TRUE(parse_bool("True"));
+
+  // Any other value should return false
+  ASSERT_FALSE(parse_bool("false"));
+  ASSERT_FALSE(parse_bool("False"));
+  ASSERT_FALSE(parse_bool(""));
+  ASSERT_FALSE(parse_bool("abc"));
+  ASSERT_FALSE(parse_bool("1"));
+}
+
+TEST(TestLexicalCasts, test_parse_string_array)
+{
+  using hardware_interface::parse_string_array;
+
+  ASSERT_THROW(parse_string_array(""), std::invalid_argument);
+  ASSERT_THROW(parse_string_array("abc"), std::invalid_argument);
+  ASSERT_THROW(parse_string_array("[abc"), std::invalid_argument);
+  ASSERT_THROW(parse_string_array("abc]"), std::invalid_argument);
+  ASSERT_THROW(parse_string_array("[[abc, def], hij]"), std::invalid_argument);
+  ASSERT_THROW(parse_string_array("[ ]"), std::invalid_argument);
+  ASSERT_THROW(parse_string_array("[,]"), std::invalid_argument);
+  ASSERT_THROW(parse_string_array("[abc,]"), std::invalid_argument);
+  ASSERT_THROW(parse_string_array("[,abc]"), std::invalid_argument);
+  ASSERT_THROW(parse_string_array("[abc,,def]"), std::invalid_argument);
+
+  ASSERT_EQ(parse_string_array("[]"), std::vector<std::string>());
+  ASSERT_EQ(parse_string_array("[abc]"), std::vector<std::string>({"abc"}));
+  ASSERT_EQ(parse_string_array("[abc,def]"), std::vector<std::string>({"abc", "def"}));
+  ASSERT_EQ(parse_string_array("[abc, def]"), std::vector<std::string>({"abc", "def"}));
+  ASSERT_EQ(parse_string_array("[ abc, def ]"), std::vector<std::string>({"abc", "def"}));
+}