From 179aad26633200f8ddb0658e5c989ee7dd023656 Mon Sep 17 00:00:00 2001
From: Christoph Pohl <christoph.pohl@kit.edu>
Date: Thu, 5 May 2022 14:02:27 +0200
Subject: [PATCH] Transform Arm and RobotArm from nested class to separate
 classes

This facilitates eg forward declarations
---
 .../RobotNameHelper.cpp                       |  66 +++---
 .../RobotStatechartHelpers/RobotNameHelper.h  | 197 +++++++++++-------
 2 files changed, 156 insertions(+), 107 deletions(-)

diff --git a/source/RobotAPI/libraries/RobotStatechartHelpers/RobotNameHelper.cpp b/source/RobotAPI/libraries/RobotStatechartHelpers/RobotNameHelper.cpp
index f5a88c0ae..4f2d0c35f 100644
--- a/source/RobotAPI/libraries/RobotStatechartHelpers/RobotNameHelper.cpp
+++ b/source/RobotAPI/libraries/RobotStatechartHelpers/RobotNameHelper.cpp
@@ -130,18 +130,18 @@ namespace armarx
         return new RobotInfoNode(name, profile, value, children);
     }
 
-    RobotNameHelper::Arm RobotNameHelper::getArm(const std::string& side) const
+    Arm RobotNameHelper::getArm(const std::string& side) const
     {
         return Arm(shared_from_this(), side);
     }
 
-    RobotNameHelper::RobotArm
+    RobotArm
     RobotNameHelper::getRobotArm(const std::string& side, const VirtualRobot::RobotPtr& robot) const
     {
         return RobotArm(Arm(shared_from_this(), side), robot);
     }
 
-    std::shared_ptr<const RobotNameHelper> RobotNameHelper::Arm::getRobotNameHelper() const
+    std::shared_ptr<const RobotNameHelper> Arm::getRobotNameHelper() const
     {
         return rnh;
     }
@@ -197,150 +197,150 @@ namespace armarx
         }
     }
 
-    std::string RobotNameHelper::Arm::getSide() const
+    std::string Arm::getSide() const
     {
         return side;
     }
 
-    std::string RobotNameHelper::Arm::getKinematicChain() const
+    std::string Arm::getKinematicChain() const
     {
         ARMARX_TRACE;
         return select("KinematicChain");
     }
 
-    std::string RobotNameHelper::Arm::getTorsoKinematicChain() const
+    std::string Arm::getTorsoKinematicChain() const
     {
         ARMARX_TRACE;
         return select("TorsoKinematicChain");
     }
 
-    std::string RobotNameHelper::Arm::getTCP() const
+    std::string Arm::getTCP() const
     {
         ARMARX_TRACE;
         return select("TCP");
     }
 
-    std::string RobotNameHelper::Arm::getForceTorqueSensor() const
+    std::string Arm::getForceTorqueSensor() const
     {
         ARMARX_TRACE;
         return select("ForceTorqueSensor");
     }
 
-    std::string RobotNameHelper::Arm::getForceTorqueSensorFrame() const
+    std::string Arm::getForceTorqueSensorFrame() const
     {
         ARMARX_TRACE;
         return select("ForceTorqueSensorFrame");
     }
 
-    std::string RobotNameHelper::Arm::getEndEffector() const
+    std::string Arm::getEndEffector() const
     {
         ARMARX_TRACE;
         return select("EndEffector");
     }
 
-    std::string RobotNameHelper::Arm::getMemoryHandName() const
+    std::string Arm::getMemoryHandName() const
     {
         ARMARX_TRACE;
         return select("MemoryHandName");
     }
 
-    std::string RobotNameHelper::Arm::getHandControllerName() const
+    std::string Arm::getHandControllerName() const
     {
         ARMARX_TRACE;
         return select("HandControllerName");
     }
 
-    std::string RobotNameHelper::Arm::getHandRootNode() const
+    std::string Arm::getHandRootNode() const
     {
         ARMARX_TRACE;
         return select("HandRootNode");
     }
 
-    std::string RobotNameHelper::Arm::getHandModelPath() const
+    std::string Arm::getHandModelPath() const
     {
         ARMARX_TRACE;
         return select("HandModelPath");
     }
 
-    std::string RobotNameHelper::Arm::getAbsoluteHandModelPath() const
+    std::string Arm::getAbsoluteHandModelPath() const
     {
         ArmarXDataPath::FindPackageAndAddDataPath(getHandModelPackage());
         auto path = getHandModelPath();
         return ArmarXDataPath::getAbsolutePath(path, path) ? path : "";
     }
 
