Made JointState a struct

Author: TimSchneider42

include/franky/joint_state.hpp

@@ -10,10 +10,9 @@ namespace franky {
 /**
  * @brief Joint state of a robot.
  *
- * This class encapsulates the joint state of a robot, which comprises the joint positions and the joint velocities.
+ * This struct encapsulates the joint state of a robot, which comprises the joint positions and the joint velocities.
  */
-class JointState {
- public:
+struct JointState {
   // Suppress implicit conversion warning
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wimplicit-conversion"
@@ -22,15 +21,15 @@ class JointState {
    *
    * @param position The joint positions.
    */
-  JointState(Vector7d position) : position_(std::move(position)), velocity_(Vector7d::Zero()) {}
+  JointState(Vector7d position) : position(std::move(position)), velocity(Vector7d::Zero()) {}
 #pragma clang diagnostic pop
 
   /**
    * @param position The joint positions.
    * @param velocity The joint velocities.
    */
   JointState(Vector7d position, Vector7d velocity)
-      : position_(std::move(position)), velocity_(std::move(velocity)) {}
+      : position(std::move(position)), velocity(std::move(velocity)) {}
 
   JointState(const JointState &) = default;
 
@@ -39,20 +38,12 @@ class JointState {
   /**
    * @brief The position component of the state.
    */
-  [[nodiscard]] inline Vector7d position() const {
-    return position_;
-  }
+  const Vector7d position;
 
   /**
    * @brief The velocity component of the state.
    */
-  [[nodiscard]] inline Vector7d velocity() const {
-    return velocity_;
-  }
-
- private:
-  Vector7d position_;
-  Vector7d velocity_;
+  const Vector7d velocity;
 };
 
 }  // namespace franky

python/bind_state_repr.cpp

@@ -215,17 +215,17 @@ void bind_state_repr(py::module &m) {
       .def(py::init<const Vector7d &>(), "position"_a)
       .def(py::init<const Vector7d &, const Vector7d &>(), "position"_a, "velocity"_a)
       .def(py::init<const JointState &>()) // Copy constructor
-      .def_property_readonly("position", &JointState::position)
-      .def_property_readonly("velocity", &JointState::velocity)
+      .def_readonly("position", &JointState::position)
+      .def_readonly("velocity", &JointState::velocity)
       .def("__repr__", [](const JointState &joint_state) {
         std::stringstream ss;
-        ss << "JointState(position=" << vecToStr(joint_state.position())
-           << ", velocity=" << vecToStr(joint_state.velocity()) << ")";
+        ss << "JointState(position=" << vecToStr(joint_state.position)
+           << ", velocity=" << vecToStr(joint_state.velocity) << ")";
         return ss.str();
       })
       .def(py::pickle(
           [](const JointState &joint_state) {  // __getstate__
-            return py::make_tuple(joint_state.position(), joint_state.velocity());
+            return py::make_tuple(joint_state.position, joint_state.velocity);
           },
           [](const py::tuple &t) {  // __setstate__
             if (t.size() != 2)

src/motion/joint_waypoint_motion.cpp

@@ -36,10 +36,11 @@ void JointWaypointMotion::setNewWaypoint(
     const PositionWaypoint<JointState> &new_waypoint,
     ruckig::InputParameter<7> &input_parameter) {
   auto new_target = new_waypoint.target;
+  auto position = new_target.position;
   if (new_waypoint.reference_type == ReferenceType::Relative)
-    new_target.position() += toEigen(input_parameter.current_position);
-  input_parameter.target_position = toStd<7>(new_target.position());
-  input_parameter.target_velocity = toStd<7>(new_target.velocity());
+    position += toEigen(input_parameter.current_position);
+  input_parameter.target_position = toStd<7>(position);
+  input_parameter.target_velocity = toStd<7>(new_target.velocity);
   input_parameter.target_acceleration = toStd<7>(Vector7d::Zero());
 }
 

src/robot.cpp

@@ -26,15 +26,15 @@ bool Robot::recoverFromErrors() {
 
 JointState Robot::currentJointState() {
   auto s = state();
-  return {Eigen::Map<const Vector7d>(state().q.data()), Eigen::Map<const Vector7d>(state().dq.data())};
+  return JointState{Eigen::Map<const Vector7d>(state().q.data()), Eigen::Map<const Vector7d>(state().dq.data())};
 }
 
 Vector7d Robot::currentJointPositions() {
-  return currentJointState().position();
+  return currentJointState().position;
 }
 
 Vector7d Robot::currentJointVelocities() {
-  return currentJointState().velocity();
+  return currentJointState().velocity;
 }
 
 Affine Robot::forwardKinematics(const Vector7d &q) {