Made RobotReceiveTimeout::timeout private

and added a getter

Author: urfeex

include/ur_client_library/ur/robot_receive_timeout.h

@@ -87,10 +87,14 @@ class RobotReceiveTimeout
    */
   int verifyRobotReceiveTimeout(const comm::ControlMode control_mode, const std::chrono::milliseconds step_time) const;
 
-  std::chrono::milliseconds timeout;
+  std::chrono::milliseconds getAsMilliseconds() const
+  {
+    return timeout_;
+  }
 
 private:
+  std::chrono::milliseconds timeout_;
   RobotReceiveTimeout(std::chrono::milliseconds timeout);
 };
 
-}  // namespace urcl
+}  // namespace urcl

src/ur/robot_receive_timeout.cpp

@@ -37,7 +37,7 @@
 
 namespace urcl
 {
-RobotReceiveTimeout::RobotReceiveTimeout(std::chrono::milliseconds timeout) : timeout(timeout)
+RobotReceiveTimeout::RobotReceiveTimeout(std::chrono::milliseconds timeout) : timeout_(timeout)
 {
 }
 
@@ -66,41 +66,41 @@ int RobotReceiveTimeout::verifyRobotReceiveTimeout(const comm::ControlMode contr
 {
   if (comm::ControlModeTypes::isControlModeNonRealtime(control_mode))
   {
-    if (timeout < step_time && timeout > std::chrono::milliseconds(0))
+    if (timeout_ < step_time && timeout_ > std::chrono::milliseconds(0))
     {
       std::stringstream ss;
-      ss << "Robot receive timeout " << timeout.count() << "ms is below the step time " << step_time.count()
+      ss << "Robot receive timeout " << timeout_.count() << "ms is below the step time " << step_time.count()
          << "ms. It will be reset to the step time.";
       URCL_LOG_ERROR(ss.str().c_str());
       return step_time.count();
     }
     else
     {
-      return timeout.count();
+      return timeout_.count();
     }
   }
   else if (comm::ControlModeTypes::isControlModeRealtime(control_mode))
   {
-    if (timeout < step_time)
+    if (timeout_ < step_time)
     {
       std::stringstream ss;
-      ss << "Realtime read timeout " << timeout.count() << "ms is below the step time " << step_time.count()
+      ss << "Realtime read timeout " << timeout_.count() << "ms is below the step time " << step_time.count()
          << ". It will be reset to the step time.";
       URCL_LOG_ERROR(ss.str().c_str());
       return step_time.count();
     }
-    else if (timeout > MAX_RT_RECEIVE_TIMEOUT_MS)
+    else if (timeout_ > MAX_RT_RECEIVE_TIMEOUT_MS)
     {
       std::stringstream ss;
-      ss << "Robot receive timeout " << timeout.count()
+      ss << "Robot receive timeout " << timeout_.count()
          << "ms is above the maximum allowed timeout for realtime commands " << MAX_RT_RECEIVE_TIMEOUT_MS.count()
          << ". It will be reset to the maximum allowed timeout.";
       URCL_LOG_ERROR(ss.str().c_str());
       return MAX_RT_RECEIVE_TIMEOUT_MS.count();
     }
     else
     {
-      return timeout.count();
+      return timeout_.count();
     }
   }
   else

tests/test_robot_receive_timeout.cpp

@@ -41,36 +41,36 @@ TEST(RobotReceiveTimeout, milliseconds_configuration)
 {
   const int expected_timeout = 100;
   RobotReceiveTimeout robot_receive_timeout = RobotReceiveTimeout::millisec(expected_timeout);
-  EXPECT_EQ(robot_receive_timeout.timeout.count(), expected_timeout);
+  EXPECT_EQ(robot_receive_timeout.getAsMilliseconds().count(), expected_timeout);
 }
 
 TEST(RobotReceiveTimeout, empty_milliseconds_configuration)
 {
   const int expected_timeout = 20;
   RobotReceiveTimeout robot_receive_timeout = RobotReceiveTimeout::millisec();
-  EXPECT_EQ(robot_receive_timeout.timeout.count(), expected_timeout);
+  EXPECT_EQ(robot_receive_timeout.getAsMilliseconds().count(), expected_timeout);
 }
 
 TEST(RobotReceiveTimeout, seconds_configuration)
 {
   float timeout = 0.1;
   RobotReceiveTimeout robot_receive_timeout = RobotReceiveTimeout::sec(timeout);
   const int expected_timeout = timeout * 1000;  // Convert to milliseconds
-  EXPECT_EQ(robot_receive_timeout.timeout.count(), expected_timeout);
+  EXPECT_EQ(robot_receive_timeout.getAsMilliseconds().count(), expected_timeout);
 }
 
 TEST(RobotReceiveTimeout, empty_seconds_configuration)
 {
   const int expected_timeout = 20;
   RobotReceiveTimeout robot_receive_timeout = RobotReceiveTimeout::sec();
-  EXPECT_EQ(robot_receive_timeout.timeout.count(), expected_timeout);
+  EXPECT_EQ(robot_receive_timeout.getAsMilliseconds().count(), expected_timeout);
 }
 
 TEST(RobotReceiveTimeout, off_configuration)
 {
   const int expected_timeout = 0;
   RobotReceiveTimeout robot_receive_timeout = RobotReceiveTimeout::off();
-  EXPECT_EQ(robot_receive_timeout.timeout.count(), expected_timeout);
+  EXPECT_EQ(robot_receive_timeout.getAsMilliseconds().count(), expected_timeout);
 }
 
 TEST(RobotReceiveTimeout, off_realtime_control_modes)