-    std::string RobotNameHelper::Arm::getHandModelPackage() const
+    std::string Arm::getHandModelPackage() const
     {
         ARMARX_TRACE;
         return select("HandModelPackage");
     }
 
-    std::string RobotNameHelper::Arm::getPalmCollisionModel() const
+    std::string Arm::getPalmCollisionModel() const
     {
         ARMARX_TRACE;
         return select("PalmCollisionModel");
     }
 
-    std::string RobotNameHelper::Arm::getFullHandCollisionModel() const
+    std::string Arm::getFullHandCollisionModel() const
     {
         ARMARX_TRACE;
         return select("FullHandCollisionModel");
     }
 
-    RobotNameHelper::RobotArm
-    RobotNameHelper::Arm::addRobot(const VirtualRobot::RobotPtr& robot) const
+    RobotArm
+    Arm::addRobot(const VirtualRobot::RobotPtr& robot) const
     {
         ARMARX_TRACE;
         return RobotArm(*this, robot);
     }
 
-    RobotNameHelper::Arm::Arm(const std::shared_ptr<const RobotNameHelper>& rnh,
+    Arm::Arm(const std::shared_ptr<const RobotNameHelper>& rnh,
                               const std::string& side) :
         rnh(rnh), side(side)
     {
     }
 
-    std::string RobotNameHelper::Arm::select(const std::string& path) const
+    std::string Arm::select(const std::string& path) const
     {
         ARMARX_TRACE;
         return rnh->select(side + "Arm/" + path);
     }
 
-    std::string RobotNameHelper::RobotArm::getSide() const
+    std::string RobotArm::getSide() const
     {
         ARMARX_TRACE;
         return arm.getSide();
     }
 
-    VirtualRobot::RobotNodeSetPtr RobotNameHelper::RobotArm::getKinematicChain() const
+    VirtualRobot::RobotNodeSetPtr RobotArm::getKinematicChain() const
     {
         ARMARX_TRACE;
         ARMARX_CHECK_NOT_NULL(robot);
         return robot->getRobotNodeSet(arm.getKinematicChain());
     }
 
-    VirtualRobot::RobotNodeSetPtr RobotNameHelper::RobotArm::getTorsoKinematicChain() const
+    VirtualRobot::RobotNodeSetPtr RobotArm::getTorsoKinematicChain() const
     {
         ARMARX_TRACE;
         ARMARX_CHECK_NOT_NULL(robot);
         return robot->getRobotNodeSet(arm.getTorsoKinematicChain());
     }
 
-    VirtualRobot::RobotNodePtr RobotNameHelper::RobotArm::getTCP() const
+    VirtualRobot::RobotNodePtr RobotArm::getTCP() const
     {
         ARMARX_TRACE;
         ARMARX_CHECK_NOT_NULL(robot);
         return robot->getRobotNode(arm.getTCP());
     }
 
-    VirtualRobot::RobotNodePtr RobotNameHelper::RobotArm::getPalmCollisionModel() const
+    VirtualRobot::RobotNodePtr RobotArm::getPalmCollisionModel() const
     {
         ARMARX_TRACE;
         ARMARX_CHECK_NOT_NULL(robot);
         return robot->getRobotNode(arm.getPalmCollisionModel());
     }
 
-    VirtualRobot::TriMeshModelPtr RobotNameHelper::RobotArm::getFullHandCollisionModel() const
+    VirtualRobot::TriMeshModelPtr RobotArm::getFullHandCollisionModel() const
     {
         ARMARX_TRACE;
         std::string abs;
@@ -349,14 +349,14 @@ namespace armarx
         return VirtualRobot::TriMeshModel::FromFile(abs);
     }
 
-    VirtualRobot::RobotNodePtr RobotNameHelper::RobotArm::getHandRootNode() const
+    VirtualRobot::RobotNodePtr RobotArm::getHandRootNode() const
     {
         ARMARX_TRACE;
         ARMARX_CHECK_NOT_NULL(robot);
         return robot->getRobotNode(arm.getHandRootNode());
     }
 
-    Eigen::Matrix4f RobotNameHelper::RobotArm::getTcp2HandRootTransform() const
+    Eigen::Matrix4f RobotArm::getTcp2HandRootTransform() const
     {
         ARMARX_TRACE;
         const auto tcp = getTCP();
@@ -366,17 +366,17 @@ namespace armarx
         return tcp->getPoseInRootFrame().inverse() * hand->getPoseInRootFrame();
     }
 
-    const VirtualRobot::RobotPtr& RobotNameHelper::RobotArm::getRobot() const
+    const VirtualRobot::RobotPtr& RobotArm::getRobot() const
     {
         return robot;
     }
 
-    const RobotNameHelper::Arm& RobotNameHelper::RobotArm::getArm() const
+    const Arm& RobotArm::getArm() const
     {
         return arm;
     }
 
-    RobotNameHelper::RobotArm::RobotArm(const Arm& arm, const VirtualRobot::RobotPtr& robot) :
+    RobotArm::RobotArm(const Arm& arm, const VirtualRobot::RobotPtr& robot) :
         arm(arm), robot(robot)
     {
         ARMARX_CHECK_NOT_NULL(robot);
diff --git a/source/RobotAPI/libraries/RobotStatechartHelpers/RobotNameHelper.h b/source/RobotAPI/libraries/RobotStatechartHelpers/RobotNameHelper.h
index 92330d05d..76c9b283f 100644
--- a/source/RobotAPI/libraries/RobotStatechartHelpers/RobotNameHelper.h
+++ b/source/RobotAPI/libraries/RobotStatechartHelpers/RobotNameHelper.h
@@ -36,23 +36,130 @@ namespace armarx
 
     class RapidXmlReaderNode;
 
-    class RobotNameHelper : public std::enable_shared_from_this<RobotNameHelper>
+    struct RobotArm;
+
+    struct Arm
     {
+        friend class RobotNameHelper;
+
     public:
-        static void writeRobotInfoNode(
-            const RobotInfoNodePtr& n,
-            std::ostream& str,
-            std::size_t indent = 0,
-            char indentChar = ' ');
 
+        std::string getSide() const;
+
+        std::string getKinematicChain() const;
+
+        std::string getTorsoKinematicChain() const;
+
+        std::string getTCP() const;
+
+        std::string getForceTorqueSensor() const;
+
+        std::string getForceTorqueSensorFrame() const;
+
+        std::string getEndEffector() const;
+
+        std::string getMemoryHandName() const;
+
+        std::string getHandControllerName() const;
+
+        std::string getHandRootNode() const;
+
+        std::string getHandModelPath() const;
+
+        std::string getAbsoluteHandModelPath() const;
+
+        std::string getHandModelPackage() const;
+
+        std::string getPalmCollisionModel() const;
+
+        std::string getFullHandCollisionModel() const;
+
+        RobotArm addRobot(const VirtualRobot::RobotPtr& robot) const;
+
+        Arm(const std::shared_ptr<const RobotNameHelper>& rnh, const std::string& side);
+
+        Arm() = default;
+
+        Arm(Arm&&) = default;
+
+        Arm(const Arm&) = default;
+
+        Arm& operator=(Arm&&) = default;
+
+        Arm& operator=(const Arm&) = default;
+
+        std::shared_ptr<const RobotNameHelper> getRobotNameHelper() const;
+
+        std::string select(const std::string& path) const;
+
+    private:
+
+        std::shared_ptr<const RobotNameHelper> rnh;
+        std::string side;
+    };
+
+    struct RobotArm
+    {
+        friend class RobotNameHelper;
+
+        friend struct Arm;
+    public:
+        std::string getSide() const;
+
+        VirtualRobot::RobotNodeSetPtr getKinematicChain() const;
+
+        VirtualRobot::RobotNodeSetPtr getTorsoKinematicChain() const;
+
+        VirtualRobot::RobotNodePtr getTCP() const;
+
+        VirtualRobot::RobotNodePtr getHandRootNode() const;
+
+        VirtualRobot::RobotNodePtr getPalmCollisionModel() const;
+
+        VirtualRobot::TriMeshModelPtr getFullHandCollisionModel() const;
+
+        Eigen::Matrix4f getTcp2HandRootTransform() const;
+
+        const Arm& getArm() const;
+
+        const VirtualRobot::RobotPtr& getRobot() const;
+
+        RobotArm(const Arm& arm, const VirtualRobot::RobotPtr& robot);
+
+        RobotArm() = default;
+
+        RobotArm(RobotArm&&) = default;
+
+        RobotArm(const RobotArm&) = default;
+
+        RobotArm& operator=(RobotArm&&) = default;
+
+        RobotArm& operator=(const RobotArm&) = default;
+
+    private:
+
+        Arm arm;
+        VirtualRobot::RobotPtr robot;
+    };
+
+    class RobotNameHelper : public std::enable_shared_from_this<RobotNameHelper>
+    {
+    public:
+        static void
+        writeRobotInfoNode(const RobotInfoNodePtr& n, std::ostream& str, std::size_t indent = 0, char indentChar = ' ');
+        using Arm = armarx::Arm;
+        using RobotArm = armarx::RobotArm;
         class Node
         {
         public:
             Node(const RobotInfoNodePtr& robotInfo);
+
             std::string value();
 
             Node select(const std::string& name, const std::vector<std::string>& profiles);
+
             bool isValid();
+
             void checkValid();
 
         private:
@@ -62,89 +169,31 @@ namespace armarx
         static const std::string LocationLeft;
         static const std::string LocationRight;
 
-        struct RobotArm;
-        struct Arm
-        {
-            friend class RobotNameHelper;
-        public:
-
-            std::string getSide() const;
-            std::string getKinematicChain() const;
-            std::string getTorsoKinematicChain() const;
-            std::string getTCP() const;
-            std::string getForceTorqueSensor() const;
-            std::string getForceTorqueSensorFrame() const;
-            std::string getEndEffector() const;
-            std::string getMemoryHandName() const;
-            std::string getHandControllerName() const;
-            std::string getHandRootNode() const;
-            std::string getHandModelPath() const;
-            std::string getAbsoluteHandModelPath() const;
-            std::string getHandModelPackage() const;
-            std::string getPalmCollisionModel() const;
-            std::string getFullHandCollisionModel() const;
-            RobotArm addRobot(const VirtualRobot::RobotPtr& robot) const;
-
-            Arm(const std::shared_ptr<const RobotNameHelper>& rnh, const std::string& side);
-            Arm() = default;
-            Arm(Arm&&) = default;
-            Arm(const Arm&) = default;
-            Arm& operator=(Arm&&) = default;
-            Arm& operator=(const Arm&) = default;
-
-            std::shared_ptr<const RobotNameHelper> getRobotNameHelper() const;
-
-            std::string select(const std::string& path) const;
-        private:
-
-            std::shared_ptr<const RobotNameHelper> rnh;
-            std::string side;
-        };
-
-        struct RobotArm
-        {
-            friend class RobotNameHelper;
-            friend struct Arm;
-        public:
-            std::string getSide() const;
-            VirtualRobot::RobotNodeSetPtr getKinematicChain() const;
-            VirtualRobot::RobotNodeSetPtr getTorsoKinematicChain() const;
-            VirtualRobot::RobotNodePtr getTCP() const;
-            VirtualRobot::RobotNodePtr getHandRootNode() const;
-            VirtualRobot::RobotNodePtr getPalmCollisionModel() const;
-            VirtualRobot::TriMeshModelPtr getFullHandCollisionModel() const;
-            Eigen::Matrix4f getTcp2HandRootTransform() const;
-            const Arm& getArm() const;
-            const VirtualRobot::RobotPtr& getRobot() const;
-
-            RobotArm(const Arm& arm, const VirtualRobot::RobotPtr& robot);
-            RobotArm() = default;
-            RobotArm(RobotArm&&) = default;
-            RobotArm(const RobotArm&) = default;
-            RobotArm& operator=(RobotArm&&) = default;
-            RobotArm& operator=(const RobotArm&) = default;
-        private:
-
-            Arm arm;
-            VirtualRobot::RobotPtr robot;
-        };
-
         std::string select(const std::string& path) const;
 
         static RobotNameHelperPtr Create(const RobotInfoNodePtr& robotInfo, const StatechartProfilePtr& profile);
-        static RobotNameHelperPtr Create(const std::string& robotXmlFilename, const StatechartProfilePtr& profile = nullptr);
+
+        static RobotNameHelperPtr
+        Create(const std::string& robotXmlFilename, const StatechartProfilePtr& profile = nullptr);
 
         RobotNameHelper(const RobotInfoNodePtr& robotInfo, const StatechartProfilePtr& profile = nullptr);
 
         RobotNameHelper(RobotNameHelper&&) = default;
+
         RobotNameHelper(const RobotNameHelper&) = default;
+
         RobotNameHelper& operator=(RobotNameHelper&&) = default;
+
         RobotNameHelper& operator=(const RobotNameHelper&) = default;
 
         Arm getArm(const std::string& side) const;
+
         RobotArm getRobotArm(const std::string& side, const VirtualRobot::RobotPtr& robot) const;
+
         const std::vector<std::string>& getProfiles() const;
+
         const RobotInfoNodePtr& getRobotInfoNodePtr() const;
+
     private:
 
         static RobotInfoNodePtr readRobotInfo(const RapidXmlReaderNode& infoNode);
-- 
GitLab